The GeometrizerEngine class encapsulates script-based setup and mutation methods for geometrizing shapes. More...

#include <geometrizerengine.h>

Inheritance diagram for geometrize::script::GeometrizerEngine:

Collaboration diagram for geometrize::script::GeometrizerEngine:

Signals
void	signal_scriptEvaluationSucceeded (const std::string &functionName, const std::string &code)
	signal_scriptEvaluationSucceeded Signal dispatched when a script is successfully parsed/evaluated. More...

void	signal_scriptEvaluationFailed (const std::string &functionName, const std::string &code, const std::string &errorMessage)
	signal_scriptEvaluationFailed Signal dispatched when a script fails to parse/evaluate. More...

Public Member Functions
	GeometrizerEngine ()

	GeometrizerEngine (const chaiscript::ChaiScript::State &state)

virtual	~GeometrizerEngine ()=default

GeometrizerEngine &	operator= (const GeometrizerEngine &)=delete

	GeometrizerEngine (const GeometrizerEngine &)=delete

void	installScripts (const std::map< std::string, std::string > &scripts)

geometrize::core::EnergyFunction	makeEnergyFunction () const
	makeEnergyFunction Returns a custom energy function for the core geometrization algorithm. More...

std::function< std::shared_ptr < geometrize::Shape >)>	makeShapeCreator (geometrize::ShapeTypes types, std::int32_t w, std::int32_t h) const
	makeShapeCreator Returns a function that generates shapes for the core geometrization algorithm This is passed to the geometrization algorithm and called across many threads. So it's unsafe to change any state used by the script engine while we're busy adding shapes. It also captures "this", meaning the engine won't be destroyed until the shape creation code is finished using it. More...

chaiscript::ChaiScript *	getEngine ()
	getEngine Gets a pointer to the script engine used by the shape mutation engine. More...

Private Member Functions
template<class T >
void	installShapeScript (const std::string &functionName, const std::map< std::string, std::string > &scripts)

void	installCustomEnergyScript (const std::string &functionName, const std::string &scriptCode)

void	setup (geometrize::Circle &shape) const

void	mutate (geometrize::Circle &shape) const

void	setSetupFunction (const std::function< void(geometrize::Circle &)> &f)

void	setMutatorFunction (const std::function< void(geometrize::Circle &)> &f)

void	setup (geometrize::Ellipse &shape) const

void	mutate (geometrize::Ellipse &shape) const

void	setSetupFunction (const std::function< void(geometrize::Ellipse &)> &f)

void	setMutatorFunction (const std::function< void(geometrize::Ellipse &)> &f)

void	setup (geometrize::Line &shape) const

void	mutate (geometrize::Line &shape) const

void	setSetupFunction (const std::function< void(geometrize::Line &)> &f)

void	setMutatorFunction (const std::function< void(geometrize::Line &)> &f)

void	setup (geometrize::Polyline &shape) const

void	mutate (geometrize::Polyline &shape) const

void	setSetupFunction (const std::function< void(geometrize::Polyline &)> &f)

void	setMutatorFunction (const std::function< void(geometrize::Polyline &)> &f)

void	setup (geometrize::QuadraticBezier &shape) const

void	mutate (geometrize::QuadraticBezier &shape) const

void	setSetupFunction (const std::function< void(geometrize::QuadraticBezier &)> &f)

void	setMutatorFunction (const std::function< void(geometrize::QuadraticBezier &)> &f)

void	setup (geometrize::Rectangle &shape) const

void	mutate (geometrize::Rectangle &shape) const

void	setSetupFunction (const std::function< void(geometrize::Rectangle &)> &f)

void	setMutatorFunction (const std::function< void(geometrize::Rectangle &)> &f)

void	setup (geometrize::RotatedEllipse &shape) const

void	mutate (geometrize::RotatedEllipse &shape) const

void	setSetupFunction (const std::function< void(geometrize::RotatedEllipse &)> &f)

void	setMutatorFunction (const std::function< void(geometrize::RotatedEllipse &)> &f)

void	setup (geometrize::RotatedRectangle &shape) const

