geometrize::commonutil Namespace Reference

Functions
static thread_local std::mt19937	mt (std::random_device{}())
void	seedRandomGenerator (std::uint32_t seed)
	seedRandomGenerator Seeds the (thread-local) random number generators. More...
std::int32_t	randomRange (std::int32_t min, std::int32_t max)
	randomRange Returns a random integer in the range, inclusive. Uses thread-local random number generators under the hood. To ensure deterministic shape generation that can be repeated for different seeds, this should be used for shape mutation, but nothing else. More...
geometrize::rgba	getAverageImageColor (const geometrize::Bitmap &image)
	getAverageImageColor Computes the average RGB color of the pixels in the bitmap. More...
bool	scanlinesContainTransparentPixels (const std::vector< geometrize::Scanline > &scanlines, const geometrize::Bitmap &image, int minAlpha)
	scanlinesContainTransparentPixels Returns true if the scanlines contain transparent pixels in the given image More...
std::tuple< std::int32_t, std::int32_t, std::int32_t, std::int32_t >	mapShapeBoundsToImage (const geometrize::ImageRunnerShapeBoundsOptions &options, const geometrize::Bitmap &image)
	mapShapeBoundsToImage Maps the given shape bound percentages to the given image, returning a bounding rectangle, or the whole image if the bounds were invalid More...
template<typename T >
T	clamp (const T &value, const T &lower, const T &upper)
	clamp Clamps a value within a range. More...

Variables
static thread_local std::uniform_int_distribution< std::int32_t >	pick

Function Documentation

clamp()

template<typename T >

T geometrize::commonutil::clamp	(	const T &	value,
		const T &	lower,
		const T &	upper
	)

clamp Clamps a value within a range.

Parameters

value	The value to clamp.
lower	The lower bound of the range.
upper	The upper bound of the range.

Returns

The clamped value.

{
    return (std::max)(lower, (std::min)(value, upper));
}

Here is the caller graph for this function:

getAverageImageColor()

geometrize::rgba geometrize::commonutil::getAverageImageColor

(

const geometrize::Bitmap &

image

)

getAverageImageColor Computes the average RGB color of the pixels in the bitmap.

Parameters

image

The image whose average color will be calculated.

Returns

The average RGB color of the image, RGBA8888 format. Alpha is set to opaque (255).

{
    const std::vector<std::uint8_t>& data{image.getDataRef()};
    const std::size_t size{data.size()};
    if(size == 0) {
        return geometrize::rgba{0, 0, 0, 0};
    }
 
    const std::size_t numPixels{size / 4U};
 
    std::uint32_t totalRed{0};
    std::uint32_t totalGreen{0};
    std::uint32_t totalBlue{0};
    for(std::size_t i = 0; i < size; i += 4U) {
        totalRed += data[i];
        totalGreen += data[i + 1U];
        totalBlue += data[i + 2U];
    }
 
    return geometrize::rgba{
        static_cast<std::uint8_t>(totalRed / numPixels),
        static_cast<std::uint8_t>(totalGreen / numPixels),
        static_cast<std::uint8_t>(totalBlue / numPixels),
        static_cast<std::uint8_t>(UINT8_MAX)
    };
}

Here is the call graph for this function:

mapShapeBoundsToImage()

std::tuple< std::int32_t, std::int32_t, std::int32_t, std::int32_t > geometrize::commonutil::mapShapeBoundsToImage	(	const geometrize::ImageRunnerShapeBoundsOptions &	options,
		const geometrize::Bitmap &	image
	)

mapShapeBoundsToImage Maps the given shape bound percentages to the given image, returning a bounding rectangle, or the whole image if the bounds were invalid

Parameters

The	options to map to the image
The	image to map the options around

Returns

The mapped shape bounds (xMin, yMin, xMax, yMax)

{
    if(!options.enabled) {
        return { 0, 0, image.getWidth() - 1, image.getHeight() - 1 };
    }
 
    const double xMinPx = options.xMinPercent / 100.0 * static_cast<double>(image.getWidth() - 1);
    const double yMinPx = options.yMinPercent / 100.0 * static_cast<double>(image.getHeight() - 1);
    const double xMaxPx = options.xMaxPercent / 100.0 * static_cast<double>(image.getWidth() - 1);
    const double yMaxPx = options.yMaxPercent / 100.0 * static_cast<double>(image.getHeight() - 1);
 
    std::int32_t xMin = static_cast<std::int32_t>(std::round(std::min(std::min(xMinPx, xMaxPx), image.getWidth() - 1.0)));
    std::int32_t yMin = static_cast<std::int32_t>(std::round(std::min(std::min(yMinPx, yMaxPx), image.getHeight() - 1.0)));
    std::int32_t xMax = static_cast<std::int32_t>(std::round(std::min(std::max(xMinPx, xMaxPx), image.getWidth() - 1.0)));
    std::int32_t yMax = static_cast<std::int32_t>(std::round(std::min(std::max(yMinPx, yMaxPx), image.getHeight() - 1.0)));
 
    // If we have a bad width or height, which is bound to cause problems - use the whole image
    if(xMax - xMin <= 1) {
        xMin = 0;
        xMax = image.getWidth() - 1;
    }
    if(yMax - yMin <= 1) {
        yMin = 0;
        yMax = image.getHeight() - 1;
    }
 
    return std::make_tuple(xMin, yMin, xMax, yMax);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mt()

static thread_local std::mt19937 geometrize::commonutil::mt ( std::random_device{}  () )

static

Here is the caller graph for this function:

randomRange()

std::int32_t geometrize::commonutil::randomRange	(	std::int32_t	min,
		std::int32_t	max
	)

randomRange Returns a random integer in the range, inclusive. Uses thread-local random number generators under the hood. To ensure deterministic shape generation that can be repeated for different seeds, this should be used for shape mutation, but nothing else.

Parameters

min	The lower bound.
max	The upper bound.

Returns

The random integer in the range.

{
    assert(min <= max);
    return pick(mt, std::uniform_int_distribution<std::int32_t>::param_type{min, max});
}

Here is the call graph for this function:

Here is the caller graph for this function:

scanlinesContainTransparentPixels()

bool geometrize::commonutil::scanlinesContainTransparentPixels	(	const std::vector< geometrize::Scanline > &	scanlines,
		const geometrize::Bitmap &	image,
		int	minAlpha
	)

scanlinesContainTransparentPixels Returns true if the scanlines contain transparent pixels in the given image

Parameters

scanlines	The scanlines to check
image	The image whose pixels to check
minAlpha	The minimum alpha level (0-255) to consider transparent

Returns

True if the scanlines contains any transparent pixels

{
    const auto& trimmedScanlines = geometrize::trimScanlines(scanlines, 0, 0, image.getWidth(), image.getHeight());
    for(const geometrize::Scanline& scanline : trimmedScanlines) {
        for(int x = scanline.x1; x < scanline.x2; x++) {
            if(image.getPixel(x, scanline.y).a < minAlpha) {
                return true;
            }
        }
    }
    return false;
}

Here is the call graph for this function:

seedRandomGenerator()

void geometrize::commonutil::seedRandomGenerator

(

std::uint32_t

seed

)

seedRandomGenerator Seeds the (thread-local) random number generators.

Parameters

seed	The random seed.

{
    mt.seed(seed);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

pick

thread_local std::uniform_int_distribution<std::int32_t> geometrize::commonutil::pick

static