Slic3r::GCodeThumbnails Namespace Reference

Classes
struct	CompressedPNG
struct	CompressedJPG
struct	CompressedQOI
struct	CompressedBIQU
struct	CompressedColPic
struct	U16HEAD
struct	ColPicHead3
struct	CompressedImageBuffer

Typedefs
typedef std::vector< std::pair< GCodeThumbnailsFormat, Vec2d > >	GCodeThumbnailDefinitionsList

Functions
std::unique_ptr< CompressedImageBuffer >	compress_thumbnail_png (const ThumbnailData &data)
std::unique_ptr< CompressedImageBuffer >	compress_thumbnail_jpg (const ThumbnailData &data)
std::unique_ptr< CompressedImageBuffer >	compress_thumbnail_qoi (const ThumbnailData &data)
int	ColPic_EncodeStr (unsigned short *fromcolor16, int picw, int pich, unsigned char *outputdata, int outputmaxtsize, int colorsmax)
std::unique_ptr< CompressedImageBuffer >	compress_thumbnail_colpic (const ThumbnailData &data)
std::unique_ptr< CompressedImageBuffer >	compress_thumbnail_btt_tft (const ThumbnailData &data)
std::string	get_hex (const unsigned int input)
std::string	rjust (std::string input, unsigned int width, char fill_char)
std::unique_ptr< CompressedImageBuffer >	compress_thumbnail (const ThumbnailData &data, GCodeThumbnailsFormat format)
static void	colmemmove (unsigned char *dec, unsigned char *src, int lenth)
static void	colmemcpy (unsigned char *dec, unsigned char *src, int lenth)
static void	colmemset (unsigned char *dec, unsigned char val, int lenth)
static void	ADList0 (unsigned short val, U16HEAD *listu16, int *listqty, int maxqty)
static int	Byte8bitEncode (unsigned short *fromcolor16, unsigned short *listu16, int listqty, int dotsqty, unsigned char *outputdata, int decMaxBytesize)
static int	ColPicEncode (unsigned short *fromcolor16, int picw, int pich, unsigned char *outputdata, int outputmaxtsize, int colorsmax)
std::pair< GCodeThumbnailDefinitionsList, ThumbnailErrors >	make_and_check_thumbnail_list (const std::string &thumbnails_string, const std::string_view def_ext)
std::pair< GCodeThumbnailDefinitionsList, ThumbnailErrors >	make_and_check_thumbnail_list (const ConfigBase &config)
std::string	get_error_string (const ThumbnailErrors &errors)
template<typename WriteToOutput, typename ThrowIfCanceledCallback>
void	export_thumbnails_to_file (ThumbnailsGeneratorCallback &thumbnail_cb, int plate_id, const std::vector< std::pair< GCodeThumbnailsFormat, Vec2d > > &thumbnails_list, WriteToOutput output, ThrowIfCanceledCallback throw_if_canceled)

---

Class Documentation

Slic3r::GCodeThumbnails::U16HEAD

struct Slic3r::GCodeThumbnails::U16HEAD

Class Members
unsigned char	A0
unsigned char	A1
unsigned char	A2
unsigned short	colo16
unsigned int	qty
unsigned char	res0
unsigned short	res1

Slic3r::GCodeThumbnails::ColPicHead3

struct Slic3r::GCodeThumbnails::ColPicHead3

Class Members
unsigned int	ColorDataSize
unsigned char	encodever
unsigned int	ListDataSize
unsigned int	mark
unsigned short	oncelistqty
unsigned int	PicH
unsigned int	PicW
unsigned char	res0
unsigned int	res1
unsigned int	res2

Typedef Documentation

GCodeThumbnailDefinitionsList

typedef std::vector<std::pair<GCodeThumbnailsFormat, Vec2d> > Slic3r::GCodeThumbnails::GCodeThumbnailDefinitionsList

Function Documentation

ADList0()

void Slic3r::GCodeThumbnails::ADList0 ( unsigned short val, U16HEAD * listu16, int * listqty, int maxqty )

static

{
    unsigned char A0;
    unsigned char A1;
    unsigned char A2;
    int           qty = *listqty;
    if (qty >= maxqty)
        return;
    for (int i = 0; i < qty; i++) {
        if (listu16[i].colo16 == val) {
            listu16[i].qty++;
            return;
        }
    }
    A0         = (unsigned char) (val >> 11);
    A1         = (unsigned char) ((val << 5) >> 10);
    A2         = (unsigned char) ((val << 11) >> 11);
    U16HEAD* a = &listu16[qty];
    a->colo16  = val;
    a->A0      = A0;
    a->A1      = A1;
    a->A2      = A2;
    a->qty     = 1;
    *listqty   = qty + 1;
}

References Slic3r::GCodeThumbnails::U16HEAD::A0, Slic3r::GCodeThumbnails::U16HEAD::A1, Slic3r::GCodeThumbnails::U16HEAD::A2, Slic3r::GCodeThumbnails::U16HEAD::colo16, and Slic3r::GCodeThumbnails::U16HEAD::qty.

Referenced by ColPicEncode().

Here is the caller graph for this function:

Byte8bitEncode()

int Slic3r::GCodeThumbnails::Byte8bitEncode ( unsigned short * fromcolor16, unsigned short * listu16, int listqty, int dotsqty, unsigned char * outputdata, int decMaxBytesize )

static

{
    unsigned char tid, sid;
    int           dots     = 0;
    int           srcindex = 0;
    int           decindex = 0;
    int           lastid   = 0;
    int           temp     = 0;
    while (dotsqty > 0) {
        dots = 1;
        for (int i = 0; i < (dotsqty - 1); i++) {
            if (fromcolor16[srcindex + i] != fromcolor16[srcindex + i + 1])
                break;
            dots++;
            if (dots == 255)
                break;
        }
        temp = 0;
        for (int i = 0; i < listqty; i++) {
            if (listu16[i] == fromcolor16[srcindex]) {
                temp = i;
                break;
            }
        }
        tid = (unsigned char) (temp % 32);
        sid = (unsigned char) (temp / 32);
        if (lastid != sid) {
            if (decindex >= decMaxBytesize)
                goto IL_END;
            outputdata[decindex] = 7;
            outputdata[decindex] <<= 5;
            outputdata[decindex] += sid;
            decindex++;
            lastid = sid;
        }
        if (dots <= 6) {
            if (decindex >= decMaxBytesize)
                goto IL_END;
            outputdata[decindex] = (unsigned char) dots;
            outputdata[decindex] <<= 5;
            outputdata[decindex] += tid;
            decindex++;
        } else {
            if (decindex >= decMaxBytesize)
                goto IL_END;
            outputdata[decindex] = 0;
            outputdata[decindex] += tid;
            decindex++;
            if (decindex >= decMaxBytesize)
                goto IL_END;
            outputdata[decindex] = (unsigned char) dots;
            decindex++;
        }
        srcindex += dots;
        dotsqty -= dots;
    }
IL_END:
    return decindex;
}

Referenced by ColPicEncode().

Here is the caller graph for this function:

colmemcpy()

void Slic3r::GCodeThumbnails::colmemcpy ( unsigned char * dec, unsigned char * src, int lenth )

static

{
    while (lenth > 0) {
        *(dec++) = *(src++);
        lenth--;
    }
}

Referenced by ColPicEncode().

Here is the caller graph for this function:

colmemmove()

void Slic3r::GCodeThumbnails::colmemmove ( unsigned char * dec, unsigned char * src, int lenth )

static

{
    if (src < dec) {
        dec += lenth - 1;
        src += lenth - 1;
        while (lenth > 0) {
            *(dec--) = *(src--);
            lenth--;
        }
    } else {
        while (lenth > 0) {
            *(dec++) = *(src++);
            lenth--;
        }
    }
}

Referenced by ColPicEncode().

Here is the caller graph for this function:

colmemset()

void Slic3r::GCodeThumbnails::colmemset ( unsigned char * dec, unsigned char val, int lenth )

static

{
    while (lenth > 0) {
        *(dec++) = val;
        lenth--;
    }
}

Referenced by ColPicEncode().

Here is the caller graph for this function:

ColPic_EncodeStr()

int Slic3r::GCodeThumbnails::ColPic_EncodeStr	(	unsigned short *	fromcolor16,
		int	picw,
		int	pich,
		unsigned char *	outputdata,
		int	outputmaxtsize,
		int	colorsmax )

{
    int           qty      = 0;
    int           temp     = 0;
    int           strindex = 0;
    int           hexindex = 0;
    unsigned char TempBytes[4];
    qty = ColPicEncode(fromcolor16, picw, pich, outputdata, outputmaxtsize, colorsmax);
    if (qty == 0)
        return 0;
    temp = 3 - (qty % 3);
    while (temp > 0) {
        outputdata[qty] = 0;
        qty++;
        temp--;
    }
    if ((qty * 4 / 3) >= outputmaxtsize)
        return 0;
    hexindex = qty;
    strindex = (qty * 4 / 3);
    while (hexindex > 0) {
        hexindex -= 3;
        strindex -= 4;
 
        TempBytes[0] = (unsigned char) (outputdata[hexindex] >> 2);
        TempBytes[1] = (unsigned char) (outputdata[hexindex] & 3);
        TempBytes[1] <<= 4;
        TempBytes[1] += ((unsigned char) (outputdata[hexindex + 1] >> 4));
        TempBytes[2] = (unsigned char) (outputdata[hexindex + 1] & 15);
        TempBytes[2] <<= 2;
        TempBytes[2] += ((unsigned char) (outputdata[hexindex + 2] >> 6));
        TempBytes[3] = (unsigned char) (outputdata[hexindex + 2] & 63);
 
        TempBytes[0] += 48;
        if (TempBytes[0] == (unsigned char) '\\')
            TempBytes[0] = 126;
        TempBytes[0 + 1] += 48;
        if (TempBytes[0 + 1] == (unsigned char) '\\')
            TempBytes[0 + 1] = 126;
        TempBytes[0 + 2] += 48;
        if (TempBytes[0 + 2] == (unsigned char) '\\')
            TempBytes[0 + 2] = 126;
        TempBytes[0 + 3] += 48;
        if (TempBytes[0 + 3] == (unsigned char) '\\')
            TempBytes[0 + 3] = 126;
 
        outputdata[strindex]     = TempBytes[0];
        outputdata[strindex + 1] = TempBytes[1];
        outputdata[strindex + 2] = TempBytes[2];
        outputdata[strindex + 3] = TempBytes[3];
    }
    qty             = qty * 4 / 3;
    outputdata[qty] = 0;
    return qty;
}

References ColPicEncode().

Referenced by compress_thumbnail_colpic().

Here is the call graph for this function:

Here is the caller graph for this function:

ColPicEncode()

int Slic3r::GCodeThumbnails::ColPicEncode ( unsigned short * fromcolor16, int picw, int pich, unsigned char * outputdata, int outputmaxtsize, int colorsmax )

static

{
    U16HEAD      l0;
    int          cha0, cha1, cha2, fid, minval;
    ColPicHead3* Head0 = nullptr;
    U16HEAD      Listu16[1024];
    int          ListQty = 0;
    int          enqty   = 0;
    int          dotsqty = picw * pich;
    if (colorsmax > 1024)
        colorsmax = 1024;
    for (int i = 0; i < dotsqty; i++) {
        int ch = (int) fromcolor16[i];
        ADList0(ch, Listu16, &ListQty, 1024);
    }
 
    for (int index = 1; index < ListQty; index++) {
        l0 = Listu16[index];
        for (int i = 0; i < index; i++) {
            if (l0.qty >= Listu16[i].qty) {
                colmemmove((unsigned char*) &Listu16[i + 1], (unsigned char*) &Listu16[i], (index - i) * sizeof(U16HEAD));
                colmemcpy((unsigned char*) &Listu16[i], (unsigned char*) &l0, sizeof(U16HEAD));
                break;
            }
        }
    }
    while (ListQty > colorsmax) {
        l0     = Listu16[ListQty - 1];
        minval = 255;
        fid    = -1;
        for (int i = 0; i < colorsmax; i++) {
            cha0 = Listu16[i].A0 - l0.A0;
            if (cha0 < 0)
                cha0 = 0 - cha0;
            cha1 = Listu16[i].A1 - l0.A1;
            if (cha1 < 0)
                cha1 = 0 - cha1;
            cha2 = Listu16[i].A2 - l0.A2;
            if (cha2 < 0)
                cha2 = 0 - cha2;
            int chall = cha0 + cha1 + cha2;
            if (chall < minval) {
                minval = chall;
                fid    = i;
            }
        }
        for (int i = 0; i < dotsqty; i++) {
            if (fromcolor16[i] == l0.colo16)
                fromcolor16[i] = Listu16[fid].colo16;
        }
        ListQty = ListQty - 1;
    }
    Head0 = ((ColPicHead3*) outputdata);
    colmemset(outputdata, 0, sizeof(ColPicHead3));
    Head0->encodever    = 3;
    Head0->oncelistqty  = 0;
    Head0->mark         = 0x05DDC33C;
    Head0->ListDataSize = ListQty * 2;
    for (int i = 0; i < ListQty; i++) {
        unsigned short* l0 = (unsigned short*) &outputdata[sizeof(ColPicHead3)];
        l0[i]              = Listu16[i].colo16;
    }
    enqty = Byte8bitEncode(fromcolor16, (unsigned short*) &outputdata[sizeof(ColPicHead3)], Head0->ListDataSize >> 1, dotsqty,
                           &outputdata[sizeof(ColPicHead3) + Head0->ListDataSize],
                           outputmaxtsize - sizeof(ColPicHead3) - Head0->ListDataSize);
    Head0->ColorDataSize = enqty;
    Head0->PicW          = picw;
    Head0->PicH          = pich;
    return sizeof(ColPicHead3) + Head0->ListDataSize + Head0->ColorDataSize;
}

References Slic3r::GCodeThumbnails::U16HEAD::A0, Slic3r::GCodeThumbnails::U16HEAD::A1, Slic3r::GCodeThumbnails::U16HEAD::A2, ADList0(), Byte8bitEncode(), colmemcpy(), colmemmove(), colmemset(), Slic3r::GCodeThumbnails::U16HEAD::colo16, Slic3r::GCodeThumbnails::ColPicHead3::ColorDataSize, Slic3r::GCodeThumbnails::ColPicHead3::encodever, Slic3r::GCodeThumbnails::ColPicHead3::ListDataSize, Slic3r::GCodeThumbnails::ColPicHead3::mark, Slic3r::GCodeThumbnails::ColPicHead3::oncelistqty, Slic3r::GCodeThumbnails::ColPicHead3::PicH, Slic3r::GCodeThumbnails::ColPicHead3::PicW, and Slic3r::GCodeThumbnails::U16HEAD::qty.

Referenced by ColPic_EncodeStr().

Here is the call graph for this function:

Here is the caller graph for this function:

compress_thumbnail()

std::unique_ptr< CompressedImageBuffer > Slic3r::GCodeThumbnails::compress_thumbnail	(	const ThumbnailData &	data,
		GCodeThumbnailsFormat	format )

{
    switch (format) {
    case GCodeThumbnailsFormat::PNG:
    default:
        return compress_thumbnail_png(data);
    case GCodeThumbnailsFormat::JPG:
        return compress_thumbnail_jpg(data);
    case GCodeThumbnailsFormat::QOI:
        return compress_thumbnail_qoi(data);
    case GCodeThumbnailsFormat::BTT_TFT:
        return compress_thumbnail_btt_tft(data);
    case GCodeThumbnailsFormat::ColPic:
        return compress_thumbnail_colpic(data);
    }
}

References Slic3r::BTT_TFT, Slic3r::ColPic, compress_thumbnail_btt_tft(), compress_thumbnail_colpic(), compress_thumbnail_jpg(), compress_thumbnail_png(), compress_thumbnail_qoi(), Slic3r::format(), Slic3r::JPG, Slic3r::PNG, and Slic3r::QOI.

Referenced by export_thumbnails_to_file().

Here is the call graph for this function:

Here is the caller graph for this function:

compress_thumbnail_btt_tft()

std::unique_ptr< CompressedImageBuffer > Slic3r::GCodeThumbnails::compress_thumbnail_btt_tft

(

const ThumbnailData &

data

)

                                                                                           {
 
    // Take vector of RGBA pixels and flip the image vertically
    std::vector<unsigned char> rgba_pixels(data.pixels.size());
    const unsigned int row_size = data.width * 4;
    for (unsigned int y = 0; y < data.height; ++y) {
        ::memcpy(rgba_pixels.data() + (data.height - y - 1) * row_size, data.pixels.data() + y * row_size, row_size);
    }
 
    auto out = std::make_unique<CompressedBIQU>();
 
    // get the output size of the data
    // add 4 bytes to the row_size to account for end of line (\r\n)
    // add 1 byte for the 0 of the c_str
    out->size = data.height * (row_size + 4) + 1;
    out->data = malloc(out->size);
 
    std::stringstream out_data;
    typedef struct {unsigned char r, g, b, a;} pixel;
    pixel px;
    for (unsigned int ypos = 0; ypos < data.height; ypos++) {
        std::stringstream line;
        line << ";";
        for (unsigned int xpos = 0; xpos < row_size; xpos+=4) {
            px.r = rgba_pixels[ypos * row_size + xpos];
            px.g = rgba_pixels[ypos * row_size + xpos + 1];
            px.b = rgba_pixels[ypos * row_size + xpos + 2];
            px.a = rgba_pixels[ypos * row_size + xpos + 3];
 
            // calculate values for RGB with alpha
            const uint8_t rv = ((px.a * px.r) / 255);
            const uint8_t gv = ((px.a * px.g) / 255);
            const uint8_t bv = ((px.a * px.b) / 255);
 
            // convert the RGB values to RGB565 hex that is right justified (same algorithm BTT firmware uses)
            auto color_565 = rjust(get_hex(((rv >> 3) << 11) | ((gv >> 2) << 5) | (bv >> 3)), 4, '0');
 
            //BTT original converter specifies these values should be '0000'
            if (color_565 == "0020" || color_565 == "0841" || color_565 == "0861")
                color_565 = "0000";
            //add the color to the line
            line << color_565;
        }
        // output line and end line (\r\n is important. BTT firmware requires it)
        out_data << line.str() << "\r\n";
        line.clear();
    }
    ::memcpy(out->data, (const void*) out_data.str().c_str(), out->size);
    return out;
}

References get_hex(), Slic3r::ThumbnailData::height, Slic3r::ThumbnailData::pixels, rjust(), and Slic3r::ThumbnailData::width.

Referenced by compress_thumbnail().

Here is the call graph for this function:

Here is the caller graph for this function:

compress_thumbnail_colpic()

std::unique_ptr< CompressedImageBuffer > Slic3r::GCodeThumbnails::compress_thumbnail_colpic

(

const ThumbnailData &

data

)

{
    const int MAX_SIZE = 512;
    int width = int(data.width);
    int height = int(data.height);
 
    // Orca: cap data size to MAX_SIZE while maintaining aspect ratio
    if (width > MAX_SIZE || height > MAX_SIZE) {
        double aspectRatio = static_cast<double>(width) / height;
        if (aspectRatio > 1.0) {
            width = MAX_SIZE;
            height = static_cast<int>(MAX_SIZE / aspectRatio);
        } else {
            height = MAX_SIZE;
            width = static_cast<int>(MAX_SIZE * aspectRatio);
        }
    }
 
    std::vector<unsigned short> color16_buf(width * height);
    std::vector<unsigned char> output_buf(height * width * 10);
 
    std::vector<uint8_t> rgba_pixels(data.pixels.size() * 4);
    size_t               row_size = width * 4;
    for (size_t y = 0; y < height; ++y)
        memcpy(rgba_pixels.data() + y * row_size, data.pixels.data() + y * row_size, row_size);
    const unsigned char* pixels;
    pixels = (const unsigned char*) rgba_pixels.data();
    int r = 0, g = 0, b = 0, a = 0, rgb = 0;
    int time = width * height - 1;
    for (int row = 0; row < height; ++row) {
        int rr = row * width;
        for (int col = 0; col < width; ++col) {
            const int pix_idx = 4 * (rr + width - col - 1);
            r                 = int(pixels[pix_idx]) >> 3;
            g                 = int(pixels[pix_idx + 1]) >> 2;
            b                 = int(pixels[pix_idx + 2]) >> 3;
            a                 = int(pixels[pix_idx + 3]);
            if (a == 0) {
                r = 46 >> 3;
                g = 51 >> 2;
                b = 72 >> 3;
            }
            rgb             = (r << 11) | (g << 5) | b;
            color16_buf[time--] = rgb;
        }
    }
 
    ColPic_EncodeStr(color16_buf.data(), width, height, output_buf.data(), output_buf.size(), 1024);
 
    auto out  = std::make_unique<CompressedColPic>();
    out->size = output_buf.size();
    out->data = malloc(out->size);
    ::memcpy(out->data, output_buf.data(), out->size);
    return out;
}

References ColPic_EncodeStr(), Slic3r::ThumbnailData::height, MAX_SIZE, Slic3r::ThumbnailData::pixels, and Slic3r::ThumbnailData::width.

Referenced by compress_thumbnail().

Here is the call graph for this function:

Here is the caller graph for this function:

compress_thumbnail_jpg()

std::unique_ptr< CompressedImageBuffer > Slic3r::GCodeThumbnails::compress_thumbnail_jpg

(

const ThumbnailData &

data

)

{
    // Take vector of RGBA pixels and flip the image vertically
    std::vector<unsigned char> rgba_pixels(data.pixels.size());
    const unsigned int row_size = data.width * 4;
    for (unsigned int y = 0; y < data.height; ++y) {
        ::memcpy(rgba_pixels.data() + (data.height - y - 1) * row_size, data.pixels.data() + y * row_size, row_size);
    }
 
    // Store pointers to scanlines start for later use
    std::vector<unsigned char*> rows_ptrs;
    rows_ptrs.reserve(data.height);
    for (unsigned int y = 0; y < data.height; ++y) {
        rows_ptrs.emplace_back(&rgba_pixels[y * row_size]);
    }
 
    std::vector<unsigned char> compressed_data(data.pixels.size());
    unsigned char* compressed_data_ptr = compressed_data.data();
    unsigned long compressed_data_size = data.pixels.size();
 
    jpeg_error_mgr err;
    jpeg_compress_struct info;
    info.err = jpeg_std_error(&err);
    jpeg_create_compress(&info);
    jpeg_mem_dest(&info, &compressed_data_ptr, &compressed_data_size);
 
    info.image_width = data.width;
    info.image_height = data.height;
    info.input_components = 4;
    info.in_color_space = JCS_EXT_RGBA;
 
    jpeg_set_defaults(&info);
    jpeg_set_quality(&info, 85, TRUE);
    jpeg_start_compress(&info, TRUE);
 
    jpeg_write_scanlines(&info, rows_ptrs.data(), data.height);
    jpeg_finish_compress(&info);
    jpeg_destroy_compress(&info);
 
    // FIXME -> Add error checking
 
    auto out = std::make_unique<CompressedJPG>();
    out->data = malloc(compressed_data_size);
    out->size = size_t(compressed_data_size);
    ::memcpy(out->data, (const void*)compressed_data.data(), out->size);
    return out;
}

References Slic3r::ThumbnailData::height, Slic3r::ThumbnailData::pixels, and Slic3r::ThumbnailData::width.

Referenced by compress_thumbnail().

Here is the caller graph for this function:

compress_thumbnail_png()

std::unique_ptr< CompressedImageBuffer > Slic3r::GCodeThumbnails::compress_thumbnail_png

(

const ThumbnailData &

data

)

{
    auto out = std::make_unique<CompressedPNG>();
    out->data = tdefl_write_image_to_png_file_in_memory_ex((const void*)data.pixels.data(), data.width, data.height, 4, &out->size, MZ_DEFAULT_LEVEL, 1);
    return out;
}

References Slic3r::ThumbnailData::height, Slic3r::ThumbnailData::pixels, and Slic3r::ThumbnailData::width.

Referenced by compress_thumbnail().

Here is the caller graph for this function:

compress_thumbnail_qoi()

std::unique_ptr< CompressedImageBuffer > Slic3r::GCodeThumbnails::compress_thumbnail_qoi

(

const ThumbnailData &

data

)

{
    qoi_desc desc;
    desc.width      = data.width;
    desc.height     = data.height;
    desc.channels   = 4;
    desc.colorspace = QOI_SRGB;
 
    // Take vector of RGBA pixels and flip the image vertically
    std::vector<uint8_t> rgba_pixels(data.pixels.size() * 4);
    size_t row_size = data.width * 4;
    for (size_t y = 0; y < data.height; ++ y)
        memcpy(rgba_pixels.data() + (data.height - y - 1) * row_size, data.pixels.data() + y * row_size, row_size);
 
    auto out = std::make_unique<CompressedQOI>();
    int  size;
    out->data = qoi_encode((const void*)rgba_pixels.data(), &desc, &size);
    out->size = size;
    return out;
}

References Slic3r::ThumbnailData::height, Slic3r::ThumbnailData::pixels, and Slic3r::ThumbnailData::width.

Referenced by compress_thumbnail().

Here is the caller graph for this function:

export_thumbnails_to_file()

template<typename WriteToOutput, typename ThrowIfCanceledCallback>

void Slic3r::GCodeThumbnails::export_thumbnails_to_file ( ThumbnailsGeneratorCallback & thumbnail_cb, int plate_id, const std::vector< std::pair< GCodeThumbnailsFormat, Vec2d > > & thumbnails_list, WriteToOutput output, ThrowIfCanceledCallback throw_if_canceled )

inline

{
    // Write thumbnails using base64 encoding
    if (thumbnail_cb == nullptr)
        return;
    short i = 0;
    bool first_ColPic = true;
    for (const auto& [format, size] : thumbnails_list) {
        static constexpr const size_t max_row_length = 78;
        ThumbnailsList                thumbnails     = thumbnail_cb(ThumbnailsParams{{size}, true, true, true, true, plate_id});
        for (const ThumbnailData &data : thumbnails) {
            if (data.is_valid()) {
                auto compressed = compress_thumbnail(data, format);
                if (compressed->data && compressed->size) {
                    if (format == GCodeThumbnailsFormat::BTT_TFT) {
                        // write BTT_TFT header
                        output((";" + rjust(get_hex(data.width), 4, '0') + rjust(get_hex(data.height), 4, '0') + "\r\n").c_str());
                        output((char *) compressed->data);
                        if (i == (thumbnails_list.size() - 1))
                            output("; bigtree thumbnail end\r\n\r\n");
                    }
                    else if (format == GCodeThumbnailsFormat::ColPic) {
                        if (first_ColPic) {
                            output((boost::format("\n\n;gimage:%s\n\n") % reinterpret_cast<char*>(compressed->data)).str().c_str());
                        } else {
                            output((boost::format("\n\n;simage:%s\n\n") % reinterpret_cast<char*>(compressed->data)).str().c_str());
                        }
                        first_ColPic = false;
                    } 
                    else {
                        output("; THUMBNAIL_BLOCK_START\n");
                        std::string encoded;
                        encoded.resize(boost::beast::detail::base64::encoded_size(compressed->size));
                        encoded.resize(boost::beast::detail::base64::encode((void *) encoded.data(), (const void *) compressed->data,
                                                                            compressed->size));                        
                        output((boost::format("\n;\n; %s begin %dx%d %d\n") % compressed->tag() % data.width % data.height % encoded.size())
                                   .str()
                                   .c_str());                        
                        while (encoded.size() > max_row_length) {
                            output((boost::format("; %s\n") % encoded.substr(0, max_row_length)).str().c_str());
                            encoded = encoded.substr(max_row_length);
                        }
 
                        // Orca write remaining ecoded data
                        if (encoded.size() > 0)
                            output((boost::format("; %s\n") % encoded).str().c_str());
 
                        output((boost::format("; %s end\n") % compressed->tag()).str().c_str());
                        output("; THUMBNAIL_BLOCK_END\n\n");
                    }
                    throw_if_canceled();
                }
            }
        }
        i++;
    }
}

References Slic3r::BTT_TFT, Slic3r::ColPic, compress_thumbnail(), Slic3r::format(), get_hex(), and rjust().

Referenced by Slic3r::GCode::_do_export().

Here is the call graph for this function:

Here is the caller graph for this function:

get_error_string()

std::string Slic3r::GCodeThumbnails::get_error_string

(

const ThumbnailErrors &

errors

)

{
    std::string error_str;
 
    if (errors.has(ThumbnailError::InvalidVal))
        error_str += "\n - " + Slic3r::format(_u8L("Invalid input format. Expected vector of dimensions in the following format: \"%1%\""), "XxY/EXT, XxY/EXT, ...");
    if (errors.has(ThumbnailError::OutOfRange))
        error_str += "\n - " + _u8L("Input value is out of range");
    if (errors.has(ThumbnailError::InvalidExt))
        error_str += "\n - " + _u8L("Some extension in the input is invalid");
 
    return error_str;
}

References _u8L, Slic3r::format(), Slic3r::enum_bitmask< option_type, typename >::has(), Slic3r::InvalidExt, Slic3r::InvalidVal, and Slic3r::OutOfRange.

Referenced by Slic3r::GCode::_do_export(), Slic3r::GUI::TabPrinter::build_fff(), and Slic3r::PrintConfigDef::handle_legacy_composite().

Here is the call graph for this function:

Here is the caller graph for this function:

get_hex()

std::string Slic3r::GCodeThumbnails::get_hex

(

const unsigned int

input

)

                                            {
    std::stringstream stream;
    stream << std::hex << input;
    return stream.str();
}

Referenced by compress_thumbnail_btt_tft(), and export_thumbnails_to_file().

Here is the caller graph for this function:

make_and_check_thumbnail_list() [1/2]

std::pair< GCodeThumbnailDefinitionsList, ThumbnailErrors > Slic3r::GCodeThumbnails::make_and_check_thumbnail_list

(

const ConfigBase &

config

)

{
    // ??? Unit tests or command line slicing may not define "thumbnails" or "thumbnails_format".
    // ??? If "thumbnails_format" is not defined, export to PNG.
 
    // generate thumbnails data to process it
 
    if (const auto thumbnails_value = config.option<ConfigOptionString>("thumbnails"))
        return make_and_check_thumbnail_list(thumbnails_value->value);
 
    return {};
}

References make_and_check_thumbnail_list(), and Slic3r::ConfigBase::option().

Here is the call graph for this function:

make_and_check_thumbnail_list() [2/2]

std::pair< GCodeThumbnailDefinitionsList, ThumbnailErrors > Slic3r::GCodeThumbnails::make_and_check_thumbnail_list	(	const std::string &	thumbnails_string,
		const std::string_view	def_ext )

{
    if (thumbnails_string.empty())
        return {};
 
    std::istringstream is(thumbnails_string);
    std::string point_str;
 
    ThumbnailErrors errors;
 
    // generate thumbnails data to process it
 
    GCodeThumbnailDefinitionsList thumbnails_list;
    while (std::getline(is, point_str, ',')) {
        Vec2d point(Vec2d::Zero());
        GCodeThumbnailsFormat format;
        std::istringstream iss(point_str);
        std::string coord_str;
        if (std::getline(iss, coord_str, 'x') && !coord_str.empty()) {
            std::istringstream(coord_str) >> point(0);
            if (std::getline(iss, coord_str, '/') && !coord_str.empty()) {
                std::istringstream(coord_str) >> point(1);
 
                if (0 < point(0) && point(0) < 1000 && 0 < point(1) && point(1) < 1000) {
                    std::string ext_str;
                    std::getline(iss, ext_str, '/');
 
                    if (ext_str.empty())
                        ext_str = def_ext.empty() ? "PNG"sv : def_ext;
 
                    // check validity of extention
                    boost::to_upper(ext_str);
                    if (!ConfigOptionEnum<GCodeThumbnailsFormat>::from_string(ext_str, format)) {
                        format = GCodeThumbnailsFormat::PNG;
                        errors = enum_bitmask(errors | ThumbnailError::InvalidExt);
                    }
 
                    thumbnails_list.emplace_back(std::make_pair(format, point));
                }
                else
                    errors = enum_bitmask(errors | ThumbnailError::OutOfRange);
                continue;
            }
        }
        errors = enum_bitmask(errors | ThumbnailError::InvalidVal);
    }
 
    return std::make_pair(std::move(thumbnails_list), errors);
}

References Slic3r::format(), Slic3r::ConfigOptionEnum< T >::from_string(), Slic3r::InvalidExt, Slic3r::InvalidVal, Slic3r::OutOfRange, and Slic3r::PNG.

Referenced by Slic3r::GCode::_do_export(), Slic3r::GUI::TabPrinter::build_fff(), Slic3r::deep_diff(), Slic3r::PrintConfigDef::handle_legacy_composite(), make_and_check_thumbnail_list(), and Slic3r::GUI::validate_thumbnails_string().

Here is the call graph for this function:

Here is the caller graph for this function:

rjust()

std::string Slic3r::GCodeThumbnails::rjust	(	std::string	input,
		unsigned int	width,
		char	fill_char )

                                                                     {
    std::stringstream stream;
    stream.fill(fill_char);
    stream.width(width);
    stream << input;
    return stream.str();
}

Referenced by compress_thumbnail_btt_tft(), and export_thumbnails_to_file().

Here is the caller graph for this function: