geometrize Namespace Reference

Namespaces
namespace	commonutil
namespace	core
namespace	exporter

Classes
class	Bitmap
	The Bitmap class is a helper class for working with bitmap data. More...
class	Circle
	The Circle class represents a circle. More...
class	Ellipse
	The Ellipse class represents an ellipse. More...
class	ImageRunner
	The ImageRunner class is a helper class for creating a set of primitives from a source image. More...
class	ImageRunnerOptions
	The ImageRunnerOptions class encapsulates preferences/options that the image runner uses. More...
struct	ImageRunnerShapeBoundsOptions
	The ImageRunnerShapeBoundsOptions struct encapsulates options for where shapes may be drawn within the image. Defines a rectangle expressed as percentages (0-100%) of the target image dimensions. More...
class	Line
	The Line class represents a simple line. More...
class	Model
	The Model class is the model for the core optimization/fitting algorithm. More...
class	Polyline
	The Polyline class represents a polyline. More...
class	QuadraticBezier
	The QuadraticBezier class represents a quadratic bezier curve. More...
class	Rectangle
	The Rectangle class represents a rectangle. More...
struct	rgba
	The rgba struct is a helper for manipulating RGBA8888 color data. More...
class	RotatedEllipse
	The RotatedEllipse class represents a rotated ellipse. More...
class	RotatedRectangle
	The RotatedRectangle class represents a rotated rectangle. More...
class	Scanline
	The Scanline class represents a scanline, a row of pixels running across a bitmap. More...
class	Shape
struct	ShapeResult
	The ShapeResult struct is a container for info about a shape added to the model. More...
class	State
	The State class relates a shape and related properties to a measure of how close it brings the working image to the target image. More...
class	Triangle
	The Triangle class represents a triangle. More...

Typedefs
using	ShapeAcceptancePreconditionFunction = std::function< bool(double lastScore, double newScore, const geometrize::Shape &shape, const std::vector< geometrize::Scanline > &lines, const geometrize::rgba &color, const geometrize::Bitmap &before, const geometrize::Bitmap &after, const geometrize::Bitmap &target)>
	ShapeAcceptancePreconditionFunction Type alias for a function that is used to decide whether or not to finally add a shape to the image. More...

Enumerations
enum	ShapeTypes : std::uint32_t {   RECTANGLE = 1U , ROTATED_RECTANGLE = 2U , TRIANGLE = 4U , ELLIPSE = 8U ,   ROTATED_ELLIPSE = 16U , CIRCLE = 32U , LINE = 64U , QUADRATIC_BEZIER = 128U ,   POLYLINE = 256U , SHAPE_COUNT = 9U }
	The ShapeTypes enum specifies the types of shapes that can be used. These can be combined to produce images composed of multiple primitive types. More...

Functions
bool	operator== (const geometrize::rgba &lhs, const geometrize::rgba &rhs)
bool	operator!= (const geometrize::rgba &lhs, const geometrize::rgba &rhs)
std::vector< float >	getRawShapeData (const geometrize::Shape &s)
std::vector< float >	getRawShapeData (const geometrize::Circle &s)
std::vector< float >	getRawShapeData (const geometrize::Ellipse &s)
std::vector< float >	getRawShapeData (const geometrize::Line &s)
std::vector< float >	getRawShapeData (const geometrize::Polyline &s)
std::vector< float >	getRawShapeData (const geometrize::QuadraticBezier &s)
std::vector< float >	getRawShapeData (const geometrize::Rectangle &s)
std::vector< float >	getRawShapeData (const geometrize::RotatedEllipse &s)
std::vector< float >	getRawShapeData (const geometrize::RotatedRectangle &s)
std::vector< float >	getRawShapeData (const geometrize::Triangle &s)
std::vector< std::pair< float, float > >	getCornerPoints (const geometrize::RotatedRectangle &r)
	getCornerPoints Gets the corner points of the given rotated rectangle. More...
std::vector< std::pair< float, float > >	getPointsOnRotatedEllipse (const geometrize::RotatedEllipse &e, std::size_t numPoints)
	getPointsOnRotatedEllipse Calculates and returns a number of points on the given rotated ellipse. More...
void	drawLines (geometrize::Bitmap &image, geometrize::rgba color, const std::vector< geometrize::Scanline > &lines)
	drawLines Draws scanlines onto an image. More...
void	copyLines (geometrize::Bitmap &destination, const geometrize::Bitmap &source, const std::vector< geometrize::Scanline > &lines)
	copyLines Copies source pixels to a destination defined by a set of scanlines. More...
std::vector< std::pair< std::int32_t, std::int32_t > >	bresenham (std::int32_t x1, std::int32_t y1, std::int32_t x2, std::int32_t y2)
	bresenham Bresenham's line algorithm. Returns the points on the line. More...
std::vector< geometrize::Scanline >	scanlinesForPolygon (const std::vector< std::pair< float, float > > &points)
	scanlinesForPolygon Gets the scanlines for a series of points that make up an arbitrary polygon. More...
std::vector< geometrize::Scanline >	rasterize (const geometrize::Shape &s, std::int32_t xMin, std::int32_t yMin, std::int32_t xMax, std::int32_t yMax)
std::vector< geometrize::Scanline >	rasterize (const geometrize::Circle &s, const std::int32_t xMin, const std::int32_t yMin, const std::int32_t xMax, const std::int32_t yMax)
std::vector< geometrize::Scanline >	rasterize (const geometrize::Ellipse &s, const std::int32_t xMin, const std::int32_t yMin, const std::int32_t xMax, const std::int32_t yMax)
std::vector< geometrize::Scanline >	rasterize (const geometrize::Line &s, const std::int32_t xMin, const std::int32_t yMin, const std::int32_t xMax, const std::int32_t yMax)
std::vector< geometrize::Scanline >	rasterize (const geometrize::Polyline &s, const std::int32_t xMin, const std::int32_t yMin, const std::int32_t xMax, const std::int32_t yMax)
std::vector< geometrize::Scanline >	rasterize (const geometrize::QuadraticBezier &s, const std::int32_t xMin, const std::int32_t yMin, const std::int32_t xMax, const std::int32_t yMax)
std::vector< geometrize::Scanline >	rasterize (const geometrize::Rectangle &s, const std::int32_t xMin, const std::int32_t yMin, const std::int32_t xMax, const std::int32_t yMax)
std::vector< geometrize::Scanline >	rasterize (const geometrize::RotatedEllipse &s, const std::int32_t xMin, const std::int32_t yMin, const std::int32_t xMax, const std::int32_t yMax)
std::vector< geometrize::Scanline >	rasterize (const geometrize::RotatedRectangle &s, const std::int32_t xMin, const std::int32_t yMin, const std::int32_t xMax, const std::int32_t yMax)
std::vector< geometrize::Scanline >	rasterize (const geometrize::Triangle &s, const std::int32_t xMin, const std::int32_t yMin, const std::int32_t xMax, const std::int32_t yMax)
bool	scanlinesOverlap (const std::vector< geometrize::Scanline > &first, const std::vector< geometrize::Scanline > &second)
	scanlinesOverlap Returns true if any of the scanlines from the first vector overlap the second More...
bool	scanlinesContain (const std::vector< geometrize::Scanline > &first, const std::vector< geometrize::Scanline > &second)
	scanlinesContain Returns true if the first vector of scanlines wholly contain the second vector of scanlines. More...
bool	shapesOverlap (const geometrize::Shape &a, const geometrize::Shape &b, const std::int32_t xMin, const std::int32_t yMin, const std::int32_t xMax, const std::int32_t yMax)
bool	shapeContains (const geometrize::Shape &container, const geometrize::Shape &containee, const std::int32_t xMin, const std::int32_t yMin, const std::int32_t xMax, const std::int32_t yMax)
std::vector< std::pair< std::int32_t, std::int32_t > >	shapeToPixels (const geometrize::Shape &shape, const std::int32_t xMin, const std::int32_t yMin, const std::int32_t xMax, const std::int32_t yMax)
bool	operator== (const geometrize::Scanline &lhs, const geometrize::Scanline &rhs)
bool	operator!= (const geometrize::Scanline &lhs, const geometrize::Scanline &rhs)
std::vector< geometrize::Scanline >	trimScanlines (const std::vector< geometrize::Scanline > &scanlines, std::int32_t minX, std::int32_t minY, std::int32_t maxX, std::int32_t maxY)
	trimScanlines Crops the scanning width of an array of scanlines so they do not scan outside of the given area. More...
std::function< std::shared_ptr< geometrize::Shape >()>	createDefaultShapeCreator (geometrize::ShapeTypes types, std::int32_t xMin, std::int32_t yMin, std::int32_t xMax, std::int32_t yMax)
	createDefaultShapeCreator Creates an instance of the default shape creator object. The setup, mutate and rasterize methods are bound with default methods. More...
std::shared_ptr< geometrize::Shape >	create (geometrize::ShapeTypes t)
	create Creates a new shape of the specified type. More...
std::shared_ptr< geometrize::Shape >	randomShape ()
	randomShape Creates a random shape. More...
std::shared_ptr< geometrize::Shape >	randomShapeOf (geometrize::ShapeTypes t)
	randomShapeOf Creates a random shape from the types supplied. More...
void	setup (geometrize::Shape &s, const std::int32_t xMin, const std::int32_t yMin, const std::int32_t xMax, const std::int32_t yMax)
void	setup (geometrize::Circle &s, const std::int32_t xMin, const std::int32_t yMin, const std::int32_t xMax, const std::int32_t yMax)
void	setup (geometrize::Ellipse &s, const std::int32_t xMin, const std::int32_t yMin, const std::int32_t xMax, const std::int32_t yMax)
void	setup (geometrize::Line &s, const std::int32_t xMin, const std::int32_t yMin, const std::int32_t xMax, const std::int32_t yMax)
void	setup (geometrize::Polyline &s, const std::int32_t xMin, const std::int32_t yMin, const std::int32_t xMax, const std::int32_t yMax)
void	setup (geometrize::QuadraticBezier &s, const std::int32_t xMin, const std::int32_t yMin, const std::int32_t xMax, const std::int32_t yMax)
void	setup (geometrize::Rectangle &s, const std::int32_t xMin, const std::int32_t yMin, const std::int32_t xMax, const std::int32_t yMax)
void	setup (geometrize::RotatedEllipse &s, const std::int32_t xMin, const std::int32_t yMin, const std::int32_t xMax, const std::int32_t yMax)
void	setup (geometrize::RotatedRectangle &s, const std::int32_t xMin, const std::int32_t yMin, const std::int32_t xMax, const std::int32_t yMax)
void	setup (geometrize::Triangle &s, const std::int32_t xMin, const std::int32_t yMin, const std::int32_t xMax, const std::int32_t yMax)
void	mutate (geometrize::Shape &s, const std::int32_t xMin, const std::int32_t yMin, const std::int32_t xMax, const std::int32_t yMax)
void	mutate (geometrize::Circle &s, const std::int32_t xMin, const std::int32_t yMin, const std::int32_t xMax, const std::int32_t yMax)
void	mutate (geometrize::Ellipse &s, const std::int32_t xMin, const std::int32_t yMin, const std::int32_t xMax, const std::int32_t yMax)
void	mutate (geometrize::Line &s, const std::int32_t xMin, const std::int32_t yMin, const std::int32_t xMax, const std::int32_t yMax)
void	mutate (geometrize::Polyline &s, const std::int32_t xMin, const std::int32_t yMin, const std::int32_t xMax, const std::int32_t yMax)
void	mutate (geometrize::QuadraticBezier &s, const std::int32_t xMin, const std::int32_t yMin, const std::int32_t xMax, const std::int32_t yMax)
void	mutate (geometrize::Rectangle &s, const std::int32_t xMin, const std::int32_t yMin, const std::int32_t xMax, const std::int32_t yMax)
void	mutate (geometrize::RotatedEllipse &s, const std::int32_t xMin, const std::int32_t yMin, const std::int32_t xMax, const std::int32_t yMax)
void	mutate (geometrize::RotatedRectangle &s, const std::int32_t xMin, const std::int32_t yMin, const std::int32_t xMax, const std::int32_t yMax)
void	mutate (geometrize::Triangle &s, const std::int32_t xMin, const std::int32_t yMin, const std::int32_t xMax, const std::int32_t yMax)
void	translate (geometrize::Shape &s, const float x, const float y)
void	translate (geometrize::Circle &s, const float x, const float y)
void	translate (geometrize::Ellipse &s, const float x, const float y)
void	translate (geometrize::Line &s, const float x, const float y)
void	translate (geometrize::Polyline &s, const float x, const float y)
void	translate (geometrize::QuadraticBezier &s, const float x, const float y)
void	translate (geometrize::Rectangle &s, const float x, const float y)
void	translate (geometrize::RotatedEllipse &s, const float x, const float y)
void	translate (geometrize::RotatedRectangle &s, const float x, const float y)
void	translate (geometrize::Triangle &s, const float x, const float y)
void	scale (geometrize::Shape &s, const float scaleFactor)
void	scale (geometrize::Circle &s, const float scaleFactor)
void	scale (geometrize::Ellipse &s, const float scaleFactor)
void	scale (geometrize::Line &s, const float scaleFactor)
void	scale (geometrize::Polyline &s, const float scaleFactor)
void	scale (geometrize::QuadraticBezier &s, const float scaleFactor)
void	scale (geometrize::Rectangle &s, const float scaleFactor)
void	scale (geometrize::RotatedEllipse &s, const float scaleFactor)
void	scale (geometrize::RotatedRectangle &s, const float scaleFactor)
void	scale (geometrize::Triangle &s, const float scaleFactor)
void	rotate (geometrize::Shape &s, const float angle)
void	rotate (geometrize::Line &s, const float angle)
void	rotate (geometrize::RotatedEllipse &s, const float angle)
void	rotate (geometrize::RotatedRectangle &s, const float angle)
void	rotate (geometrize::Triangle &s, const float angle)

Variables
const std::array< ShapeTypes, static_cast< std::size_t >(ShapeTypes::SHAPE_COUNT)>	allShapes
	allShapes is a convenient array of all of the members of ShapeTypes. More...
const std::vector< std::pair< ShapeTypes, std::string > >	shapeTypeNames
	shapeTypeNames provides a convenient mapping to names of types of shape (all lower case, underscores instead of spaces e.g. rotated_ellipse). More...

Typedef Documentation

ShapeAcceptancePreconditionFunction

using geometrize::ShapeAcceptancePreconditionFunction = typedef std::function<bool( double lastScore, double newScore, const geometrize::Shape& shape, const std::vector<geometrize::Scanline>& lines, const geometrize::rgba& color, const geometrize::Bitmap& before, const geometrize::Bitmap& after, const geometrize::Bitmap& target)>

ShapeAcceptancePreconditionFunction Type alias for a function that is used to decide whether or not to finally add a shape to the image.

Parameters

lastScore	The image similarity score prior to adding the shape
newScore	What the image similarity score would be after adding the shape
shape	The shape that this function shall decide whether to add
lines	The scanlines for the pixels in the shape
color	The colour of the shape
before	The image prior to adding the shape
after	The image as it would be after adding the shape
target	The image that we are trying to replicate

Returns

True to add the shape to the image, false not to

Enumeration Type Documentation

ShapeTypes

enum geometrize::ShapeTypes : std::uint32_t

The ShapeTypes enum specifies the types of shapes that can be used. These can be combined to produce images composed of multiple primitive types.

Author

Sam Twidale (https://samcodes.co.uk/)

Enumerator
RECTANGLE
ROTATED_RECTANGLE
TRIANGLE
ELLIPSE
ROTATED_ELLIPSE
CIRCLE
LINE
QUADRATIC_BEZIER
POLYLINE
SHAPE_COUNT

{
    RECTANGLE = 1U,
    ROTATED_RECTANGLE = 2U,
    TRIANGLE = 4U,
    ELLIPSE = 8U,
    ROTATED_ELLIPSE = 16U,
    CIRCLE = 32U,
    LINE = 64U,
    QUADRATIC_BEZIER = 128U,
    POLYLINE = 256U,
    SHAPE_COUNT = 9U
};

Function Documentation

bresenham()

std::vector< std::pair< std::int32_t, std::int32_t > > geometrize::bresenham	(	std::int32_t	x1,
		std::int32_t	y1,
		std::int32_t	x2,
		std::int32_t	y2
	)

bresenham Bresenham's line algorithm. Returns the points on the line.

Parameters

x1	The start x-coordinate.
y1	The start y-coordinate.
x2	The end x-coordinate.
y2	The end y-coordinate.

Returns

The points on the resulting line.

{
    std::int32_t dx{x2 - x1};
    const std::int8_t ix{static_cast<std::int8_t>((dx > 0) - (dx < 0))};
    dx = std::abs(dx) << 1;
 
    std::int32_t dy{y2 - y1};
    const std::int8_t iy{static_cast<std::int8_t>((dy > 0) - (dy < 0))};
    dy = std::abs(dy) << 1;
 
    std::vector<std::pair<std::int32_t, std::int32_t>> points;
    points.push_back(std::make_pair(x1, y1));
 
    if (dx >= dy) {
        std::int32_t error(dy - (dx >> 1));
        while (x1 != x2) {
            if (error >= 0 && (error || (ix > 0))) {
                error -= dx;
                y1 += iy;
            }
 
            error += dy;
            x1 += ix;
 
            points.push_back(std::make_pair(x1, y1));
        }
    } else {
        std::int32_t error(dx - (dy >> 1));
        while (y1 != y2) {
            if (error >= 0 && (error || (iy > 0))) {
                error -= dy;
                x1 += ix;
            }
 
            error += dx;
            y1 += iy;
 
            points.push_back(std::make_pair(x1, y1));
        }
    }
 
    return points;
}

Here is the caller graph for this function:

copyLines()

void geometrize::copyLines	(	geometrize::Bitmap &	destination,
		const geometrize::Bitmap &	source,
		const std::vector< geometrize::Scanline > &	lines
	)

copyLines Copies source pixels to a destination defined by a set of scanlines.

Parameters

destination	The destination bitmap to copy the lines to.
source	The source bitmap to copy the lines from.
lines	The scanlines that comprise the source to destination copying mask.

{
    for(const geometrize::Scanline& line : lines) {
        const std::int32_t y{line.y};
        for(std::int32_t x = line.x1; x <= line.x2; x++) {
            destination.setPixel(x, y, source.getPixel(x, y));
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

create()

std::shared_ptr< geometrize::Shape > geometrize::create

(

geometrize::ShapeTypes

t

)

create Creates a new shape of the specified type.

Parameters

t	The type of shape to create.

Returns

The new shape.

{
    switch(t) {
        case geometrize::ShapeTypes::POLYLINE:
            return std::make_shared<geometrize::Polyline>();
        case geometrize::ShapeTypes::QUADRATIC_BEZIER:
            return std::make_shared<geometrize::QuadraticBezier>();
        case geometrize::ShapeTypes::CIRCLE:
            return std::make_shared<geometrize::Circle>();
        case geometrize::ShapeTypes::ELLIPSE:
            return std::make_shared<geometrize::Ellipse>();
        case geometrize::ShapeTypes::ROTATED_ELLIPSE:
            return std::make_shared<geometrize::RotatedEllipse>();
        case geometrize::ShapeTypes::ROTATED_RECTANGLE:
            return std::make_shared<geometrize::RotatedRectangle>();
        case geometrize::ShapeTypes::TRIANGLE:
            return std::make_shared<geometrize::Triangle>();
        case geometrize::ShapeTypes::RECTANGLE:
            return std::make_shared<geometrize::Rectangle>();
        case geometrize::ShapeTypes::LINE:
            return std::make_shared<geometrize::Line>();
        default:
            assert(0 && "Bad shape type specified");
    };
 
    assert(0 && "Unhandled shape type encountered");
    return std::make_shared<geometrize::Rectangle>();
}

Here is the caller graph for this function:

createDefaultShapeCreator()

std::function< std::shared_ptr< geometrize::Shape >()> geometrize::createDefaultShapeCreator	(	geometrize::ShapeTypes	types,
		std::int32_t	xMin,
		std::int32_t	yMin,
		std::int32_t	xMax,
		std::int32_t	yMax
	)

createDefaultShapeCreator Creates an instance of the default shape creator object. The setup, mutate and rasterize methods are bound with default methods.

Parameters

types	The types of shapes to create.
xMin	The minimum x coordinate of the shapes created.
yMin	The minimum y coordinate of the shapes created.
xMax	The maximum x coordinate of the shapes created.
yMax	The maximum y coordinate of the shapes created.

Returns

The default shape creator.

{
    auto f = [types, xMin, yMin, xMax, yMax]() {
        std::shared_ptr<geometrize::Shape> s = geometrize::randomShapeOf(types);
 
        switch(s->getType()) {
        case geometrize::ShapeTypes::RECTANGLE: {
            s->setup = [xMin, yMin, xMax, yMax](geometrize::Shape& s) { return geometrize::setup(static_cast<geometrize::Rectangle&>(s), xMin, yMin, xMax, yMax); };
            s->mutate = [xMin, yMin, xMax, yMax](geometrize::Shape& s) { geometrize::mutate(static_cast<geometrize::Rectangle&>(s), xMin, yMin, xMax, yMax); };
            s->rasterize = [xMin, yMin, xMax, yMax](const geometrize::Shape& s) { return geometrize::rasterize(static_cast<const geometrize::Rectangle&>(s), xMin, yMin, xMax, yMax); };
            break;
        }
        case geometrize::ShapeTypes::ROTATED_RECTANGLE: {
            s->setup = [xMin, yMin, xMax, yMax](geometrize::Shape& s) { return geometrize::setup(static_cast<geometrize::RotatedRectangle&>(s), xMin, yMin, xMax, yMax); };
            s->mutate = [xMin, yMin, xMax, yMax](geometrize::Shape& s) { geometrize::mutate(static_cast<geometrize::RotatedRectangle&>(s), xMin, yMin, xMax, yMax); };
            s->rasterize = [xMin, yMin, xMax, yMax](const geometrize::Shape& s) { return geometrize::rasterize(static_cast<const geometrize::RotatedRectangle&>(s), xMin, yMin, xMax, yMax); };
            break;
        }
        case geometrize::ShapeTypes::TRIANGLE: {
            s->setup = [xMin, yMin, xMax, yMax](geometrize::Shape& s) { return geometrize::setup(static_cast<geometrize::Triangle&>(s), xMin, yMin, xMax, yMax); };
            s->mutate = [xMin, yMin, xMax, yMax](geometrize::Shape& s) { geometrize::mutate(static_cast<geometrize::Triangle&>(s), xMin, yMin, xMax, yMax); };
            s->rasterize = [xMin, yMin, xMax, yMax](const geometrize::Shape& s) { return geometrize::rasterize(static_cast<const geometrize::Triangle&>(s), xMin, yMin, xMax, yMax); };
            break;
        }
        case geometrize::ShapeTypes::ELLIPSE: {
            s->setup = [xMin, yMin, xMax, yMax](geometrize::Shape& s) { return geometrize::setup(static_cast<geometrize::Ellipse&>(s), xMin, yMin, xMax, yMax); };
            s->mutate = [xMin, yMin, xMax, yMax](geometrize::Shape& s) { geometrize::mutate(static_cast<geometrize::Ellipse&>(s), xMin, yMin, xMax, yMax); };
            s->rasterize = [xMin, yMin, xMax, yMax](const geometrize::Shape& s) { return geometrize::rasterize(static_cast<const geometrize::Ellipse&>(s), xMin, yMin, xMax, yMax); };
            break;
        }
        case geometrize::ShapeTypes::ROTATED_ELLIPSE: {
            s->setup = [xMin, yMin, xMax, yMax](geometrize::Shape& s) { return geometrize::setup(static_cast<geometrize::RotatedEllipse&>(s), xMin, yMin, xMax, yMax); };
            s->mutate = [xMin, yMin, xMax, yMax](geometrize::Shape& s) { geometrize::mutate(static_cast<geometrize::RotatedEllipse&>(s), xMin, yMin, xMax, yMax); };
            s->rasterize = [xMin, yMin, xMax, yMax](const geometrize::Shape& s) { return geometrize::rasterize(static_cast<const geometrize::RotatedEllipse&>(s), xMin, yMin, xMax, yMax); };
            break;
        }
        case geometrize::ShapeTypes::CIRCLE: {
            s->setup = [xMin, yMin, xMax, yMax](geometrize::Shape& s) { return geometrize::setup(static_cast<geometrize::Circle&>(s), xMin, yMin, xMax, yMax); };
            s->mutate = [xMin, yMin, xMax, yMax](geometrize::Shape& s) { geometrize::mutate(static_cast<geometrize::Circle&>(s), xMin, yMin, xMax, yMax); };
            s->rasterize = [xMin, yMin, xMax, yMax](const geometrize::Shape& s) { return geometrize::rasterize(static_cast<const geometrize::Circle&>(s), xMin, yMin, xMax, yMax); };
            break;
        }
        case geometrize::ShapeTypes::LINE: {
            s->setup = [xMin, yMin, xMax, yMax](geometrize::Shape& s) { return geometrize::setup(static_cast<geometrize::Line&>(s), xMin, yMin, xMax, yMax); };
            s->mutate = [xMin, yMin, xMax, yMax](geometrize::Shape& s) { geometrize::mutate(static_cast<geometrize::Line&>(s), xMin, yMin, xMax, yMax); };
            s->rasterize = [xMin, yMin, xMax, yMax](const geometrize::Shape& s) { return geometrize::rasterize(static_cast<const geometrize::Line&>(s), xMin, yMin, xMax, yMax); };
            break;
        }
        case geometrize::ShapeTypes::QUADRATIC_BEZIER: {
            s->setup = [xMin, yMin, xMax, yMax](geometrize::Shape& s) { return geometrize::setup(static_cast<geometrize::QuadraticBezier&>(s), xMin, yMin, xMax, yMax); };
            s->mutate = [xMin, yMin, xMax, yMax](geometrize::Shape& s) { geometrize::mutate(static_cast<geometrize::QuadraticBezier&>(s), xMin, yMin, xMax, yMax); };
            s->rasterize = [xMin, yMin, xMax, yMax](const geometrize::Shape& s) { return geometrize::rasterize(static_cast<const geometrize::QuadraticBezier&>(s), xMin, yMin, xMax, yMax); };
            break;
        }
        case geometrize::ShapeTypes::POLYLINE: {
            s->setup = [xMin, yMin, xMax, yMax](geometrize::Shape& s) { return geometrize::setup(static_cast<geometrize::Polyline&>(s), xMin, yMin, xMax, yMax); };
            s->mutate = [xMin, yMin, xMax, yMax](geometrize::Shape& s) { geometrize::mutate(static_cast<geometrize::Polyline&>(s), xMin, yMin, xMax, yMax); };
            s->rasterize = [xMin, yMin, xMax, yMax](const geometrize::Shape& s) { return geometrize::rasterize(static_cast<const geometrize::Polyline&>(s), xMin, yMin, xMax, yMax); };
            break;
        }
        default:
            assert(0 && "Bad shape type");
        }
 
        return s;
    };
 
    return f;
}

Here is the call graph for this function:

Here is the caller graph for this function:

drawLines()

void geometrize::drawLines	(	geometrize::Bitmap &	image,
		geometrize::rgba	color,
		const std::vector< geometrize::Scanline > &	lines
	)

drawLines Draws scanlines onto an image.

Parameters

image	The image to be drawn to.
color	The color of the scanlines.
lines	The scanlines to draw.

{
    // Convert the non-premultiplied color to alpha-premultiplied 16-bits per channel RGBA
    // In other words, scale the rgb color components by the alpha component
    std::uint32_t sr{color.r};
    sr |= sr << 8;
    sr *= color.a;
    sr /= UINT8_MAX;
    std::uint32_t sg{color.g};
    sg |= sg << 8;
    sg *= color.a;
    sg /= UINT8_MAX;
    std::uint32_t sb{color.b};
    sb |= sb << 8;
    sb *= color.a;
    sb /= UINT8_MAX;
    std::uint32_t sa{color.a};
    sa |= sa << 8;
 
    const std::uint32_t m{UINT16_MAX};
    const std::uint32_t aa{(m - sa) * 257U};
 
    for(const geometrize::Scanline& line : lines) {
        const std::int32_t y{line.y};
 
        for(std::int32_t x = line.x1; x <= line.x2; x++) {
            const geometrize::rgba d(image.getPixel(x, y));
 
            const std::uint8_t r{static_cast<std::uint8_t>(((d.r * aa + sr * m) / m) >> 8)};
            const std::uint8_t g{static_cast<std::uint8_t>(((d.g * aa + sg * m) / m) >> 8)};
            const std::uint8_t b{static_cast<std::uint8_t>(((d.b * aa + sb * m) / m) >> 8)};
            const std::uint8_t a{static_cast<std::uint8_t>(((d.a * aa + sa * m) / m) >> 8)};
 
            image.setPixel(x, y, geometrize::rgba{r, g, b, a});
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

getCornerPoints()

std::vector< std::pair< float, float > > geometrize::getCornerPoints

(

const geometrize::RotatedRectangle &

r

)

getCornerPoints Gets the corner points of the given rotated rectangle.

Parameters

r	The rotated rectangle.

Returns

The corner points of the rotated rectangle.

{
    const float x1{(std::fmin)(r.m_x1, r.m_x2)};
    const float x2{(std::fmax)(r.m_x1, r.m_x2)};
    const float y1{(std::fmin)(r.m_y1, r.m_y2)};
    const float y2{(std::fmax)(r.m_y1, r.m_y2)};
 
    const float cx{(x2 + x1) / 2.0f};
    const float cy{(y2 + y1) / 2.0f};
 
    const float ox1{x1 - cx};
    const float ox2{x2 - cx};
    const float oy1{y1 - cy};
    const float oy2{y2 - cy};
 
    const float rads{r.m_angle * 3.141f / 180.0f};
    const float c{std::cos(rads)};
    const float s{std::sin(rads)};
 
    const std::pair<float, float> ul{ox1 * c - oy1 * s + cx, ox1 * s + oy1 * c + cy};
    const std::pair<float, float> bl{ox1 * c - oy2 * s + cx, ox1 * s + oy2 * c + cy};
    const std::pair<float, float> ur{ox2 * c - oy1 * s + cx, ox2 * s + oy1 * c + cy};
    const std::pair<float, float> br{ox2 * c - oy2 * s + cx, ox2 * s + oy2 * c + cy};
 
    return {ul, ur, br, bl};
}

Here is the caller graph for this function:

getPointsOnRotatedEllipse()

std::vector< std::pair< float, float > > geometrize::getPointsOnRotatedEllipse	(	const geometrize::RotatedEllipse &	e,
		std::size_t	numPoints
	)

getPointsOnRotatedEllipse Calculates and returns a number of points on the given rotated ellipse.

Parameters

e	The rotated ellipse.

Returns

A vector containing the points on the rotated ellipse.

{    
    std::vector<std::pair<float, float>> points;
    const float rads{e.m_angle * (3.141f / 180.0f)};
    const float co{std::cos(rads)};
    const float si{std::sin(rads)};
 
    for(std::uint32_t i = 0; i < numPoints; i++) {
        const float angle{((360.0f / numPoints) * i) * (3.141f / 180.0f)};
        const float crx{e.m_rx * std::cos(angle)};
        const float cry{e.m_ry * std::sin(angle)};
        points.push_back(std::make_pair(crx * co - cry * si + e.m_x, crx * si + cry * co + e.m_y));
    }
 
    return points;
}

Here is the caller graph for this function:

getRawShapeData() [1/10]

std::vector< float > geometrize::getRawShapeData

(

const geometrize::Circle &

s

)

{
    return { s.m_x, s.m_y, s.m_r };
}

getRawShapeData() [2/10]

std::vector< float > geometrize::getRawShapeData

(

const geometrize::Ellipse &

s

)

{
    return { s.m_x, s.m_y, s.m_rx, s.m_ry };
}

getRawShapeData() [3/10]

std::vector< float > geometrize::getRawShapeData

(

const geometrize::Line &

s

)

{
    return { s.m_x1, s.m_y1, s.m_x2, s.m_y2 };
}

getRawShapeData() [4/10]

std::vector< float > geometrize::getRawShapeData

(

const geometrize::Polyline &

s

)

{
    std::vector<float> data;
    for(std::size_t i = 0; i < s.m_points.size(); i++) {
        data.push_back(s.m_points[i].first);
        data.push_back(s.m_points[i].second);
    }
 
    return data;
}

getRawShapeData() [5/10]

std::vector< float > geometrize::getRawShapeData

(

const geometrize::QuadraticBezier &

s

)

{
    return { s.m_x1, s.m_y1, s.m_cx, s.m_cy, s.m_x2, s.m_y2 };
}

getRawShapeData() [6/10]

std::vector< float > geometrize::getRawShapeData

(

const geometrize::Rectangle &

s

)

{
    return {
        ((std::fmin)(s.m_x1, s.m_x2)),
        ((std::fmin)(s.m_y1, s.m_y2)),
        ((std::fmax)(s.m_x1, s.m_x2)),
        ((std::fmax)(s.m_y1, s.m_y2))
    };
}

getRawShapeData() [7/10]

std::vector< float > geometrize::getRawShapeData

(

const geometrize::RotatedEllipse &

s

)

{
    return { s.m_x, s.m_y, s.m_rx, s.m_ry, s.m_angle };
}

getRawShapeData() [8/10]

std::vector< float > geometrize::getRawShapeData

(

const geometrize::RotatedRectangle &

s

)

{
    return {
        ((std::fmin)(s.m_x1, s.m_x2)),
        ((std::fmin)(s.m_y1, s.m_y2)),
        ((std::fmax)(s.m_x1, s.m_x2)),
        ((std::fmax)(s.m_y1, s.m_y2)),
        s.m_angle
    };
}

getRawShapeData() [9/10]

std::vector< float > geometrize::getRawShapeData

(

const geometrize::Shape &

s

)

{
    switch(s.getType()) {
    case geometrize::ShapeTypes::RECTANGLE:
        return getRawShapeData(static_cast<const geometrize::Rectangle&>(s));
    case geometrize::ShapeTypes::ROTATED_RECTANGLE:
        return getRawShapeData(static_cast<const geometrize::RotatedRectangle&>(s));
    case geometrize::ShapeTypes::TRIANGLE:
        return getRawShapeData(static_cast<const geometrize::Triangle&>(s));
    case geometrize::ShapeTypes::ELLIPSE:
        return getRawShapeData(static_cast<const geometrize::Ellipse&>(s));
    case geometrize::ShapeTypes::ROTATED_ELLIPSE:
        return getRawShapeData(static_cast<const geometrize::RotatedEllipse&>(s));
    case geometrize::ShapeTypes::CIRCLE:
        return getRawShapeData(static_cast<const geometrize::Circle&>(s));
    case geometrize::ShapeTypes::LINE:
        return getRawShapeData(static_cast<const geometrize::Line&>(s));
    case geometrize::ShapeTypes::QUADRATIC_BEZIER:
        return getRawShapeData(static_cast<const geometrize::QuadraticBezier&>(s));
    case geometrize::ShapeTypes::POLYLINE:
        return getRawShapeData(static_cast<const geometrize::Polyline&>(s));
    default:
        assert(0 && "Bad shape type");
        return {};
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

getRawShapeData() [10/10]

std::vector< float > geometrize::getRawShapeData

(

const geometrize::Triangle &

s

)

{
    return { s.m_x1, s.m_y1, s.m_x2, s.m_y2, s.m_x3, s.m_y3 };
}

mutate() [1/10]

void geometrize::mutate	(	geometrize::Circle &	s,
		const std::int32_t	xMin,
		const std::int32_t	yMin,
		const std::int32_t	xMax,
		const std::int32_t	yMax
	)

{
    const std::int32_t r{geometrize::commonutil::randomRange(0, 1)};
    switch(r) {
        case 0:
        {
            s.m_x = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_x) + geometrize::commonutil::randomRange(-16, 16), xMin, xMax - 1);
            s.m_y = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_y) + geometrize::commonutil::randomRange(-16, 16), yMin, yMax - 1);
            break;
        }
        case 1:
        {
            s.m_r = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_r) + geometrize::commonutil::randomRange(-16, 16), 1, xMax - 1);
            break;
        }
    }
}

Here is the call graph for this function:

mutate() [2/10]

void geometrize::mutate	(	geometrize::Ellipse &	s,
		const std::int32_t	xMin,
		const std::int32_t	yMin,
		const std::int32_t	xMax,
		const std::int32_t	yMax
	)

{
    const std::int32_t r{geometrize::commonutil::randomRange(0, 2)};
    switch(r) {
        case 0:
        {
            s.m_x = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_x) + geometrize::commonutil::randomRange(-16, 16), xMin, xMax - 1);
            s.m_y = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_y) + geometrize::commonutil::randomRange(-16, 16), yMin, yMax - 1);
            break;
        }
        case 1:
        {
            s.m_rx = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_rx) + geometrize::commonutil::randomRange(-16, 16), 1, xMax - 1);
            break;
        }
        case 2:
        {
            s.m_ry = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_ry) + geometrize::commonutil::randomRange(-16, 16), 1, yMax - 1);
            break;
        }
    }
}

Here is the call graph for this function:

mutate() [3/10]

void geometrize::mutate	(	geometrize::Line &	s,
		const std::int32_t	xMin,
		const std::int32_t	yMin,
		const std::int32_t	xMax,
		const std::int32_t	yMax
	)

{
    const std::int32_t r{geometrize::commonutil::randomRange(0, 1)};
 
    switch(r) {
        case 0:
        {
            s.m_x1 = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_x1) + geometrize::commonutil::randomRange(-16, 16), xMin, xMax - 1);
            s.m_y1 = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_y1) + geometrize::commonutil::randomRange(-16, 16), yMin, yMax - 1);
            break;
        }
        case 1:
        {
            s.m_x2 = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_x2) + geometrize::commonutil::randomRange(-16, 16), xMin, xMax - 1);
            s.m_y2 = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_y2) + geometrize::commonutil::randomRange(-16, 16), yMin, yMax - 1);
            break;
        }
    }
}

Here is the call graph for this function:

mutate() [4/10]

void geometrize::mutate	(	geometrize::Polyline &	s,
		const std::int32_t	xMin,
		const std::int32_t	yMin,
		const std::int32_t	xMax,
		const std::int32_t	yMax
	)

{
    const std::int32_t i{geometrize::commonutil::randomRange(static_cast<std::size_t>(0), s.m_points.size() - 1)};
 
    std::pair<std::int32_t, std::int32_t> point{s.m_points[i]};
    point.first = geometrize::commonutil::clamp(point.first + geometrize::commonutil::randomRange(-64, 64), xMin, xMax - 1);
    point.second = geometrize::commonutil::clamp(point.second + geometrize::commonutil::randomRange(-64, 64), yMin, yMax - 1);
 
    s.m_points[i] = point;
}

Here is the call graph for this function:

mutate() [5/10]

void geometrize::mutate	(	geometrize::QuadraticBezier &	s,
		const std::int32_t	xMin,
		const std::int32_t	yMin,
		const std::int32_t	xMax,
		const std::int32_t	yMax
	)

{
    const std::int32_t r{geometrize::commonutil::randomRange(0, 2)};
    switch(r) {
        case 0:
        {
            s.m_cx = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_cx) + geometrize::commonutil::randomRange(-8, 8), xMin, xMax - 1);
            s.m_cy = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_cy) + geometrize::commonutil::randomRange(-8, 8), yMin, yMax - 1);
            break;
        }
        case 1:
        {
            // NOTE +1 on the minimum values for paranoia reasons as I wrote it that way originally, not sure if it's needed
            s.m_x1 = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_x1) + geometrize::commonutil::randomRange(-8, 8), xMin + 1, xMax - 1);
            s.m_y1 = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_y1) + geometrize::commonutil::randomRange(-8, 8), yMin + 1, yMax - 1);
            break;
        }
        case 2:
        {
            // NOTE +1 on the minimum values for paranoia reasons as I wrote it that way originally, not sure if it's needed
            s.m_x2 = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_x2) + geometrize::commonutil::randomRange(-8, 8), xMin + 1, xMax - 1);
            s.m_y2 = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_y2) + geometrize::commonutil::randomRange(-8, 8), yMin + 1, yMax - 1);
            break;
        }
    }
}

Here is the call graph for this function:

mutate() [6/10]

void geometrize::mutate	(	geometrize::Rectangle &	s,
		const std::int32_t	xMin,
		const std::int32_t	yMin,
		const std::int32_t	xMax,
		const std::int32_t	yMax
	)

{
    const std::int32_t r{geometrize::commonutil::randomRange(0, 1)};
    switch(r) {
        case 0:
        {
            s.m_x1 = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_x1) + geometrize::commonutil::randomRange(-16, 16), xMin, xMax - 1);
            s.m_y1 = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_y1) + geometrize::commonutil::randomRange(-16, 16), yMin, yMax - 1);
            break;
        }
        case 1:
        {
            s.m_x2 = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_x2) + geometrize::commonutil::randomRange(-16, 16), xMin, xMax - 1);
            s.m_y2 = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_y2) + geometrize::commonutil::randomRange(-16, 16), yMin, yMax - 1);
            break;
        }
    }
}

Here is the call graph for this function:

mutate() [7/10]

void geometrize::mutate	(	geometrize::RotatedEllipse &	s,
		const std::int32_t	xMin,
		const std::int32_t	yMin,
		const std::int32_t	xMax,
		const std::int32_t	yMax
	)

{
    const std::int32_t r{geometrize::commonutil::randomRange(0, 3)};
    switch(r) {
        case 0:
        {
            s.m_x = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_x) + geometrize::commonutil::randomRange(-16, 16), xMin, xMax - 1);
            s.m_y = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_y) + geometrize::commonutil::randomRange(-16, 16), yMin, yMax - 1);
            break;
        }
        case 1:
        {
            s.m_rx = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_rx) + geometrize::commonutil::randomRange(-16, 16), 1, xMax - 1);
            break;
        }
        case 2:
        {
            s.m_ry = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_ry) + geometrize::commonutil::randomRange(-16, 16), 1, yMax - 1);
            break;
        }
        case 3:
        {
            s.m_angle = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_angle) + geometrize::commonutil::randomRange(-16, 16), 0, 360);
            break;
        }
    }
}

Here is the call graph for this function:

mutate() [8/10]

void geometrize::mutate	(	geometrize::RotatedRectangle &	s,
		const std::int32_t	xMin,
		const std::int32_t	yMin,
		const std::int32_t	xMax,
		const std::int32_t	yMax
	)

{
    const std::int32_t r{geometrize::commonutil::randomRange(0, 2)};
    switch(r) {
        case 0:
        {
            s.m_x1 = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_x1) + geometrize::commonutil::randomRange(-16, 16), xMin, xMax);
            s.m_y1 = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_y1) + geometrize::commonutil::randomRange(-16, 16), yMin, yMax);
            break;
        }
        case 1:
        {
            s.m_x2 = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_x2) + geometrize::commonutil::randomRange(-16, 16), xMin, xMax);
            s.m_y2 = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_y2) + geometrize::commonutil::randomRange(-16, 16), yMin, yMax);
            break;
        }
        case 2:
        {
            s.m_angle = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_angle) + geometrize::commonutil::randomRange(-4, 4), 0, 360);
            break;
        }
    }
}

Here is the call graph for this function:

mutate() [9/10]

void geometrize::mutate	(	geometrize::Shape &	s,
		const std::int32_t	xMin,
		const std::int32_t	yMin,
		const std::int32_t	xMax,
		const std::int32_t	yMax
	)

{
    switch(s.getType()) {
    case geometrize::ShapeTypes::RECTANGLE:
        mutate(static_cast<geometrize::Rectangle&>(s), xMin, yMin, xMax, yMax);
        break;
    case geometrize::ShapeTypes::ROTATED_RECTANGLE:
        mutate(static_cast<geometrize::RotatedRectangle&>(s), xMin, yMin, xMax, yMax);
        break;
    case geometrize::ShapeTypes::TRIANGLE:
        mutate(static_cast<geometrize::Triangle&>(s), xMin, yMin, xMax, yMax);
        break;
    case geometrize::ShapeTypes::ELLIPSE:
        mutate(static_cast<geometrize::Ellipse&>(s), xMin, yMin, xMax, yMax);
        break;
    case geometrize::ShapeTypes::ROTATED_ELLIPSE:
        mutate(static_cast<geometrize::RotatedEllipse&>(s), xMin, yMin, xMax, yMax);
        break;
    case geometrize::ShapeTypes::CIRCLE:
        mutate(static_cast<geometrize::Circle&>(s), xMin, yMin, xMax, yMax);
        break;
    case geometrize::ShapeTypes::LINE:
        mutate(static_cast<geometrize::Line&>(s), xMin, yMin, xMax, yMax);
        break;
    case geometrize::ShapeTypes::QUADRATIC_BEZIER:
        mutate(static_cast<geometrize::QuadraticBezier&>(s), xMin, yMin, xMax, yMax);
        break;
    case geometrize::ShapeTypes::POLYLINE:
        mutate(static_cast<geometrize::Polyline&>(s), xMin, yMin, xMax, yMax);
        break;
    default:
        assert(0 && "Bad shape type");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutate() [10/10]

void geometrize::mutate	(	geometrize::Triangle &	s,
		const std::int32_t	xMin,
		const std::int32_t	yMin,
		const std::int32_t	xMax,
		const std::int32_t	yMax
	)

{
    const std::int32_t r{geometrize::commonutil::randomRange(0, 2)};
    switch(r) {
        case 0:
        {
            s.m_x1 = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_x1) + geometrize::commonutil::randomRange(-32, 32), xMin, xMax);
            s.m_y1 = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_y1) + geometrize::commonutil::randomRange(-32, 32), yMin, yMax);
            break;
        }
        case 1:
        {
            s.m_x2 = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_x2) + geometrize::commonutil::randomRange(-32, 32), xMin, xMax);
            s.m_y2 = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_y2) + geometrize::commonutil::randomRange(-32, 32), yMin, yMax);
            break;
        }
        case 2:
        {
            s.m_x3 = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_x3) + geometrize::commonutil::randomRange(-32, 32), xMin, xMax);
            s.m_y3 = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_y3) + geometrize::commonutil::randomRange(-32, 32), yMin, yMax);
            break;
        }
    }
}

Here is the call graph for this function:

operator!=() [1/2]

bool geometrize::operator!=	(	const geometrize::rgba &	lhs,
		const geometrize::rgba &	rhs
	)

{
    return lhs.r != rhs.r || lhs.g != rhs.g || lhs.b != rhs.b || lhs.a != rhs.a;
}

operator!=() [2/2]

bool geometrize::operator!=	(	const geometrize::Scanline &	lhs,
		const geometrize::Scanline &	rhs
	)

{
    return lhs.y != rhs.y || lhs.x1 != rhs.x1 || lhs.x2 != rhs.x2;
}

operator==() [1/2]

bool geometrize::operator==	(	const geometrize::rgba &	lhs,
		const geometrize::rgba &	rhs
	)

{
    return lhs.r == rhs.r && lhs.g == rhs.g && lhs.b == rhs.b && lhs.a == rhs.a;
}

operator==() [2/2]

bool geometrize::operator==	(	const geometrize::Scanline &	lhs,
		const geometrize::Scanline &	rhs
	)

{
    return lhs.y == rhs.y && lhs.x1 == rhs.x1 && lhs.x2 == rhs.x2;
}

randomShape()

std::shared_ptr< geometrize::Shape > geometrize::randomShape

(

)

randomShape Creates a random shape.

Returns

The new shape.

{
    return create(geometrize::allShapes[commonutil::randomRange(0, static_cast<int>(geometrize::allShapes.size()) - 1)]);
}

Here is the call graph for this function:

Here is the caller graph for this function:

randomShapeOf()

std::shared_ptr< geometrize::Shape > geometrize::randomShapeOf

(

geometrize::ShapeTypes

t

)

randomShapeOf Creates a random shape from the types supplied.

Parameters

t	The types of shape to possibly create.

Returns

The new shape.

{
    std::vector<ShapeTypes> typeVector;
    for(const ShapeTypes type : geometrize::allShapes) {
        if((type & types) == type) {
            typeVector.push_back(type);
        }
    }
 
    if(typeVector.size() == 0) {
        return randomShape(); // If there are no types specified, create one randomly
    }
 
    return create(typeVector.at(commonutil::randomRange(0, static_cast<std::int32_t>(typeVector.size() - 1))));
}

Here is the call graph for this function:

Here is the caller graph for this function:

rasterize() [1/10]

std::vector< geometrize::Scanline > geometrize::rasterize	(	const geometrize::Circle &	s,
		const std::int32_t	xMin,
		const std::int32_t	yMin,
		const std::int32_t	xMax,
		const std::int32_t	yMax
	)

{
    std::vector<geometrize::Scanline> lines;
 
    const std::int32_t r{static_cast<std::int32_t>(s.m_r)};
    for(std::int32_t y = -r; y <= r; y++) {
        std::vector<std::int32_t> xScan;
        for(std::int32_t x = -r; x <= r; x++) {
            if(x * x + y * y <= r * r) {
                xScan.push_back(x);
            }
        }
 
        if(!xScan.empty()) {
            const std::int32_t fy{static_cast<std::int32_t>(s.m_y) + y};
            const std::int32_t x1{commonutil::clamp(static_cast<std::int32_t>(s.m_x) + xScan.front(), xMin, xMax - 1)};
            const std::int32_t x2{commonutil::clamp(static_cast<std::int32_t>(s.m_x) + xScan.back(), xMin, xMax - 1)};
            lines.push_back(geometrize::Scanline(fy, x1, x2));
        }
    }
 
    return geometrize::trimScanlines(lines, xMin, yMin, xMax, yMax);
}

Here is the call graph for this function:

rasterize() [2/10]

std::vector< geometrize::Scanline > geometrize::rasterize	(	const geometrize::Ellipse &	s,
		const std::int32_t	xMin,
		const std::int32_t	yMin,
		const std::int32_t	xMax,
		const std::int32_t	yMax
	)

{
    std::vector<geometrize::Scanline> lines;
 
    const float aspect{static_cast<float>(s.m_rx) / static_cast<float>(s.m_ry)};
 
    for (std::int32_t dy = 0; dy < s.m_ry; dy++) {
        const std::int32_t y1{static_cast<std::int32_t>(s.m_y) - dy};
        const std::int32_t y2{static_cast<std::int32_t>(s.m_y) + dy};
 
        if ((y1 < yMin || y1 >= yMax) && (y2 < yMin || y2 >= yMax)) {
            continue;
        }
 
        const std::int32_t v{static_cast<std::int32_t>(std::sqrt(s.m_ry * s.m_ry - dy * dy) * aspect)};
        std::int32_t x1{static_cast<std::int32_t>(s.m_x) - v};
        std::int32_t x2{static_cast<std::int32_t>(s.m_x) + v};
        if (x1 < xMin) {
            x1 = xMin;
        }
        if (x2 >= xMax) {
            x2 = xMax - 1;
        }
 
        if (y1 >= xMin && y1 < yMax) {
            lines.push_back(Scanline(y1, x1, x2));
        }
        if (y2 >= yMin && y2 < yMax && dy > 0) {
            lines.push_back(Scanline(y2, x1, x2));
        }
    }
 
    return geometrize::trimScanlines(lines, xMin, yMin, xMax, yMax);
}

Here is the call graph for this function:

rasterize() [3/10]

std::vector< geometrize::Scanline > geometrize::rasterize	(	const geometrize::Line &	s,
		const std::int32_t	xMin,
		const std::int32_t	yMin,
		const std::int32_t	xMax,
		const std::int32_t	yMax
	)

{
    std::vector<geometrize::Scanline> lines;
 
    const std::vector<std::pair<std::int32_t, std::int32_t>> points{geometrize::bresenham(static_cast<std::int32_t>(s.m_x1), static_cast<std::int32_t>(s.m_y1), static_cast<std::int32_t>(s.m_x2), static_cast<std::int32_t>(s.m_y2))};
    for(const auto& point : points) {
       lines.push_back(geometrize::Scanline(point.second, point.first, point.first));
    }
 
    return geometrize::trimScanlines(lines, xMin, yMin, xMax, yMax);
}

Here is the call graph for this function:

rasterize() [4/10]

std::vector< geometrize::Scanline > geometrize::rasterize	(	const geometrize::Polyline &	s,
		const std::int32_t	xMin,
		const std::int32_t	yMin,
		const std::int32_t	xMax,
		const std::int32_t	yMax
	)

{
    std::vector<geometrize::Scanline> lines;
 
    // Prevent scanline overlap, it messes up the energy functions that rely on the scanlines not intersecting themselves
    std::set<std::pair<std::int32_t, std::int32_t>> duplicates;
 
    for(std::size_t i = 0; i < s.m_points.size(); i++) {
        const std::pair<std::int32_t, std::int32_t> p0{s.m_points[i].first, s.m_points[i].second};
        const std::pair<std::int32_t, std::int32_t> p1{i < (s.m_points.size() - 1) ? std::make_pair(static_cast<std::int32_t>(s.m_points[i + 1].first), static_cast<std::int32_t>(s.m_points[i + 1].second)) : p0};
 
        const std::vector<std::pair<std::int32_t, std::int32_t>> points{geometrize::bresenham(p0.first, p0.second, p1.first, p1.second)};
        for(const auto& point : points) {
            if(duplicates.insert(point).second) {
                lines.push_back(geometrize::Scanline(point.second, point.first, point.first));
            }
        }
    }
 
    return geometrize::trimScanlines(lines, xMin, yMin, xMax, yMax);
}

Here is the call graph for this function:

rasterize() [5/10]

std::vector< geometrize::Scanline > geometrize::rasterize	(	const geometrize::QuadraticBezier &	s,
		const std::int32_t	xMin,
		const std::int32_t	yMin,
		const std::int32_t	xMax,
		const std::int32_t	yMax
	)

{
    std::vector<geometrize::Scanline> scanlines;
 
    std::vector<std::pair<std::int32_t, std::int32_t>> points;
    const std::uint32_t pointCount{20};
    for(std::uint32_t i = 0; i <= pointCount; i++) {
        const float t{static_cast<float>(i) / static_cast<float>(pointCount)};
        const float tp{1 - t};
        const std::int32_t x{static_cast<std::int32_t>(tp * (tp * s.m_x1 + (t * s.m_cx)) + t * ((tp * s.m_cx) + (t * s.m_x2)))};
        const std::int32_t y{static_cast<std::int32_t>(tp * (tp * s.m_y1 + (t * s.m_cy)) + t * ((tp * s.m_cy) + (t * s.m_y2)))};
        points.push_back(std::make_pair(x, y));
    }
 
    // Prevent scanline overlap, it messes up the energy functions that rely on the scanlines not intersecting themselves
    std::set<std::pair<std::int32_t, std::int32_t>> duplicates;
 
    for(std::uint32_t i = 0; i < points.size() - 1; i++) {
        const std::pair<std::int32_t, std::int32_t> p0{points[i]};
        const std::pair<std::int32_t, std::int32_t> p1{points[i + 1]};
 
        const std::vector<std::pair<std::int32_t, std::int32_t>> points{geometrize::bresenham(static_cast<std::int32_t>(p0.first), static_cast<std::int32_t>(p0.second), static_cast<std::int32_t>(p1.first), static_cast<std::int32_t>(p1.second))};
        for(const std::pair<std::int32_t, std::int32_t>& point : points) {
            if(duplicates.insert(point).second) {
                scanlines.push_back(geometrize::Scanline(point.second, point.first, point.first));
            }
        }
    }
 
    return geometrize::trimScanlines(scanlines, xMin, yMin, xMax, yMax);
}

Here is the call graph for this function:

rasterize() [6/10]

std::vector< geometrize::Scanline > geometrize::rasterize	(	const geometrize::Rectangle &	s,
		const std::int32_t	xMin,
		const std::int32_t	yMin,
		const std::int32_t	xMax,
		const std::int32_t	yMax
	)

{
    const std::int32_t x1{static_cast<std::int32_t>((std::fmin)(s.m_x1, s.m_x2))};
    const std::int32_t x2{static_cast<std::int32_t>((std::fmax)(s.m_x1, s.m_x2))};
    const std::int32_t y1{static_cast<std::int32_t>((std::fmin)(s.m_y1, s.m_y2))};
    const std::int32_t y2{static_cast<std::int32_t>((std::fmax)(s.m_y1, s.m_y2))};
 
    std::vector<geometrize::Scanline> lines;
    for(std::int32_t y = y1; y <= y2; y++) {
        lines.push_back(geometrize::Scanline(y, x1, x2));
    }
    return geometrize::trimScanlines(lines, xMin, yMin, xMax, yMax);
}

Here is the call graph for this function:

rasterize() [7/10]

std::vector< geometrize::Scanline > geometrize::rasterize	(	const geometrize::RotatedEllipse &	s,
		const std::int32_t	xMin,
		const std::int32_t	yMin,
		const std::int32_t	xMax,
		const std::int32_t	yMax
	)

{
    const std::uint32_t pointCount{20};
    std::vector<std::pair<float, float>> points = getPointsOnRotatedEllipse(s, pointCount);
 
    std::vector<geometrize::Scanline> scanlines{geometrize::scanlinesForPolygon(points)};
    return geometrize::trimScanlines(scanlines, xMin, yMin, xMax, yMax);
}

Here is the call graph for this function:

rasterize() [8/10]

std::vector< geometrize::Scanline > geometrize::rasterize	(	const geometrize::RotatedRectangle &	s,
		const std::int32_t	xMin,
		const std::int32_t	yMin,
		const std::int32_t	xMax,
		const std::int32_t	yMax
	)

{
    std::vector<geometrize::Scanline> scanlines{geometrize::scanlinesForPolygon(getCornerPoints(s))};
    return geometrize::trimScanlines(scanlines, xMin, yMin, xMax, yMax);
}

Here is the call graph for this function:

rasterize() [9/10]

std::vector< geometrize::Scanline > geometrize::rasterize	(	const geometrize::Shape &	s,
		std::int32_t	xMin,
		std::int32_t	yMin,
		std::int32_t	xMax,
		std::int32_t	yMax
	)

{
    switch(s.getType()) {
    case geometrize::ShapeTypes::RECTANGLE:
        return rasterize(static_cast<const geometrize::Rectangle&>(s), xMin, yMin, xMax, yMax);
    case geometrize::ShapeTypes::ROTATED_RECTANGLE:
        return rasterize(static_cast<const geometrize::RotatedRectangle&>(s), xMin, yMin, xMax, yMax);
    case geometrize::ShapeTypes::TRIANGLE:
        return rasterize(static_cast<const geometrize::Triangle&>(s), xMin, yMin, xMax, yMax);
    case geometrize::ShapeTypes::ELLIPSE:
        return rasterize(static_cast<const geometrize::Ellipse&>(s), xMin, yMin, xMax, yMax);
    case geometrize::ShapeTypes::ROTATED_ELLIPSE:
        return rasterize(static_cast<const geometrize::RotatedEllipse&>(s), xMin, yMin, xMax, yMax);
    case geometrize::ShapeTypes::CIRCLE:
        return rasterize(static_cast<const geometrize::Circle&>(s), xMin, yMin, xMax, yMax);
    case geometrize::ShapeTypes::LINE:
        return rasterize(static_cast<const geometrize::Line&>(s), xMin, yMin, xMax, yMax);
    case geometrize::ShapeTypes::QUADRATIC_BEZIER:
        return rasterize(static_cast<const geometrize::QuadraticBezier&>(s), xMin, yMin, xMax, yMax);
    case geometrize::ShapeTypes::POLYLINE:
        return rasterize(static_cast<const geometrize::Polyline&>(s), xMin, yMin, xMax, yMax);
    default:
        assert(0 && "Bad shape type");
        return std::vector<geometrize::Scanline>{};
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

rasterize() [10/10]

std::vector< geometrize::Scanline > geometrize::rasterize	(	const geometrize::Triangle &	s,
		const std::int32_t	xMin,
		const std::int32_t	yMin,
		const std::int32_t	xMax,
		const std::int32_t	yMax
	)

{
     std::vector<geometrize::Scanline> scanlines = geometrize::scanlinesForPolygon({
         {static_cast<std::int32_t>(s.m_x1), static_cast<std::int32_t>(s.m_y1)},
         {static_cast<std::int32_t>(s.m_x2), static_cast<std::int32_t>(s.m_y2)},
         {static_cast<std::int32_t>(s.m_x3), static_cast<std::int32_t>(s.m_y3)}});
 
    return geometrize::trimScanlines(scanlines, xMin, yMin, xMax, yMax);
}

Here is the call graph for this function:

rotate() [1/5]

void geometrize::rotate	(	geometrize::Line &	s,
		const float	angle
	)

{
    const float xMid = (s.m_x1 + s.m_x2) / 2;
    const float yMid = (s.m_y1 + s.m_y2) / 2;
 
    translate(s, -xMid, -yMid);
 
    const float x1 = s.m_x1;
    const float x2 = s.m_x2;
    const float y1 = s.m_y1;
    const float y2 = s.m_y2;
    const float cosAngle = std::cos(angle);
    const float sinAngle = std::sin(angle);
 
    s.m_x1 = x1 * cosAngle - y1 * sinAngle;
    s.m_y1 = x1 * sinAngle + y1 * cosAngle;
    s.m_x2 = x2 * cosAngle - y2 * sinAngle;
    s.m_y2 = x2 * sinAngle + y2 * cosAngle;
 
    translate(s, xMid, yMid);
}

Here is the call graph for this function:

rotate() [2/5]

void geometrize::rotate	(	geometrize::RotatedEllipse &	s,
		const float	angle
	)

{
    s.m_angle = wrapMinMax(s.m_angle + angle, 0, 360);
}

rotate() [3/5]

void geometrize::rotate	(	geometrize::RotatedRectangle &	s,
		const float	angle
	)

{
    s.m_angle = wrapMinMax(s.m_angle + angle, 0, 360);
}

rotate() [4/5]

void geometrize::rotate	(	geometrize::Shape &	s,
		const float	angle
	)

{
    switch(s.getType()) {
    case geometrize::ShapeTypes::ROTATED_RECTANGLE:
        rotate(static_cast<geometrize::RotatedRectangle&>(s), angle);
        break;
    case geometrize::ShapeTypes::TRIANGLE:
        rotate(static_cast<geometrize::Triangle&>(s), angle);
        break;
    case geometrize::ShapeTypes::ROTATED_ELLIPSE:
        rotate(static_cast<geometrize::RotatedEllipse&>(s), angle);
        break;
    case geometrize::ShapeTypes::LINE:
        rotate(static_cast<geometrize::Line&>(s), angle);
        break;
    default:
        break;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

rotate() [5/5]

void geometrize::rotate	(	geometrize::Triangle &	s,
		const float	angle
	)

{
    const float xMid = (s.m_x1 + s.m_x2 + s.m_x3) / 3;
    const float yMid = (s.m_y1 + s.m_y2 + s.m_y3) / 3;
 
    translate(s, -xMid, -yMid);
 
    const float x1 = s.m_x1;
    const float x2 = s.m_x2;
    const float x3 = s.m_x3;
    const float y1 = s.m_y1;
    const float y2 = s.m_y2;
    const float y3 = s.m_y3;
    const float cosAngle = std::cos(angle);
    const float sinAngle = std::sin(angle);
 
    s.m_x1 = x1 * cosAngle - y1 * sinAngle;
    s.m_y1 = x1 * sinAngle + y1 * cosAngle;
    s.m_x2 = x2 * cosAngle - y2 * sinAngle;
    s.m_y2 = x2 * sinAngle + y2 * cosAngle;
    s.m_x3 = x3 * cosAngle - y3 * sinAngle;
    s.m_y3 = x3 * sinAngle + y3 * cosAngle;
 
    translate(s, xMid, yMid);
}

Here is the call graph for this function:

scale() [1/10]

void geometrize::scale	(	geometrize::Circle &	s,
		const float	scaleFactor
	)

{
    s.m_r *= scaleFactor;
}

scale() [2/10]

void geometrize::scale	(	geometrize::Ellipse &	s,
		const float	scaleFactor
	)

{
    s.m_rx *= scaleFactor;
    s.m_ry *= scaleFactor;
}

scale() [3/10]

void geometrize::scale	(	geometrize::Line &	s,
		const float	scaleFactor
	)

{
    const float xMid = (s.m_x1 + s.m_x2) / 2;
    const float yMid = (s.m_y1 + s.m_y2) / 2;
 
    s.m_x1 = (s.m_x1 - xMid) * scaleFactor + xMid;
    s.m_x2 = (s.m_x2 - xMid) * scaleFactor + xMid;
 
    s.m_y1 = (s.m_y1 - yMid) * scaleFactor + yMid;
    s.m_y2 = (s.m_y2 - yMid) * scaleFactor + yMid;
}

scale() [4/10]

void geometrize::scale	(	geometrize::Polyline &	s,
		const float	scaleFactor
	)

{
    std::vector<std::pair<float, float>> points;
 
    for(std::size_t i = 0; i < s.m_points.size(); i+=2) {
        if(i == s.m_points.size() - 1 || i == s.m_points.size()) {
            continue;
        }
        const float x1 = s.m_points[i].first;
        const float x2 = s.m_points[i + 1].first;
        const float y1 = s.m_points[i].second;
        const float y2 = s.m_points[i + 1].second;
 
        const float xLen = (x1 + x2) / 2;
        const float yLen = (y1 + y2) / 2;
 
        points.push_back({(x1 - xLen) * scaleFactor + xLen, (y1 - yLen) * scaleFactor + yLen});
        points.push_back({(x1 - xLen) * scaleFactor + xLen, (y2 - yLen) * scaleFactor + yLen});
    }
 
    s.m_points = points;
}

scale() [5/10]

void geometrize::scale	(	geometrize::QuadraticBezier &	s,
		const float	scaleFactor
	)

{
    assert(0 && "TODO");
}

scale() [6/10]

void geometrize::scale	(	geometrize::Rectangle &	s,
		const float	scaleFactor
	)

{
    const float xMid = (s.m_x1 + s.m_x2) / 2;
    const float yMid = (s.m_y1 + s.m_y2) / 2;
 
    s.m_x1 = (s.m_x1 - xMid) * scaleFactor + xMid;
    s.m_y1 = (s.m_y1 - yMid) * scaleFactor + yMid;
    s.m_x2 = (s.m_x2 - xMid) * scaleFactor + xMid;
    s.m_y2 = (s.m_y2 - yMid) * scaleFactor + yMid;
}

scale() [7/10]

void geometrize::scale	(	geometrize::RotatedEllipse &	s,
		const float	scaleFactor
	)

{
    s.m_rx *= scaleFactor;
    s.m_ry *= scaleFactor;
}

scale() [8/10]

void geometrize::scale	(	geometrize::RotatedRectangle &	s,
		const float	scaleFactor
	)

{
    const float xMid = (s.m_x1 + s.m_x2) / 2;
    const float yMid = (s.m_y1 + s.m_y2) / 2;
 
    s.m_x1 = (s.m_x1 - xMid) * scaleFactor + xMid;
    s.m_y1 = (s.m_y1 - yMid) * scaleFactor + yMid;
    s.m_x2 = (s.m_x2 - xMid) * scaleFactor + xMid;
    s.m_y2 = (s.m_y2 - yMid) * scaleFactor + yMid;
}

scale() [9/10]

void geometrize::scale	(	geometrize::Shape &	s,
		const float	scaleFactor
	)

{
    switch(s.getType()) {
    case geometrize::ShapeTypes::RECTANGLE:
        scale(static_cast<geometrize::Rectangle&>(s), scaleFactor);
        break;
    case geometrize::ShapeTypes::ROTATED_RECTANGLE:
        scale(static_cast<geometrize::RotatedRectangle&>(s), scaleFactor);
        break;
    case geometrize::ShapeTypes::TRIANGLE:
        scale(static_cast<geometrize::Triangle&>(s), scaleFactor);
        break;
    case geometrize::ShapeTypes::ELLIPSE:
        scale(static_cast<geometrize::Ellipse&>(s), scaleFactor);
        break;
    case geometrize::ShapeTypes::ROTATED_ELLIPSE:
        scale(static_cast<geometrize::RotatedEllipse&>(s), scaleFactor);
        break;
    case geometrize::ShapeTypes::CIRCLE:
        scale(static_cast<geometrize::Circle&>(s), scaleFactor);
        break;
    case geometrize::ShapeTypes::LINE:
        scale(static_cast<geometrize::Line&>(s), scaleFactor);
        break;
    case geometrize::ShapeTypes::QUADRATIC_BEZIER:
        scale(static_cast<geometrize::QuadraticBezier&>(s), scaleFactor);
        break;
    case geometrize::ShapeTypes::POLYLINE:
        scale(static_cast<geometrize::Polyline&>(s), scaleFactor);
        break;
    default:
        assert(0 && "Bad shape type");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

scale() [10/10]

void geometrize::scale	(	geometrize::Triangle &	s,
		const float	scaleFactor
	)

{
    const float xMid = (s.m_x1 + s.m_x2 + s.m_x3) / 3;
    const float yMid = (s.m_y1 + s.m_y2 + s.m_y3) / 3;
 
    s.m_x1 = (s.m_x1 - xMid) * scaleFactor + xMid;
    s.m_y1 = (s.m_y1 - yMid) * scaleFactor + yMid;
    s.m_x2 = (s.m_x2 - xMid) * scaleFactor + xMid;
    s.m_y2 = (s.m_y2 - yMid) * scaleFactor + yMid;
    s.m_x3 = (s.m_x3 - xMid) * scaleFactor + xMid;
    s.m_y3 = (s.m_y3 - yMid) * scaleFactor + yMid;
}

scanlinesContain()

bool geometrize::scanlinesContain	(	const std::vector< geometrize::Scanline > &	first,
		const std::vector< geometrize::Scanline > &	second
	)

scanlinesContain Returns true if the first vector of scanlines wholly contain the second vector of scanlines.

Parameters

first	First collection of scanlines.
second	Second collection of scanlines.

Returns

True if the first set of scanlines wholly contains the second set, else false.

{
    for(const auto& s : second) {
        bool contained = false;
        for(const auto& f : first) {
            if(f.y == s.y) {
                if(f.x1 <= s.x1 && f.x2 >= s.x2) {
                    contained = true;
                    break;
                }
            }
        }
 
        if(!contained) {
            return false;
        }
    }
 
    return true;
}

Here is the caller graph for this function:

scanlinesForPolygon()

std::vector< geometrize::Scanline > geometrize::scanlinesForPolygon

(

const std::vector< std::pair< float, float > > &

points

)

scanlinesForPolygon Gets the scanlines for a series of points that make up an arbitrary polygon.

Parameters

points

The vertices of the polygon.

Returns

Scanlines for the polygon.

{
    std::vector<geometrize::Scanline> lines;
 
    // Get the pixel outline of the polygon
    std::vector<std::pair<std::int32_t, std::int32_t>> edges;
    for(std::size_t i = 0; i < points.size(); i++) {
        const std::pair<std::int32_t, std::int32_t> p1{static_cast<std::int32_t>(points[i].first), static_cast<std::int32_t>(points[i].second)};
        const std::pair<std::int32_t, std::int32_t> p2{(i == (points.size() - 1)) ? std::make_pair(static_cast<std::int32_t>(points[0U].first), static_cast<std::int32_t>(points[0U].second)) : std::make_pair(static_cast<std::int32_t>(points[i + 1U].first), static_cast<std::int32_t>(points[i + 1U].second))};
        const std::vector<std::pair<std::int32_t, std::int32_t>> p1p2{geometrize::bresenham(p1.first, p1.second, p2.first, p2.second)};
        edges.insert(edges.end(), p1p2.begin(), p1p2.end());
    }
 
    // Convert outline to scanlines
    std::map<std::int32_t, std::set<std::int32_t>> yToXs;
    for(std::pair<std::int32_t, std::int32_t> point : edges) {
        yToXs[point.second].insert(point.first);
    }
    for(const auto& it : yToXs) {
        const geometrize::Scanline scanline(it.first,
        *(std::min_element(it.second.begin(), it.second.end())),
        *(std::max_element(it.second.begin(), it.second.end())));
        lines.push_back(scanline);
    }
 
    return lines;
}

Here is the call graph for this function:

Here is the caller graph for this function:

scanlinesOverlap()

bool geometrize::scanlinesOverlap	(	const std::vector< geometrize::Scanline > &	first,
		const std::vector< geometrize::Scanline > &	second
	)

scanlinesOverlap Returns true if any of the scanlines from the first vector overlap the second

Parameters

first	First collection of scanlines.
second	Second collection of scanlines.

Returns

True if there are any overlaps, else false.

{
    for(const auto& f : first) {
        for(const auto& s : second) {
            if(f.y == s.y) {
                if(f.x1 <= s.x2 && f.x2 >= s.x1) {
                    return true;
                }
            }
        }
    }
    return false;
}

Here is the caller graph for this function:

setup() [1/10]

void geometrize::setup	(	geometrize::Circle &	s,
		const std::int32_t	xMin,
		const std::int32_t	yMin,
		const std::int32_t	xMax,
		const std::int32_t	yMax
	)

{
    s.m_x = geometrize::commonutil::randomRange(xMin, xMax - 1);
    s.m_y = geometrize::commonutil::randomRange(yMin, yMax - 1);
    s.m_r = geometrize::commonutil::randomRange(1, 32);
}

Here is the call graph for this function:

setup() [2/10]

void geometrize::setup	(	geometrize::Ellipse &	s,
		const std::int32_t	xMin,
		const std::int32_t	yMin,
		const std::int32_t	xMax,
		const std::int32_t	yMax
	)

{
    s.m_x = geometrize::commonutil::randomRange(xMin, xMax - 1);
    s.m_y = geometrize::commonutil::randomRange(yMin, yMax - 1);
    s.m_rx = geometrize::commonutil::randomRange(1, 32);
    s.m_ry = geometrize::commonutil::randomRange(1, 32);
}

Here is the call graph for this function:

setup() [3/10]

void geometrize::setup	(	geometrize::Line &	s,
		const std::int32_t	xMin,
		const std::int32_t	yMin,
		const std::int32_t	xMax,
		const std::int32_t	yMax
	)

{
    const std::pair<std::int32_t, std::int32_t> startingPoint{std::make_pair(geometrize::commonutil::randomRange(xMin, xMax), geometrize::commonutil::randomRange(yMin, yMax - 1))};
 
    s.m_x1 = geometrize::commonutil::clamp(startingPoint.first + geometrize::commonutil::randomRange(-32, 32), xMin, xMax - 1);
    s.m_y1 = geometrize::commonutil::clamp(startingPoint.second + geometrize::commonutil::randomRange(-32, 32), yMin, yMax - 1);
    s.m_x2 = geometrize::commonutil::clamp(startingPoint.first + geometrize::commonutil::randomRange(-32, 32), xMin, xMax - 1);
    s.m_y2 = geometrize::commonutil::clamp(startingPoint.second + geometrize::commonutil::randomRange(-32, 32), yMin, yMax - 1);
}

Here is the call graph for this function:

setup() [4/10]

void geometrize::setup	(	geometrize::Polyline &	s,
		const std::int32_t	xMin,
		const std::int32_t	yMin,
		const std::int32_t	xMax,
		const std::int32_t	yMax
	)

{
    const std::pair<std::int32_t, std::int32_t> startingPoint{std::make_pair(geometrize::commonutil::randomRange(xMin, xMax), geometrize::commonutil::randomRange(yMin, yMax - 1))};
    for(std::int32_t i = 0; i < 4; i++) {
        const std::pair<std::int32_t, std::int32_t> point{
            geometrize::commonutil::clamp(startingPoint.first + geometrize::commonutil::randomRange(-32, 32), xMin, xMax - 1),
            geometrize::commonutil::clamp(startingPoint.second + geometrize::commonutil::randomRange(-32, 32), yMin, yMax - 1)
        };
        s.m_points.push_back(point);
    }
}

Here is the call graph for this function:

setup() [5/10]

void geometrize::setup	(	geometrize::QuadraticBezier &	s,
		const std::int32_t	xMin,
		const std::int32_t	yMin,
		const std::int32_t	xMax,
		const std::int32_t	yMax
	)

{
    s.m_x1 = geometrize::commonutil::randomRange(xMin, xMax - 1);
    s.m_y1 = geometrize::commonutil::randomRange(yMin, yMax - 1);
    s.m_cx = geometrize::commonutil::randomRange(xMin, xMax - 1);
    s.m_cy = geometrize::commonutil::randomRange(yMin, yMax - 1);
    s.m_x2 = geometrize::commonutil::randomRange(xMin, xMax - 1);
    s.m_y2 = geometrize::commonutil::randomRange(yMin, yMax - 1);
}

Here is the call graph for this function:

setup() [6/10]

void geometrize::setup	(	geometrize::Rectangle &	s,
		const std::int32_t	xMin,
		const std::int32_t	yMin,
		const std::int32_t	xMax,
		const std::int32_t	yMax
	)

{
    s.m_x1 = geometrize::commonutil::randomRange(xMin, xMax - 1);
    s.m_y1 = geometrize::commonutil::randomRange(yMin, yMax - 1);
    s.m_x2 = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_x1) + geometrize::commonutil::randomRange(1, 32), xMin, xMax - 1);
    s.m_y2 = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_y1) + geometrize::commonutil::randomRange(1, 32), yMin, yMax - 1);
}

Here is the call graph for this function:

setup() [7/10]

void geometrize::setup	(	geometrize::RotatedEllipse &	s,
		const std::int32_t	xMin,
		const std::int32_t	yMin,
		const std::int32_t	xMax,
		const std::int32_t	yMax
	)

{
    s.m_x = geometrize::commonutil::randomRange(xMin, xMax - 1);
    s.m_y = geometrize::commonutil::randomRange(yMin, yMax - 1);
    s.m_rx = geometrize::commonutil::randomRange(1, 32);
    s.m_ry = geometrize::commonutil::randomRange(1, 32);
    s.m_angle = geometrize::commonutil::randomRange(0, 360);
}

Here is the call graph for this function:

setup() [8/10]

void geometrize::setup	(	geometrize::RotatedRectangle &	s,
		const std::int32_t	xMin,
		const std::int32_t	yMin,
		const std::int32_t	xMax,
		const std::int32_t	yMax
	)

{
    s.m_x1 = geometrize::commonutil::randomRange(xMin, xMax - 1);
    s.m_y1 = geometrize::commonutil::randomRange(yMin, yMax - 1);
    s.m_x2 = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_x1) + geometrize::commonutil::randomRange(1, 32), xMin, xMax);
    s.m_y2 = geometrize::commonutil::clamp(static_cast<std::int32_t>(s.m_y1) + geometrize::commonutil::randomRange(1, 32), yMin, yMax);
    s.m_angle = geometrize::commonutil::randomRange(0, 360);
}

Here is the call graph for this function:

setup() [9/10]

void geometrize::setup	(	geometrize::Shape &	s,
		const std::int32_t	xMin,
		const std::int32_t	yMin,
		const std::int32_t	xMax,
		const std::int32_t	yMax
	)

{
    switch(s.getType()) {
    case geometrize::ShapeTypes::RECTANGLE:
        setup(static_cast<geometrize::Rectangle&>(s), xMin, yMin, xMax, yMax);
        break;
    case geometrize::ShapeTypes::ROTATED_RECTANGLE:
        setup(static_cast<geometrize::RotatedRectangle&>(s), xMin, yMin, xMax, yMax);
        break;
    case geometrize::ShapeTypes::TRIANGLE:
        setup(static_cast<geometrize::Triangle&>(s), xMin, yMin, xMax, yMax);
        break;
    case geometrize::ShapeTypes::ELLIPSE:
        setup(static_cast<geometrize::Ellipse&>(s), xMin, yMin, xMax, yMax);
        break;
    case geometrize::ShapeTypes::ROTATED_ELLIPSE:
        setup(static_cast<geometrize::RotatedEllipse&>(s), xMin, yMin, xMax, yMax);
        break;
    case geometrize::ShapeTypes::CIRCLE:
        setup(static_cast<geometrize::Circle&>(s), xMin, yMin, xMax, yMax);
        break;
    case geometrize::ShapeTypes::LINE:
        setup(static_cast<geometrize::Line&>(s), xMin, yMin, xMax, yMax);
        break;
    case geometrize::ShapeTypes::QUADRATIC_BEZIER:
        setup(static_cast<geometrize::QuadraticBezier&>(s), xMin, yMin, xMax, yMax);
        break;
    case geometrize::ShapeTypes::POLYLINE:
        setup(static_cast<geometrize::Polyline&>(s), xMin, yMin, xMax, yMax);
        break;
    default:
        assert(0 && "Bad shape type");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

setup() [10/10]

void geometrize::setup	(	geometrize::Triangle &	s,
		const std::int32_t	xMin,
		const std::int32_t	yMin,
		const std::int32_t	xMax,
		const std::int32_t	yMax
	)

{
    s.m_x1 = geometrize::commonutil::randomRange(xMin, xMax - 1);
    s.m_y1 = geometrize::commonutil::randomRange(yMin, yMax - 1);
    s.m_x2 = s.m_x1 + geometrize::commonutil::randomRange(-32, 32);
    s.m_y2 = s.m_y1 + geometrize::commonutil::randomRange(-32, 32);
    s.m_x3 = s.m_x1 + geometrize::commonutil::randomRange(-32, 32);
    s.m_y3 = s.m_y1 + geometrize::commonutil::randomRange(-32, 32);
}

Here is the call graph for this function:

shapeContains()

bool geometrize::shapeContains	(	const geometrize::Shape &	container,
		const geometrize::Shape &	containee,
		const std::int32_t	xMin,
		const std::int32_t	yMin,
		const std::int32_t	xMax,
		const std::int32_t	yMax
	)

{
    return geometrize::scanlinesContain(rasterize(container, xMin, yMin, xMax, yMax), rasterize(containee, xMin, yMin, xMax, yMax));
}

Here is the call graph for this function:

shapesOverlap()

bool geometrize::shapesOverlap	(	const geometrize::Shape &	a,
		const geometrize::Shape &	b,
		const std::int32_t	xMin,
		const std::int32_t	yMin,
		const std::int32_t	xMax,
		const std::int32_t	yMax
	)

{
    return geometrize::scanlinesOverlap(geometrize::rasterize(a, xMin, yMin, xMax, yMax), geometrize::rasterize(b, xMin, yMin, xMax, yMax));
}

Here is the call graph for this function:

shapeToPixels()

std::vector< std::pair< std::int32_t, std::int32_t > > geometrize::shapeToPixels	(	const geometrize::Shape &	shape,
		const std::int32_t	xMin,
		const std::int32_t	yMin,
		const std::int32_t	xMax,
		const std::int32_t	yMax
	)

{
    const auto scanlines = geometrize::rasterize(shape, xMin, yMin, xMax, yMax);
    std::vector<std::pair<std::int32_t, std::int32_t>> points = {};
    for(const auto& scanline : scanlines) {
        for(std::int32_t x = scanline.x1; x <= scanline.x2; x++) {
            points.push_back({x, scanline.y});
        }
    }
    return points;
}

Here is the call graph for this function:

translate() [1/10]

void geometrize::translate	(	geometrize::Circle &	s,
		const float	x,
		const float	y
	)

{
    s.m_x += x;
    s.m_y += y;
}

translate() [2/10]

void geometrize::translate	(	geometrize::Ellipse &	s,
		const float	x,
		const float	y
	)

{
    s.m_x += x;
    s.m_y += y;
}

translate() [3/10]

void geometrize::translate	(	geometrize::Line &	s,
		const float	x,
		const float	y
	)

{
    s.m_x1 += x;
    s.m_y1 += y;
    s.m_x2 += x;
    s.m_y2 += y;
}

translate() [4/10]

void geometrize::translate	(	geometrize::Polyline &	s,
		const float	x,
		const float	y
	)

{
    for(auto& point : s.m_points) {
        point.first += x;
        point.second += y;
    }
}

translate() [5/10]

void geometrize::translate	(	geometrize::QuadraticBezier &	s,
		const float	x,
		const float	y
	)

{
    s.m_cx += x;
    s.m_cy += y;
    s.m_x1 += x;
    s.m_y1 += y;
    s.m_x2 += x;
    s.m_y2 += y;
}

translate() [6/10]

void geometrize::translate	(	geometrize::Rectangle &	s,
		const float	x,
		const float	y
	)

{
    s.m_x1 += x;
    s.m_y1 += y;
    s.m_x2 += x;
    s.m_y2 += y;
}

translate() [7/10]

void geometrize::translate	(	geometrize::RotatedEllipse &	s,
		const float	x,
		const float	y
	)

{
    s.m_x += x;
    s.m_y += y;
}

translate() [8/10]

void geometrize::translate	(	geometrize::RotatedRectangle &	s,
		const float	x,
		const float	y
	)

{
    s.m_x1 += x;
    s.m_y1 += y;
    s.m_x2 += x;
    s.m_y2 += y;
}

translate() [9/10]

void geometrize::translate	(	geometrize::Shape &	s,
		const float	x,
		const float	y
	)

{
    switch(s.getType()) {
    case geometrize::ShapeTypes::RECTANGLE:
        translate(static_cast<geometrize::Rectangle&>(s), x, y);
        break;
    case geometrize::ShapeTypes::ROTATED_RECTANGLE:
        translate(static_cast<geometrize::RotatedRectangle&>(s), x, y);
        break;
    case geometrize::ShapeTypes::TRIANGLE:
        translate(static_cast<geometrize::Triangle&>(s), x, y);
        break;
    case geometrize::ShapeTypes::ELLIPSE:
        translate(static_cast<geometrize::Ellipse&>(s), x, y);
        break;
    case geometrize::ShapeTypes::ROTATED_ELLIPSE:
        translate(static_cast<geometrize::RotatedEllipse&>(s), x, y);
        break;
    case geometrize::ShapeTypes::CIRCLE:
        translate(static_cast<geometrize::Circle&>(s), x, y);
        break;
    case geometrize::ShapeTypes::LINE:
        translate(static_cast<geometrize::Line&>(s), x, y);
        break;
    case geometrize::ShapeTypes::QUADRATIC_BEZIER:
        translate(static_cast<geometrize::QuadraticBezier&>(s), x, y);
        break;
    case geometrize::ShapeTypes::POLYLINE:
        translate(static_cast<geometrize::Polyline&>(s), x, y);
        break;
    default:
        assert(0 && "Bad shape type");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

translate() [10/10]

void geometrize::translate	(	geometrize::Triangle &	s,
		const float	x,
		const float	y
	)

{
    s.m_x1 += x;
    s.m_y1 += y;
    s.m_x2 += x;
    s.m_y2 += y;
    s.m_x3 += x;
    s.m_y3 += y;
}

trimScanlines()

std::vector< geometrize::Scanline > geometrize::trimScanlines	(	const std::vector< geometrize::Scanline > &	scanlines,
		std::int32_t	minX,
		std::int32_t	minY,
		std::int32_t	maxX,
		std::int32_t	maxY
	)

trimScanlines Crops the scanning width of an array of scanlines so they do not scan outside of the given area.

Parameters

scanlines	The scanlines to crop.
minX	The minimum x value to crop to.
minY	The minimum y value to crop to.
maxX	The maximum x value to crop to.
maxY	The maximum y value to crop to.

Returns

A new vector of cropped scanlines.

{
    std::vector<geometrize::Scanline> trimmedScanlines;
 
    for(const geometrize::Scanline& line : scanlines) {
        if(line.y < minY || line.y >= maxY) {
            continue;
        }
        if(line.x1 > line.x2) {
            continue;
        }
        const float x1 = geometrize::commonutil::clamp(line.x1, minX, maxX - 1);
        const float x2 = geometrize::commonutil::clamp(line.x2, minX, maxX - 1);
        trimmedScanlines.emplace_back(Scanline(line.y, x1, x2));
    }
    return trimmedScanlines;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

allShapes

const std::array< ShapeTypes, static_cast< std::size_t >(ShapeTypes::SHAPE_COUNT)> geometrize::allShapes

Initial value:

=
{
    ShapeTypes::RECTANGLE,
    ShapeTypes::ROTATED_RECTANGLE,
    ShapeTypes::TRIANGLE,
    ShapeTypes::ELLIPSE,
    ShapeTypes::ROTATED_ELLIPSE,
    ShapeTypes::CIRCLE,
    ShapeTypes::LINE,
    ShapeTypes::QUADRATIC_BEZIER,
    ShapeTypes::POLYLINE
}

allShapes is a convenient array of all of the members of ShapeTypes.

shapeTypeNames

const std::vector< std::pair< ShapeTypes, std::string > > geometrize::shapeTypeNames

Initial value:

=
{
    { ShapeTypes::RECTANGLE, "rectangle" },
    { ShapeTypes::ROTATED_RECTANGLE, "rotated_rectangle" },
    { ShapeTypes::TRIANGLE, "triangle" },
    { ShapeTypes::ELLIPSE, "ellipse" },
    { ShapeTypes::ROTATED_ELLIPSE, "rotated_ellipse" },
    { ShapeTypes::CIRCLE, "circle" },
    { ShapeTypes::LINE, "line" },
    { ShapeTypes::QUADRATIC_BEZIER, "quadratic_bezier" },
    { ShapeTypes::POLYLINE, "polyline" }
}

shapeTypeNames provides a convenient mapping to names of types of shape (all lower case, underscores instead of spaces e.g. rotated_ellipse).