void	mutate (geometrize::RotatedRectangle &shape) const

void	setSetupFunction (const std::function< void(geometrize::RotatedRectangle &)> &f)

void	setMutatorFunction (const std::function< void(geometrize::RotatedRectangle &)> &f)

void	setup (geometrize::Triangle &shape) const

void	mutate (geometrize::Triangle &shape) const

void	setSetupFunction (const std::function< void(geometrize::Triangle &)> &f)

void	setMutatorFunction (const std::function< void(geometrize::Triangle &)> &f)

void	setCustomEnergyFunction (const geometrize::core::EnergyFunction &f)

Private Attributes
std::function< void(geometrize::Circle &)>	m_setupCircle

std::function< void(geometrize::Ellipse &)>	m_setupEllipse

std::function< void(geometrize::Line &)>	m_setupLine

std::function< void(geometrize::Polyline &)>	m_setupPolyline

std::function< void(geometrize::QuadraticBezier &)>	m_setupQuadraticBezier

std::function< void(geometrize::Rectangle &)>	m_setupRectangle

std::function< void(geometrize::RotatedEllipse &)>	m_setupRotatedEllipse

std::function< void(geometrize::RotatedRectangle &)>	m_setupRotatedRectangle

std::function< void(geometrize::Triangle &)>	m_setupTriangle

std::function< void(geometrize::Circle &)>	m_mutateCircle

std::function< void(geometrize::Ellipse &)>	m_mutateEllipse

std::function< void(geometrize::Line &)>	m_mutateLine

std::function< void(geometrize::Polyline &)>	m_mutatePolyline

std::function< void(geometrize::QuadraticBezier &)>	m_mutateQuadraticBezier

std::function< void(geometrize::Rectangle &)>	m_mutateRectangle

std::function< void(geometrize::RotatedEllipse &)>	m_mutateRotatedEllipse

std::function< void(geometrize::RotatedRectangle &)>	m_mutateRotatedRectangle

std::function< void(geometrize::Triangle &)>	m_mutateTriangle

geometrize::core::EnergyFunction	m_customEnergyFunction

std::unique_ptr < chaiscript::ChaiScript >	m_engine

Detailed Description

The GeometrizerEngine class encapsulates script-based setup and mutation methods for geometrizing shapes.

Constructor & Destructor Documentation

geometrize::script::GeometrizerEngine::GeometrizerEngine ( )

                                      : m_engine{script::createShapeMutatorEngine()}
 {
 }

Here is the call graph for this function:

geometrize::script::GeometrizerEngine::GeometrizerEngine ( const chaiscript::ChaiScript::State & state )

                                                                            : m_engine{script::createShapeMutatorEngine()}
 {
     m_engine->set_state(state);
 }

Here is the call graph for this function:

virtual geometrize::script::GeometrizerEngine::~GeometrizerEngine ( )

virtualdefault

geometrize::script::GeometrizerEngine::GeometrizerEngine ( const GeometrizerEngine & )

delete

Member Function Documentation

chaiscript::ChaiScript * geometrize::script::GeometrizerEngine::getEngine ( )

getEngine Gets a pointer to the script engine used by the shape mutation engine.

Returns: A pointer to the script engine used by the shape mutation engine.

 {
     return m_engine.get();
 }

Here is the caller graph for this function:

void geometrize::script::GeometrizerEngine::installCustomEnergyScript	(	const std::string &	functionName,
		const std::string &	scriptCode
	)

inlineprivate

     {
         try {
             m_engine->eval(scriptCode);
         } catch(...) {
             // Either syntax error or the function was already defined
             //assert(0 && "Encountered script error when adding custom energy function");
         }
 
         try {
             const auto f{m_engine->eval<geometrize::core::EnergyFunction>(functionName)};
 
             const geometrize::core::EnergyFunction g = [f](
                     const std::vector<geometrize::Scanline>& lines,
                     const std::uint32_t alpha,
                     const geometrize::Bitmap& target,
                     const geometrize::Bitmap& current,
                     geometrize::Bitmap& buffer,
                     const double score) {
                 try {
                     return f(lines, alpha, target, current, buffer, score);
                 } catch(std::exception& e) {
                     std::cout << e.what() << std::endl;
                     return 0.0;
                 }
             };
 
             setCustomEnergyFunction(g);
             return;
         } catch(std::exception& e) {
             std::cout << e.what() << std::endl;
         }
 
         assert(0 && "Checking for unrecognized required function, will ignore it");
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void geometrize::script::GeometrizerEngine::installScripts ( const std::map< std::string, std::string > & scripts )

 {
     installShapeScript<geometrize::Circle>("setupCircle", scripts);
     installShapeScript<geometrize::Ellipse>("setupEllipse", scripts);
     installShapeScript<geometrize::Line>("setupLine", scripts);
     installShapeScript<geometrize::Polyline>("setupPolyline", scripts);
     installShapeScript<geometrize::QuadraticBezier>("setupQuadraticBezier", scripts);
     installShapeScript<geometrize::Rectangle>("setupRectangle", scripts);
     installShapeScript<geometrize::RotatedEllipse>("setupRotatedEllipse", scripts);
     installShapeScript<geometrize::RotatedRectangle>("setupRotatedRectangle", scripts);
     installShapeScript<geometrize::Triangle>("setupTriangle", scripts);
 
     installShapeScript<geometrize::Circle>("mutateCircle", scripts);
     installShapeScript<geometrize::Ellipse>("mutateEllipse", scripts);
     installShapeScript<geometrize::Line>("mutateLine", scripts);
     installShapeScript<geometrize::Polyline>("mutatePolyline", scripts);
     installShapeScript<geometrize::QuadraticBezier>("mutateQuadraticBezier", scripts);
     installShapeScript<geometrize::Rectangle>("mutateRectangle", scripts);
     installShapeScript<geometrize::RotatedEllipse>("mutateRotatedEllipse", scripts);
     installShapeScript<geometrize::RotatedRectangle>("mutateRotatedRectangle", scripts);
     installShapeScript<geometrize::Triangle>("mutateTriangle", scripts);
 
     const auto iter = scripts.find("customEnergyFunction");
     if(iter != scripts.end()) {
         installCustomEnergyScript(iter->first, iter->second);
     }
 }

Here is the call graph for this function:

template<class T >

void geometrize::script::GeometrizerEngine::installShapeScript	(	const std::string &	functionName,
		const std::map< std::string, std::string > &	scripts
	)

inlineprivate

     {
         try {
             const auto it{scripts.find(functionName)};
             assert(it != scripts.end());
             m_engine->eval(it->second);
         } catch(...) {
             // Either syntax error or the function was already defined
             //assert(0 && "Encountered script error when adding default shape function");
         }
 
         try {
             const auto f{m_engine->eval<std::function<void(T&)>>(functionName)};
 
             const auto g = [f](T& s) {
                 try {
                     f(s);
                 } catch(std::exception& e) {
                     std::cout << e.what() << std::endl;
                 }
             };
 
              const std::string setupPrefix{"setup"};
              const std::string mutatePrefix{"mutate"};
              if(functionName.find(setupPrefix) == 0) {
                  setSetupFunction(g);
                  return;
              } else if(functionName.find(mutatePrefix) == 0) {
                  setMutatorFunction(g);
                  return;
              }
         } catch(std::exception& e) {
             std::cout << e.what() << std::endl;
         }
 
         assert(0 && "Checking for unrecognized required function, will ignore it");
     }

Here is the call graph for this function:

geometrize::core::EnergyFunction geometrize::script::GeometrizerEngine::makeEnergyFunction ( ) const

inline

makeEnergyFunction Returns a custom energy function for the core geometrization algorithm.

Returns: An energy function, for passing to an ImageRunner.

     {
         auto self(shared_from_this());
         geometrize::core::EnergyFunction f = [self, this](const std::vector<geometrize::Scanline>& lines,
                 const std::uint32_t alpha,
                 const geometrize::Bitmap& target,
                 const geometrize::Bitmap& current,
                 geometrize::Bitmap& buffer,
                 double score) {
             return m_customEnergyFunction(lines, alpha, target, current, buffer, score);
         };
         return f;
     }

std::function<std::shared_ptr<geometrize::Shape>)> geometrize::script::GeometrizerEngine::makeShapeCreator	(	geometrize::ShapeTypes	types,
		std::int32_t	w,
		std::int32_t	h
	)		const

inline

makeShapeCreator Returns a function that generates shapes for the core geometrization algorithm This is passed to the geometrization algorithm and called across many threads. So it's unsafe to change any state used by the script engine while we're busy adding shapes. It also captures "this", meaning the engine won't be destroyed until the shape creation code is finished using it.

Returns: A function that generates shapes for the core geometrization algorithm, for passing to an ImageRunner.

     {
         auto self(shared_from_this());
         auto f = [self, this, types, w, h]() {
             std::shared_ptr<geometrize::Shape> s = geometrize::randomShapeOf(types);
 
             switch(s->getType()) {
             case geometrize::ShapeTypes::RECTANGLE: {
                 s->setup = [this](geometrize::Shape& s) { return setup(static_cast<geometrize::Rectangle&>(s)); };
                 s->mutate = [this](geometrize::Shape& s) { mutate(static_cast<geometrize::Rectangle&>(s)); };
                 s->rasterize = [w, h](const geometrize::Shape& s) { return geometrize::rasterize(static_cast<const geometrize::Rectangle&>(s), w, h); };
                 break;
             }
             case geometrize::ShapeTypes::ROTATED_RECTANGLE: {
                 s->setup = [this](geometrize::Shape& s) { return setup(static_cast<geometrize::RotatedRectangle&>(s)); };
                 s->mutate = [this](geometrize::Shape& s) { mutate(static_cast<geometrize::RotatedRectangle&>(s)); };
                 s->rasterize = [w, h](const geometrize::Shape& s) { return geometrize::rasterize(static_cast<const geometrize::RotatedRectangle&>(s), w, h); };
                 break;
             }
             case geometrize::ShapeTypes::TRIANGLE: {
                 s->setup = [this](geometrize::Shape& s) { return setup(static_cast<geometrize::Triangle&>(s)); };
                 s->mutate = [this](geometrize::Shape& s) { mutate(static_cast<geometrize::Triangle&>(s)); };
                 s->rasterize = [w, h](const geometrize::Shape& s) { return geometrize::rasterize(static_cast<const geometrize::Triangle&>(s), w, h); };
                 break;
             }
             case geometrize::ShapeTypes::ELLIPSE: {
                 s->setup = [this](geometrize::Shape& s) { return setup(static_cast<geometrize::Ellipse&>(s)); };
                 s->mutate = [this](geometrize::Shape& s) { mutate(static_cast<geometrize::Ellipse&>(s)); };
                 s->rasterize = [w, h](const geometrize::Shape& s) { return geometrize::rasterize(static_cast<const geometrize::Ellipse&>(s), w, h); };
                 break;
             }
             case geometrize::ShapeTypes::ROTATED_ELLIPSE: {
                 s->setup = [this](geometrize::Shape& s) { return setup(static_cast<geometrize::RotatedEllipse&>(s)); };
                 s->mutate = [this](geometrize::Shape& s) { mutate(static_cast<geometrize::RotatedEllipse&>(s)); };
                 s->rasterize = [w, h](const geometrize::Shape& s) { return geometrize::rasterize(static_cast<const geometrize::RotatedEllipse&>(s), w, h); };
                 break;
             }
             case geometrize::ShapeTypes::CIRCLE: {
                 s->setup = [this](geometrize::Shape& s) { return setup(static_cast<geometrize::Circle&>(s)); };
                 s->mutate = [this](geometrize::Shape& s) { mutate(static_cast<geometrize::Circle&>(s)); };
                 s->rasterize = [w, h](const geometrize::Shape& s) { return geometrize::rasterize(static_cast<const geometrize::Circle&>(s), w, h); };
                 break;
             }
             case geometrize::ShapeTypes::LINE: {
                 s->setup = [this](geometrize::Shape& s) { return setup(static_cast<geometrize::Line&>(s)); };
                 s->mutate = [this](geometrize::Shape& s) { mutate(static_cast<geometrize::Line&>(s)); };
                 s->rasterize = [w, h](const geometrize::Shape& s) { return geometrize::rasterize(static_cast<const geometrize::Line&>(s), w, h); };
                 break;
             }
             case geometrize::ShapeTypes::QUADRATIC_BEZIER: {
                 s->setup = [this](geometrize::Shape& s) { return setup(static_cast<geometrize::QuadraticBezier&>(s)); };
                 s->mutate = [this](geometrize::Shape& s) { mutate(static_cast<geometrize::QuadraticBezier&>(s)); };
                 s->rasterize = [w, h](const geometrize::Shape& s) { return geometrize::rasterize(static_cast<const geometrize::QuadraticBezier&>(s), w, h); };
                 break;
             }
             case geometrize::ShapeTypes::POLYLINE: {
                 s->setup = [this](geometrize::Shape& s) { return setup(static_cast<geometrize::Polyline&>(s)); };
                 s->mutate = [this](geometrize::Shape& s) { mutate(static_cast<geometrize::Polyline&>(s)); };
                 s->rasterize = [w, h](const geometrize::Shape& s) { return geometrize::rasterize(static_cast<const geometrize::Polyline&>(s), w, h); };
                 break;
             }
             default:
                 assert(0 && "Bad shape type");
             }
 
             return s;
         };
 
         return f;
     }

Here is the call graph for this function:

void geometrize::script::GeometrizerEngine::mutate ( geometrize::Circle & shape ) const

inlineprivate

     {
         m_mutateCircle(shape);
     }

Here is the caller graph for this function:

void geometrize::script::GeometrizerEngine::mutate ( geometrize::Ellipse & shape ) const

inlineprivate

     {
         m_mutateEllipse(shape);
     }

void geometrize::script::GeometrizerEngine::mutate ( geometrize::Line & shape ) const

inlineprivate

     {
         m_mutateLine(shape);
     }

void geometrize::script::GeometrizerEngine::mutate ( geometrize::Polyline & shape ) const

inlineprivate

     {
         m_mutatePolyline(shape);
     }

void geometrize::script::GeometrizerEngine::mutate ( geometrize::QuadraticBezier & shape ) const

inlineprivate

     {
         m_mutateQuadraticBezier(shape);
     }

void geometrize::script::GeometrizerEngine::mutate ( geometrize::Rectangle & shape ) const

inlineprivate

     {
         m_mutateRectangle(shape);
     }

void geometrize::script::GeometrizerEngine::mutate ( geometrize::RotatedEllipse & shape ) const

inlineprivate

     {
         m_mutateRotatedEllipse(shape);
     }

void geometrize::script::GeometrizerEngine::mutate ( geometrize::RotatedRectangle & shape ) const

inlineprivate

     {
         m_mutateRotatedRectangle(shape);
     }

void geometrize::script::GeometrizerEngine::mutate ( geometrize::Triangle & shape ) const

inlineprivate

     {
         m_mutateTriangle(shape);
     }

GeometrizerEngine& geometrize::script::GeometrizerEngine::operator= ( const GeometrizerEngine & )

delete

void geometrize::script::GeometrizerEngine::setCustomEnergyFunction ( const geometrize::core::EnergyFunction & f )

inlineprivate

     {
         m_customEnergyFunction = f;
     }

Here is the caller graph for this function:

void geometrize::script::GeometrizerEngine::setMutatorFunction ( const std::function< void(geometrize::Circle &)> & f )

inlineprivate

     {
         m_mutateCircle = f;
     }

Here is the caller graph for this function:

void geometrize::script::GeometrizerEngine::setMutatorFunction ( const std::function< void(geometrize::Ellipse &)> & f )

inlineprivate

     {
         m_mutateEllipse = f;
     }

void geometrize::script::GeometrizerEngine::setMutatorFunction ( const std::function< void(geometrize::Line &)> & f )

inlineprivate

     {
         m_mutateLine = f;
     }

void geometrize::script::GeometrizerEngine::setMutatorFunction ( const std::function< void(geometrize::Polyline &)> & f )

inlineprivate

     {
         m_mutatePolyline = f;
     }

void geometrize::script::GeometrizerEngine::setMutatorFunction ( const std::function< void(geometrize::QuadraticBezier &)> & f )

inlineprivate

     {
         m_mutateQuadraticBezier = f;
     }

void geometrize::script::GeometrizerEngine::setMutatorFunction ( const std::function< void(geometrize::Rectangle &)> & f )

inlineprivate

     {
         m_mutateRectangle = f;
     }

void geometrize::script::GeometrizerEngine::setMutatorFunction ( const std::function< void(geometrize::RotatedEllipse &)> & f )

inlineprivate

     {
         m_mutateRotatedEllipse = f;
     }

void geometrize::script::GeometrizerEngine::setMutatorFunction ( const std::function< void(geometrize::RotatedRectangle &)> & f )

inlineprivate

     {
         m_mutateRotatedRectangle = f;
     }

void geometrize::script::GeometrizerEngine::setMutatorFunction ( const std::function< void(geometrize::Triangle &)> & f )

inlineprivate

     {
         m_mutateTriangle = f;
     }

void geometrize::script::GeometrizerEngine::setSetupFunction ( const std::function< void(geometrize::Circle &)> & f )

inlineprivate

     {
         m_setupCircle = f;
     }

Here is the caller graph for this function:

void geometrize::script::GeometrizerEngine::setSetupFunction ( const std::function< void(geometrize::Ellipse &)> & f )

inlineprivate

     {
         m_setupEllipse = f;
     }

void geometrize::script::GeometrizerEngine::setSetupFunction ( const std::function< void(geometrize::Line &)> & f )

inlineprivate

     {
         m_setupLine = f;
     }

void geometrize::script::GeometrizerEngine::setSetupFunction ( const std::function< void(geometrize::Polyline &)> & f )

inlineprivate

     {
         m_setupPolyline = f;
     }

void geometrize::script::GeometrizerEngine::setSetupFunction ( const std::function< void(geometrize::QuadraticBezier &)> & f )

inlineprivate

     {
         m_setupQuadraticBezier = f;
     }

void geometrize::script::GeometrizerEngine::setSetupFunction ( const std::function< void(geometrize::Rectangle &)> & f )

inlineprivate

     {
         m_setupRectangle = f;
     }

void geometrize::script::GeometrizerEngine::setSetupFunction ( const std::function< void(geometrize::RotatedEllipse &)> & f )

inlineprivate

     {
         m_setupRotatedEllipse = f;
     }

void geometrize::script::GeometrizerEngine::setSetupFunction ( const std::function< void(geometrize::RotatedRectangle &)> & f )

inlineprivate

     {
         m_setupRotatedRectangle = f;
     }

void geometrize::script::GeometrizerEngine::setSetupFunction ( const std::function< void(geometrize::Triangle &)> & f )

inlineprivate

     {
         m_setupTriangle = f;
     }

void geometrize::script::GeometrizerEngine::setup ( geometrize::Circle & shape ) const

inlineprivate

     {
         m_setupCircle(shape);
     }

Here is the caller graph for this function:

void geometrize::script::GeometrizerEngine::setup ( geometrize::Ellipse & shape ) const

inlineprivate

     {
         m_setupEllipse(shape);
     }

void geometrize::script::GeometrizerEngine::setup ( geometrize::Line & shape ) const

inlineprivate

     {
         m_setupLine(shape);
     }

void geometrize::script::GeometrizerEngine::setup ( geometrize::Polyline & shape ) const

inlineprivate

     {
         m_setupPolyline(shape);
     }

void geometrize::script::GeometrizerEngine::setup ( geometrize::QuadraticBezier & shape ) const

inlineprivate

     {
         m_setupQuadraticBezier(shape);
     }

void geometrize::script::GeometrizerEngine::setup ( geometrize::Rectangle & shape ) const

inlineprivate

     {
         m_setupRectangle(shape);
     }

void geometrize::script::GeometrizerEngine::setup ( geometrize::RotatedEllipse & shape ) const

inlineprivate

     {
         m_setupRotatedEllipse(shape);
     }

void geometrize::script::GeometrizerEngine::setup ( geometrize::RotatedRectangle & shape ) const

inlineprivate

     {
         m_setupRotatedRectangle(shape);
     }

void geometrize::script::GeometrizerEngine::setup ( geometrize::Triangle & shape ) const

inlineprivate

     {
         m_setupTriangle(shape);
     }

void geometrize::script::GeometrizerEngine::signal_scriptEvaluationFailed	(	const std::string &	functionName,
		const std::string &	code,
		const std::string &	errorMessage
	)

signal

signal_scriptEvaluationFailed Signal dispatched when a script fails to parse/evaluate.

Parameters

functionName	The name of the function.
code	The code of the function.
error	The text of the error message, if any.

Here is the caller graph for this function:

void geometrize::script::GeometrizerEngine::signal_scriptEvaluationSucceeded	(	const std::string &	functionName,
		const std::string &	code
	)

signal

signal_scriptEvaluationSucceeded Signal dispatched when a script is successfully parsed/evaluated.

Parameters

functionName	The name of the function.
code	The code of the function.

Here is the caller graph for this function:

Member Data Documentation

geometrize::core::EnergyFunction geometrize::script::GeometrizerEngine::m_customEnergyFunction

private

std::unique_ptr<chaiscript::ChaiScript> geometrize::script::GeometrizerEngine::m_engine

private

std::function<void(geometrize::Circle&)> geometrize::script::GeometrizerEngine::m_mutateCircle

private

std::function<void(geometrize::Ellipse&)> geometrize::script::GeometrizerEngine::m_mutateEllipse

private

std::function<void(geometrize::Line&)> geometrize::script::GeometrizerEngine::m_mutateLine

private

std::function<void(geometrize::Polyline&)> geometrize::script::GeometrizerEngine::m_mutatePolyline

private

std::function<void(geometrize::QuadraticBezier&)> geometrize::script::GeometrizerEngine::m_mutateQuadraticBezier

private

std::function<void(geometrize::Rectangle&)> geometrize::script::GeometrizerEngine::m_mutateRectangle

private

std::function<void(geometrize::RotatedEllipse&)> geometrize::script::GeometrizerEngine::m_mutateRotatedEllipse

private

std::function<void(geometrize::RotatedRectangle&)> geometrize::script::GeometrizerEngine::m_mutateRotatedRectangle

private

std::function<void(geometrize::Triangle&)> geometrize::script::GeometrizerEngine::m_mutateTriangle

private

std::function<void(geometrize::Circle&)> geometrize::script::GeometrizerEngine::m_setupCircle

private

std::function<void(geometrize::Ellipse&)> geometrize::script::GeometrizerEngine::m_setupEllipse

private

std::function<void(geometrize::Line&)> geometrize::script::GeometrizerEngine::m_setupLine

private

std::function<void(geometrize::Polyline&)> geometrize::script::GeometrizerEngine::m_setupPolyline

private

std::function<void(geometrize::QuadraticBezier&)> geometrize::script::GeometrizerEngine::m_setupQuadraticBezier

private

std::function<void(geometrize::Rectangle&)> geometrize::script::GeometrizerEngine::m_setupRectangle

private

std::function<void(geometrize::RotatedEllipse&)> geometrize::script::GeometrizerEngine::m_setupRotatedEllipse

private

std::function<void(geometrize::RotatedRectangle&)> geometrize::script::GeometrizerEngine::m_setupRotatedRectangle

private

std::function<void(geometrize::Triangle&)> geometrize::script::GeometrizerEngine::m_setupTriangle

private

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

/home/travis/build/Tw1ddle/geometrize-docs/geometrize/geometrize/script/geometrizerengine.h
/home/travis/build/Tw1ddle/geometrize-docs/geometrize/geometrize/script/geometrizerengine.cpp

Signals

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation