geometrize::core Namespace Reference

Typedefs
using	EnergyFunction = std::function< double(const std::vector< geometrize::Scanline > &lines, const std::uint32_t alpha, const geometrize::Bitmap &target, const geometrize::Bitmap &current, geometrize::Bitmap &buffer, double score)>
	EnergyFunction Type alias for a function that calculates a measure of the improvement adding the scanlines of a shape provides - lower energy is better. More...

Functions
double	defaultEnergyFunction (const std::vector< geometrize::Scanline > &lines, const std::uint32_t alpha, const geometrize::Bitmap &target, const geometrize::Bitmap &current, geometrize::Bitmap &buffer, double score)
	defaultEnergyFunction The default/built-in energy function that calculates a measure of the improvement adding the scanlines of a shape provides - lower energy is better. More...
geometrize::rgba	computeColor (const geometrize::Bitmap &target, const geometrize::Bitmap &current, const std::vector< geometrize::Scanline > &lines, std::uint8_t alpha)
	computeColor Calculates the color of the scanlines. More...
double	differenceFull (const geometrize::Bitmap &first, const geometrize::Bitmap &second)
	differenceFull Calculates the root-mean-square error between two bitmaps. More...
double	differencePartial (const geometrize::Bitmap &target, const geometrize::Bitmap &before, const geometrize::Bitmap &after, double score, const std::vector< Scanline > &lines)
	differencePartial Calculates the root-mean-square error between the parts of the two bitmaps within the scanline mask. This is for optimization purposes, it lets us calculate new error values only for parts of the image we know have changed. More...
geometrize::State	bestHillClimbState (const std::function< std::shared_ptr< geometrize::Shape >(void)> &shapeCreator, std::uint32_t alpha, std::uint32_t n, std::uint32_t age, const geometrize::Bitmap &target, const geometrize::Bitmap &current, geometrize::Bitmap &buffer, double lastScore, const EnergyFunction &customEnergyFunction=nullptr)
	bestHillClimbState Gets the best state using a hill climbing algorithm. More...

Typedef Documentation

EnergyFunction

using geometrize::core::EnergyFunction = typedef std::function<double( const std::vector<geometrize::Scanline>& lines, const std::uint32_t alpha, const geometrize::Bitmap& target, const geometrize::Bitmap& current, geometrize::Bitmap& buffer, double score)>

EnergyFunction Type alias for a function that calculates a measure of the improvement adding the scanlines of a shape provides - lower energy is better.

The core functions for Geometrize.

Author

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

Parameters

lines	The scanlines of the shape.
alpha	The alpha of the scanlines.
target	The target bitmap.
current	The current bitmap.
buffer	The buffer bitmap.
score	The score.

Returns

The energy measure.

Function Documentation

bestHillClimbState()

geometrize::State geometrize::core::bestHillClimbState	(	const std::function< std::shared_ptr< geometrize::Shape >(void)> &	shapeCreator,
		std::uint32_t	alpha,
		std::uint32_t	n,
		std::uint32_t	age,
		const geometrize::Bitmap &	target,
		const geometrize::Bitmap &	current,
		geometrize::Bitmap &	buffer,
		double	lastScore,
		const EnergyFunction &	customEnergyFunction = nullptr
	)

bestHillClimbState Gets the best state using a hill climbing algorithm.

Parameters

shapeCreator	A function that will create the shapes that will be chosen from.
alpha	The opacity of the shape.
n	The number of random states to generate.
age	The number of hillclimbing steps.
target	The target bitmap.
current	The current bitmap.
buffer	The buffer bitmap.
lastScore	The last score.
customEnergyFunction	An optional function to calculate the energy (if unspecified a default implementation is used).

Returns

The best state acquired from hill climbing i.e. the one with the lowest energy.

{
    const EnergyFunction& e = customEnergyFunction ? customEnergyFunction : geometrize::core::defaultEnergyFunction;
 
    const geometrize::State state{bestRandomState(shapeCreator, alpha, n, target, current, buffer, lastScore, e)};
    return ::hillClimb(state, age, target, current, buffer, lastScore, e);
}

Here is the call graph for this function:

Here is the caller graph for this function:

computeColor()

geometrize::rgba geometrize::core::computeColor	(	const geometrize::Bitmap &	target,
		const geometrize::Bitmap &	current,
		const std::vector< geometrize::Scanline > &	lines,
		std::uint8_t	alpha
	)

computeColor Calculates the color of the scanlines.

Parameters

target	The target image.
current	The current image.
lines	The scanlines.
alpha	The alpha of the scanline.

Returns

The color of the scanlines.

{
    // Early out to avoid integer divide by 0
    if(lines.empty()) {
        return geometrize::rgba{0, 0, 0, 0};
    }
 
    std::int64_t totalRed{0};
    std::int64_t totalGreen{0};
    std::int64_t totalBlue{0};
    std::int64_t count{0};
    const std::int32_t a{static_cast<std::int32_t>(257.0f * 255.0f / static_cast<float>(alpha))};
 
    // For each scanline
    for(const geometrize::Scanline& line : lines) {
        const std::int32_t y{line.y};
        for(std::int32_t x = line.x1; x <= line.x2; x++) {
            // Get the overlapping target and current colors
            const geometrize::rgba t(target.getPixel(x, y));
            const geometrize::rgba c(current.getPixel(x, y));
 
            const std::int32_t tr{t.r};
            const std::int32_t tg{t.g};
            const std::int32_t tb{t.b};
            const std::int32_t cr{c.r};
            const std::int32_t cg{c.g};
            const std::int32_t cb{c.b};
 
            // Mix the red, green and blue components, blending by the given alpha value
            totalRed += static_cast<std::int64_t>((tr - cr) * a + cr * 257);
            totalGreen += static_cast<std::int64_t>((tg - cg) * a + cg * 257);
            totalBlue += static_cast<std::int64_t>((tb - cb) * a + cb * 257);
            count++;
        }
    }
 
    const std::int32_t rr{static_cast<std::int32_t>(totalRed / count) >> 8};
    const std::int32_t gg{static_cast<std::int32_t>(totalGreen / count) >> 8};
    const std::int32_t bb{static_cast<std::int32_t>(totalBlue / count) >> 8};
 
    // Scale totals down to 0-255 range and return average blended color
    const std::uint8_t r{static_cast<std::uint8_t>(commonutil::clamp(rr, INT32_C(0), INT32_C(255)))};
    const std::uint8_t g{static_cast<std::uint8_t>(commonutil::clamp(gg, INT32_C(0), INT32_C(255)))};
    const std::uint8_t b{static_cast<std::uint8_t>(commonutil::clamp(bb, INT32_C(0), INT32_C(255)))};
 
    return geometrize::rgba{r, g, b, alpha};
}

Here is the call graph for this function:

Here is the caller graph for this function:

defaultEnergyFunction()

double geometrize::core::defaultEnergyFunction	(	const std::vector< geometrize::Scanline > &	lines,
		const std::uint32_t	alpha,
		const geometrize::Bitmap &	target,
		const geometrize::Bitmap &	current,
		geometrize::Bitmap &	buffer,
		double	score
	)

defaultEnergyFunction The default/built-in energy function that calculates a measure of the improvement adding the scanlines of a shape provides - lower energy is better.

Parameters

lines	The scanlines of the shape.
alpha	The alpha of the scanlines.
target	The target bitmap.
current	The current bitmap.
buffer	The buffer bitmap.
score	The score.

Returns

The energy measure.

{
    const geometrize::rgba color(geometrize::core::computeColor(target, current, lines, alpha)); // Calculate best color for areas covered by the scanlines
    geometrize::copyLines(buffer, current, lines); // Copy area covered by scanlines to buffer bitmap
    geometrize::drawLines(buffer, color, lines); // Blend scanlines into the buffer using the color calculated earlier
    return geometrize::core::differencePartial(target, current, buffer, score, lines); // Get error measure between areas of current and modified buffers covered by scanlines
}

Here is the call graph for this function:

Here is the caller graph for this function:

differenceFull()

double geometrize::core::differenceFull	(	const geometrize::Bitmap &	first,
		const geometrize::Bitmap &	second
	)

differenceFull Calculates the root-mean-square error between two bitmaps.

Parameters

first	The first bitmap.
second	The second bitmap.

Returns

The difference/error measure between the two bitmaps.

{
    assert(first.getWidth() == second.getWidth());
    assert(first.getHeight() == second.getHeight());
 
    const std::size_t width{first.getWidth()};
    const std::size_t height{first.getHeight()};
    std::uint64_t total{0};
 
    for(std::size_t y = 0; y < height; y++) {
        for(std::size_t x = 0; x < width; x++) {
            const geometrize::rgba f(first.getPixel(x, y));
            const geometrize::rgba s(second.getPixel(x, y));
 
            const std::int32_t dr = {static_cast<std::int32_t>(f.r) - static_cast<std::int32_t>(s.r)};
            const std::int32_t dg = {static_cast<std::int32_t>(f.g) - static_cast<std::int32_t>(s.g)};
            const std::int32_t db = {static_cast<std::int32_t>(f.b) - static_cast<std::int32_t>(s.b)};
            const std::int32_t da = {static_cast<std::int32_t>(f.a) - static_cast<std::int32_t>(s.a)};
            total += (dr * dr + dg * dg + db * db + da * da);
        }
    }
    return std::sqrt(static_cast<double>(total) / (static_cast<double>(width) * static_cast<double>(height) * 4.0)) / 255.0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

differencePartial()

double geometrize::core::differencePartial	(	const geometrize::Bitmap &	target,
		const geometrize::Bitmap &	before,
		const geometrize::Bitmap &	after,
		double	score,
		const std::vector< Scanline > &	lines
	)

differencePartial Calculates the root-mean-square error between the parts of the two bitmaps within the scanline mask. This is for optimization purposes, it lets us calculate new error values only for parts of the image we know have changed.

Parameters

target	The target bitmap.
before	The bitmap before the change.
after	The bitmap after the change.
score	The score.
lines	The scanlines.

Returns

The difference/error between the two bitmaps, masked by the scanlines.

{
    const std::uint64_t rgbaCount{target.getWidth() * target.getHeight() * 4U};
    std::uint64_t total{static_cast<std::uint64_t>((score * 255.0) * (score * 255.0) * rgbaCount)};
    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 t(target.getPixel(x, y));
            const geometrize::rgba b(before.getPixel(x, y));
            const geometrize::rgba a(after.getPixel(x, y));
 
            const std::int32_t dtbr{static_cast<std::int32_t>(t.r) - static_cast<std::int32_t>(b.r)};
            const std::int32_t dtbg{static_cast<std::int32_t>(t.g) - static_cast<std::int32_t>(b.g)};
            const std::int32_t dtbb{static_cast<std::int32_t>(t.b) - static_cast<std::int32_t>(b.b)};
            const std::int32_t dtba{static_cast<std::int32_t>(t.a) - static_cast<std::int32_t>(b.a)};
 
            const std::int32_t dtar{static_cast<std::int32_t>(t.r) - static_cast<std::int32_t>(a.r)};
            const std::int32_t dtag{static_cast<std::int32_t>(t.g) - static_cast<std::int32_t>(a.g)};
            const std::int32_t dtab{static_cast<std::int32_t>(t.b) - static_cast<std::int32_t>(a.b)};
            const std::int32_t dtaa{static_cast<std::int32_t>(t.a) - static_cast<std::int32_t>(a.a)};
 
            total -= static_cast<std::uint64_t>(dtbr * dtbr + dtbg * dtbg + dtbb * dtbb + dtba * dtba);
            total += static_cast<std::uint64_t>(dtar * dtar + dtag * dtag + dtab * dtab + dtaa * dtaa);
        }
    }
 
    const double result{std::sqrt(static_cast<double>(total) / static_cast<double>(rgbaCount)) / 255.0};
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function: