geometrize::task::ImageTask::ImageTaskImpl Class Reference

Collaboration diagram for geometrize::task::ImageTask::ImageTaskImpl:

Public Member Functions
	ImageTaskImpl (ImageTask *pQ, const std::string &displayName, Bitmap &bitmap, Qt::ConnectionType workerConnectionType)
	ImageTaskImpl (ImageTask *pQ, const std::string &displayName, Bitmap &bitmap, const Bitmap &initial, Qt::ConnectionType workerConnectionType)
	~ImageTaskImpl ()
ImageTaskImpl &	operator= (const ImageTaskImpl &)=delete
	ImageTaskImpl (const ImageTaskImpl &)=delete
geometrize::script::GeometrizerEngine &	getGeometrizer ()
Bitmap &	getTarget ()
Bitmap &	getCurrent ()
const Bitmap &	getTarget () const
const Bitmap &	getCurrent () const
std::uint32_t	getWidth () const
std::uint32_t	getHeight () const
std::string	getDisplayName () const
std::size_t	getTaskId () const
bool	isStepping () const
void	stepModel ()
void	drawShape (const std::shared_ptr< geometrize::Shape > shape, const geometrize::rgba color)
void	drawBackgroundRectangle (const geometrize::rgba color)
void	modelWillStep ()
void	modelDidStep (const std::vector< geometrize::ShapeResult > shapes)
preferences::ImageTaskPreferences &	getPreferences ()
void	setPreferences (const preferences::ImageTaskPreferences preferences)

Private Member Functions
void	init (const Qt::ConnectionType connectionType)
void	connectSignals (const Qt::ConnectionType connectionType)
void	disconnectAll ()

Static Private Member Functions
static std::size_t	getId ()

Private Attributes
ImageTask *	q
preferences::ImageTaskPreferences	m_preferences
const std::string	m_displayName
	Runtime configuration parameters for the runner. More...
const std::size_t	m_id
	The display name of the image task. More...
QThread	m_workerThread
	A unique id for the image task. More...
ImageTaskWorker	m_worker
	Thread that the image task worker runs on. More...
geometrize::script::GeometrizerEngine	m_geometrizer
	The image task worker. More...

Constructor & Destructor Documentation

ImageTaskImpl() [1/3]

geometrize::task::ImageTask::ImageTaskImpl::ImageTaskImpl ( ImageTask *  pQ, const std::string &  displayName, Bitmap &  bitmap, Qt::ConnectionType  workerConnectionType  )

inline

                                                                                                                      :
        q{pQ}, m_preferences{}, m_displayName{displayName}, m_id{getId()}, m_worker{bitmap}
    {
        init(workerConnectionType);
    }

ImageTaskImpl() [2/3]

geometrize::task::ImageTask::ImageTaskImpl::ImageTaskImpl ( ImageTask *  pQ, const std::string &  displayName, Bitmap &  bitmap, const Bitmap &  initial, Qt::ConnectionType  workerConnectionType  )

inline

                                                                                                                                             :
        q{pQ}, m_preferences{}, m_displayName{displayName}, m_id{getId()}, m_worker{bitmap, initial}
    {
        init(workerConnectionType);
    }

~ImageTaskImpl()

geometrize::task::ImageTask::ImageTaskImpl::~ImageTaskImpl ( )

inline

    {
        disconnectAll();
 
        m_workerThread.quit();
        if(!m_workerThread.wait(1000)) {
            m_workerThread.terminate();
            m_workerThread.wait();
        }
    }

Here is the call graph for this function:

ImageTaskImpl() [3/3]

geometrize::task::ImageTask::ImageTaskImpl::ImageTaskImpl ( const ImageTaskImpl &  )

delete

Member Function Documentation

connectSignals()

void geometrize::task::ImageTask::ImageTaskImpl::connectSignals ( const Qt::ConnectionType  connectionType )

inlineprivate

    {
        q->connect(q, &ImageTask::signal_step, &m_worker, &ImageTaskWorker::step, connectionType);
        q->connect(q, &ImageTask::signal_drawShape, &m_worker, &ImageTaskWorker::drawShape, connectionType);
        q->connect(&m_worker, &ImageTaskWorker::signal_willStep, q, &ImageTask::modelWillStep, Qt::BlockingQueuedConnection);
        q->connect(&m_worker, &ImageTaskWorker::signal_didStep, q, &ImageTask::modelDidStep, Qt::BlockingQueuedConnection);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

disconnectAll()

void geometrize::task::ImageTask::ImageTaskImpl::disconnectAll ( )

inlineprivate

    {
        q->disconnect(q, &ImageTask::signal_step, &m_worker, &ImageTaskWorker::step);
        q->disconnect(q, &ImageTask::signal_drawShape, &m_worker, &ImageTaskWorker::drawShape);
        q->disconnect(&m_worker, &ImageTaskWorker::signal_willStep, q, &ImageTask::modelWillStep);
        q->disconnect(&m_worker, &ImageTaskWorker::signal_didStep, q, &ImageTask::modelDidStep);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

drawBackgroundRectangle()

void geometrize::task::ImageTask::ImageTaskImpl::drawBackgroundRectangle ( const geometrize::rgba  color )

inline

    {
        const std::int32_t w = m_worker.getTarget().getWidth();
        const std::int32_t h = m_worker.getTarget().getHeight();
        const std::shared_ptr<geometrize::Rectangle> rectangle = std::make_shared<geometrize::Rectangle>(0, 0, w, h);
        rectangle->rasterize = [w, h](const geometrize::Shape& s) { return geometrize::rasterize(static_cast<const geometrize::Rectangle&>(s), 0, 0, w, h); };
 
        emit q->signal_drawShape(rectangle, color);
    }

Here is the call graph for this function:

drawShape()

void geometrize::task::ImageTask::ImageTaskImpl::drawShape ( const std::shared_ptr< geometrize::Shape >  shape, const geometrize::rgba  color  )

inline

    {
        emit q->signal_drawShape(shape, color);
    }

getCurrent() [1/2]

Bitmap& geometrize::task::ImageTask::ImageTaskImpl::getCurrent ( )

inline

    {
        return m_worker.getCurrent();
    }

Here is the call graph for this function:

getCurrent() [2/2]

const Bitmap& geometrize::task::ImageTask::ImageTaskImpl::getCurrent ( ) const

inline

    {
        return m_worker.getCurrent();
    }

Here is the call graph for this function:

getDisplayName()

std::string geometrize::task::ImageTask::ImageTaskImpl::getDisplayName ( ) const

inline

    {
        return m_displayName;
    }

getGeometrizer()

geometrize::script::GeometrizerEngine& geometrize::task::ImageTask::ImageTaskImpl::getGeometrizer ( )

inline

    {
        return m_geometrizer;
    }

getHeight()

std::uint32_t geometrize::task::ImageTask::ImageTaskImpl::getHeight ( ) const

inline

    {
        return m_worker.getCurrent().getHeight();
    }

Here is the call graph for this function:

getId()

static std::size_t geometrize::task::ImageTask::ImageTaskImpl::getId ( )

inlinestaticprivate

    {
        static std::atomic<std::size_t> id{0U};
        return id++;
    }

getPreferences()

preferences::ImageTaskPreferences& geometrize::task::ImageTask::ImageTaskImpl::getPreferences ( )

inline

    {
        return m_preferences;
    }

getTarget() [1/2]

Bitmap& geometrize::task::ImageTask::ImageTaskImpl::getTarget ( )

inline

    {
        return m_worker.getTarget();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

getTarget() [2/2]

const Bitmap& geometrize::task::ImageTask::ImageTaskImpl::getTarget ( ) const

inline

    {
        return m_worker.getTarget();
    }

Here is the call graph for this function:

getTaskId()

std::size_t geometrize::task::ImageTask::ImageTaskImpl::getTaskId ( ) const

inline

    {
        return m_id;
    }

getWidth()

std::uint32_t geometrize::task::ImageTask::ImageTaskImpl::getWidth ( ) const

inline

    {
        return m_worker.getCurrent().getWidth();
    }

Here is the call graph for this function:

init()

void geometrize::task::ImageTask::ImageTaskImpl::init ( const Qt::ConnectionType  connectionType )

inlineprivate

    {
        const auto& shapeBounds = m_preferences.getImageRunnerOptions().shapeBounds;
 
        m_geometrizer.getEngine()->set_global(chaiscript::var(q), "task");
 
        const auto [xMin, yMin, xMax, yMax] = geometrize::commonutil::mapShapeBoundsToImage(shapeBounds, getTarget());
 
        m_geometrizer.getEngine()->set_global(chaiscript::var(xMin), "xMin");
        m_geometrizer.getEngine()->set_global(chaiscript::var(yMin), "yMin");
        m_geometrizer.getEngine()->set_global(chaiscript::var(xMax), "xMax");
        m_geometrizer.getEngine()->set_global(chaiscript::var(yMax), "yMax");
 
        qRegisterMetaType<std::vector<geometrize::ShapeResult>>();
        qRegisterMetaType<geometrize::ImageRunnerOptions>();
        qRegisterMetaType<std::function<std::shared_ptr<geometrize::Shape>()>>();
        qRegisterMetaType<std::shared_ptr<geometrize::Shape>>();
        qRegisterMetaType<geometrize::rgba>();
        qRegisterMetaType<geometrize::core::EnergyFunction>();
        qRegisterMetaType<geometrize::ShapeAcceptancePreconditionFunction>();
 
        m_worker.moveToThread(&m_workerThread);
 
        connectSignals(connectionType);
 
        m_workerThread.start();
    }

Here is the call graph for this function:

isStepping()

bool geometrize::task::ImageTask::ImageTaskImpl::isStepping ( ) const

inline

    {
        return m_worker.isStepping();
    }

Here is the call graph for this function:

modelDidStep()

void geometrize::task::ImageTask::ImageTaskImpl::modelDidStep ( const std::vector< geometrize::ShapeResult >  shapes )

inline

    {
        emit q->signal_modelDidStep(shapes);
    }

modelWillStep()

void geometrize::task::ImageTask::ImageTaskImpl::modelWillStep ( )

inline

    {
        emit q->signal_modelWillStep();
    }

operator=()

ImageTaskImpl& geometrize::task::ImageTask::ImageTaskImpl::operator= ( const ImageTaskImpl &  )

delete

setPreferences()

void geometrize::task::ImageTask::ImageTaskImpl::setPreferences ( const preferences::ImageTaskPreferences  preferences )

inline

    {
        m_preferences = preferences;
        emit q->signal_preferencesSet();
    }

stepModel()

void geometrize::task::ImageTask::ImageTaskImpl::stepModel ( )

inline

    {
        const bool isScriptModeEnabled = m_preferences.isScriptModeEnabled();
        const auto imageRunnerOptions = m_preferences.getImageRunnerOptions();
 
        // Install the scripts that are required for the geometrization process
        m_geometrizer.installScripts(m_preferences.getScripts());
 
        // Install the additional precondition scripts to decide whether to accept/reject shapes offered back by the library
        std::vector<std::pair<std::string, std::string>> addShapePreconditionScripts;
        for(const auto& script : m_preferences.getScripts()) {
            if(QString::fromStdString(script.first).startsWith("add_shape_precondition_")) { // NOTE prefix is also used by the scripting widgets elsewhere
                addShapePreconditionScripts.push_back(std::make_pair(script.first, script.second));
            }
        }
 
        const auto addShapePreconditionFunction =
                [this](const std::vector<std::pair<std::string, std::string>>& scripts)
                -> geometrize::ShapeAcceptancePreconditionFunction
        {
            if(scripts.empty()) {
                return nullptr;
            }
 
            const geometrize::ShapeAcceptancePreconditionFunction g = [this, scripts](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) {
                std::vector<bool> retValues;
                try {
                    m_geometrizer.getEngine()->set_global(chaiscript::var(lastScore), "candidateShapeLastScore");
                    m_geometrizer.getEngine()->set_global(chaiscript::var(newScore), "candidateShapeNextScore");
                    m_geometrizer.getEngine()->set_global(chaiscript::var(shape), "candidateShape");
                    m_geometrizer.getEngine()->set_global(chaiscript::var(lines), "candidateScanlines");
                    m_geometrizer.getEngine()->set_global(chaiscript::var(color), "candidateShapeColor");
                    m_geometrizer.getEngine()->set_global(chaiscript::var(before), "beforeBitmap");
                    m_geometrizer.getEngine()->set_global(chaiscript::var(after), "afterBitmap");
                    m_geometrizer.getEngine()->set_global(chaiscript::var(target), "targetBitmap");
 
                    for(const auto& script : scripts) {
                        retValues.emplace_back(m_geometrizer.getEngine()->eval<bool>(script.second));
                    }
                    return std::all_of(retValues.begin(), retValues.end(), [](const bool b) { return b == true; });
                } catch(std::exception& e) {
                    std::cout << e.what() << std::endl;
                }
                return false;
            };
            return g;
        }(addShapePreconditionScripts);
 
        // Opt out of the multithreaded scripts if the engine is disabled (use the default/C++ implementations)
        if(!isScriptModeEnabled) {
            emit q->signal_step(imageRunnerOptions, nullptr, nullptr, addShapePreconditionFunction);
            return;
        }
 
        const auto& target = m_worker.getTarget();
 
        const auto bounds = geometrize::commonutil::mapShapeBoundsToImage(imageRunnerOptions.shapeBounds, target);
 
        // Scripting is enabled - clone the entire geometrizer engine
        // This is important because many threads will be working with it when geometrizing shapes
        // and we don't want to mess with the state of the engine on the main thread while these threads are working with it
        const auto geometrizerEngineClone = [this]() {
            auto engine = std::make_shared<geometrize::script::GeometrizerEngine>(m_geometrizer.getEngine()->get_state());
            engine->installScripts(m_preferences.getScripts());
            return engine;
        }();
 
        // Pick the shape creation function
        const auto shapeCreator = [geometrizerEngineClone, imageRunnerOptions, bounds]() {
            // NOTE - this method uses shared_from_this to keep the engine alive
            const auto [xMin, yMin, xMax, yMax] = bounds;
            return geometrizerEngineClone->makeShapeCreator(imageRunnerOptions.shapeTypes, xMin, yMin, xMax, yMax);
        }();
 
        // Pick the energy calculation function
        const geometrize::core::EnergyFunction energyFunction = [geometrizerEngineClone]() {
            // NOTE - this method uses shared_from_this to keep the engine alive
            return geometrizerEngineClone->makeEnergyFunction();
        }();
 
        emit q->signal_step(imageRunnerOptions, shapeCreator, energyFunction, addShapePreconditionFunction);
    }

Here is the call graph for this function:

Member Data Documentation

m_displayName

const std::string geometrize::task::ImageTask::ImageTaskImpl::m_displayName

private

Runtime configuration parameters for the runner.

m_geometrizer

geometrize::script::GeometrizerEngine geometrize::task::ImageTask::ImageTaskImpl::m_geometrizer

private

The image task worker.

m_id

const std::size_t geometrize::task::ImageTask::ImageTaskImpl::m_id

private

The display name of the image task.

m_preferences

preferences::ImageTaskPreferences geometrize::task::ImageTask::ImageTaskImpl::m_preferences

private

m_worker

ImageTaskWorker geometrize::task::ImageTask::ImageTaskImpl::m_worker

private

Thread that the image task worker runs on.

m_workerThread

QThread geometrize::task::ImageTask::ImageTaskImpl::m_workerThread

private

A unique id for the image task.

q

ImageTask* geometrize::task::ImageTask::ImageTaskImpl::q

private

---

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

• /home/appveyor/projects/geometrize-docs/geometrize/geometrize/task/imagetask.cpp