ACloudViewer  3.9.4
A Modern Library for 3D Data Processing
primitives.cpp
Go to the documentation of this file.
1 // ----------------------------------------------------------------------------
2 // - CloudViewer: www.cloudViewer.org -
3 // ----------------------------------------------------------------------------
4 // Copyright (c) 2018-2024 www.cloudViewer.org
5 // SPDX-License-Identifier: MIT
6 // ----------------------------------------------------------------------------
7 
8 // CV_CORE_LIB
9 #include <Logging.h>
10 
11 // CV_DB_LIB
12 #include <ecvBox.h>
13 #include <ecvCone.h>
14 #include <ecvCoordinateSystem.h>
15 #include <ecvCylinder.h>
16 #include <ecvDisc.h>
17 #include <ecvDish.h>
18 #include <ecvExtru.h>
19 #include <ecvFacet.h>
20 #include <ecvGenericPrimitive.h>
21 #include <ecvMesh.h>
22 #include <ecvPlanarEntityInterface.h>
23 #include <ecvPlane.h>
24 #include <ecvPointCloud.h>
25 #include <ecvQuadric.h>
26 #include <ecvSphere.h>
27 #include <ecvTorus.h>
28 
29 // LOCAL
30 #include "pybind/docstring.h"
31 #include "pybind/geometry/geometry.h"
32 #include "pybind/geometry/geometry_trampoline.h"
33 
34 namespace cloudViewer {
35 namespace geometry {
36 
37 void pybind_primitives(py::module& m) {
38  // cloudViewer.geometry.ccGenericPrimitive
39  py::class_<ccGenericPrimitive, PyGenericPrimitive<ccGenericPrimitive>,
40  std::shared_ptr<ccGenericPrimitive>, ccMesh>
41  primitive(m, "ccGenericPrimitive", "The base primitives class.");
42  primitive
43  .def("__repr__",
44  [](const ccGenericPrimitive& prim) {
45  std::string info = fmt::format(
46  "ccGenericPrimitive with type {}, precision {}",
47  prim.getTypeName().toStdString(),
48  prim.getDrawingPrecision());
49  return info;
50  })
51  .def(
52  "clone",
53  [](const ccGenericPrimitive& prim) {
54  return std::shared_ptr<ccGenericPrimitive>(
55  prim.clone());
56  },
57  "Clones primitive.")
58  .def(
59  "get_type_name",
60  [](const ccGenericPrimitive& prim) {
61  return prim.getTypeName().toStdString();
62  },
63  "Returns type name (sphere, cylinder, etc.)")
64  .def(
65  "set_color",
66  [](ccGenericPrimitive& prim, const Eigen::Vector3d& color) {
67  prim.setColor(ecvColor::Rgb::FromEigen(color));
68  },
69  "Sets primitive color (shortcut).", "color"_a)
70  .def("has_drawing_precision",
71  &ccGenericPrimitive::hasDrawingPrecision,
72  "Whether drawing is dependent on 'precision' parameter.")
73  .def("set_drawing_precision",
74  &ccGenericPrimitive::setDrawingPrecision,
75  "Sets drawing precision.", "steps"_a)
76  .def("get_drawing_precision",
77  &ccGenericPrimitive::getDrawingPrecision,
78  "Returns drawing precision (or 0 if feature is not "
79  "supported).")
80  .def(
81  "get_transformation",
82  [](const ccGenericPrimitive& prim) {
83  return ccGLMatrixd::ToEigenMatrix4(
84  prim.getTransformation());
85  },
86  "Returns the transformation that is currently applied to "
87  "the vertices.")
88  .def(
89  "get_transformation_history",
90  [](const ccGenericPrimitive& prim) {
91  return ccGLMatrixd::ToEigenMatrix4(
92  prim.getGLTransformationHistory());
93  },
94  "inherited methods (ccHObject).");
95  docstring::ClassMethodDocInject(m, "ccGenericPrimitive", "clone");
96  docstring::ClassMethodDocInject(m, "ccGenericPrimitive", "get_type_name");
97  docstring::ClassMethodDocInject(m, "ccGenericPrimitive", "set_color",
98  {{"color", "rgb color."}});
99  docstring::ClassMethodDocInject(m, "ccGenericPrimitive",
100  "has_drawing_precision");
101  docstring::ClassMethodDocInject(
102  m, "ccGenericPrimitive", "set_drawing_precision",
103  {{"steps",
104  "Warnings: "
105  "- steps should always be >= "
106  "ccGenericPrimitive::MIN_DRAWING_PRECISION"
107  "- changes primitive content(calls "
108  "ccGenericPrimitive::updateRepresentation)"
109  "- may fail if not enough memory!"
110  "- param steps drawing precision"
111  "return success(false if not enough memory)"}});
112  docstring::ClassMethodDocInject(m, "ccGenericPrimitive",
113  "get_drawing_precision");
114  docstring::ClassMethodDocInject(m, "ccGenericPrimitive",
115  "get_transformation");
116  docstring::ClassMethodDocInject(m, "ccGenericPrimitive",
117  "get_transformation_history");
118 
119  // cloudViewer.geometry.ccPlane
120  py::class_<ccPlane, ccGenericPrimitive, std::shared_ptr<ccPlane>,
121  ccPlanarEntityInterface>
122  pyplane(m, "ccPlane", py::multiple_inheritance(),
123  "The 3D plane primitive.");
124  py::detail::bind_default_constructor<ccPlane>(pyplane);
125  py::detail::bind_copy_functions<ccPlane>(pyplane);
126  pyplane.def(py::init([](const std::string& name) {
127  return new ccPlane(name.c_str());
128  }),
129  "Simplified constructor", "name"_a = "Plane")
130  .def(py::init([](PointCoordinateType width,
131  PointCoordinateType height,
132  const Eigen::Matrix4d& trans_matrix,
133  const std::string& name) {
134  const ccGLMatrix matrix =
135  ccGLMatrix::FromEigenMatrix(trans_matrix);
136  auto prim =
137  new ccPlane(width, height, &matrix, name.c_str());
138  prim->clearTriNormals();
139  return prim;
140  }),
141  "Plane normal corresponds to 'Z' dimension: "
142  "\n"
143  "-param width plane width along 'X' dimension; "
144  "\n"
145  "-param height plane width along 'Y' dimension; "
146  "\n"
147  "param trans_matrix optional 3D transformation (can be set "
148  "afterwards with ccDrawableObject::setGLTransformation); "
149  "\n"
150  "-param name name.",
151  "width"_a, "height"_a,
152  "trans_matrix"_a = Eigen::Matrix4d::Identity(),
153  "name"_a = "Plane")
154  .def("__repr__",
155  [](ccPlane& plane) {
156  const PointCoordinateType* eq = plane.getEquation();
157  std::string info = fmt::format(
158  "ccPlane with faces {}, width {}, height {} and "
159  "equation {}x + {}y + {}z = {}",
160  plane.size(), plane.getXWidth(), plane.getYWidth(),
161  eq[0], eq[1], eq[2], eq[3]);
162  return info;
163  })
164  .def("flip", &ccPlane::flip, "Flips the plane.")
165  .def("get_width", &ccPlane::getXWidth, "Returns 'X' width.")
166  .def(
167  "set_width",
168  [](ccPlane& plane, PointCoordinateType width,
169  bool auto_update) {
170  plane.setXWidth(width, auto_update);
171  },
172  "Sets 'X' width.", "width"_a, "auto_update"_a = true)
173  .def("get_height", &ccPlane::getYWidth, "Returns 'Y' width.")
174  .def(
175  "set_height",
176  [](ccPlane& plane, PointCoordinateType height,
177  bool auto_update) {
178  plane.setYWidth(height, auto_update);
179  },
180  "Sets 'Y' width.", "height"_a, "auto_update"_a = true)
181  .def(
182  "get_center",
183  [](const ccPlane& plane) {
184  return CCVector3d::fromArray(plane.getCenter());
185  },
186  "Returns the plane center.")
187  .def(
188  "get_normal",
189  [](const ccPlane& plane) {
190  return CCVector3d::fromArray(plane.getNormal());
191  },
192  "inherited from ccPlanarEntityInterface, returns the plane "
193  "normal.")
194  .def(
195  "get_equation",
196  [](const ccPlane& plane) {
197  CCVector3 N;
198  PointCoordinateType constVal = 0;
199  plane.getEquation(N, constVal);
200  return std::make_tuple(CCVector3d::fromArray(N),
201  constVal);
202  },
203  "Returns the equation of the plane. Equation: N.P + "
204  "constVal = 0; "
205  "i.e.Nx.x + Ny.y + Nz.z + constVal = 0");
206 
207  docstring::ClassMethodDocInject(m, "ccPlane", "flip");
208  docstring::ClassMethodDocInject(m, "ccPlane", "get_width");
209  docstring::ClassMethodDocInject(
210  m, "ccPlane", "set_width",
211  {{"width", "plane 'X' width."}, {"auto_update", "auto update"}});
212  docstring::ClassMethodDocInject(m, "ccPlane", "get_height");
213  docstring::ClassMethodDocInject(
214  m, "ccPlane", "set_height",
215  {{"height", "plane 'Y' width."}, {"auto_update", "auto update"}});
216  docstring::ClassMethodDocInject(m, "ccPlane", "get_center");
217  docstring::ClassMethodDocInject(m, "ccPlane", "get_normal");
218  docstring::ClassMethodDocInject(m, "ccPlane", "get_equation");
219 
220  // cloudViewer.geometry.ccBox
221  py::class_<ccBox, PyGenericPrimitive<ccBox>, std::shared_ptr<ccBox>,
222  ccGenericPrimitive>
223  pybox(m, "ccBox", "The 3D Box primitive.");
224  py::detail::bind_default_constructor<ccBox>(pybox);
225  py::detail::bind_copy_functions<ccBox>(pybox);
226  pybox.def(py::init([](const std::string& name) {
227  return new ccBox(name.c_str());
228  }),
229  "Simplified constructor", "name"_a = "Box")
230  .def(py::init([](const Eigen::Vector3d& dims,
231  const Eigen::Matrix4d& trans_matrix,
232  const std::string& name) {
233  const ccGLMatrix matrix =
234  ccGLMatrix::FromEigenMatrix(trans_matrix);
235  auto prim = new ccBox(CCVector3::fromArray(dims), &matrix,
236  name.c_str());
237  prim->clearTriNormals();
238  return prim;
239  }),
240  "Box dimensions axis along each dimension are defined in a "
241  "single 3D vector: "
242  "A box is in fact composed of 6 planes (ccPlane)."
243  "\n"
244  "-param dims box dimensions; "
245  "\n"
246  "-param trans_matrix optional 3D transformation (can be set "
247  "afterwards with ccDrawableObject::setGLTransformation); "
248  "\n"
249  "-param name name.",
250  "dims"_a, "trans_matrix"_a = Eigen::Matrix4d::Identity(),
251  "name"_a = "Box")
252  .def("__repr__",
253  [](const ccBox& box) {
254  const CCVector3& dims = box.getDimensions();
255  std::string info = fmt::format(
256  "ccBox with faces {} and dimension ({}, {}, {})",
257  box.size(), dims.x, dims.y, dims.z);
258  return info;
259  })
260  .def(
261  "get_dimensions",
262  [](ccBox& box) {
263  return CCVector3d::fromArray(box.getDimensions());
264  },
265  "Returns box dimensions.")
266  .def(
267  "set_dimensions",
268  [](ccBox& box, const Eigen::Vector3d& dims) {
269  CCVector3 tempDims = CCVector3::fromArray(dims);
270  box.setDimensions(tempDims);
271  },
272  "Returns box dimensions.", "dims"_a);
273 
274  docstring::ClassMethodDocInject(m, "ccBox", "get_dimensions");
275  docstring::ClassMethodDocInject(
276  m, "ccBox", "set_dimensions",
277  {{"dims", "box dimensions (width, length, height)."}});
278 
279  // cloudViewer.geometry.ccSphere
280  py::class_<ccSphere, PyGenericPrimitive<ccSphere>,
281  std::shared_ptr<ccSphere>, ccGenericPrimitive>
282  pysphere(m, "ccSphere", "The 3D sphere primitive.");
283  py::detail::bind_default_constructor<ccSphere>(pysphere);
284  py::detail::bind_copy_functions<ccSphere>(pysphere);
285  pysphere.def(py::init([](const std::string& name) {
286  return new ccSphere(name.c_str());
287  }),
288  "Simplified constructor", "name"_a = "Sphere")
289  .def(py::init([](PointCoordinateType radius,
290  const Eigen::Matrix4d& trans_matrix,
291  unsigned precision, const std::string& name) {
292  const ccGLMatrix matrix =
293  ccGLMatrix::FromEigenMatrix(trans_matrix);
294  auto prim = new ccSphere(radius, &matrix, name.c_str(),
295  precision);
296  prim->clearTriNormals();
297  return prim;
298  }),
299  "-param radius sphere radius; "
300  "\n"
301  "-param trans_matrix optional 3D transformation (can be set "
302  "afterwards with ccDrawableObject::setGLTransformation); "
303  "\n"
304  "-param precision drawing precision (angular step = "
305  "360/precision).",
306  "\n"
307  "-param name name.",
308  "radius"_a, "trans_matrix"_a = Eigen::Matrix4d::Identity(),
309  "precision"_a = 24, "name"_a = "Sphere")
310  .def("__repr__",
311  [](const ccSphere& sphere) {
312  std::string info =
313  fmt::format("ccSphere with faces {} and radius {}",
314  sphere.size(), sphere.getRadius());
315  return info;
316  })
317  .def("get_radius", &ccSphere::getRadius, "Returns sphere radius.")
318  .def("set_radius", &ccSphere::setRadius, "Sets sphere radius.",
319  "radius"_a);
320 
321  docstring::ClassMethodDocInject(m, "ccSphere", "get_radius");
322  docstring::ClassMethodDocInject(
323  m, "ccSphere", "set_radius",
324  {{"radius",
325  "sphere radius, warning changes primitive content "
326  "(calls ccGenericPrimitive::updateRepresentation)."}});
327 
328  // cloudViewer.geometry.ccTorus
329  py::class_<ccTorus, PyGenericPrimitive<ccTorus>, std::shared_ptr<ccTorus>,
330  ccGenericPrimitive>
331  pytorus(m, "ccTorus", "The 3D torus primitive.");
332  py::detail::bind_default_constructor<ccTorus>(pytorus);
333  py::detail::bind_copy_functions<ccTorus>(pytorus);
334  pytorus.def(py::init([](const std::string& name) {
335  return new ccTorus(name.c_str());
336  }),
337  "Simplified constructor", "name"_a = "Torus")
338  .def(py::init([](PointCoordinateType inside_radius,
339  PointCoordinateType outside_radius,
340  double angle_rad, bool rectangular_section,
341  PointCoordinateType rect_section_height,
342  const Eigen::Matrix4d& trans_matrix,
343  unsigned precision, const std::string& name) {
344  const ccGLMatrix matrix =
345  ccGLMatrix::FromEigenMatrix(trans_matrix);
346  auto prim = new ccTorus(inside_radius, outside_radius,
347  angle_rad, rectangular_section,
348  rect_section_height, &matrix,
349  name.c_str(), precision);
350  prim->clearTriNormals();
351  return prim;
352  }),
353  "Torus is defined in the XY plane by default: "
354  "\n"
355  "-param inside_radius inside radius.",
356  "\n"
357  "-param outside_radius outside radius.",
358  "\n"
359  "-param angle_rad subtended angle (in radians).",
360  "\n"
361  "-param rectangular_section whether section is rectangular or "
362  "round.",
363  "\n"
364  "-param rect_section_height section height (if rectangular "
365  "torus).",
366  "\n"
367  "-param trans_matrix optional 3D transformation (can be set "
368  "afterwards with ccDrawableObject::setGLTransformation); "
369  "\n"
370  "-param precision drawing precision (angular step = "
371  "360/precision).",
372  "\n"
373  "-param name name.",
374  "inside_radius"_a, "outside_radius"_a,
375  "angle_rad"_a = 2.0 * M_PI, "rectangular_section"_a = false,
376  "rect_section_height"_a = 0,
377  "trans_matrix"_a = Eigen::Matrix4d::Identity(),
378  "precision"_a = 24, "name"_a = "Torus")
379  .def("__repr__",
380  [](const ccTorus& torus) {
381  std::string info = fmt::format(
382  "ccTorus with faces {}, inside-radius {}, "
383  "outside-radius {} and height {}",
384  torus.size(), torus.getInsideRadius(),
385  torus.getOutsideRadius(),
386  torus.getRectSectionHeight());
387  return info;
388  })
389  .def("get_inside_radius", &ccTorus::getInsideRadius,
390  "Returns the torus inside radius.")
391  .def("get_outside_radius", &ccTorus::getOutsideRadius,
392  "Returns the torus outside radius.")
393  .def("get_rect_section_height", &ccTorus::getRectSectionHeight,
394  "Returns the torus rectangular section height (along Y-axis) "
395  "if applicable.")
396  .def("get_rectangular_section", &ccTorus::getRectSection,
397  "Returns whether torus has a rectangular (true) or circular "
398  "(false) section.")
399  .def("get_angle_rad", &ccTorus::getAngleRad,
400  "Returns the torus subtended angle (in radians).");
401 
402  docstring::ClassMethodDocInject(m, "ccTorus", "get_inside_radius");
403  docstring::ClassMethodDocInject(m, "ccTorus", "get_outside_radius");
404  docstring::ClassMethodDocInject(m, "ccTorus", "get_rect_section_height");
405  docstring::ClassMethodDocInject(m, "ccTorus", "get_rectangular_section");
406  docstring::ClassMethodDocInject(m, "ccTorus", "get_angle_rad");
407 
408  // cloudViewer.geometry.ccQuadric
409  py::class_<ccQuadric, PyGenericPrimitive<ccQuadric>,
410  std::shared_ptr<ccQuadric>, ccGenericPrimitive>
411  pyquadric(m, "ccQuadric", "The 3D quadric primitive.");
412  py::detail::bind_default_constructor<ccQuadric>(pyquadric);
413  py::detail::bind_copy_functions<ccQuadric>(pyquadric);
414  pyquadric
415  .def(py::init([](const std::string& name) {
416  return new ccQuadric(name.c_str());
417  }),
418  "Simplified constructor", "name"_a = "Quadric")
419  .def(py::init([](const Eigen::Vector2d& min_corner,
420  const Eigen::Vector2d& max_corner,
421  const Eigen::Vector6d& equation,
422  const Eigen::Vector3i& dimensions,
423  const Eigen::Matrix4d& trans_matrix,
424  unsigned precision, const std::string& name) {
425  const ccGLMatrix matrix =
426  ccGLMatrix::FromEigenMatrix(trans_matrix);
427  CCVector2 minCorner(
428  static_cast<PointCoordinateType>(min_corner(0)),
429  static_cast<PointCoordinateType>(min_corner(1)));
430  CCVector2 maxCorner(
431  static_cast<PointCoordinateType>(max_corner(0)),
432  static_cast<PointCoordinateType>(max_corner(1)));
433  PointCoordinateType eq[6];
434  for (size_t i = 0; i < 6; ++i) {
435  eq[i] = static_cast<PointCoordinateType>(equation(i));
436  }
437 
438  Tuple3ub dims(static_cast<unsigned char>(dimensions(0)),
439  static_cast<unsigned char>(dimensions(1)),
440  static_cast<unsigned char>(dimensions(2)));
441 
442  auto prim =
443  new ccQuadric(minCorner, maxCorner, eq, &dims,
444  &matrix, name.c_str(), precision);
445  prim->clearTriNormals();
446  return prim;
447  }),
448  "-Quadric orthogonal dimension is 'Z' by default: "
449  "\n"
450  "-param min_corner min corner of the 'representation' base "
451  "area; "
452  "\n"
453  "-param max_corner max corner of the 'representation' base "
454  "area; "
455  "\n"
456  "-param equation equation coefficients ( Z = a + b.X + c.Y + "
457  "d.X^2 + e.X.Y + f.Y^2); "
458  "\n"
459  "-param dimensions optional dimension indexes; "
460  "\n"
461  "-param trans_matrix optional 3D transformation (can be set "
462  "afterwards with ccDrawableObject::setGLTransformation); "
463  "\n"
464  "-param precision drawing precision (angular step = "
465  "360/precision).",
466  "\n"
467  "-param name name.",
468  "min_corner"_a, "max_corner"_a, "equation"_a,
469  "dimensions"_a = Eigen::Vector3i::Ones(),
470  "trans_matrix"_a = Eigen::Matrix4d::Identity(),
471  "precision"_a = 24, "name"_a = "Quadric")
472  .def("__repr__",
473  [](const ccQuadric& quadric) {
474  std::string info = fmt::format(
475  "ccQuadric with faces {} and equations: {}",
476  quadric.size(),
477  quadric.getEquationString().toStdString());
478  return info;
479  })
480  .def(
481  "get_min_corner",
482  [](const ccQuadric& quadric) {
483  return Eigen::Vector2d(quadric.getMinCorner().x,
484  quadric.getMinCorner().y);
485  },
486  "Returns the quadric min corner.")
487  .def(
488  "get_max_corner",
489  [](const ccQuadric& quadric) {
490  return Eigen::Vector2d(quadric.getMaxCorner().x,
491  quadric.getMaxCorner().y);
492  },
493  "Returns the quadric max corner.")
494  .def(
495  "get_equation_coefficient",
496  [](const ccQuadric& quadric) {
497  const PointCoordinateType* equation =
498  quadric.getEquationCoefs();
499  Eigen::Vector6d coefficient(6);
500  for (size_t i = 0; i < 6; ++i) {
501  coefficient(i) = static_cast<double>(equation[i]);
502  }
503  return coefficient;
504  },
505  "Returns the quadric equation coefficients.")
506  .def(
507  "get_equation_dims",
508  [](const ccQuadric& quadric) {
509  const Tuple3ub& dims = quadric.getEquationDims();
510  return Eigen::Vector3i(static_cast<int>(dims.x),
511  static_cast<int>(dims.y),
512  static_cast<int>(dims.z));
513  },
514  "Returns the quadric equation 'coordinate system' (X,Y,Z "
515  "dimensions indexes).")
516  .def(
517  "get_equation_string",
518  [](const ccQuadric& quadric) {
519  return quadric.getEquationString().toStdString();
520  },
521  "Returns the quadric equation coefficients as a string.")
522  .def(
523  "project_on_quadric",
524  [](const ccQuadric& quadric, const Eigen::Vector3d& point) {
525  const CCVector3 P = CCVector3::fromArray(point);
526  CCVector3 Q;
527  PointCoordinateType elevation =
528  quadric.projectOnQuadric(P, Q);
529  return std::make_tuple(elevation,
530  CCVector3d::fromArray(point));
531  },
532  "Returns the quadric equation coefficients as a string.")
533  .def_static(
534  "fit",
535  [](cloudViewer::GenericIndexedCloudPersist& cloud) {
536  cloudViewer::GenericIndexedCloudPersist* persistCloud =
537  static_cast<
538  cloudViewer::
539  GenericIndexedCloudPersist*>(
540  &cloud);
541  if (!persistCloud) {
542  cloudViewer::utility::LogWarning(
543  "[ccQuadric::Fit] Illegal input "
544  "parameters, only support point cloud!");
545  return std::make_tuple(
546  std::make_shared<ccQuadric>("Quadric"),
547  0.0);
548  }
549  double rms = 0.0;
550  ccQuadric* quadric = ccQuadric::Fit(persistCloud, &rms);
551  return std::make_tuple(
552  std::shared_ptr<ccQuadric>(quadric), rms);
553  },
554  "Fits a quadric primitive on a cloud", "cloud"_a);
555 
556  docstring::ClassMethodDocInject(m, "ccQuadric", "get_min_corner");
557  docstring::ClassMethodDocInject(m, "ccQuadric", "get_max_corner");
558  docstring::ClassMethodDocInject(m, "ccQuadric", "get_equation_coefficient");
559  docstring::ClassMethodDocInject(m, "ccQuadric", "get_equation_dims");
560  docstring::ClassMethodDocInject(m, "ccQuadric", "get_equation_string");
561  docstring::ClassMethodDocInject(m, "ccQuadric", "project_on_quadric");
562 
563  // cloudViewer.geometry.ccCone
564  py::class_<ccCone, PyGenericPrimitive<ccCone>, std::shared_ptr<ccCone>,
565  ccGenericPrimitive>
566  pycone(m, "ccCone", "The 3D cone primitive.");
567  py::detail::bind_default_constructor<ccCone>(pycone);
568  py::detail::bind_copy_functions<ccCone>(pycone);
569  pycone.def(py::init([](const std::string& name) {
570  return new ccCone(name.c_str());
571  }),
572  "Simplified constructor", "name"_a = "Cone")
573  .def(py::init([](PointCoordinateType bottom_radius,
574  PointCoordinateType top_radius,
575  PointCoordinateType height,
576  PointCoordinateType x_off,
577  PointCoordinateType y_off,
578  const Eigen::Matrix4d& trans_matrix,
579  unsigned precision, const std::string& name) {
580  const ccGLMatrix matrix =
581  ccGLMatrix::FromEigenMatrix(trans_matrix);
582  auto prim = new ccCone(bottom_radius, top_radius, height,
583  x_off, y_off, &matrix, name.c_str(),
584  precision);
585  prim->clearTriNormals();
586  return prim;
587  }),
588  "Cone axis corresponds to the 'Z' dimension by default: "
589  "\n"
590  "-param bottom_radius cone bottom radius; "
591  "\n"
592  "-param top_radius cone top radius; "
593  "\n"
594  "-param height cone height (transformation should point to "
595  "the axis center); "
596  "\n"
597  "-param x_off displacement of axes along X-axis (Snout mode); "
598  "\n"
599  "-param y_off displacement of axes along Y-axis (Snout mode); "
600  "\n"
601  "-param trans_matrix optional 3D transformation (can be set "
602  "afterwards with ccDrawableObject::setGLTransformation); "
603  "\n"
604  "-param precision drawing precision (angular step = "
605  "360/precision); "
606  "\n"
607  "-param name primitive name.",
608  "bottom_radius"_a, "top_radius"_a, "height"_a, "x_off"_a = 0,
609  "y_off"_a = 0, "trans_matrix"_a = Eigen::Matrix4d::Identity(),
610  "precision"_a = 24, "name"_a = "Cone")
611  .def("__repr__",
612  [](const ccCone& cone) {
613  std::string info = fmt::format(
614  "ccCone with faces {}, bottom radius {}, top "
615  "radius {} and height {}",
616  cone.size(), cone.getBottomRadius(),
617  cone.getTopRadius(), cone.getHeight());
618  return info;
619  })
620  .def("get_height", &ccCone::getHeight, "Returns cone height.")
621  .def("set_height", &ccCone::setHeight, "Sets cone height",
622  "height"_a)
623  .def("get_bottom_radius", &ccCone::getBottomRadius,
624  "Returns cone bottom radius.")
625  .def("set_bottom_radius", &ccCone::setBottomRadius,
626  "Sets cone bottom radius.", "radius"_a)
627  .def("get_top_radius", &ccCone::getTopRadius,
628  "Returns cone top radius.")
629  .def("set_top_radius", &ccCone::setTopRadius,
630  "Sets cone top radius.", "radius"_a)
631  .def(
632  "get_bottom_center",
633  [](const ccCone& cone) {
634  CCVector3d::fromArray(cone.getBottomCenter());
635  },
636  "Returns cone axis bottom end point after applying "
637  "transformation")
638  .def(
639  "get_top_center",
640  [](const ccCone& cone) {
641  CCVector3d::fromArray(cone.getTopCenter());
642  },
643  "Returns cone axis top end point after applying "
644  "transformation")
645  .def(
646  "get_small_center",
647  [](const ccCone& cone) {
648  CCVector3d::fromArray(cone.getSmallCenter());
649  },
650  "Returns cone axis end point associated with whichever "
651  "radii is smaller")
652  .def(
653  "get_large_center",
654  [](const ccCone& cone) {
655  CCVector3d::fromArray(cone.getLargeCenter());
656  },
657  "Returns cone axis end point associated with whichever "
658  "radii is larger")
659  .def("get_small_radius", &ccCone::getSmallRadius,
660  "Returns whichever cone radii is smaller")
661  .def("get_large_radius", &ccCone::getLargeRadius,
662  "Returns whichever cone radii is larger")
663  .def("is_snout_mode", &ccCone::isSnoutMode,
664  "Returns true if the Cone was created in snout mode.");
665 
666  docstring::ClassMethodDocInject(m, "ccCone", "get_height");
667  docstring::ClassMethodDocInject(
668  m, "ccCone", "set_height",
669  {{"height",
670  "changes primitive content (calls "
671  "ccGenericPrimitive::updateRepresentation)."}});
672  docstring::ClassMethodDocInject(m, "ccCone", "get_bottom_radius");
673  docstring::ClassMethodDocInject(
674  m, "ccCone", "set_bottom_radius",
675  {{"radius",
676  "changes primitive content (calls "
677  "ccGenericPrimitive::updateRepresentation)."}});
678  docstring::ClassMethodDocInject(m, "ccCone", "get_top_radius");
679  docstring::ClassMethodDocInject(
680  m, "ccCone", "set_top_radius",
681  {{"radius",
682  "changes primitive content (calls "
683  "ccGenericPrimitive::updateRepresentation)."}});
684  docstring::ClassMethodDocInject(m, "ccCone", "get_bottom_center");
685  docstring::ClassMethodDocInject(m, "ccCone", "get_top_center");
686  docstring::ClassMethodDocInject(m, "ccCone", "get_small_center");
687  docstring::ClassMethodDocInject(m, "ccCone", "get_large_center");
688  docstring::ClassMethodDocInject(m, "ccCone", "get_small_radius");
689  docstring::ClassMethodDocInject(m, "ccCone", "get_large_radius");
690  docstring::ClassMethodDocInject(m, "ccCone", "is_snout_mode");
691 
692  // cloudViewer.geometry.ccCylinder
693  py::class_<ccCylinder, PyGenericPrimitive<ccCylinder>,
694  std::shared_ptr<ccCylinder>, ccCone>
695  pycylinder(m, "ccCylinder", "The 3D Box primitive.");
696  py::detail::bind_default_constructor<ccCylinder>(pycylinder);
697  py::detail::bind_copy_functions<ccCylinder>(pycylinder);
698  pycylinder
699  .def(py::init([](const std::string& name) {
700  return new ccCylinder(name.c_str());
701  }),
702  "Simplified constructor", "name"_a = "Cylinder")
703  .def(py::init([](PointCoordinateType radius,
704  PointCoordinateType height,
705  const Eigen::Matrix4d& trans_matrix,
706  unsigned precision, const std::string& name) {
707  const ccGLMatrix matrix =
708  ccGLMatrix::FromEigenMatrix(trans_matrix);
709  auto prim = new ccCylinder(radius, height, &matrix,
710  name.c_str(), precision);
711  prim->clearTriNormals();
712  return prim;
713  }),
714  "Cylinder axis corresponds to the 'Z' dimension: "
715  "Internally represented by a cone with the same top and "
716  "bottom radius. "
717  "\n"
718  "-param radius cylinder radius"
719  "\n"
720  "-param height cylinder height(transformation should point to "
721  "the axis center)"
722  "\n"
723  "-param trans_matrix optional 3D transformation (can be set "
724  "afterwards with ccDrawableObject::setGLTransformation); "
725  "\n"
726  "-param precision drawing precision (angular step = "
727  "360/precision); "
728  "\n"
729  "-param name name.",
730  "radius"_a, "height"_a,
731  "trans_matrix"_a = Eigen::Matrix4d::Identity(),
732  "precision"_a = 24, "name"_a = "Cylinder")
733  .def("__repr__", [](const ccCylinder& cylinder) {
734  std::string info = fmt::format(
735  "ccCylinder with faces {}, radius {} and height {}",
736  cylinder.size(), cylinder.getBottomRadius(),
737  cylinder.getHeight());
738  return info;
739  });
740 
741  // cloudViewer.geometry.ccDish
742  py::class_<ccDish, PyGenericPrimitive<ccDish>, std::shared_ptr<ccDish>,
743  ccGenericPrimitive>
744  pydish(m, "ccDish", "The 3D dish primitive.");
745  py::detail::bind_default_constructor<ccDish>(pydish);
746  py::detail::bind_copy_functions<ccDish>(pydish);
747  pydish.def(py::init([](const std::string& name) {
748  return new ccDish(name.c_str());
749  }),
750  "Simplified constructor", "name"_a = "Dish")
751  .def(py::init([](PointCoordinateType base_radius,
752  PointCoordinateType height,
753  PointCoordinateType second_radius,
754  const Eigen::Matrix4d& trans_matrix,
755  unsigned precision, const std::string& name) {
756  const ccGLMatrix matrix =
757  ccGLMatrix::FromEigenMatrix(trans_matrix);
758  auto prim = new ccDish(base_radius, height, second_radius,
759  &matrix, name.c_str(), precision);
760  prim->clearTriNormals();
761  return prim;
762  }),
763  "dish dimensions axis along each dimension are defined in a "
764  "single 3D vector: "
765  "A dish is in fact composed of 6 planes (ccPlane)."
766  "\n"
767  "-param radius base radius; "
768  "\n"
769  "-param height maximum height of dished surface above base; "
770  "\n"
771  "-param radius2 If radius2 is zero, dish is drawn as a "
772  "section of sphere. If radius2 is >0, dish is defined as half "
773  "of an ellipsoid.; "
774  "\n"
775  "-param trans_matrix optional 3D transformation (can be set "
776  "afterwards with ccDrawableObject::setGLTransformation); "
777  "\n"
778  "-param precision drawing precision (angular step = "
779  "360/precision); "
780  "\n"
781  "-param name name.",
782  "base_radius"_a, "height"_a, "second_radius"_a = 0,
783  "trans_matrix"_a = Eigen::Matrix4d::Identity(),
784  "precision"_a = 24, "name"_a = "Dish")
785  .def("__repr__",
786  [](const ccDish& dish) {
787  std::string info = fmt::format(
788  "ccDish with faces {}, R1 {}, R2 {} and heigth {}",
789  dish.size(), dish.getBaseRadius(),
790  dish.getSecondRadius(), dish.getHeight());
791  return info;
792  })
793  .def("get_base_radius", &ccDish::getBaseRadius,
794  "Returns the dish base radius.")
795  .def("get_second_radius", &ccDish::getSecondRadius,
796  "Returns the dish second radius.")
797  .def("get_height", &ccDish::getHeight, "Returns the dish height.");
798 
799  docstring::ClassMethodDocInject(m, "ccDish", "get_base_radius");
800  docstring::ClassMethodDocInject(m, "ccDish", "get_second_radius");
801  docstring::ClassMethodDocInject(m, "ccDish", "get_height");
802 
803  // cloudViewer.geometry.ccExtru
804  py::class_<ccExtru, PyGenericPrimitive<ccExtru>, std::shared_ptr<ccExtru>,
805  ccGenericPrimitive>
806  pyextru(m, "ccExtru", "The 3D extru primitive.");
807  py::detail::bind_default_constructor<ccExtru>(pyextru);
808  py::detail::bind_copy_functions<ccExtru>(pyextru);
809  pyextru.def(py::init([](const std::string& name) {
810  return new ccExtru(name.c_str());
811  }),
812  "Simplified constructor", "name"_a = "Extrusion")
813  .def(py::init([](const std::vector<Eigen::Vector2d>& profile,
814  PointCoordinateType height,
815  const Eigen::Matrix4d& trans_matrix,
816  const std::string& name) {
817  const ccGLMatrix matrix =
818  ccGLMatrix::FromEigenMatrix(trans_matrix);
819  std::vector<CCVector2> tempProfile(profile.size());
820  for (const auto& pro : profile) {
821  tempProfile.emplace_back(CCVector2(
822  static_cast<PointCoordinateType>(pro(0)),
823  static_cast<PointCoordinateType>(pro(1))));
824  }
825  auto prim = new ccExtru(tempProfile, height, &matrix,
826  name.c_str());
827  prim->clearTriNormals();
828  return prim;
829  }),
830  "extru dimensions axis along each dimension are defined in a "
831  "single 3D vector: "
832  "A extru is in fact composed of 6 planes (ccPlane)."
833  "\n"
834  "-param profile 2D profile to extrude; "
835  "\n"
836  "-param height extrusion thickness; "
837  "\n"
838  "-param trans_matrix optional 3D transformation (can be set "
839  "afterwards with ccDrawableObject::setGLTransformation); "
840  "\n"
841  "-param name name.",
842  "profile"_a, "height"_a,
843  "trans_matrix"_a = Eigen::Matrix4d::Identity(),
844  "name"_a = "Extrusion")
845  .def("__repr__",
846  [](const ccExtru& extru) {
847  std::string info =
848  fmt::format("ccExtru with faces {} and height {}",
849  extru.size(), extru.getThickness());
850  return info;
851  })
852  .def("get_thickness", &ccExtru::getThickness,
853  "Returns extrusion thickness.")
854  .def(
855  "get_profile",
856  [](const ccExtru& extru) {
857  const std::vector<CCVector2>& profile =
858  extru.getProfile();
859  std::vector<Eigen::Vector2d> outProfile;
860  for (const auto& pro : profile) {
861  outProfile.emplace_back(
862  Eigen::Vector2d(pro.x, pro.y));
863  }
864  return outProfile;
865  },
866  "Returns extrusion profile.");
867 
868  docstring::ClassMethodDocInject(m, "ccExtru", "get_thickness");
869  docstring::ClassMethodDocInject(m, "ccExtru", "get_profile");
870 
871  // cloudViewer.geometry.ccDisc
872  py::class_<ccDisc, PyGenericPrimitive<ccDisc>, std::shared_ptr<ccDisc>,
873  ccGenericPrimitive>
874  pydisc(m, "ccDisc", "The 3D disc primitive.");
875  py::detail::bind_default_constructor<ccDisc>(pydisc);
876  py::detail::bind_copy_functions<ccDisc>(pydisc);
877  pydisc.def(py::init([](const std::string& name) {
878  return new ccDisc(name.c_str());
879  }),
880  "Simplified constructor", "name"_a = "Disc")
881  .def(py::init([](PointCoordinateType radius,
882  const Eigen::Matrix4d& trans_matrix,
883  unsigned precision, const std::string& name) {
884  const ccGLMatrix matrix =
885  ccGLMatrix::FromEigenMatrix(trans_matrix);
886  auto prim = new ccDisc(radius, &matrix, name.c_str(),
887  precision);
888  prim->clearTriNormals();
889  return prim;
890  }),
891  "Disc is defined in the XY plane by default: "
892  "\n"
893  "-param radius disc radius; "
894  "\n"
895  "-param trans_matrix optional 3D transformation (can be set "
896  "afterwards with ccDrawableObject::setGLTransformation); "
897  "\n"
898  "-param precision drawing precision (angular step = "
899  "360/precision); "
900  "\n"
901  "-param name name.",
902  "radius"_a, "trans_matrix"_a = Eigen::Matrix4d::Identity(),
903  "precision"_a = 72, "name"_a = "Disc")
904  .def("__repr__",
905  [](const ccDisc& disc) {
906  std::string info =
907  fmt::format("ccDisc with faces {} and radius {}",
908  disc.size(), disc.getRadius());
909  return info;
910  })
911  .def("get_radius", &ccDisc::getRadius, "Returns disc radius.")
912  .def("set_radius", &ccDisc::setRadius, "Sets disc radius.",
913  "radius"_a);
914 
915  docstring::ClassMethodDocInject(m, "ccDisc", "get_radius");
916  docstring::ClassMethodDocInject(
917  m, "ccDisc", "set_radius",
918  {{"radius",
919  "disc radius, warning changes primitive content "
920  "(calls ccGenericPrimitive::updateRepresentation)."}});
921 
922  // cloudViewer.geometry.ccBox
923  py::class_<ccCoordinateSystem, PyGenericPrimitive<ccCoordinateSystem>,
924  std::shared_ptr<ccCoordinateSystem>, ccGenericPrimitive>
925  pyCS(m, "ccCoordinateSystem", "The 3D Coordinate System.");
926  py::detail::bind_default_constructor<ccCoordinateSystem>(pyCS);
927  py::detail::bind_copy_functions<ccCoordinateSystem>(pyCS);
928  pyCS.def(py::init([](const std::string& name) {
929  return new ccCoordinateSystem(name.c_str());
930  }),
931  "Simplified constructor", "name"_a = "CoordinateSystem")
932  .def(py::init([](PointCoordinateType display_scale,
933  PointCoordinateType axis_width,
934  const Eigen::Matrix4d& trans_matrix,
935  const std::string& name) {
936  const ccGLMatrix matrix =
937  ccGLMatrix::FromEigenMatrix(trans_matrix);
938  auto prim = new ccCoordinateSystem(
939  display_scale, axis_width, &matrix, name.c_str());
940  prim->clearTriNormals();
941  return prim;
942  }),
943  "Coordinate System is essentially just a way to visualize a "
944  "transform matrix. param transMat optional "
945  "3D transformation (can be set afterwards with "
946  "ccDrawableObject::setGLTransformation) param name name.",
947  "display_scale"_a, "axis_width"_a,
948  "trans_matrix"_a = Eigen::Matrix4d::Identity(),
949  "name"_a = "Box")
950  .def(py::init([](const Eigen::Matrix4d& trans_matrix,
951  const std::string& name) {
952  const ccGLMatrix matrix =
953  ccGLMatrix::FromEigenMatrix(trans_matrix);
954  auto prim = new ccCoordinateSystem(&matrix, name.c_str());
955  prim->clearTriNormals();
956  return prim;
957  }),
958  "Coordinate System is essentially just a way to visualize a "
959  "transform matrix. param transMat optional "
960  "3D transformation (can be set afterwards with "
961  "ccDrawableObject::setGLTransformation) param name name.",
962  "trans_matrix"_a = Eigen::Matrix4d::Identity(),
963  "name"_a = "Box")
964  .def("__repr__",
965  [](const ccCoordinateSystem& cs) {
966  const CCVector3 origin = cs.getOrigin();
967  PointCoordinateType axis_width = cs.getAxisWidth();
968  PointCoordinateType display_scale = cs.getDisplayScale();
969  std::string info = fmt::format(
970  "ccCoordinateSystem with origin ({}, {}, {}) "
971  "display scale {} and axis width {}",
972  origin.x, origin.y, origin.z, display_scale,
973  axis_width);
974  return info;
975  })
976  .def("axis_planes_shown", &ccCoordinateSystem::axisPlanesAreShown,
977  "Returns whether axis planes are Shown.")
978  .def("show_axis_planes", &ccCoordinateSystem::ShowAxisPlanes,
979  "Sets whether axis planes are Shown.", "show"_a)
980  .def("axis_lines_shown", &ccCoordinateSystem::axisLinesAreShown,
981  "Returns whether axis lines are Shown.")
982  .def("show_axis_lines", &ccCoordinateSystem::ShowAxisLines,
983  "Sets whether axis lines are Shown.", "show"_a)
984  .def("get_axis_width", &ccCoordinateSystem::getAxisWidth,
985  "Returns axis width.")
986  .def("set_axis_width", &ccCoordinateSystem::setAxisWidth,
987  "Sets axis width.", "width"_a)
988  .def("get_display_scale", &ccCoordinateSystem::getDisplayScale,
989  "Returns display scale.")
990  .def("set_display_scale", &ccCoordinateSystem::setDisplayScale,
991  "Sets display scale.", "scale"_a)
992  .def("get_xy_plane", &ccCoordinateSystem::getXYplane,
993  "Returns xy plane.")
994  .def("get_yz_plane", &ccCoordinateSystem::getYZplane,
995  "Returns yz plane.")
996  .def("get_zx_plane", &ccCoordinateSystem::getZXplane,
997  "Returns zx plane.")
998  .def(
999  "get_origin",
1000  [](ccCoordinateSystem& cs) {
1001  return CCVector3d::fromArray(cs.getOrigin());
1002  },
1003  "Returns CoordinateSystem origin.");
1004 
1005  docstring::ClassMethodDocInject(m, "ccCoordinateSystem",
1006  "axis_planes_shown");
1007  docstring::ClassMethodDocInject(m, "ccCoordinateSystem", "show_axis_planes",
1008  {{"show", "axis planes shown flag."}});
1009  docstring::ClassMethodDocInject(m, "ccCoordinateSystem",
1010  "axis_lines_shown");
1011  docstring::ClassMethodDocInject(m, "ccCoordinateSystem", "show_axis_lines",
1012  {{"show", "axis lines shown flag."}});
1013 
1014  docstring::ClassMethodDocInject(m, "ccCoordinateSystem", "get_axis_width");
1015  docstring::ClassMethodDocInject(
1016  m, "ccCoordinateSystem", "set_axis_width",
1017  {{"width", "Coordinate system axis width."}});
1018  docstring::ClassMethodDocInject(m, "ccCoordinateSystem",
1019  "get_display_scale");
1020  docstring::ClassMethodDocInject(
1021  m, "ccCoordinateSystem", "set_display_scale",
1022  {{"scale", "Coordinate system display scale."}});
1023  docstring::ClassMethodDocInject(m, "ccCoordinateSystem", "get_xy_plane");
1024  docstring::ClassMethodDocInject(m, "ccCoordinateSystem", "get_yz_plane");
1025  docstring::ClassMethodDocInject(m, "ccCoordinateSystem", "get_zx_plane");
1026  docstring::ClassMethodDocInject(m, "ccCoordinateSystem", "get_origin");
1027 }
1028 
1029 void pybind_primitives_methods(py::module& m) {}
1030 
1031 } // namespace geometry
1032 } // namespace cloudViewer
M_PI
constexpr double M_PI
Pi.
Definition: CVConst.h:19
CCVector2
Vector2Tpl< PointCoordinateType > CCVector2
Default 2D Vector.
Definition: CVGeom.h:780
PointCoordinateType
float PointCoordinateType
Type of the coordinates of a (N-D) point.
Definition: CVTypes.h:16
format
filament::Texture::InternalFormat format
Definition: FilamentResourceManager.cpp:181
width
int width
Definition: FileIOFactory.cpp:142
name
std::string name
Definition: FileIOFactory.cpp:129
height
int height
Definition: FileIOFactory.cpp:143
color
math::float4 color
Definition: LineSetBuffers.cpp:46
profile
CloudViewerScene::LightingProfile profile
Definition: O3DVisualizer.cpp:271
Tuple3Tpl::y
Type y
Definition: CVGeom.h:137
Tuple3Tpl::x
Type x
Definition: CVGeom.h:137
Tuple3Tpl::z
Type z
Definition: CVGeom.h:137
Vector2Tpl::x
Type x
Definition: CVGeom.h:36
Vector2Tpl::y
Type y
Definition: CVGeom.h:36
Vector3Tpl< double >::fromArray
static Vector3Tpl fromArray(const int a[3])
Constructor from an int array.
Definition: CVGeom.h:268
ccBox
Box (primitive)
Definition: ecvBox.h:16
ccBox::getDimensions
const CCVector3 & getDimensions() const
Returns box dimensions.
Definition: ecvBox.h:47
ccBox::setDimensions
void setDimensions(CCVector3 &dims)
Sets box dimensions.
Definition: ecvBox.h:41
ccCone
Cone (primitive)
Definition: ecvCone.h:16
ccCone::getTopRadius
PointCoordinateType getTopRadius() const
Returns top radius.
Definition: ecvCone.h:70
ccCone::getLargeCenter
virtual CCVector3 getLargeCenter() const
Returns cone axis end point associated with whichever radii is larger.
ccCone::getLargeRadius
virtual PointCoordinateType getLargeRadius() const
Returns whichever cone radii is larger.
ccCone::getTopCenter
virtual CCVector3 getTopCenter() const
Returns cone axis top end point after applying transformation.
ccCone::getHeight
PointCoordinateType getHeight() const
Returns height.
Definition: ecvCone.h:52
ccCone::getSmallRadius
virtual PointCoordinateType getSmallRadius() const
Returns whichever cone radii is smaller.
ccCone::isSnoutMode
virtual bool isSnoutMode() const
Returns true if the Cone was created in snout mode.
Definition: ecvCone.h:94
ccCone::setTopRadius
virtual void setTopRadius(PointCoordinateType radius)
Sets top radius.
ccCone::getSmallCenter
virtual CCVector3 getSmallCenter() const
Returns cone axis end point associated with whichever radii is smaller.
ccCone::getBottomRadius
PointCoordinateType getBottomRadius() const
Returns bottom radius.
Definition: ecvCone.h:60
ccCone::setHeight
void setHeight(PointCoordinateType height)
Sets height.
ccCone::getBottomCenter
virtual CCVector3 getBottomCenter() const
Returns cone axis bottom end point after applying transformation.
ccCone::setBottomRadius
virtual void setBottomRadius(PointCoordinateType radius)
Sets bottom radius.
ccCoordinateSystem
Coordinate System (primitive)
Definition: ecvCoordinateSystem.h:19
ccCoordinateSystem::axisPlanesAreShown
bool axisPlanesAreShown() const
Definition: ecvCoordinateSystem.h:54
ccCoordinateSystem::getOrigin
CCVector3 getOrigin() const
Definition: ecvCoordinateSystem.h:75
ccCoordinateSystem::getZXplane
std::shared_ptr< ccPlane > getZXplane() const
ccCoordinateSystem::getXYplane
std::shared_ptr< ccPlane > getXYplane() const
ccCoordinateSystem::ShowAxisLines
void ShowAxisLines(bool show)
ccCoordinateSystem::ShowAxisPlanes
void ShowAxisPlanes(bool show)
ccCoordinateSystem::setDisplayScale
void setDisplayScale(PointCoordinateType scale)
ccCoordinateSystem::getYZplane
std::shared_ptr< ccPlane > getYZplane() const
ccCoordinateSystem::getDisplayScale
PointCoordinateType getDisplayScale() const
Definition: ecvCoordinateSystem.h:68
ccCoordinateSystem::axisLinesAreShown
bool axisLinesAreShown() const
Definition: ecvCoordinateSystem.h:58
ccCoordinateSystem::getAxisWidth
PointCoordinateType getAxisWidth() const
Definition: ecvCoordinateSystem.h:63
ccCoordinateSystem::setAxisWidth
void setAxisWidth(PointCoordinateType width)
ccCylinder
Cylinder (primitive)
Definition: ecvCylinder.h:16
ccDisc
Disc (primitive)
Definition: ecvDisc.h:16
ccDisc::getRadius
PointCoordinateType getRadius() const
Returns radius.
Definition: ecvDisc.h:41
ccDisc::setRadius
void setRadius(PointCoordinateType radius)
Sets radius.
ccDish
Dish.
Definition: ecvDish.h:16
ccDish::getSecondRadius
PointCoordinateType getSecondRadius() const
Returns the dish second radius.
Definition: ecvDish.h:55
ccDish::getBaseRadius
PointCoordinateType getBaseRadius() const
Returns the dish base radius.
Definition: ecvDish.h:53
ccDish::getHeight
PointCoordinateType getHeight() const
Returns the dish height.
Definition: ecvDish.h:59
ccExtru
Profile extrusion (primitive)
Definition: ecvExtru.h:17
ccExtru::getThickness
PointCoordinateType getThickness() const
Returns extrusion thickness.
Definition: ecvExtru.h:47
ccExtru::getProfile
const std::vector< CCVector2 > & getProfile() const
Returns profile.
Definition: ecvExtru.h:50
ccGLMatrixTpl< float >::FromEigenMatrix
static ccGLMatrixTpl< float > FromEigenMatrix(const Eigen::Matrix< double, 4, 4 > &mat)
Definition: ecvGLMatrixTpl.h:54
ccGLMatrixTpl< double >::ToEigenMatrix4
static Eigen::Matrix< double, 4, 4 > ToEigenMatrix4(const ccGLMatrixTpl< float > &mat)
Definition: ecvGLMatrixTpl.h:67
ccGLMatrix
Float version of ccGLMatrixTpl.
Definition: ecvGLMatrix.h:19
ccGenericPrimitive
Generic primitive interface.
Definition: ecvGenericPrimitive.h:16
ccGenericPrimitive::getTypeName
virtual QString getTypeName() const =0
Returns type name (sphere, cylinder, etc.)
ccGenericPrimitive::setDrawingPrecision
virtual bool setDrawingPrecision(unsigned steps)
Sets drawing precision.
ccGenericPrimitive::setColor
virtual void setColor(const ecvColor::Rgb &col)
Sets primitive color (shortcut)
ccGenericPrimitive::getDrawingPrecision
virtual unsigned getDrawingPrecision() const
Returns drawing precision (or 0 if feature is not supported)
Definition: ecvGenericPrimitive.h:72
ccGenericPrimitive::hasDrawingPrecision
virtual bool hasDrawingPrecision() const
Whether drawing is dependent on 'precision' parameter.
Definition: ecvGenericPrimitive.h:52
ccGenericPrimitive::clone
virtual ccGenericPrimitive * clone() const =0
Clones primitive.
ccGenericPrimitive::getGLTransformationHistory
const ccGLMatrix & getGLTransformationHistory() const override
inherited methods (ccHObject)
ccGenericPrimitive::getTransformation
virtual ccGLMatrix & getTransformation()
Returns the transformation that is currently applied to the vertices.
Definition: ecvGenericPrimitive.h:77
ccMesh
Triangular mesh.
Definition: ecvMesh.h:35
ccMesh::clearTriNormals
void clearTriNormals()
Removes per-triangle normals.
Definition: ecvMesh.h:353
ccMesh::size
virtual unsigned size() const override
Returns the number of triangles.
ccPlanarEntityInterface
Interface for a planar entity.
Definition: ecvPlanarEntityInterface.h:18
ccPlane
Plane (primitive)
Definition: ecvPlane.h:18
ccPlane::getCenter
CCVector3 getCenter() const
Returns the center.
Definition: ecvPlane.h:56
ccPlane::getNormal
CCVector3 getNormal() const override
Returns the entity normal.
Definition: ecvPlane.h:73
ccPlane::flip
void flip()
Flips the plane.
ccPlane::setXWidth
void setXWidth(PointCoordinateType w, bool autoUpdate=true)
Sets 'X' width.
Definition: ecvPlane.h:61
ccPlane::getEquation
void getEquation(CCVector3 &N, PointCoordinateType &constVal) const
Returns the equation of the plane.
ccPlane::getXWidth
PointCoordinateType getXWidth() const
Returns 'X' width.
Definition: ecvPlane.h:50
ccPlane::getYWidth
PointCoordinateType getYWidth() const
Returns 'Y' width.
Definition: ecvPlane.h:53
ccPlane::setYWidth
void setYWidth(PointCoordinateType h, bool autoUpdate=true)
Sets 'Y' width.
Definition: ecvPlane.h:67
ccQuadric
Quadric (primitive)
Definition: ecvQuadric.h:16
ccQuadric::getEquationDims
const Tuple3ub & getEquationDims() const
Definition: ecvQuadric.h:69
ccQuadric::getMaxCorner
const CCVector2 & getMaxCorner() const
Returns the quadric max corner.
Definition: ecvQuadric.h:62
ccQuadric::getEquationString
QString getEquationString() const
Returns the quadric equation coefficients as a string.
ccQuadric::getEquationCoefs
const PointCoordinateType * getEquationCoefs() const
Returns the quadric equation coefficients.
Definition: ecvQuadric.h:65
ccQuadric::getMinCorner
const CCVector2 & getMinCorner() const
Returns the quadric min corner.
Definition: ecvQuadric.h:60
ccQuadric::projectOnQuadric
PointCoordinateType projectOnQuadric(const CCVector3 &P, CCVector3 &Q) const
Projects a 3D point in the quadric coordinate system.
ccQuadric::Fit
static ccQuadric * Fit(cloudViewer::GenericIndexedCloudPersist *cloud, double *rms)
Fits a quadric primitive on a cloud.
ccSphere
Sphere (primitive)
Definition: ecvSphere.h:16
ccSphere::setRadius
void setRadius(PointCoordinateType radius)
Sets radius.
ccSphere::getRadius
PointCoordinateType getRadius() const
Returns radius.
Definition: ecvSphere.h:45
ccTorus
Torus (primitive)
Definition: ecvTorus.h:16
ccTorus::getAngleRad
double getAngleRad() const
Returns the torus subtended angle (in radians)
Definition: ecvTorus.h:76
ccTorus::getInsideRadius
PointCoordinateType getInsideRadius() const
Returns the torus inside radius.
Definition: ecvTorus.h:60
ccTorus::getRectSectionHeight
PointCoordinateType getRectSectionHeight() const
Definition: ecvTorus.h:69
ccTorus::getOutsideRadius
PointCoordinateType getOutsideRadius() const
Returns the torus outside radius.
Definition: ecvTorus.h:64
ccTorus::getRectSection
bool getRectSection() const
Definition: ecvTorus.h:74
cloudViewer::GenericIndexedCloudPersist
A generic 3D point cloud with index-based and presistent access to points.
Definition: GenericIndexedCloudPersist.h:19
ecvColor::RgbTpl::FromEigen
constexpr static RgbTpl FromEigen(const Eigen::Vector3d &t)
Definition: ecvColorTypes.h:86
LogWarning
#define LogWarning(...)
Definition: Logging.h:72
geometry_trampoline.h
Eigen::Vector6d
Eigen::Matrix< double, 6, 1 > Vector6d
Definition: Eigen.h:107
cloudViewer::docstring::ClassMethodDocInject
void ClassMethodDocInject(py::module &pybind_module, const std::string &class_name, const std::string &function_name, const std::unordered_map< std::string, std::string > &map_parameter_body_docs)
Definition: docstring.cpp:27
cloudViewer::geometry::pybind_primitives_methods
void pybind_primitives_methods(py::module &m)
Definition: primitives.cpp:1029
cloudViewer::geometry::pybind_primitives
void pybind_primitives(py::module &m)
Definition: primitives.cpp:37
cloudViewer
Generic file read and write utility for python interface.
Definition: AutoSegmentationTools.h:16
knncpp::Vector3i
Eigen::Matrix< Index, 3, 1 > Vector3i
Definition: knncpp.h:30
point
Definition: lsd.c:149