Geometrize  1.0
An application for geometrizing images into geometric primitives
Signals | Public Member Functions | Private Member Functions | Private Attributes | List of all members
geometrize::script::GeometrizerEngine Class Reference

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

#include <geometrizerengine.h>

Inheritance diagram for geometrize::script::GeometrizerEngine:
Inheritance graph
[legend]
Collaboration diagram for geometrize::script::GeometrizerEngine:
Collaboration graph
[legend]

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 xMin, std::int32_t yMin, std::int32_t xMax, std::int32_t yMax) 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

◆ GeometrizerEngine() [1/3]

geometrize::script::GeometrizerEngine::GeometrizerEngine ( )
43  : m_engine{script::createShapeMutatorEngine()}
44 {
45 }
Here is the call graph for this function:

◆ GeometrizerEngine() [2/3]

geometrize::script::GeometrizerEngine::GeometrizerEngine ( const chaiscript::ChaiScript::State &  state)
47  : m_engine{script::createShapeMutatorEngine()}
48 {
49  m_engine->set_state(state);
50 }
Here is the call graph for this function:

◆ ~GeometrizerEngine()

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

◆ GeometrizerEngine() [3/3]

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

Member Function Documentation

◆ getEngine()

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.
53 {
54  return m_engine.get();
55 }
Here is the caller graph for this function:

◆ installCustomEnergyScript()

void geometrize::script::GeometrizerEngine::installCustomEnergyScript ( const std::string &  functionName,
const std::string &  scriptCode 
)
inlineprivate
229  {
230  try {
231  m_engine->eval(scriptCode);
232  } catch(...) {
233  // Either syntax error or the function was already defined
234  //assert(0 && "Encountered script error when adding custom energy function");
235  }
236 
237  try {
238  const auto f{m_engine->eval<geometrize::core::EnergyFunction>(functionName)};
239 
240  const geometrize::core::EnergyFunction g = [f](
241  const std::vector<geometrize::Scanline>& lines,
242  const std::uint32_t alpha,
243  const geometrize::Bitmap& target,
244  const geometrize::Bitmap& current,
245  geometrize::Bitmap& buffer,
246  const double score) {
247  try {
248  return f(lines, alpha, target, current, buffer, score);
249  } catch(std::exception& e) {
250  std::cout << e.what() << std::endl;
251  return 0.0;
252  }
253  };
254 
255  setCustomEnergyFunction(g);
256  return;
257  } catch(std::exception& e) {
258  std::cout << e.what() << std::endl;
259  }
260 
261  assert(0 && "Checking for unrecognized required function, will ignore it");
262  }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ installScripts()

void geometrize::script::GeometrizerEngine::installScripts ( const std::map< std::string, std::string > &  scripts)
58 {
59  installShapeScript<geometrize::Circle>("setupCircle", scripts);
60  installShapeScript<geometrize::Ellipse>("setupEllipse", scripts);
61  installShapeScript<geometrize::Line>("setupLine", scripts);
62  installShapeScript<geometrize::Polyline>("setupPolyline", scripts);
63  installShapeScript<geometrize::QuadraticBezier>("setupQuadraticBezier", scripts);
64  installShapeScript<geometrize::Rectangle>("setupRectangle", scripts);
65  installShapeScript<geometrize::RotatedEllipse>("setupRotatedEllipse", scripts);
66  installShapeScript<geometrize::RotatedRectangle>("setupRotatedRectangle", scripts);
67  installShapeScript<geometrize::Triangle>("setupTriangle", scripts);
68 
69  installShapeScript<geometrize::Circle>("mutateCircle", scripts);
70  installShapeScript<geometrize::Ellipse>("mutateEllipse", scripts);
71  installShapeScript<geometrize::Line>("mutateLine", scripts);
72  installShapeScript<geometrize::Polyline>("mutatePolyline", scripts);
73  installShapeScript<geometrize::QuadraticBezier>("mutateQuadraticBezier", scripts);
74  installShapeScript<geometrize::Rectangle>("mutateRectangle", scripts);
75  installShapeScript<geometrize::RotatedEllipse>("mutateRotatedEllipse", scripts);
76  installShapeScript<geometrize::RotatedRectangle>("mutateRotatedRectangle", scripts);
77  installShapeScript<geometrize::Triangle>("mutateTriangle", scripts);
78 
79  const auto iter = scripts.find("customEnergyFunction");
80  if(iter != scripts.end()) {
81  installCustomEnergyScript(iter->first, iter->second);
82  }
83 }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ installShapeScript()

