geometrize::Model::ModelImpl Class Reference

Collaboration diagram for geometrize::Model::ModelImpl:

Public Member Functions
	ModelImpl (const geometrize::Bitmap &target)
	ModelImpl (const geometrize::Bitmap &target, const geometrize::Bitmap &initial)
	~ModelImpl ()=default
ModelImpl &	operator= (const ModelImpl &)=delete
	ModelImpl (const ModelImpl &)=delete
void	reset (const geometrize::rgba backgroundColor)
std::int32_t	getWidth () const
std::int32_t	getHeight () const
std::vector< geometrize::State >	getHillClimbState (const std::function< std::shared_ptr< geometrize::Shape >(void)> shapeCreator, const std::uint8_t alpha, const std::uint32_t shapeCount, const std::uint32_t maxShapeMutations, std::uint32_t maxThreads, const geometrize::core::EnergyFunction energyFunction)
std::vector< geometrize::ShapeResult >	step (const std::function< std::shared_ptr< geometrize::Shape >(void)> shapeCreator, const std::uint8_t alpha, const std::uint32_t shapeCount, const std::uint32_t maxShapeMutations, const std::uint32_t maxThreads, const geometrize::core::EnergyFunction &energyFunction, const geometrize::ShapeAcceptancePreconditionFunction &addShapePrecondition)
geometrize::ShapeResult	drawShape (const std::shared_ptr< geometrize::Shape > shape, const geometrize::rgba color)
geometrize::Bitmap &	getTarget ()
geometrize::Bitmap &	getCurrent ()
const geometrize::Bitmap &	getTarget () const
const geometrize::Bitmap &	getCurrent () const
void	setSeed (const std::uint32_t seed)

Private Attributes
geometrize::Bitmap	m_target
	The target bitmap, the bitmap we aim to approximate. More...
geometrize::Bitmap	m_current
	The current bitmap. More...
double	m_lastScore
	Score derived from calculating the difference between bitmaps. More...
std::atomic< std::uint32_t >	m_baseRandomSeed
	The base value used for seeding the random number generator (the one the user has control over). More...
std::atomic< std::uint32_t >	m_randomSeedOffset
	Seed used for random number generation. Note: incremented by each std::async call used for model stepping. More...

Static Private Attributes
static const std::uint32_t	defaultMaxThreads {4}

Constructor & Destructor Documentation

ModelImpl() [1/3]

geometrize::Model::ModelImpl::ModelImpl ( const geometrize::Bitmap &  target )

inline

                                              :
        m_target{target},
        m_current{target.getWidth(), target.getHeight(), geometrize::commonutil::getAverageImageColor(m_target)},
        m_lastScore{geometrize::core::differenceFull(m_target, m_current)},
        m_baseRandomSeed{0U},
        m_randomSeedOffset{0U}
    {}

ModelImpl() [2/3]

geometrize::Model::ModelImpl::ModelImpl ( const geometrize::Bitmap &  target, const geometrize::Bitmap &  initial  )

inline

                                                                               :
        m_target{target},
        m_current{initial},
        m_lastScore{geometrize::core::differenceFull(m_target, m_current)},
        m_baseRandomSeed{0U},
        m_randomSeedOffset{0U}
    {
        assert(m_target.getWidth() == m_current.getWidth());
        assert(m_target.getHeight() == m_current.getHeight());
    }

Here is the call graph for this function:

~ModelImpl()

geometrize::Model::ModelImpl::~ModelImpl ( )

default

ModelImpl() [3/3]

geometrize::Model::ModelImpl::ModelImpl ( const ModelImpl &  )

delete

Member Function Documentation

drawShape()

geometrize::ShapeResult geometrize::Model::ModelImpl::drawShape ( const std::shared_ptr< geometrize::Shape >  shape, const geometrize::rgba  color  )

inline

    {
        const std::vector<geometrize::Scanline> lines{shape->rasterize(*shape)};
        const geometrize::Bitmap before{m_current};
        geometrize::drawLines(m_current, color, lines);
 
        m_lastScore = geometrize::core::differencePartial(m_target, before, m_current, m_lastScore, lines);
 
        const geometrize::ShapeResult result{m_lastScore, color, shape};
        return result;
    }

Here is the call graph for this function:

getCurrent() [1/2]

geometrize::Bitmap & geometrize::Model::ModelImpl::getCurrent ( )

inline

    {
        return m_current;
    }

getCurrent() [2/2]

const geometrize::Bitmap & geometrize::Model::ModelImpl::getCurrent ( ) const

inline

    {
        return m_current;
    }

getHeight()

std::int32_t geometrize::Model::ModelImpl::getHeight ( ) const

inline

    {
        return m_target.getHeight();
    }

Here is the call graph for this function:

getHillClimbState()

std::vector< geometrize::State > geometrize::Model::ModelImpl::getHillClimbState ( const std::function< std::shared_ptr< geometrize::Shape >(void)>  shapeCreator, const std::uint8_t  alpha, const std::uint32_t  shapeCount, const std::uint32_t  maxShapeMutations, std::uint32_t  maxThreads, const geometrize::core::EnergyFunction  energyFunction  )

inline

    {
        // Ensure that the maximum number of threads is a sane value
        if(maxThreads == 0) {
            maxThreads = std::thread::hardware_concurrency();
            if(maxThreads == 0) {
                assert(0 && "Failed to get the number of concurrent threads supported by the implementation");
                maxThreads = defaultMaxThreads;
            }
        }
 
        std::vector<std::future<geometrize::State>> futures{maxThreads};
        for(std::uint32_t i = 0; i < futures.size(); i++) {
            std::future<geometrize::State> handle{std::async(std::launch::async, [&](const std::uint32_t seed, const double lastScore) {
                // Ensure that the results of the random generation are the same between tasks with identical settings
                // The RNG is thread-local and std::async may use a thread pool (which is why this is necessary)
                // Note this implementation requires maxThreads to be the same between tasks for each task to produce the same results.
                geometrize::commonutil::seedRandomGenerator(seed);
 
                geometrize::Bitmap buffer{m_current};
                return core::bestHillClimbState(shapeCreator, alpha, shapeCount, maxShapeMutations, m_target, m_current, buffer, lastScore, energyFunction);
            }, m_baseRandomSeed + m_randomSeedOffset++, m_lastScore)};
            futures[i] = std::move(handle);
        }
 
        std::vector<geometrize::State> states;
 
        for(auto& f : futures) {
            try {
                states.emplace_back(f.get());
            } catch(std::exception& e) {
                assert(0 && "Encountered exception when getting hill climb state");
                std::cout << e.what() << std::endl;
                throw e;
            } catch (...) {
                assert(0 && "Encountered exception when getting hill climb state");
                throw;
            }
        }
        return states;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

getTarget() [1/2]

geometrize::Bitmap & geometrize::Model::ModelImpl::getTarget ( )

inline

    {
        return m_target;
    }

getTarget() [2/2]

const geometrize::Bitmap & geometrize::Model::ModelImpl::getTarget ( ) const

inline

    {
        return m_target;
    }

getWidth()

std::int32_t geometrize::Model::ModelImpl::getWidth ( ) const

inline

    {
        return m_target.getWidth();
    }

Here is the call graph for this function:

operator=()

ModelImpl & geometrize::Model::ModelImpl::operator= ( const ModelImpl &  )

delete

reset()

void geometrize::Model::ModelImpl::reset ( const geometrize::rgba  backgroundColor )

inline

    {
        m_current.fill(backgroundColor);
        m_lastScore = geometrize::core::differenceFull(m_target, m_current);
    }

Here is the call graph for this function:

setSeed()

void geometrize::Model::ModelImpl::setSeed ( const std::uint32_t  seed )

inline

    {
        m_baseRandomSeed = seed;
    }

step()

std::vector< geometrize::ShapeResult > geometrize::Model::ModelImpl::step ( const std::function< std::shared_ptr< geometrize::Shape >(void)>  shapeCreator, const std::uint8_t  alpha, const std::uint32_t  shapeCount, const std::uint32_t  maxShapeMutations, const std::uint32_t  maxThreads, const geometrize::core::EnergyFunction &  energyFunction, const geometrize::ShapeAcceptancePreconditionFunction &  addShapePrecondition  )

inline

    {
        std::vector<geometrize::State> states{getHillClimbState(shapeCreator, alpha, shapeCount, maxShapeMutations, maxThreads, energyFunction)};
        if(states.empty()) {
            assert(0 && "Failed to get a hill climb state");
            return {};
        }
 
        std::vector<geometrize::State>::iterator it = std::min_element(states.begin(), states.end(), [](const geometrize::State& a, const geometrize::State& b) {
            return a.m_score < b.m_score;
        });
 
        // Draw the shape onto the image
        const std::shared_ptr<geometrize::Shape> shape = it->m_shape;
        const std::vector<geometrize::Scanline> lines{shape->rasterize(*shape)};
        const geometrize::rgba color(geometrize::core::computeColor(m_target, m_current, lines, alpha));
        const geometrize::Bitmap before{m_current};
        geometrize::drawLines(m_current, color, lines);
 
        // Check for an improvement - if not, roll back and return no result
        const double newScore = geometrize::core::differencePartial(m_target, before, m_current, m_lastScore, lines);
        const auto& addShapeCondition = addShapePrecondition ? addShapePrecondition : defaultAddShapePrecondition;
        if(!addShapeCondition(m_lastScore, newScore, *shape, lines, color, before, m_current, m_target)) {
            m_current = before;
            return {};
        }
 
        // Improvement - set new baseline and return the new shape
        m_lastScore = newScore;
        const geometrize::ShapeResult result{m_lastScore, color, shape};
        return { result };
    }

Here is the call graph for this function:

Member Data Documentation

defaultMaxThreads

const std::uint32_t geometrize::Model::ModelImpl::defaultMaxThreads {4}

staticprivate

m_baseRandomSeed

std::atomic<std::uint32_t> geometrize::Model::ModelImpl::m_baseRandomSeed

private

The base value used for seeding the random number generator (the one the user has control over).

m_current

geometrize::Bitmap geometrize::Model::ModelImpl::m_current

private

The current bitmap.

m_lastScore

double geometrize::Model::ModelImpl::m_lastScore

private

Score derived from calculating the difference between bitmaps.

m_randomSeedOffset

std::atomic<std::uint32_t> geometrize::Model::ModelImpl::m_randomSeedOffset

private

Seed used for random number generation. Note: incremented by each std::async call used for model stepping.

m_target

geometrize::Bitmap geometrize::Model::ModelImpl::m_target

private

The target bitmap, the bitmap we aim to approximate.

---

The documentation for this class was generated from the following file:

• /home/appveyor/projects/geometrize-lib-docs/geometrize-lib/geometrize/geometrize/model.cpp