MorphoGraphX  2.0-1-227
MeshProcessMeasures3D.hpp
Go to the documentation of this file.
1 //
2 // This file is part of MorphoGraphX - http://www.MorphoGraphX.org
3 // Copyright (C) 2012-2015 Richard S. Smith and collaborators.
4 //
5 // If you use MorphoGraphX in your work, please cite:
6 // http://dx.doi.org/10.7554/eLife.05864
7 //
8 // MorphoGraphX is free software, and is licensed under under the terms of the
9 // GNU General (GPL) Public License version 2.0, http://www.gnu.org/licenses.
10 //
11 #ifndef MESH_PROCESS_MEASURES_3D_HPP
12 #define MESH_PROCESS_MEASURES_3D_HPP
13 
14 #include <Process.hpp>
15 #include <Progress.hpp>
16 #include <Information.hpp>
17 
18 namespace mgx
19 {
20 
21  class mgxBase_EXPORT Measure3DVolume : public Process
22  {
23  public:
24  Measure3DVolume(const Process& process) : Process(process)
25  {
26  setName("Mesh/Heat Map/Measures 3D/Geometry/Volume");
27  setDesc("Volume of a 3D cell.");
28  setIcon(QIcon(":/images/MakeHeatMap.png"));
29 
30  }
31  bool processParms();
32 
33  bool run(IntFloatAttr& heatMap);
34  bool run()
35  {
36  if(!checkState().mesh(MESH_ANY))
37  return false;
38  Mesh *mesh = currentMesh();
39  return run(mesh);
40  }
41 
42  bool run(Mesh* mesh){
43  return run(mesh, mesh->labelHeat());
44  }
45 
46  bool run(Mesh* mesh, IntFloatAttr& heatMap);
47 
48  };
49 
50 
51  class mgxBase_EXPORT Measure3DNeighbors : public Process
52  {
53  public:
54  Measure3DNeighbors(const Process& process) : Process(process)
55  {
56  setName("Mesh/Heat Map/Measures 3D/Network/Neighbors");
57  setDesc("Number of neighbors of a 3D cell.");
58  setIcon(QIcon(":/images/MakeHeatMap.png"));
59 
60  }
61  bool processParms();
62 
63  bool run(IntFloatAttr& heatMap);
64  bool run()
65  {
66  if(!checkState().mesh(MESH_ANY))
67  return false;
68  Mesh *mesh = currentMesh();
69  return run(mesh);
70  }
71 
72  bool run(Mesh* mesh){
73  return run(mesh, mesh->labelHeat());
74  }
75 
76  bool run(Mesh* mesh, IntFloatAttr& heatMap);
77 
78  };
79 
80 
81  class mgxBase_EXPORT Measure3DWallArea : public Process
82  {
83  public:
84  Measure3DWallArea(const Process& process) : Process(process)
85  {
86  setName("Mesh/Heat Map/Measures 3D/Geometry/Cell Wall Area");
87  setDesc("Cell Wall Area of a 3D cell");
88  setIcon(QIcon(":/images/MakeHeatMap.png"));
89  }
90 
91  bool processParms();
92 
93  bool run(IntFloatAttr& heatMap);
94  bool run()
95  {
96  if(!checkState().mesh(MESH_ANY))
97  return false;
98  Mesh *mesh = currentMesh();
99  return run(mesh);
100  }
101 
102  bool run(Mesh* mesh){
103  return run(mesh, mesh->labelHeat());
104  }
105 
106  bool run(Mesh* mesh, IntFloatAttr& heatMap);
107 
108  };
109  class mgxBase_EXPORT Measure3DCoordLong : public Process
110  {
111  public:
112  Measure3DCoordLong(const Process& process) : Process(process)
113  {
114  setName("Mesh/Heat Map/Measures 3D/Cell Atlas/Coord Longitudinal");
115  setDesc("Longitudinal Coord of a 3D cell. Requires the Cell Atlas measure maps.");
116  setIcon(QIcon(":/images/MakeHeatMap.png"));
117  }
118 
119  bool processParms();
120 
121  bool run()
122  {
123  if(!checkState().mesh(MESH_ANY))
124  return false;
125  Mesh *mesh = currentMesh();
126  return run(mesh);
127  }
128 
129  bool run(Mesh* mesh){
130  return run(mesh, mesh->labelHeat());
131  }
132 
133  bool run(Mesh* mesh, IntFloatAttr& heatMap);
134 
135  };
136 
137  class mgxBase_EXPORT Measure3DCoordCirc : public Process
138  {
139  public:
140  Measure3DCoordCirc(const Process& process) : Process(process)
141  {
142  setName("Mesh/Heat Map/Measures 3D/Cell Atlas/Coord Circumferential");
143  setDesc("Circumferential Coord of a 3D cell. Requires the Cell Atlas measure maps.");
144  setIcon(QIcon(":/images/MakeHeatMap.png"));
145  }
146 
147  bool processParms();
148 
149  bool run(IntFloatAttr& heatMap);
150  bool run()
151  {
152  if(!checkState().mesh(MESH_ANY))
153  return false;
154  Mesh *mesh = currentMesh();
155  return run(mesh);
156  }
157 
158  bool run(Mesh* mesh){
159  return run(mesh, mesh->labelHeat());
160  }
161 
162  bool run(Mesh* mesh, IntFloatAttr& heatMap);
163 
164  };
165 
166  class mgxBase_EXPORT Measure3DCoordRad : public Process
167  {
168  public:
169  Measure3DCoordRad(const Process& process) : Process(process)
170  {
171  setName("Mesh/Heat Map/Measures 3D/Cell Atlas/Coord Radial");
172  setDesc("Radial Coord of a 3D cell. Requires the Cell Atlas measure maps.");
173  setIcon(QIcon(":/images/MakeHeatMap.png"));
174  }
175 
176  bool processParms();
177 
178  bool run(IntFloatAttr& heatMap);
179  bool run()
180  {
181  if(!checkState().mesh(MESH_ANY))
182  return false;
183  Mesh *mesh = currentMesh();
184  return run(mesh);
185  }
186 
187  bool run(Mesh* mesh){
188  return run(mesh, mesh->labelHeat());
189  }
190 
191  bool run(Mesh* mesh, IntFloatAttr& heatMap);
192 
193  };
194 
195  class mgxBase_EXPORT Measure3DSizeLong : public Process
196  {
197  public:
198  Measure3DSizeLong(const Process& process) : Process(process)
199  {
200  setName("Mesh/Heat Map/Measures 3D/Cell Atlas/Cell Length Longitudinal");
201  setDesc("Longitudinal Cell Size of a 3D cell. Requires the Cell Atlas measure maps.");
202  setIcon(QIcon(":/images/MakeHeatMap.png"));
203 
204  }
205  bool processParms();
206 
207  bool run(IntFloatAttr& heatMap);
208  bool run()
209  {
210  if(!checkState().mesh(MESH_ANY))
211  return false;
212  Mesh *mesh = currentMesh();
213  return run(mesh);
214  }
215 
216  bool run(Mesh* mesh){
217  return run(mesh, mesh->labelHeat());
218  }
219 
220  bool run(Mesh* mesh, IntFloatAttr& heatMap);
221 
222  };
223  class mgxBase_EXPORT Measure3DSizeCirc : public Process
224  {
225  public:
226  Measure3DSizeCirc(const Process& process) : Process(process)
227  {
228  setName("Mesh/Heat Map/Measures 3D/Cell Atlas/Cell Length Circumferential");
229  setDesc("Circumferential Cell Size of a 3D cell. Requires the Cell Atlas measure maps.");
230  setIcon(QIcon(":/images/MakeHeatMap.png"));
231  }
232 
233  bool processParms();
234 
235  bool run(IntFloatAttr& heatMap);
236  bool run()
237  {
238  if(!checkState().mesh(MESH_ANY))
239  return false;
240  Mesh *mesh = currentMesh();
241  return run(mesh);
242  }
243 
244  bool run(Mesh* mesh){
245  return run(mesh, mesh->labelHeat());
246  }
247 
248  bool run(Mesh* mesh, IntFloatAttr& heatMap);
249 
250  };
251 
252  class mgxBase_EXPORT Measure3DSizeRad : public Process
253  {
254  public:
255  Measure3DSizeRad(const Process& process) : Process(process)
256  {
257  setName("Mesh/Heat Map/Measures 3D/Cell Atlas/Cell Length Radial");
258  setDesc("Radial Cell Size of a 3D cell. Requires the Cell Atlas measure maps.");
259  setIcon(QIcon(":/images/MakeHeatMap.png"));
260  }
261 
262  bool processParms();
263 
264  bool run(IntFloatAttr& heatMap);
265  bool run()
266  {
267  if(!checkState().mesh(MESH_ANY))
268  return false;
269  Mesh *mesh = currentMesh();
270  return run(mesh);
271  }
272 
273  bool run(Mesh* mesh){
274  return run(mesh, mesh->labelHeat());
275  }
276 
277  bool run(Mesh* mesh, IntFloatAttr& heatMap);
278 
279  };
280 
281  class mgxBase_EXPORT Measure3DSizeX : public Process
282  {
283  public:
284  Measure3DSizeX(const Process& process) : Process(process)
285  {
286  setName("Mesh/Heat Map/Measures 3D/Geometry/Cell Length X");
287  setDesc("Cell Size in x dimension of a 3D cell");
288  setIcon(QIcon(":/images/MakeHeatMap.png"));
289  }
290 
291  bool processParms();
292 
293  bool run(IntFloatAttr& heatMap);
294  bool run()
295  {
296  if(!checkState().mesh(MESH_ANY))
297  return false;
298  Mesh *mesh = currentMesh();
299  return run(mesh);
300  }
301 
302  bool run(Mesh* mesh){
303  return run(mesh, mesh->labelHeat());
304  }
305 
306  bool run(Mesh* mesh, IntFloatAttr& heatMap);
307 
308  };
309 
310  class mgxBase_EXPORT Measure3DSizeY : public Process
311  {
312  public:
313  Measure3DSizeY(const Process& process) : Process(process)
314  {
315  setName("Mesh/Heat Map/Measures 3D/Geometry/Cell Length Y");
316  setDesc("Cell Size in y dimension of a 3D cell");
317  setIcon(QIcon(":/images/MakeHeatMap.png"));
318  }
319  bool processParms();
320 
321  bool run(IntFloatAttr& heatMap);
322  bool run()
323  {
324  if(!checkState().mesh(MESH_ANY))
325  return false;
326  Mesh *mesh = currentMesh();
327  return run(mesh);
328  }
329 
330  bool run(Mesh* mesh){
331  return run(mesh, mesh->labelHeat());
332  }
333 
334  bool run(Mesh* mesh, IntFloatAttr& heatMap);
335 
336  };
337 
338  class mgxBase_EXPORT Measure3DSizeZ : public Process
339  {
340  public:
341  Measure3DSizeZ(const Process& process) : Process(process)
342  {
343  setName("Mesh/Heat Map/Measures 3D/Geometry/Cell Length Z");
344  setDesc("Cell Size in z dimension of a 3D cell");
345  setIcon(QIcon(":/images/MakeHeatMap.png"));
346  }
347 
348  bool processParms();
349 
350  bool run(IntFloatAttr& heatMap);
351  bool run()
352  {
353  if(!checkState().mesh(MESH_ANY))
354  return false;
355  Mesh *mesh = currentMesh();
356  return run(mesh);
357  }
358 
359  bool run(Mesh* mesh){
360  return run(mesh, mesh->labelHeat());
361  }
362 
363  bool run(Mesh* mesh, IntFloatAttr& heatMap);
364 
365  };
366 
367  class mgxBase_EXPORT Measure3DSizeCustom : public Process
368  {
369  public:
370  Measure3DSizeCustom(const Process& process) : Process(process)
371  {
372  setName("Mesh/Heat Map/Measures 3D/Geometry/Cell Length Custom");
373  setDesc("Cell Size in custom direction a 3D cell \n"
374  "Requires a valid Custom Directions Attribute Map in the active mesh \n"
375  "(which can be generated using the Custom processes in Cell Axis");
376  setIcon(QIcon(":/images/MakeHeatMap.png"));
377 
378  addParm("Custom Direction","Custom Direction Dimension","X", QStringList() << "X" << "Y" << "Z");
379 
380  addParm("Custom Direction Heat","Custom Direction Heat","X", QStringList() << "X" << "Y" << "Z");
381  addParm("Attribute Map X","Attribute Map X","customX");
382  addParm("Attribute Map Y","Attribute Map Y","customY");
383  addParm("Attribute Map Z","Attribute Map Z","customZ");
384 
385  }
386 
387  bool processParms();
388 
389  bool run(IntFloatAttr& heatMap);
390  bool run()
391  {
392  if(!checkState().mesh(MESH_ANY))
393  return false;
394  Mesh *mesh = currentMesh();
395  return run(mesh, parm("Custom Direction"), parm("Attribute Map X"), parm("Attribute Map Y"), parm("Attribute Map Z"));
396  }
397 
398  bool run(Mesh* mesh, QString dim, QString attr1, QString attr2, QString attr3){
399  return run(mesh, dim, attr1, attr2, attr3, mesh->labelHeat());
400  }
401 
402  bool run(Mesh* mesh, QString dim, QString attr1, QString attr2, QString attr3, IntFloatAttr& heatMap);
403 
404  };
405 
406 
407  class mgxBase_EXPORT Measure3DVolumeSurfaceRatio : public Process
408  {
409  public:
410  Measure3DVolumeSurfaceRatio(const Process& process) : Process(process)
411  {
412  setName("Mesh/Heat Map/Measures 3D/Geometry/Volume Surface Ratio");
413  setDesc("Volume Surface Ratio of a 3D cell (root3(volume)/root2(wall area)). Requires the Cell Atlas measure maps.");
414  setIcon(QIcon(":/images/MakeHeatMap.png"));
415 
416  addParm("Root Volume","Root Volume","3.0");
417  addParm("Root Wall Area","Root Wall Area","2.0");
418 
419  }
420  bool processParms();
421 
422  bool run(IntFloatAttr& heatMap);
423  bool run()
424  {
425  if(!checkState().mesh(MESH_ANY))
426  return false;
427  Mesh *mesh = currentMesh();
428  return run(mesh, parm("Root Volume").toDouble(), parm("Root Wall Area").toDouble());
429  }
430 
431  bool run(Mesh* mesh, double powerVol, double powerWall){
432  return run(mesh, mesh->labelHeat(), powerVol, powerWall);
433  }
434 
435  bool run(Mesh* mesh, IntFloatAttr& heatMap, double powerVol, double powerWall);
436 
437  };
438 
439  class mgxBase_EXPORT Measure3DOutsideWallArea : public Process
440  {
441  public:
442  Measure3DOutsideWallArea(const Process& process) : Process(process)
443  {
444  setName("Mesh/Heat Map/Measures 3D/Geometry/Outside Wall Area Ratio");
445  setDesc("Wall Area of a cell not shared with a neighbor cell");
446  setIcon(QIcon(":/images/MakeHeatMap.png"));
447  }
448 
449  bool processParms();
450 
451  bool run(IntFloatAttr& heatMap);
452  bool run()
453  {
454  if(!checkState().mesh(MESH_ANY))
455  return false;
456  Mesh *mesh = currentMesh();
457  return run(mesh);
458  }
459 
460  bool run(Mesh* mesh){
461  return run(mesh, mesh->labelHeat());
462  }
463 
464  bool run(Mesh* mesh, IntFloatAttr& heatMap);
465 
466  };
467 
468  class mgxBase_EXPORT Measure3DOutsideWallAreaPercent : public Process
469  {
470  public:
471  Measure3DOutsideWallAreaPercent(const Process& process) : Process(process)
472  {
473  setName("Mesh/Heat Map/Measures 3D/Geometry/Outside Wall Area Ratio");
474  setDesc("Wall Area of a cell not shared with a neighbor cell");
475  setIcon(QIcon(":/images/MakeHeatMap.png"));
476  }
477 
478  bool processParms();
479 
480  bool run(IntFloatAttr& heatMap);
481  bool run()
482  {
483  if(!checkState().mesh(MESH_ANY))
484  return false;
485  Mesh *mesh = currentMesh();
486  return run(mesh);
487  }
488 
489  bool run(Mesh* mesh){
490  return run(mesh, mesh->labelHeat());
491  }
492 
493  bool run(Mesh* mesh, IntFloatAttr& heatMap);
494 
495  };
496 
497  class mgxBase_EXPORT Measure3DCellDistance : public Process
498  {
499  public:
500  Measure3DCellDistance(const Process& process) : Process(process)
501  {
502  setName("Mesh/Heat Map/Measures 3D/Location/Cell Distance");
503  setDesc("Distance through the tissue to the nearest selected cells.");
504  setIcon(QIcon(":/images/MakeHeatMap.png"));
505 
506  addParm("Wall Weights","Wall Weights","Euclidean", QStringList() << "1 / Wall Length" << "1" << "Euclidean");
507  addParm("Restrict connectivity to same cell type", "Restrict connectivity to same cell type", "No", booleanChoice());
508  }
509 
510  bool processParms();
511 
512  // bool run(IntFloatAttr& heatMap);
513  bool run()
514  {
515  if(!checkState().mesh(MESH_ANY))
516  return false;
517  Mesh *mesh = currentMesh();
518  return run(mesh, parm("Wall Weights"), stringToBool(parm("Restrict connectivity to same cell type")));
519  }
520 
521  bool run(Mesh* mesh, QString weight, bool cellTypes){
522  return run(mesh, weight, cellTypes, mesh->labelHeat());
523  }
524 
525  bool run(Mesh* mesh, QString weight, bool cellTypes, IntFloatAttr& heatMap);
526 
527  };
528 
529 
530  class mgxBase_EXPORT Measure3DCellDistanceBezierRing : public Process
531  {
532  public:
533  Measure3DCellDistanceBezierRing(const Process& process) : Process(process)
534  {
535  setName("Mesh/Heat Map/Measures 3D/Location/Cell Distance Bezier Ring");
536  setDesc("Distance through the tissue to the nearest selected cells.");
537  setIcon(QIcon(":/images/MakeHeatMap.png"));
538 
539  addParm("Wall Weights","Wall Weights","1", QStringList() << "1" << "Euclidean");
540  addParm("Restrict connectivity to same cell type", "Restrict connectivity to same cell type", "Yes", booleanChoice());
541  addParm("Direct Distance Limit (um)","Direct Distance Limit (um)","20.0");
542  addParm("Selected as Direct","Selected as Direct","Yes", booleanChoice());
543  addParm("Consider Ring Orientation","Consider Ring Orientation","Yes", booleanChoice());
544  addParm("Select Direct Cells","Select Direct Cells","No", booleanChoice());
545  addParm("Keep Selected Cells","Keep Selected Cells","Yes", booleanChoice());
546  }
547 
548  bool processParms();
549 
550  // bool run(IntFloatAttr& heatMap);
551  bool run()
552  {
553  if(!checkState().mesh(MESH_ANY))
554  return false;
555  Mesh *mesh = currentMesh();
556  return run(mesh, parm("Wall Weights"), stringToBool(parm("Restrict connectivity to same cell type")),
557  parm("Direct Distance Limit (um)").toDouble(), stringToBool(parm("Selected as Direct")),
558  stringToBool(parm("Consider Ring Orientation")), stringToBool(parm("Select Direct Cells")), stringToBool(parm("Keep Selected Cells")), mesh->labelHeat());
559  }
560 
561  // bool run(Mesh* mesh, QString weight, bool cellTypes, double thresholdDis, bool selectCells){
562  // return run(mesh, weight, cellTypes, thresholdDis, selectCells, mesh->labelHeat());
563  // }
564 
565  bool run(Mesh* mesh, QString weight, bool cellTypes, double thresholdDis, bool selectedAsDirect, bool considerOrientation,
566  bool selectCells, bool keep, IntFloatAttr& heatMap);
567 
568  };
569 
570  class mgxBase_EXPORT Measure3DCellCoord : public Process
571  {
572  public:
573  Measure3DCellCoord(const Process& process) : Process(process)
574  {
575  setName("Mesh/Heat Map/Measures 3D/Location/Cell Coordinate");
576  setDesc("Distance through the tissue to the nearest selected cells.");
577  setIcon(QIcon(":/images/MakeHeatMap.png"));
578 
579  addParm("Dimension","Dimension","X", QStringList() << "X" << "Y" << "Z" << "Distance Origin"); // 0
580  }
581 
582  bool run()
583  {
584  if(!checkState().mesh(MESH_ANY))
585  return false;
586  Mesh *mesh = currentMesh();
587  Stack* s = currentStack();
588  return run(s, mesh, parm("Dimension"),mesh->labelHeat());
589  }
590 
591  bool run(Stack* s, Mesh* mesh, QString dim, IntFloatAttr& heatMap);
592 
593  };
594 
595  class mgxBase_EXPORT Measure3DDistanceToMesh : public Process
596  {
597  public:
598  Measure3DDistanceToMesh(const Process& process) : Process(process)
599  {
600  setName("Mesh/Heat Map/Measures 3D/Location/Mesh Distance");
601  setDesc("Distance to the other mesh");
602  setIcon(QIcon(":/images/MakeHeatMap.png"));
603  }
604 
605  bool run(IntFloatAttr& heatMap);
606  bool run()
607  {
608  if(!checkState().mesh(MESH_ANY))
609  return false;
610  Mesh *mesh = currentMesh();
611  Mesh *mesh2 = otherMesh();
612  return run(mesh, mesh2);
613  }
614 
615  bool run(Mesh* mesh, Mesh* mesh2){
616  return run(mesh, mesh2, mesh->labelHeat());
617  }
618 
619  bool run(Mesh* mesh, Mesh* mesh2, IntFloatAttr& heatMap);
620 
621  };
622 
623 
624  class mgxBase_EXPORT MeasureDistanceToBezier3D : public Process
625  {
626  public:
627  MeasureDistanceToBezier3D(const Process& process) : Process(process)
628  {
629  setName("Mesh/Heat Map/Measures 3D/Location/Distance to Bezier");
630  setDesc("Computes for each cell the distance to a defined Bezier grid or line");
631  setIcon(QIcon(":/images/MakeHeatMap.png"));
632 
633  addParm("Consider Orientation","Consider Orientation","Yes",booleanChoice());
634  addParm("Reverse Orientation","Reverse Orientation","No",booleanChoice());
635  }
636  bool processParms();
637 
638  bool run()
639  {
640  if(!checkState().mesh(MESH_ANY))
641  return false;
642  Mesh *mesh = currentMesh();
643  Stack *s1 = currentStack();
644  return run(s1, mesh, stringToBool(parm("Consider Orientation")), stringToBool(parm("Reverse Orientation")), mesh->labelHeat());
645  }
646 
647  bool run(const Stack *s1, Mesh* mesh, bool orient, bool reverse, IntFloatAttr& heatMap);
648 
649  };
650 
651 
652  class mgxBase_EXPORT MeasureBezierLineCoord3D : public Process
653  {
654  public:
655  MeasureBezierLineCoord3D(const Process& process) : Process(process)
656  {
657  setName("Mesh/Heat Map/Measures 3D/Location/Bezier Coord");
658  setDesc("TBD");
659  setIcon(QIcon(":/images/MakeHeatMap.png"));
660 
661  }
662  bool processParms();
663 
664  bool run()
665  {
666  if(!checkState().mesh(MESH_ANY))
667  return false;
668  Mesh *mesh = currentMesh();
669  Stack *s1 = currentStack();
670  return run(s1, mesh, mesh->labelHeat());
671  }
672 
673  bool run(const Stack *s1, Mesh* mesh, IntFloatAttr& heatMap);
674 
675  };
676 
677 
678  class mgxBase_EXPORT MeasureDistanceToBezierPlane3D : public Process
679  {
680  public:
681  MeasureDistanceToBezierPlane3D(const Process& process) : Process(process)
682  {
683  setName("Mesh/Heat Map/Measures 3D/Location/Distance to Plane from Bezier");
684  setDesc("Computes for each cell the distance to fitted plane of the supporting points of a defined Bezier grid or line");
685  setIcon(QIcon(":/images/MakeHeatMap.png"));
686 
687  addParm("Consider Orientation","Consider Orientation","Yes",booleanChoice());
688  addParm("Reverse Orientation","Reverse Orientation","No",booleanChoice());
689  }
690  bool processParms();
691 
692  bool run()
693  {
694  if(!checkState().mesh(MESH_ANY))
695  return false;
696  Mesh *mesh = currentMesh();
697  Stack *s1 = currentStack();
698  return run(s1, mesh, stringToBool(parm("Consider Orientation")), stringToBool(parm("Reverse Orientation")), mesh->labelHeat());
699  }
700 
701  bool run(const Stack *s1, Mesh* mesh, bool orient, bool reverse, IntFloatAttr& heatMap);
702 
703  };
704 
705 
706 }
707 
708 #endif
mgx::Measure3DVolumeSurfaceRatio::Measure3DVolumeSurfaceRatio
Measure3DVolumeSurfaceRatio(const Process &process)
Definition: MeshProcessMeasures3D.hpp:410
mgx::Measure3DCellDistance
Definition: MeshProcessMeasures3D.hpp:497
mgx::Measure3DSizeZ::run
bool run()
Runs the process.
Definition: MeshProcessMeasures3D.hpp:351
mgx::Measure3DSizeLong::run
bool run(Mesh *mesh)
Definition: MeshProcessMeasures3D.hpp:216
mgx::Measure3DCoordCirc::run
bool run(Mesh *mesh)
Definition: MeshProcessMeasures3D.hpp:158
mgx::Measure3DVolumeSurfaceRatio::run
bool run()
Runs the process.
Definition: MeshProcessMeasures3D.hpp:423
Process.hpp
mgx::Measure3DWallArea::Measure3DWallArea
Measure3DWallArea(const Process &process)
Definition: MeshProcessMeasures3D.hpp:84
mgx::Measure3DSizeCustom::run
bool run()
Runs the process.
Definition: MeshProcessMeasures3D.hpp:390
mgx::Measure3DCellCoord
Definition: MeshProcessMeasures3D.hpp:570
mgx::Measure3DCellCoord::run
bool run()
Runs the process.
Definition: MeshProcessMeasures3D.hpp:582
Information.hpp
mgx::Measure3DSizeZ
Definition: MeshProcessMeasures3D.hpp:338
mgx::Measure3DSizeCustom
Definition: MeshProcessMeasures3D.hpp:367
mgx::Measure3DSizeLong
Definition: MeshProcessMeasures3D.hpp:195
mgx::Measure3DCellDistance::run
bool run(Mesh *mesh, QString weight, bool cellTypes)
Definition: MeshProcessMeasures3D.hpp:521
mgx::Measure3DNeighbors::Measure3DNeighbors
Measure3DNeighbors(const Process &process)
Definition: MeshProcessMeasures3D.hpp:54
mgx::Measure3DCoordRad
Definition: MeshProcessMeasures3D.hpp:166
mgx::Measure3DCoordRad::run
bool run()
Runs the process.
Definition: MeshProcessMeasures3D.hpp:179
mgx::Measure3DOutsideWallAreaPercent::Measure3DOutsideWallAreaPercent
Measure3DOutsideWallAreaPercent(const Process &process)
Definition: MeshProcessMeasures3D.hpp:471
mgx::Measure3DCellCoord::Measure3DCellCoord
Measure3DCellCoord(const Process &process)
Definition: MeshProcessMeasures3D.hpp:573
mgx::Measure3DOutsideWallArea::run
bool run()
Runs the process.
Definition: MeshProcessMeasures3D.hpp:452
mgx::Measure3DOutsideWallAreaPercent::run
bool run(Mesh *mesh)
Definition: MeshProcessMeasures3D.hpp:489
mgx::Measure3DDistanceToMesh::run
bool run()
Runs the process.
Definition: MeshProcessMeasures3D.hpp:606
mgx::Measure3DCoordLong::run
bool run(Mesh *mesh)
Definition: MeshProcessMeasures3D.hpp:129
mgx::Stack
Definition: Stack.hpp:33
mgx::Measure3DCellDistanceBezierRing
Definition: MeshProcessMeasures3D.hpp:530
mgx::Measure3DSizeCirc
Definition: MeshProcessMeasures3D.hpp:223
mgx::Measure3DNeighbors::run
bool run(Mesh *mesh)
Definition: MeshProcessMeasures3D.hpp:72
mgx::Measure3DSizeRad::run
bool run(Mesh *mesh)
Definition: MeshProcessMeasures3D.hpp:273
mgx::Measure3DCellDistance::Measure3DCellDistance
Measure3DCellDistance(const Process &process)
Definition: MeshProcessMeasures3D.hpp:500
mgx
Distributed matrix library.
Definition: Assert.hpp:26
mgx::Measure3DVolumeSurfaceRatio
Definition: MeshProcessMeasures3D.hpp:407
mgx::Measure3DSizeX::run
bool run()
Runs the process.
Definition: MeshProcessMeasures3D.hpp:294
mgx::Measure3DCoordCirc
Definition: MeshProcessMeasures3D.hpp:137
mgx::Measure3DVolume::run
bool run(Mesh *mesh)
Definition: MeshProcessMeasures3D.hpp:42
mgx::Measure3DSizeCirc::run
bool run(Mesh *mesh)
Definition: MeshProcessMeasures3D.hpp:244
mgx::Measure3DOutsideWallArea::run
bool run(Mesh *mesh)
Definition: MeshProcessMeasures3D.hpp:460
mgx::MeasureDistanceToBezierPlane3D
Definition: MeshProcessMeasures3D.hpp:678
mgx::Measure3DVolumeSurfaceRatio::run
bool run(Mesh *mesh, double powerVol, double powerWall)
Definition: MeshProcessMeasures3D.hpp:431
mgx::MeasureDistanceToBezier3D::MeasureDistanceToBezier3D
MeasureDistanceToBezier3D(const Process &process)
Definition: MeshProcessMeasures3D.hpp:627
mgx::Measure3DVolume
Definition: MeshProcessMeasures3D.hpp:21
mgx::MeasureBezierLineCoord3D
Definition: MeshProcessMeasures3D.hpp:652
mgx::Measure3DSizeRad::Measure3DSizeRad
Measure3DSizeRad(const Process &process)
Definition: MeshProcessMeasures3D.hpp:255
mgx::MeasureBezierLineCoord3D::MeasureBezierLineCoord3D
MeasureBezierLineCoord3D(const Process &process)
Definition: MeshProcessMeasures3D.hpp:655
mgx::Measure3DSizeZ::run
bool run(Mesh *mesh)
Definition: MeshProcessMeasures3D.hpp:359
mgx::Measure3DSizeX::Measure3DSizeX
Measure3DSizeX(const Process &process)
Definition: MeshProcessMeasures3D.hpp:284
mgx::Process
Definition: Process.hpp:219
mgx::Measure3DCellDistanceBezierRing::run
bool run()
Runs the process.
Definition: MeshProcessMeasures3D.hpp:551
mgx::Measure3DWallArea::run
bool run()
Runs the process.
Definition: MeshProcessMeasures3D.hpp:94
mgx::MeasureBezierLineCoord3D::run
bool run()
Runs the process.
Definition: MeshProcessMeasures3D.hpp:664
mgx::Measure3DSizeCustom::run
bool run(Mesh *mesh, QString dim, QString attr1, QString attr2, QString attr3)
Definition: MeshProcessMeasures3D.hpp:398
mgx::MeasureDistanceToBezierPlane3D::MeasureDistanceToBezierPlane3D
MeasureDistanceToBezierPlane3D(const Process &process)
Definition: MeshProcessMeasures3D.hpp:681
mgx::stringToBool
mgx_EXPORT bool stringToBool(const QString &string)
Helper function converting a string into a boolean.
mgx::Measure3DCoordCirc::Measure3DCoordCirc
Measure3DCoordCirc(const Process &process)
Definition: MeshProcessMeasures3D.hpp:140
mgx::Measure3DCellDistanceBezierRing::Measure3DCellDistanceBezierRing
Measure3DCellDistanceBezierRing(const Process &process)
Definition: MeshProcessMeasures3D.hpp:533
mgx::Measure3DVolume::Measure3DVolume
Measure3DVolume(const Process &process)
Definition: MeshProcessMeasures3D.hpp:24
mgx::Measure3DNeighbors
Definition: MeshProcessMeasures3D.hpp:51
mgx::Measure3DSizeX
Definition: MeshProcessMeasures3D.hpp:281
mgx::Measure3DVolume::run
bool run()
Runs the process.
Definition: MeshProcessMeasures3D.hpp:34
mgx::Measure3DCoordLong
Definition: MeshProcessMeasures3D.hpp:109
mgx::Measure3DSizeZ::Measure3DSizeZ
Measure3DSizeZ(const Process &process)
Definition: MeshProcessMeasures3D.hpp:341
mgx::Measure3DSizeY::Measure3DSizeY
Measure3DSizeY(const Process &process)
Definition: MeshProcessMeasures3D.hpp:313
mgx::Measure3DSizeLong::run
bool run()
Runs the process.
Definition: MeshProcessMeasures3D.hpp:208
mgx::Measure3DOutsideWallAreaPercent::run
bool run()
Runs the process.
Definition: MeshProcessMeasures3D.hpp:481
Progress.hpp
mgx::Measure3DDistanceToMesh::Measure3DDistanceToMesh
Measure3DDistanceToMesh(const Process &process)
Definition: MeshProcessMeasures3D.hpp:598
mgx::Measure3DCoordLong::Measure3DCoordLong
Measure3DCoordLong(const Process &process)
Definition: MeshProcessMeasures3D.hpp:112
mgx::Measure3DSizeRad
Definition: MeshProcessMeasures3D.hpp:252
mgx::Mesh::labelHeat
IntFloatAttr & labelHeat()
Reference to map of heat data by label.
Definition: Mesh.hpp:901
mgx::Mesh
Definition: Mesh.hpp:54
mgx::MeasureDistanceToBezier3D::run
bool run()
Runs the process.
Definition: MeshProcessMeasures3D.hpp:638
mgx::Measure3DSizeCirc::run
bool run()
Runs the process.
Definition: MeshProcessMeasures3D.hpp:236
mgx::Measure3DDistanceToMesh::run
bool run(Mesh *mesh, Mesh *mesh2)
Definition: MeshProcessMeasures3D.hpp:615
mgx::Measure3DSizeCirc::Measure3DSizeCirc
Measure3DSizeCirc(const Process &process)
Definition: MeshProcessMeasures3D.hpp:226
mgx::Measure3DCellDistance::run
bool run()
Runs the process.
Definition: MeshProcessMeasures3D.hpp:513
mgx::Measure3DSizeY::run
bool run()
Runs the process.
Definition: MeshProcessMeasures3D.hpp:322
mgx::Measure3DDistanceToMesh
Definition: MeshProcessMeasures3D.hpp:595
mgx::Measure3DWallArea
Definition: MeshProcessMeasures3D.hpp:81
mgx::Measure3DOutsideWallAreaPercent
Definition: MeshProcessMeasures3D.hpp:468
mgx::Measure3DSizeRad::run
bool run()
Runs the process.
Definition: MeshProcessMeasures3D.hpp:265
mgx::Measure3DWallArea::run
bool run(Mesh *mesh)
Definition: MeshProcessMeasures3D.hpp:102
mgx::Measure3DSizeCustom::Measure3DSizeCustom
Measure3DSizeCustom(const Process &process)
Definition: MeshProcessMeasures3D.hpp:370
mgx::Measure3DSizeLong::Measure3DSizeLong
Measure3DSizeLong(const Process &process)
Definition: MeshProcessMeasures3D.hpp:198
mgx::Measure3DSizeX::run
bool run(Mesh *mesh)
Definition: MeshProcessMeasures3D.hpp:302
mgx::Measure3DOutsideWallArea
Definition: MeshProcessMeasures3D.hpp:439
mgx::Measure3DOutsideWallArea::Measure3DOutsideWallArea
Measure3DOutsideWallArea(const Process &process)
Definition: MeshProcessMeasures3D.hpp:442
mgx::MeasureDistanceToBezierPlane3D::run
bool run()
Runs the process.
Definition: MeshProcessMeasures3D.hpp:692
mgx::Measure3DSizeY::run
bool run(Mesh *mesh)
Definition: MeshProcessMeasures3D.hpp:330
mgx::Measure3DCoordCirc::run
bool run()
Runs the process.
Definition: MeshProcessMeasures3D.hpp:150
mgx::Measure3DCoordRad::run
bool run(Mesh *mesh)
Definition: MeshProcessMeasures3D.hpp:187
mgx::Measure3DSizeY
Definition: MeshProcessMeasures3D.hpp:310
mgx::MeasureDistanceToBezier3D
Definition: MeshProcessMeasures3D.hpp:624
mgx::Measure3DCoordRad::Measure3DCoordRad
Measure3DCoordRad(const Process &process)
Definition: MeshProcessMeasures3D.hpp:169
mgx::Measure3DCoordLong::run
bool run()
Runs the process.
Definition: MeshProcessMeasures3D.hpp:121
mgx::AttrMap< int, float >
mgx::Measure3DNeighbors::run
bool run()
Runs the process.
Definition: MeshProcessMeasures3D.hpp:64
Generated on Fri Jul 9 2021 18:34:54 for MorphoGraphX by   doxygen 1.8.17