template<class T >
void geometrize::script::GeometrizerEngine::installShapeScript ( const std::string &  functionName,
const std::map< std::string, std::string > &  scripts 
)
inlineprivate
191  {
192  try {
193  const auto it{scripts.find(functionName)};
194  assert(it != scripts.end());
195  m_engine->eval(it->second);
196  } catch(...) {
197  // Either syntax error or the function was already defined
198  //assert(0 && "Encountered script error when adding default shape function");
199  }
200 
201  try {
202  const auto f{m_engine->eval<std::function<void(T&)>>(functionName)};
203 
204  const auto g = [f](T& s) {
205  try {
206  f(s);
207  } catch(std::exception& e) {
208  std::cout << e.what() << std::endl;
209  }
210  };
211 
212  const std::string setupPrefix{"setup"};
213  const std::string mutatePrefix{"mutate"};
214  if(functionName.find(setupPrefix) == 0) {
215  setSetupFunction(g);
216  return;
217  } else if(functionName.find(mutatePrefix) == 0) {
218  setMutatorFunction(g);
219  return;
220  }
221  } catch(std::exception& e) {
222  std::cout << e.what() << std::endl;
223  }
224 
225  assert(0 && "Checking for unrecognized required function, will ignore it");
226  }
Here is the call graph for this function:

◆ makeEnergyFunction()

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.
75  {
76  auto self(shared_from_this());
77  geometrize::core::EnergyFunction f = [self, this](const std::vector<geometrize::Scanline>& lines,
78  const std::uint32_t alpha,
79  const geometrize::Bitmap& target,
80  const geometrize::Bitmap& current,
81  geometrize::Bitmap& buffer,
82  double score) {
83  return m_customEnergyFunction(lines, alpha, target, current, buffer, score);
84  };
85  return f;
86  }

◆ makeShapeCreator()

std::function<std::shared_ptr<geometrize::Shape>)> geometrize::script::GeometrizerEngine::makeShapeCreator ( geometrize::ShapeTypes  types,
std::int32_t  xMin,
std::int32_t  yMin,
std::int32_t  xMax,
std::int32_t  yMax 
) 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.
96  {
97  auto self(shared_from_this());
98  auto f = [self, this, types, xMin, yMin, xMax, yMax]() {
99  std::shared_ptr<geometrize::Shape> s = geometrize::randomShapeOf(types);
100 
101  switch(s->getType()) {
102  case geometrize::ShapeTypes::RECTANGLE: {
103  s->setup = [this](geometrize::Shape& s) { return setup(static_cast<geometrize::Rectangle&>(s)); };
104  s->mutate = [this](geometrize::Shape& s) { mutate(static_cast<geometrize::Rectangle&>(s)); };
105  s->rasterize = [xMin, yMin, xMax, yMax](const geometrize::Shape& s) { return geometrize::rasterize(static_cast<const geometrize::Rectangle&>(s), xMin, yMin, xMax, yMax); };
106  break;
107  }
108  case geometrize::ShapeTypes::ROTATED_RECTANGLE: {
109  s->setup = [this](geometrize::Shape& s) { return setup(static_cast<geometrize::RotatedRectangle&>(s)); };
110  s->mutate = [this](geometrize::Shape& s) { mutate(static_cast<geometrize::RotatedRectangle&>(s)); };
111  s->rasterize = [xMin, yMin, xMax, yMax](const geometrize::Shape& s) { return geometrize::rasterize(static_cast<const geometrize::RotatedRectangle&>(s), xMin, yMin, xMax, yMax); };
112  break;
113  }
114  case geometrize::ShapeTypes::TRIANGLE: {
115  s->setup = [this](geometrize::Shape& s) { return setup(static_cast<geometrize::Triangle&>(s)); };
116  s->mutate = [this](geometrize::Shape& s) { mutate(static_cast<geometrize::Triangle&>(s)); };
117  s->rasterize = [xMin, yMin, xMax, yMax](const geometrize::Shape& s) { return geometrize::rasterize(static_cast<const geometrize::Triangle&>(s), xMin, yMin, xMax, yMax); };
118  break;
119  }
120  case geometrize::ShapeTypes::ELLIPSE: {
121  s->setup = [this](geometrize::Shape& s) { return setup(static_cast<geometrize::Ellipse&>(s)); };
122  s->mutate = [this](geometrize::Shape& s) { mutate(static_cast<geometrize::Ellipse&>(s)); };
123  s->rasterize = [xMin, yMin, xMax, yMax](const geometrize::Shape& s) { return geometrize::rasterize(static_cast<const geometrize::Ellipse&>(s), xMin, yMin, xMax, yMax); };
124  break;
125  }
126  case geometrize::ShapeTypes::ROTATED_ELLIPSE: {
127  s->setup = [this](geometrize::Shape& s) { return setup(static_cast<geometrize::RotatedEllipse&>(s)); };
128  s->mutate = [this](geometrize::Shape& s) { mutate(static_cast<geometrize::RotatedEllipse&>(s)); };
129  s->rasterize = [xMin, yMin, xMax, yMax](const geometrize::Shape& s) { return geometrize::rasterize(static_cast<const geometrize::RotatedEllipse&>(s), xMin, yMin, xMax, yMax); };
130  break;
131  }
132  case geometrize::ShapeTypes::CIRCLE: {
133  s->setup = [this](geometrize::Shape& s) { return setup(static_cast<geometrize::Circle&>(s)); };
134  s->mutate = [this](geometrize::Shape& s) { mutate(static_cast<geometrize::Circle&>(s)); };
135  s->rasterize = [xMin, yMin, xMax, yMax](const geometrize::Shape& s) { return geometrize::rasterize(static_cast<const geometrize::Circle&>(s), xMin, yMin, xMax, yMax); };
136  break;
137  }
138  case geometrize::ShapeTypes::LINE: {
139  s->setup = [this](geometrize::Shape& s) { return setup(static_cast<geometrize::Line&>(s)); };
140  s->mutate = [this](geometrize::Shape& s) { mutate(static_cast<geometrize::Line&>(s)); };
141  s->rasterize = [xMin, yMin, xMax, yMax](const geometrize::Shape& s) { return geometrize::rasterize(static_cast<const geometrize::Line&>(s), xMin, yMin, xMax, yMax); };
142  break;
143  }
144  case geometrize::ShapeTypes::QUADRATIC_BEZIER: {
145  s->setup = [this](geometrize::Shape& s) { return setup(static_cast<geometrize::QuadraticBezier&>(s)); };
146  s->mutate = [this](geometrize::Shape& s) { mutate(static_cast<geometrize::QuadraticBezier&>(s)); };
147  s->rasterize = [xMin, yMin, xMax, yMax](const geometrize::Shape& s) { return geometrize::rasterize(static_cast<const geometrize::QuadraticBezier&>(s), xMin, yMin, xMax, yMax); };
148  break;
149  }
150  case geometrize::ShapeTypes::POLYLINE: {
151  s->setup = [this](geometrize::Shape& s) { return setup(static_cast<geometrize::Polyline&>(s)); };
152  s->mutate = [this](geometrize::Shape& s) { mutate(static_cast<geometrize::Polyline&>(s)); };
153  s->rasterize = [xMin, yMin, xMax, yMax](const geometrize::Shape& s) { return geometrize::rasterize(static_cast<const geometrize::Polyline&>(s), xMin, yMin, xMax, yMax); };
154  break;
155  }
156  default:
157  assert(0 && "Bad shape type");
158  }
159 
160  return s;
161  };
162 
163  return f;
164  }
Here is the call graph for this function:

◆ mutate() [1/9]

void geometrize::script::GeometrizerEngine::mutate ( geometrize::Circle &  shape) const
inlineprivate
270  {
271  m_mutateCircle(shape);
272  }
Here is the caller graph for this function:

◆ mutate() [2/9]

void geometrize::script::GeometrizerEngine::mutate ( geometrize::Ellipse &  shape) const
inlineprivate
290  {
291  m_mutateEllipse(shape);
292  }

◆ mutate() [3/9]

void geometrize::script::GeometrizerEngine::mutate ( geometrize::Line &  shape) const
inlineprivate
310  {
311  m_mutateLine(shape);
312  }

◆ mutate() [4/9]

void geometrize::script::GeometrizerEngine::mutate ( geometrize::Polyline &  shape) const
inlineprivate
330  {
331  m_mutatePolyline(shape);
332  }

◆ mutate() [5/9]

void geometrize::script::GeometrizerEngine::mutate ( geometrize::QuadraticBezier &  shape) const
inlineprivate
350  {
351  m_mutateQuadraticBezier(shape);
352  }

◆ mutate() [6/9]

void geometrize::script::GeometrizerEngine::mutate ( geometrize::Rectangle &  shape) const
inlineprivate
370  {
371  m_mutateRectangle(shape);
372  }

◆ mutate() [7/9]

void geometrize::script::GeometrizerEngine::mutate ( geometrize::RotatedEllipse &  shape) const
inlineprivate
390  {
391  m_mutateRotatedEllipse(shape);
392  }

◆ mutate() [8/9]

void geometrize::script::GeometrizerEngine::mutate ( geometrize::RotatedRectangle &  shape) const
inlineprivate
410  {
411  m_mutateRotatedRectangle(shape);
412  }

◆ mutate() [9/9]

void geometrize::script::GeometrizerEngine::mutate ( geometrize::Triangle &  shape) const
inlineprivate
430  {
431  m_mutateTriangle(shape);
432  }

◆ operator=()

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

◆ setCustomEnergyFunction()

void geometrize::script::GeometrizerEngine::setCustomEnergyFunction ( const geometrize::core::EnergyFunction &  f)
inlineprivate
445  {
446  m_customEnergyFunction = f;
447  }
Here is the caller graph for this function:

◆ setMutatorFunction() [1/9]

void geometrize::script::GeometrizerEngine::setMutatorFunction ( const std::function< void(geometrize::Circle &)> &  f)
inlineprivate
280  {
281  m_mutateCircle = f;
282  }
Here is the caller graph for this function:

◆ setMutatorFunction() [2/9]

void geometrize::script::GeometrizerEngine::setMutatorFunction ( const std::function< void(geometrize::Ellipse &)> &  f)
inlineprivate
300  {
301  m_mutateEllipse = f;
302  }

◆ setMutatorFunction() [3/9]

void geometrize::script::GeometrizerEngine::setMutatorFunction ( const std::function< void(geometrize::Line &)> &  f)
inlineprivate
320  {
321  m_mutateLine = f;
322  }

◆ setMutatorFunction() [4/9]

void geometrize::script::GeometrizerEngine::setMutatorFunction ( const std::function< void(geometrize::Polyline &)> &  f)
inlineprivate
340  {
341  m_mutatePolyline = f;
342  }

◆ setMutatorFunction() [5/9]

void geometrize::script::GeometrizerEngine::setMutatorFunction ( const std::function< void(geometrize::QuadraticBezier &)> &  f)
inlineprivate
360  {
361  m_mutateQuadraticBezier = f;
362  }

◆ setMutatorFunction() [6/9]

void geometrize::script::GeometrizerEngine::setMutatorFunction ( const std::function< void(geometrize::Rectangle &)> &  f)
inlineprivate
380  {
381  m_mutateRectangle = f;
382  }

◆ setMutatorFunction() [7/9]

void geometrize::script::GeometrizerEngine::setMutatorFunction ( const std::function< void(geometrize::RotatedEllipse &)> &  f)
inlineprivate
400  {
401  m_mutateRotatedEllipse = f;
402  }

◆ setMutatorFunction() [8/9]

void geometrize::script::GeometrizerEngine::setMutatorFunction ( const std::function< void(geometrize::RotatedRectangle &)> &  f)
inlineprivate
420  {
421  m_mutateRotatedRectangle = f;
422  }

◆ setMutatorFunction() [9/9]

void geometrize::script::GeometrizerEngine::setMutatorFunction ( const std::function< void(geometrize::Triangle &)> &  f)
inlineprivate
440  {
441  m_mutateTriangle = f;
442  }

◆ setSetupFunction() [1/9]

void geometrize::script::GeometrizerEngine::setSetupFunction ( const std::function< void(geometrize::Circle &)> &  f)
inlineprivate
275  {
276  m_setupCircle = f;
277  }
Here is the caller graph for this function:

◆ setSetupFunction() [2/9]

void geometrize::script::GeometrizerEngine::setSetupFunction ( const std::function< void(geometrize::Ellipse &)> &  f)
inlineprivate
295  {
296  m_setupEllipse = f;
297  }

◆ setSetupFunction() [3/9]

void geometrize::script::GeometrizerEngine::setSetupFunction ( const std::function< void(geometrize::Line &)> &  f)
inlineprivate
315  {
316  m_setupLine = f;
317  }

◆ setSetupFunction() [4/9]

void geometrize::script::GeometrizerEngine::setSetupFunction ( const std::function< void(geometrize::Polyline &)> &  f)
inlineprivate
335  {
336  m_setupPolyline = f;
337  }

◆ setSetupFunction() [5/9]

void geometrize::script::GeometrizerEngine::setSetupFunction ( const std::function< void(geometrize::QuadraticBezier &)> &  f)
inlineprivate
355  {
356  m_setupQuadraticBezier = f;
357  }

◆ setSetupFunction() [6/9]

void geometrize::script::GeometrizerEngine::setSetupFunction ( const std::function< void(geometrize::Rectangle &)> &  f)
inlineprivate
375  {
376  m_setupRectangle = f;
377  }

◆ setSetupFunction() [7/9]

void geometrize::script::GeometrizerEngine::setSetupFunction ( const std::function< void(geometrize::RotatedEllipse &)> &  f)
inlineprivate
395  {
396  m_setupRotatedEllipse = f;
397  }

◆ setSetupFunction() [8/9]

void geometrize::script::GeometrizerEngine::setSetupFunction ( const std::function< void(geometrize::RotatedRectangle &)> &  f)
inlineprivate
415  {
416  m_setupRotatedRectangle = f;
417  }

◆ setSetupFunction() [9/9]

void geometrize::script::GeometrizerEngine::setSetupFunction ( const std::function< void(geometrize::Triangle &)> &  f)
inlineprivate
435  {
436  m_setupTriangle = f;
437  }

◆ setup() [1/9]

void geometrize::script::GeometrizerEngine::setup ( geometrize::Circle &  shape) const
inlineprivate
265  {
266  m_setupCircle(shape);
267  }
Here is the caller graph for this function:

◆ setup() [2/9]

void geometrize::script::GeometrizerEngine::setup ( geometrize::Ellipse &  shape) const
inlineprivate
285  {
286  m_setupEllipse(shape);
287  }

◆ setup() [3/9]

void geometrize::script::GeometrizerEngine::setup ( geometrize::Line &  shape) const
inlineprivate
305  {
306  m_setupLine(shape);
307  }

◆ setup() [4/9]

void geometrize::script::GeometrizerEngine::setup ( geometrize::Polyline &  shape) const
inlineprivate
325  {
326  m_setupPolyline(shape);
327  }

◆ setup() [5/9]

void geometrize::script::GeometrizerEngine::setup ( geometrize::QuadraticBezier &  shape) const
inlineprivate
345  {
346  m_setupQuadraticBezier(shape);
347  }

◆ setup() [6/9]

void geometrize::script::GeometrizerEngine::setup ( geometrize::Rectangle &  shape) const
inlineprivate
365  {
366  m_setupRectangle(shape);
367  }

◆ setup() [7/9]

void geometrize::script::GeometrizerEngine::setup ( geometrize::RotatedEllipse &  shape) const
inlineprivate
385  {
386  m_setupRotatedEllipse(shape);
387  }

◆ setup() [8/9]

void geometrize::script::GeometrizerEngine::setup ( geometrize::RotatedRectangle &  shape) const
inlineprivate
405  {
406  m_setupRotatedRectangle(shape);
407  }

◆ setup() [9/9]

void geometrize::script::GeometrizerEngine::setup ( geometrize::Triangle &  shape) const
inlineprivate
425  {
426  m_setupTriangle(shape);
427  }

◆ signal_scriptEvaluationFailed

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
functionNameThe name of the function.
codeThe code of the function.
errorThe text of the error message, if any.
Here is the caller graph for this function:

◆ signal_scriptEvaluationSucceeded

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
functionNameThe name of the function.
codeThe code of the function.
Here is the caller graph for this function:

Member Data Documentation

◆ m_customEnergyFunction

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

◆ m_engine

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

◆ m_mutateCircle

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

◆ m_mutateEllipse

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

◆ m_mutateLine

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

◆ m_mutatePolyline

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

◆ m_mutateQuadraticBezier

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

◆ m_mutateRectangle

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

◆ m_mutateRotatedEllipse

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

◆ m_mutateRotatedRectangle

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

◆ m_mutateTriangle

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

◆ m_setupCircle

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

◆ m_setupEllipse

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

◆ m_setupLine

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

◆ m_setupPolyline

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

◆ m_setupQuadraticBezier

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

◆ m_setupRectangle

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

◆ m_setupRotatedEllipse

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

◆ m_setupRotatedRectangle

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

◆ m_setupTriangle

std::function<void(geometrize::Triangle&)> geometrize::script::GeometrizerEngine::m_setupTriangle
private
The documentation for this class was generated from the following files:
geometrize::script::GeometrizerEngine::mutate
void mutate(geometrize::Circle &shape) const
Definition: geometrizerengine.h:269
geometrize::script::GeometrizerEngine::m_setupEllipse
std::function< void(geometrize::Ellipse &)> m_setupEllipse
Definition: geometrizerengine.h:450
geometrize::script::GeometrizerEngine::m_mutateRectangle
std::function< void(geometrize::Rectangle &)> m_mutateRectangle
Definition: geometrizerengine.h:464
geometrize::script::GeometrizerEngine::m_mutateTriangle
std::function< void(geometrize::Triangle &)> m_mutateTriangle
Definition: geometrizerengine.h:467
geometrize::script::GeometrizerEngine::m_mutateCircle
std::function< void(geometrize::Circle &)> m_mutateCircle
Definition: geometrizerengine.h:459
geometrize::script::createShapeMutatorEngine
std::unique_ptr< chaiscript::ChaiScript > createShapeMutatorEngine()
createShapeMutatorEngine Creates a Chaiscript engine object for mutating shapes.
Definition: chaiscriptcreator.cpp:88
geometrize::script::GeometrizerEngine::m_setupRotatedEllipse
std::function< void(geometrize::RotatedEllipse &)> m_setupRotatedEllipse
Definition: geometrizerengine.h:455
geometrize::script::GeometrizerEngine::m_mutateEllipse
std::function< void(geometrize::Ellipse &)> m_mutateEllipse
Definition: geometrizerengine.h:460
geometrize::script::GeometrizerEngine::m_setupQuadraticBezier
std::function< void(geometrize::QuadraticBezier &)> m_setupQuadraticBezier
Definition: geometrizerengine.h:453
geometrize::script::GeometrizerEngine::m_mutateQuadraticBezier
std::function< void(geometrize::QuadraticBezier &)> m_mutateQuadraticBezier
Definition: geometrizerengine.h:463
geometrize::script::GeometrizerEngine::m_mutatePolyline
std::function< void(geometrize::Polyline &)> m_mutatePolyline
Definition: geometrizerengine.h:462
geometrize::script::GeometrizerEngine::m_customEnergyFunction
geometrize::core::EnergyFunction m_customEnergyFunction
Definition: geometrizerengine.h:469
geometrize::script::GeometrizerEngine::m_setupLine
std::function< void(geometrize::Line &)> m_setupLine
Definition: geometrizerengine.h:451
geometrize::script::GeometrizerEngine::m_setupTriangle
std::function< void(geometrize::Triangle &)> m_setupTriangle
Definition: geometrizerengine.h:457
geometrize::script::GeometrizerEngine::m_mutateRotatedEllipse
std::function< void(geometrize::RotatedEllipse &)> m_mutateRotatedEllipse
Definition: geometrizerengine.h:465
geometrize::script::GeometrizerEngine::m_mutateLine
std::function< void(geometrize::Line &)> m_mutateLine
Definition: geometrizerengine.h:461
geometrize::script::GeometrizerEngine::m_mutateRotatedRectangle
std::function< void(geometrize::RotatedRectangle &)> m_mutateRotatedRectangle
Definition: geometrizerengine.h:466
geometrize::script::GeometrizerEngine::m_setupPolyline
std::function< void(geometrize::Polyline &)> m_setupPolyline
Definition: geometrizerengine.h:452
geometrize::script::GeometrizerEngine::setup
void setup(geometrize::Circle &shape) const
Definition: geometrizerengine.h:264
geometrize::script::GeometrizerEngine::m_setupRectangle
std::function< void(geometrize::Rectangle &)> m_setupRectangle
Definition: geometrizerengine.h:454
geometrize::script::GeometrizerEngine::setCustomEnergyFunction
void setCustomEnergyFunction(const geometrize::core::EnergyFunction &f)
Definition: geometrizerengine.h:444
geometrize::script::GeometrizerEngine::setSetupFunction
void setSetupFunction(const std::function< void(geometrize::Circle &)> &f)
Definition: geometrizerengine.h:274
geometrize::script::GeometrizerEngine::m_setupRotatedRectangle
std::function< void(geometrize::RotatedRectangle &)> m_setupRotatedRectangle
Definition: geometrizerengine.h:456
geometrize::script::GeometrizerEngine::setMutatorFunction
void setMutatorFunction(const std::function< void(geometrize::Circle &)> &f)
Definition: geometrizerengine.h:279
geometrize::script::GeometrizerEngine::m_setupCircle
std::function< void(geometrize::Circle &)> m_setupCircle
Definition: geometrizerengine.h:449
geometrize::script::GeometrizerEngine::installCustomEnergyScript
void installCustomEnergyScript(const std::string &functionName, const std::string &scriptCode)
Definition: geometrizerengine.h:228
geometrize::script::GeometrizerEngine::m_engine
std::unique_ptr< chaiscript::ChaiScript > m_engine
Definition: geometrizerengine.h:471
Generated on Mon Dec 13 2021 01:05:11 for Geometrize by doxygen 1.8.20