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

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);
     }

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);
     }

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:

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

delete

Member Function Documentation

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:

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:

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), w, h); };
 
         emit q->signal_drawShape(rectangle, color);
     }

Here is the call graph for this function:

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

inline

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

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

inline

     {
         return m_worker.getCurrent();
     }

Here is the call graph for this function:

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

inline

     {
         return m_worker.getCurrent();
     }

Here is the call graph for this function:

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

inline

     {
         return m_displayName;
     }

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

inline

     {
         return m_geometrizer;
     }

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

inline

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

Here is the call graph for this function:

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

inlinestaticprivate

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

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

inline

     {
         return m_preferences;
     }

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

inline

     {
         return m_worker.getTarget();
     }

Here is the call graph for this function:

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

inline

     {
         return m_worker.getTarget();
     }

Here is the call graph for this function:

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

inline

     {
         return m_id;
     }

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

inline

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

Here is the call graph for this function:

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

inlineprivate

     {
         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>();
 
         m_worker.moveToThread(&m_workerThread);
         m_workerThread.start();
 
         connectSignals(connectionType);
     }

Here is the call graph for this function:

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

inline

     {
         return m_worker.isStepping();
     }

Here is the call graph for this function:

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

inline

     {
         emit q->signal_modelDidStep(shapes);
     }

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

inline

     {
         emit q->signal_modelWillStep();
     }

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

delete

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

inline

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

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

inline

     {
         const bool isScriptModeEnabled = m_preferences.isScriptModeEnabled();
         const auto imageRunnerOptions = m_preferences.getImageRunnerOptions();
 
         // Early out if the script engine is disabled (use the default/C++ implementations)
         if(!isScriptModeEnabled) {
             emit q->signal_step(imageRunnerOptions, nullptr, nullptr);
             return;
         }
 
         const auto scripts = m_preferences.getScripts();
         const std::int32_t targetWidth = m_worker.getTarget().getWidth();
         const std::int32_t targetHeight = m_worker.getTarget().getHeight();
 
         // 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
         const auto geometrizerEngineClone = [this, scripts]() {
             auto engine = std::make_shared<geometrize::script::GeometrizerEngine>(m_geometrizer.getEngine()->get_state());
 
             // Install the scripts that are required for the geometrization process
             engine->installScripts(scripts);
             return engine;
         }();
 
         // Pick the shape creation function
         const auto shapeCreator = [geometrizerEngineClone, imageRunnerOptions, targetWidth, targetHeight]() {
             // NOTE - this method uses shared_from_this to keep the engine alive
             return geometrizerEngineClone->makeShapeCreator(imageRunnerOptions.shapeTypes, targetWidth, targetHeight);
         }();
 
         // 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);
     }

Here is the call graph for this function:

Member Data Documentation

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

private

Runtime configuration parameters for the runner.

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

private

The image task worker.

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

private

The display name of the image task.

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

private

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

private

Thread that the image task worker runs on.

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

private

A unique id for the image task.

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

private

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

/home/travis/build/Tw1ddle/geometrize-docs/geometrize/geometrize/task/imagetask.cpp

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation