geometrize::exporter Namespace Reference

Classes
struct	SVGExportOptions
	The SVGExportOptions struct represents the options that can be set for the SVG export. More...

Enumerations
enum class	RotatedEllipseSVGExportMode { ELLIPSE_ITEM = 0 , POLYGON = 1 }

Functions
void	writeToStream (std::ostringstream &stream, const std::uint8_t &t)
std::string	exportBitmapData (const geometrize::Bitmap &bitmapData)
	exportBitmapData Exports the raw image data to a binary dump - just the data as RGBA8888, no zero-padding or anything. More...
std::uint16_t	flip16 (const std::uint16_t &v)
std::uint32_t	flip32 (const std::uint32_t &v)
bool	bigEndian ()
void	writeToStream (std::ostringstream &stream, const std::uint32_t &t)
void	writeToStream (std::ostringstream &stream, const std::uint16_t &t)
std::string	exportBMP (const geometrize::Bitmap &bitmapData)
	exportBMP Exports the image data to a RGB888 bitmap image file (BMP). More...
std::string	exportShapeArray (const std::vector< geometrize::ShapeResult > &data)
	exportShapeArray Exports shape data to a compact array-style format. Data is three lines per shape, each line: shapeEnumTypeId shapeData R,G,B,A More...
std::string	exportShapeJson (const std::vector< geometrize::ShapeResult > &data)
	exportShapeJson Exports shape data to JSON. More...
std::string	getSingleShapeSVGData (const geometrize::rgba &color, const geometrize::Shape &shape, SVGExportOptions options=SVGExportOptions{})
	getSvgShapeData Gets the SVG data for a single shape. This is just the <rect>/<path> etc block for the shape itself, not a complete SVG image. More...
std::string	exportSingleShapeSVG (const geometrize::rgba &color, const geometrize::Shape &shape, const std::uint32_t width, const std::uint32_t height, SVGExportOptions options=SVGExportOptions{})
	exportSVG Exports a single shape as a complete SVG image. More...
std::string	exportSVG (const std::vector< geometrize::ShapeResult > &data, const std::uint32_t width, const std::uint32_t height, SVGExportOptions options=SVGExportOptions{})
	exportSVG Exports shape data as a complete SVG image. More...

Variables
static const std::string	SVG_STYLE_HOOK = "::svg_style_hook::"
	SVG_STYLE_HOOK A hook that an SVG exporter should use to augment shape styling produced by the getSvgShapeData method. More...

Enumeration Type Documentation

RotatedEllipseSVGExportMode

enum class geometrize::exporter::RotatedEllipseSVGExportMode

strong

Enumerator
ELLIPSE_ITEM
POLYGON

{
    ELLIPSE_ITEM = 0, // Export as a translated, rotated and scaled svg <ellipse>. OpenFL's SVG library can't handle this
    POLYGON = 1 // Export as a <polygon>, OpenFL's SVG library can handle this, but it looks quite ugly
};

Function Documentation

bigEndian()

bool geometrize::exporter::bigEndian ( )

inline

{
   std::uint32_t v{1};
   return (1 != reinterpret_cast<char*>(&v)[0]);
}

Here is the caller graph for this function:

exportBitmapData()

std::string geometrize::exporter::exportBitmapData

(

const geometrize::Bitmap &

bitmapData

)

exportBitmapData Exports the raw image data to a binary dump - just the data as RGBA8888, no zero-padding or anything.

Parameters

bitmapData

The image data to save as binary data.

Returns

A string containing the raw bitmap data.

{
    std::ostringstream stream(std::ios::binary);
 
    for(std::uint32_t y = 0U; y < bitmapData.getHeight(); y++) {
        for(std::uint32_t x = 0U; x < bitmapData.getWidth(); x++) {
            const geometrize::rgba pixel(bitmapData.getPixel(x, y));
            writeToStream(stream, pixel.r);
            writeToStream(stream, pixel.g);
            writeToStream(stream, pixel.b);
            writeToStream(stream, pixel.a);
        }
    }
 
    return stream.str();
}

Here is the call graph for this function:

exportBMP()

std::string geometrize::exporter::exportBMP

(

const geometrize::Bitmap &

bitmapData

)

exportBMP Exports the image data to a RGB888 bitmap image file (BMP).

Parameters

bitmapData

The image data to save as a bitmap image file.

Returns

A string containing the bitmap data.

{
    std::ostringstream stream(std::ios::binary);
 
    const std::uint32_t BITMAP_FILE_HEADER_SIZE{14U};
    const std::uint32_t BITMAP_INFORMATION_HEADER_SIZE{40U};
 
    const std::uint32_t width{bitmapData.getWidth()}; // The width of the image in pixels.
    const std::uint32_t height{bitmapData.getHeight()}; // The height of the image in pixels.
 
    // Per row pad byte count, used to ensure that each row is a multiple of 4 bytes.
    const std::uint32_t padding{ ((width * 3) % 4 != 0) ? 4 - ((width * 3) % 4) : 0};
 
    // Bitmap Information Header
    const std::uint32_t ifSize{BITMAP_INFORMATION_HEADER_SIZE}; // The number of bytes required by the structure.
    const std::uint16_t planes{1U}; // The number of planes for the target device. This value must be set to 1.
    const std::uint16_t bitCount{24U}; // The number of bits that define each pixel and the maximum number of colors in the bitmap.
    const std::uint32_t compression{0U}; // Specifies the bitmap compression type.
    const std::uint32_t imageSize{(((width * 3U) + padding) & 0x0000FFFC) * height}; // The size of the image in bytes.
    const std::uint32_t xPelsPerMeter{0U}; // The horizontal resolution in pixels-per-meter.
    const std::uint32_t yPelsPerMeter{0U}; // The vertical resolution in pixels-per-meter.
    const std::uint32_t colorsUsed{0U}; // The number of color indexes in the color table actually used by the bitmap.
    const std::uint32_t colorsImportant{0U}; // The number of color indexes required for displaying the bitmap. If zero, all colors are required.
 
    // Bitmap File Header
    const std::uint16_t type{19778U}; // The file type.
    const std::uint32_t fhSize{BITMAP_INFORMATION_HEADER_SIZE + BITMAP_FILE_HEADER_SIZE + imageSize}; // The size in bytes of the bitmap file.
    const std::uint16_t reserved1{0U}; // Reserved, must be zero.
    const std::uint16_t reserved2{0U}; // Reserved, must be zero.
    const std::uint32_t offbits{BITMAP_INFORMATION_HEADER_SIZE + BITMAP_FILE_HEADER_SIZE}; // The offset, in bytes, from the beginning of the BitmapFileHeader structure to the bitmap bits.
 
    writeToStream(stream, type);
    writeToStream(stream, fhSize);
    writeToStream(stream, reserved1);
    writeToStream(stream, reserved2);
    writeToStream(stream, offbits);
 
    writeToStream(stream, ifSize);
    writeToStream(stream, width);
    writeToStream(stream, height);
    writeToStream(stream, planes);
    writeToStream(stream, bitCount);
    writeToStream(stream, compression);
    writeToStream(stream, imageSize);
    writeToStream(stream, xPelsPerMeter);
    writeToStream(stream, yPelsPerMeter);
    writeToStream(stream, colorsUsed);
    writeToStream(stream, colorsImportant);
 
    // Bitmap Image Data
    for(std::uint32_t y = 0U; y < bitmapData.getHeight(); y++) {
        for(std::uint32_t x = 0U; x < bitmapData.getWidth(); x++) {
            const geometrize::rgba pixel(bitmapData.getPixel(x, y));
            writeToStream(stream, pixel.b);
            writeToStream(stream, pixel.g);
            writeToStream(stream, pixel.r);
        }
        for (std::uint32_t pad = 0U; pad < padding; pad++) {
            const std::uint8_t zeroPad{0U};
            writeToStream(stream, zeroPad);
        }
    }
 
    return stream.str();
}

Here is the call graph for this function:

exportShapeArray()

std::string geometrize::exporter::exportShapeArray

(

const std::vector< geometrize::ShapeResult > &

data

)

exportShapeArray Exports shape data to a compact array-style format. Data is three lines per shape, each line: shapeEnumTypeId shapeData R,G,B,A

Parameters

data	The shape data to export.

Returns

A string containing the exported data.

{
    std::ostringstream stream;
 
    for(std::size_t i = 0; i < data.size(); i++) {
        const geometrize::ShapeResult& s(data[i]);
 
        stream << static_cast<std::underlying_type<geometrize::ShapeTypes>::type>(s.shape->getType()) << "\n";
 
        const std::vector<float> shapeData{getRawShapeData(*s.shape.get())};
        for(std::size_t d = 0; d < shapeData.size(); d++) {
            stream << shapeData[d];
            if(d != (shapeData.size() - 1U)) {
                stream << ",";
            }
        }
        stream << "\n";
 
        stream << static_cast<std::uint32_t>(s.color.r) << ","
               << static_cast<std::uint32_t>(s.color.g) << ","
               << static_cast<std::uint32_t>(s.color.b) << ","
               << static_cast<std::uint32_t>(s.color.a);
 
        if(i != (data.size() - 1U)) {
            stream << "\n";
        }
    }
 
    return stream.str();
}

Here is the call graph for this function:

exportShapeJson()

std::string geometrize::exporter::exportShapeJson

(

const std::vector< geometrize::ShapeResult > &

data

)

exportShapeJson Exports shape data to JSON.

Parameters

data	The shape data to export.

Returns

A string containing the exported JSON.

{
    std::ostringstream stream;
    stream << "{\"shapes\":\n[";
 
    for(std::size_t i = 0; i < data.size(); i++) {
        const geometrize::ShapeResult& s(data[i]);
        const geometrize::ShapeTypes type{s.shape->getType()};
        const std::vector<float> shapeData{getRawShapeData(*s.shape.get())};
        const geometrize::rgba color(s.color);
        const double score{s.score};
 
        stream << "{" << "\"type\":" << static_cast<std::underlying_type<geometrize::ShapeTypes>::type>(type) << ", \"data\":[";
        for(std::size_t d = 0; d < shapeData.size(); d++) {
            stream << shapeData[d];
            if(d <= shapeData.size() - 2) {
                stream << ",";
            }
        }
        stream << "],\"color\":[" << static_cast<std::uint32_t>(color.r) << "," << static_cast<std::uint32_t>(color.g) << "," << static_cast<std::uint32_t>(color.b) << "," << static_cast<std::uint32_t>(color.a) << "],";
        stream << "\"score\":" << score << "}";
 
        if(i <= data.size() - 2) {
            stream << ",\n";
        }
    }
 
    stream << "\n]}";
    return stream.str();
}

Here is the call graph for this function:

exportSingleShapeSVG()

std::string geometrize::exporter::exportSingleShapeSVG	(	const geometrize::rgba &	color,
		const geometrize::Shape &	shape,
		const std::uint32_t	width,
		const std::uint32_t	height,
		SVGExportOptions	options = SVGExportOptions{}
	)

exportSVG Exports a single shape as a complete SVG image.

Parameters

color	The color of the shape to export.
shape	The shape to export.
width	The width of the SVG image.
height	The height of the SVG image.
options	additional options used by the exporter.

Returns

A string representing the SVG image.

{
    std::stringstream stream;
 
    stream << "<?xml version=\"1.0\" standalone=\"no\"?>" << "\n";
    stream << "<svg xmlns=\"https://www.w3.org/2000/svg\" version=\"1.2\" baseProfile=\"tiny\" " <<
              "width=\"" << width << "\" " << "height=\"" << height << "\" " <<
              "viewBox=\"" << 0 << " " << 0 << " " << width << " " << height << "\">" << "\n";
 
    stream << ::getSingleShapeSVGData(color, shape, options);
 
    stream << "</svg>";
 
    return stream.str();
}

Here is the call graph for this function:

exportSVG()

std::string geometrize::exporter::exportSVG	(	const std::vector< geometrize::ShapeResult > &	data,
		const std::uint32_t	width,
		const std::uint32_t	height,
		SVGExportOptions	options = SVGExportOptions{}
	)

exportSVG Exports shape data as a complete SVG image.

Parameters

data	The shape data to export.
width	The width of the SVG image.
height	The height of the SVG image.
options	additional options used by the exporter.

Returns

A string representing the SVG image.

{
    std::stringstream stream;
 
    stream << "<?xml version=\"1.0\" standalone=\"no\"?>" << "\n";
    stream << "<svg xmlns=\"https://www.w3.org/2000/svg\" version=\"1.2\" baseProfile=\"tiny\" " <<
              "width=\"" << width << "\" " << "height=\"" << height << "\" " <<
              "viewBox=\"" << 0 << " " << 0 << " " << width << " " << height << "\">" << "\n";
 
    for(std::size_t i = 0; i < data.size(); i++) {
        options.itemId = i;
 
        const geometrize::ShapeResult& s(data[i]);
 
        stream << ::getSingleShapeSVGData(s.color, *(s.shape), options);
    }
 
    stream << "</svg>";
 
    return stream.str();
}

Here is the call graph for this function:

flip16()

std::uint16_t geometrize::exporter::flip16 ( const std::uint16_t &  v )

inline

{
    return (v >> 8) | (v << 8);
}

Here is the caller graph for this function:

flip32()

std::uint32_t geometrize::exporter::flip32 ( const std::uint32_t &  v )

inline

{
    return (v & 0xFF000000) >> 0x18 | (v & 0x000000FF) << 0x18 | (v & 0x00FF0000) >> 0x08 | (v & 0x0000FF00) << 0x08;
}

Here is the caller graph for this function:

getSingleShapeSVGData()

std::string geometrize::exporter::getSingleShapeSVGData	(	const geometrize::rgba &	color,
		const geometrize::Shape &	shape,
		SVGExportOptions	options = SVGExportOptions{}
	)

getSvgShapeData Gets the SVG data for a single shape. This is just the <rect>/<path> etc block for the shape itself, not a complete SVG image.

Parameters

color	The color of the shape.
shape	The shape to convert to SVG data.
options	additional options used by the exporter.

Returns

The SVG shape data for the given shape.

{
    return ::getSingleShapeSVGData(color, shape, options);
}

Here is the call graph for this function:

Here is the caller graph for this function:

writeToStream() [1/3]

void geometrize::exporter::writeToStream ( std::ostringstream &  stream, const std::uint16_t &  t  )

inline

{
    if(bigEndian()) {
        const std::uint16_t flipped{flip16(t)};
        stream.write(reinterpret_cast<const char*>(&flipped), sizeof(std::uint16_t));
    } else {
        stream.write(reinterpret_cast<const char*>(&t), sizeof(std::uint16_t));
    }
}

Here is the call graph for this function:

writeToStream() [2/3]

void geometrize::exporter::writeToStream ( std::ostringstream &  stream, const std::uint32_t &  t  )

inline

{
    if(bigEndian()) {
        const std::uint32_t flipped{flip32(t)};
        stream.write(reinterpret_cast<const char*>(&flipped), sizeof(std::uint32_t));
    } else {
        stream.write(reinterpret_cast<const char*>(&t), sizeof(std::uint32_t));
    }
}

Here is the call graph for this function:

writeToStream() [3/3]

void geometrize::exporter::writeToStream ( std::ostringstream &  stream, const std::uint8_t &  t  )

inline

{
    stream.write(reinterpret_cast<const char*>(&t), sizeof(std::uint8_t));
}

Here is the caller graph for this function:

Variable Documentation

SVG_STYLE_HOOK

const std::string geometrize::exporter::SVG_STYLE_HOOK = "::svg_style_hook::"

static

SVG_STYLE_HOOK A hook that an SVG exporter should use to augment shape styling produced by the getSvgShapeData method.