CVB++ 15.0
decl_point_cloud.hpp
1#pragma once
2
3#include <unordered_map>
4#include <limits>
5
6#include "../_cexports/c_core_3d.h"
7
8#include "decl_composite.hpp"
9
10#include "../affine_matrix_3d.hpp"
11#include "../cuboid.hpp"
12#include "../data_type.hpp"
13#include "../exception.hpp"
14#include "../global.hpp"
15#include "../image.hpp"
16#include "../matrix_3d.hpp"
17#include "../matrix_3d_h.hpp"
18#include "../point_3d.hpp"
19#include "../point_3d_h.hpp"
20#include "../size_2d.hpp"
21#include "../plane.hpp"
22#include "../utilities/system_info.hpp"
23#include "../components_pointers_3d.hpp"
24
25#include "../plane_3d.hpp"
26
27#include "../calibrator_3d.hpp"
28#include "../core_3d.hpp"
29
30namespace Cvb
31{
32
33 CVB_BEGIN_INLINE_NS
34
35 template <>
36 inline HandleGuard<PointCloud>::HandleGuard(void *handle) noexcept
37 : HandleGuard<PointCloud>(handle, [](void *handle) { CVB_CALL_CAPI(ReleaseObject(handle)); })
38 {
39 }
40
61 class PointCloud
62 {
63 private:
64 template <class Point>
65 static PointCloudFlags PointTypeToFlags()
66 {
67 if (std::is_same<Point, Cvb::Point3D<float>>::value)
69 else if (std::is_same<Point, Cvb::Point3D<double>>::value)
71 else if (std::is_same<Point, Cvb::Point3DC<float>>::value)
73 else if (std::is_same<Point, Cvb::Point3DC<double>>::value)
75 else if (std::is_same<Point, Cvb::Point3DH<float>>::value)
77 else if (std::is_same<Point, Cvb::Point3DH<double>>::value)
79 else
80 throw std::invalid_argument("Point must be one of the Cvb::Point3D types.");
81 }
82
83 protected:
84 struct PrivateTag
85 {
86 };
87
88 public:
89 using GuardType = HandleGuard<PointCloud>;
90
92
99 static PointCloudPtr FromHandle(HandleGuard<PointCloud> &&guard);
100
101 template <class T>
102 static std::shared_ptr<T> FromHandle(HandleGuard<PointCloud> &&guard)
103 {
104 // required for generic object creation
105 return T::FromHandle(std::move(guard));
106 }
107
109
114 template <class T>
116
118
134 static PointCloudPtr FromMemory(void *buffer, size_t size, PointCloudFlags flags, Cvb::PointCloudFileFormat format);
135
137
153 template <class Point>
154 static PointCloudPtr FromMemory(void *buffer, size_t size, Cvb::PointCloudFileFormat format)
155 {
156 auto flags = PointTypeToFlags<Point>();
157 return FromMemory(buffer, size, flags, format);
158 }
159
161
166 {
167 CExports::CVC3DPointCloudLayout layout = CExports::CVC3DPCL_Invalid;
168 Internal::DoResCall([&]() { return CVB_CALL_CAPI(CVC3DPointCloudAnalyzeLayout(Handle(), layout)); });
169 return static_cast<PointCloudLayout>(layout);
170 }
171
173
177 class DataType DataType() const
178 {
179 CExports::cvbdatatype_t dt = 0;
180 Internal::DoResCall([&]() { return CVB_CALL_CAPI(CVC3DPointCloudGetDatatype(Handle(), dt)); });
181 return Cvb::DataType::FromNativeDescriptor(static_cast<int>(dt));
182 }
183
185
190 {
191 CExports::cvbint64_t numPoints = 0;
192 Internal::DoResCall([&]() { return CVB_CALL_CAPI(CVC3DPointCloudGetNumPoints(Handle(), numPoints)); });
193 return static_cast<std::size_t>(numPoints);
194 }
195
197
202 {
203 ComponentsPointers3D components;
204 auto error = TryPointComponents(components);
205 if (error)
207 return components;
208 }
209
211
216 template <class T>
218 {
219 return PointsTyped(points);
220 }
221
223
228 template <class T>
230 {
231 return PointsHTyped(pointsH);
232 }
233
235
240 {
241 Cuboid boundingBox;
242 Internal::DoResCall([&]() {
243 return CVB_CALL_CAPI(
244 CVC3DPointCloudCalculateBoundingBox(Handle(), *reinterpret_cast<CExports::CVC3DCuboid *>(&boundingBox)));
245 });
246 return boundingBox;
247 }
248
250
255 {
256 Point3D<double> center;
257 Internal::DoResCall([&]() {
258 return CVB_CALL_CAPI(
259 CVC3DPointCloudCalculateCenterOfGravity(Handle(), *reinterpret_cast<CExports::CVC3DPointD *>(&center)));
260 });
261 return center;
262 }
263
265
270 {
271 Matrix3D matrix;
272 Internal::DoResCall([&]() {
273 return CVB_CALL_CAPI(
274 CVC3DPointCloudCalculateCovarianceMatrix(Handle(), *reinterpret_cast<CExports::CVC3DMatrix *>(&matrix)));
275 });
276 return matrix;
277 }
278
280
286 {
288 }
289
291
297 Plane3D FitPlane(const Cuboid &aoi) const
298 {
299 CExports::CVC3DPlane plane = {0};
300 CExports::cvbres_t res = CVB_CALL_CAPI(CVC3DPointCloudCalculatePlaneFromCuboid(
301 Handle(), *reinterpret_cast<const CExports::CVC3DCuboid *>(&aoi), plane));
302 if (res < 0)
303 std::rethrow_exception(CvbException::FromCvbResult(res, "failed to calculate plane from cuboid."));
304 return Plane3D(plane.Normal.X, plane.Normal.Y, plane.Normal.Z, plane.DistanceToOrigin);
305 }
306
308
315 template <class T>
316 std::shared_ptr<T> Crop(const Cuboid &clipBox) const
317 {
318 return Internal::DoResCallShareOut<T>([&](void *&handle) {
319 return CVB_CALL_CAPI(
320 CVC3DCreateCroppedPointCloud(Handle(), *reinterpret_cast<const CExports::CVC3DCuboid *>(&clipBox), handle));
321 });
322 }
323
327
348 template <class T>
349 std::shared_ptr<T> FrustumCrop(const Cuboid &clipBox, Angle theta, Angle phi) const
350 {
351 return Internal::DoResCallShareOut<T>([&](void *&handle) {
352 return CVB_CALL_CAPI(CVC3DCreateFrustumCroppedPointCloud(
353 Handle(), *reinterpret_cast<const CExports::CVC3DCuboid *>(&clipBox), theta.Deg(), phi.Deg(), handle));
354 });
355 }
356
359
390 template <class T>
391 std::shared_ptr<T> PlaneCrop(const Plane3D &plane, const ValueRange<double> &range, CropRange cropRange) const
392 {
393 return Internal::DoResCallShareOut<T>([&](void *&handle) {
394 return CVB_CALL_CAPI(
395 CVC3DCreatePlaneCroppedPointCloud(Handle(), *reinterpret_cast<const CExports::CVC3DPlane *>(&plane),
396 *reinterpret_cast<const CExports::CVC3DRange *>(&range),
397 static_cast<CExports::CVC3DCropRange>(cropRange), handle));
398 });
399 }
400
403
435 template <class T>
436 std::shared_ptr<T> PlaneCrop(const Plane3D &plane, double threshold,
437 CropDirection cropBelowAbove = CropDirection::Below) const
438 {
439 // get correct plane
440 auto planeUsed = plane;
441 if (std::fabs(plane.Normal().Z())
442 < 1e-7) // if plane is parallel to z axis above/below is not define -> no cropping is done
444 else if (plane.Normal().Z() < 0) // make sure, that z shows up to get right definition of above and below.
445 {
446 planeUsed.SetNormal(Point3D<double>(-plane.Normal().X(), -plane.Normal().Y(), -plane.Normal().Z()));
447 planeUsed.SetDistanceToOrigin(-plane.DistanceToOrigin());
448 }
449
450 // get correct range
452 if (cropBelowAbove == CropDirection::Above)
454
455 return PlaneCrop<T>(planeUsed, range, CropRange::CropWithinRange);
456 }
457
460
467 {
468 return Internal::DoResCallShareOut<PointCloud>([&](void *&handle) {
469 return CVB_CALL_CAPI(CVC3DCreateDownsampledPointCloud(Handle(),
470 static_cast<CExports::CVC3DDownsampleMode>(mode),
471 static_cast<CExports::cvbint64_t>(value), handle));
472 });
473 }
474
476
484 {
485 return Internal::DoResCallShareOut<PointCloud>(
486 [&](void *&handle) { return CVB_CALL_CAPI(CVC3DCreateDuplicatePointCloud(Handle(), handle)); });
487 }
488
490
494 void Save(const String &fileName) const
495 {
496 Save(fileName, static_cast<PointCloudFlags>(0));
497 }
498
499 void Save(const String &fileName, PointCloudFlags flags) const
500 {
501 Internal::DoResCall([&]() {
502 return CVB_CALL_CAPI(CVC3DWriteFileTyped(Handle(), static_cast<CExports::cvbval_t>(flags), fileName.c_str()));
503 });
504 }
505
508
514 {
515 return Internal::DoResCallShareOut<PointCloud>([&](void *&handle) {
516 return CVB_CALL_CAPI(CVC3DCreateConvertedPointCloud(Handle(), static_cast<CExports::cvbval_t>(flags), handle));
517 });
518 }
519
521
527 {
528 return Internal::DoResCallShareOut<PointCloud>([&](void *&handle) {
529 return CVB_CALL_CAPI(
530 CVC3DCreateScaledPointCloud(Handle(), *reinterpret_cast<CExports::CVC3DFactors *>(&factors), handle));
531 });
532 }
533
535
542 SparsePointCloudPtr Transform(const AffineMatrix3D &transformation) const;
543
545
552 SparsePointCloudPtr Transform(const Matrix3DH &transformation) const;
553
556
561 void Transform(const AffineMatrix3D &affineTransformation, SparsePointCloud &pointCloud);
562
565
570 void Transform(const Cvb::Matrix3DH &transformation, SparsePointCloud &pointCloud);
571
573
583 double background) const
584 {
585 return Internal::DoResCallObjectOut<Image>([&](void *&handle) {
586 return CVB_CALL_CAPI(CVC3DCreateRangeMapFromPointCloud(
587 Handle(), *reinterpret_cast<CExports::CVC3DRange *>(&xRange),
588 *reinterpret_cast<CExports::CVC3DRange *>(&yRange), static_cast<CExports::cvbdim_t>(size.Width()),
589 static_cast<CExports::cvbdim_t>(size.Height()), background, handle));
590 });
591 }
592
594
598 int PlaneCount() const noexcept
599 {
600 CExports::cvbdim_t numPlanes = 0;
601 CVB_CALL_CAPI(CVCPlaneEnumGetCount(Handle(), numPlanes));
602 return static_cast<int>(numPlanes);
603 }
604
606
611 {
613 std::generate_n(std::back_inserter(planes), PlaneCount(), [this, i = 0]() mutable { return Plane(i++); });
614 return planes;
615 }
616
618
625 PlanePtr Plane(int index) const
626 {
627 if (index < 0 || index >= PlaneCount())
628 throw std::length_error("index out of range");
629
630 CExports::CVPLANE handle = nullptr;
631 CVB_CALL_CAPI_CHECKED(CVCPlaneEnumGetAt(Handle(), static_cast<CExports::cvbdim_t>(index), handle));
632 auto plane = Plane::FromHandle(HandleGuard<class Plane>(handle));
633
634 auto iter = planes_.find(plane->Handle());
635 if (iter != planes_.end())
636 {
637 if (auto _plane = iter->second.lock())
638 return _plane;
639 }
640
641 planes_[plane->Handle()] = plane;
642 return plane;
643 }
644
646
662 {
663 std::size_t bufSize{};
664 CExports::cvbres_t res =
665 CVB_CALL_CAPI(CVC3DPointCloudToMemorySize(Handle(), static_cast<CExports::cvbval_t>(flags),
666 static_cast<CExports::CVC3DPointCloudFileFormat>(format), bufSize));
667 if (res < 0)
668 std::rethrow_exception(CvbException::FromCvbResult(res, "failed to get memory size."));
669
670 return bufSize;
671 }
672
674
689 template <class Point>
691 {
692 auto flags = PointTypeToFlags<Point>();
693 return MemorySize(flags, format);
694 }
695
697
720 void ToMemory(PointCloudFlags flags, Cvb::PointCloudFileFormat format, size_t size, void *buffer) const
721 {
722 auto res = CVB_CALL_CAPI(CVC3DPointCloudToMemory(Handle(), static_cast<CExports::cvbval_t>(flags),
723 static_cast<CExports::CVC3DPointCloudFileFormat>(format), buffer,
724 size));
725 if (res < 0)
726 std::rethrow_exception(CvbException::FromCvbResult(res, "failed to save point cloud to memory."));
727 }
728
730
753 template <class Point>
754 void ToMemory(Cvb::PointCloudFileFormat format, size_t size, std::uint8_t *buffer) const
755 {
756 auto flags = PointTypeToFlags<Point>();
757 ToMemory(flags, format, size, buffer);
758 }
759
764 void *Handle() const noexcept
765 {
766 return handle_.Handle();
767 }
768
769 PointCloud(const PointCloud &other) noexcept = delete;
770 PointCloud &operator=(const PointCloud &other) noexcept = delete;
771 PointCloud(PointCloud &&other) noexcept = delete;
772 PointCloud &operator=(PointCloud &&other) noexcept = delete;
773
774 virtual ~PointCloud() = default;
775
776 protected:
777 explicit PointCloud(HandleGuard<PointCloud> &&guard) noexcept
778 : handle_(std::move(guard))
779 {
780 }
781
782 static bool IsDense(void *handle)
783 {
784 CExports::cvbdim_t width = 0;
785 CExports::cvbdim_t height = 0;
786 auto res = CVB_CALL_CAPI(CVC3DPointCloudGetLatticeSize(handle, width, height));
788 return false;
789 else if (res < 0)
790 Utilities::SystemInfo::ThrowLastError(res);
791
792 return true;
793 }
794
795 std::exception_ptr TryPointComponents(ComponentsPointers3D &components) const noexcept
796 {
797 auto res = CVB_CALL_CAPI(CVC3DPointCloudGetPointComponentsPointers(
798 Handle(), reinterpret_cast<void *&>(components.xBasePtr_), components.xInc_,
799 reinterpret_cast<void *&>(components.yBasePtr_), components.yInc_,
800 reinterpret_cast<void *&>(components.zBasePtr_), components.zInc_,
801 reinterpret_cast<void *&>(components.wBasePtr_), components.wInc_, components.numPoints_));
802 if (!CExports::CheckErrorCode(res))
804
805 CExports::cvbdatatype_t dataType = 0;
806 CVB_CALL_CAPI(CVC3DPointCloudGetPointsConfidencePointer(
807 Handle(), reinterpret_cast<void *&>(components.confidenceBasePtr_), components.confidenceInc_, dataType));
808 return {};
809 }
810
811 template <class T>
812 std::exception_ptr TryPointComponents(ComponentsPointers3D &components) const noexcept
813 {
814 auto error = TryPointComponents(components);
815 if (error)
816 return error;
817
819 return std::make_exception_ptr(std::runtime_error("data type does not match for components pointers"));
820
821#ifdef _MSC_VER
822# pragma warning(push, 1)
823# pragma warning(disable : 4127) // conditional expression is constant
824#endif
825
826 if (std::is_same<T, Point3DH<typename T::ValueType>>::value && !components.BasePtrW())
827 return std::make_exception_ptr(std::runtime_error("point cloud has no W components use Point3D"));
828
829 if (std::is_same<T, Point3D<typename T::ValueType>>::value && components.BasePtrW())
830 return std::make_exception_ptr(std::runtime_error("point cloud has W components use Point3DH"));
831
832#ifdef _MSC_VER
833# pragma warning(pop)
834#endif
835
836 return {};
837 }
838
839 private:
840 std::size_t PointsTyped(Cvb::Point3D<double> *&points) const
841 {
842 return Internal::DoResCallValueOut<std::size_t>([&](std::size_t &value) {
843 return CVB_CALL_CAPI(
844 CVC3DPointCloudGetPointDsPointer(Handle(), reinterpret_cast<CExports::CVC3DPointD *&>(points), value));
845 });
846 }
847
848 std::size_t PointsTyped(Point3D<float> *&points) const
849 {
850 return Internal::DoResCallValueOut<std::size_t>([&](std::size_t &value) {
851 return CVB_CALL_CAPI(
852 CVC3DPointCloudGetPointFsPointer(Handle(), reinterpret_cast<CExports::CVC3DPointF *&>(points), value));
853 });
854 }
855
856 std::size_t PointsHTyped(Cvb::Point3DH<double> *&pointsH)
857 {
858 return Internal::DoResCallValueOut<std::size_t>([&](std::size_t &value) {
859 return CVB_CALL_CAPI(
860 CVC3DPointCloudGetPointHDsPointer(Handle(), reinterpret_cast<CExports::CVC3DPointHD *&>(pointsH), value));
861 });
862 }
863
864 std::size_t PointsHTyped(Cvb::Point3DH<float> *&pointsH)
865 {
866 return Internal::DoResCallValueOut<std::size_t>([&](std::size_t &value) {
867 return CVB_CALL_CAPI(
868 CVC3DPointCloudGetPointHFsPointer(Handle(), reinterpret_cast<CExports::CVC3DPointHF *&>(pointsH), value));
869 });
870 }
871
872 mutable std::unordered_map<void *, std::weak_ptr<class Plane>> planes_;
873
874 HandleGuard<PointCloud> handle_;
875 };
876
877 CVB_END_INLINE_NS
878} // namespace Cvb
T back_inserter(T... args)
Affine transformation for 3D containing a transformation matrix and a translation vector.
Definition affine_matrix_3d.hpp:140
Object for convenient and type - safe handling of angles.
Definition angle.hpp:16
double Deg() const noexcept
Get the value in degrees.
Definition angle.hpp:89
Point components of the point cloud.
Definition components_pointers_3d.hpp:18
3D rectangle in the X, Y and Z domain.
Definition cuboid.hpp:19
static DataType FromNativeType() noexcept
Construct a data type descriptor from one of the native data type value equivalents.
Definition data_type.hpp:173
static DataType FromNativeDescriptor(int dataTypeDescriptor) noexcept
Construct a data type descriptor from one of the native library's descriptor values.
Definition data_type.hpp:31
Double precision row-major 4x4 matrix.
Definition matrix_3d_h.hpp:44
Double precision 3x3 matrix class.
Definition matrix_3d.hpp:54
A plane in 3D space in Hessian normal form.
Definition plane_3d.hpp:19
double DistanceToOrigin() const noexcept
Gets the distance to the origin in point units.
Definition plane_3d.hpp:78
Point3D< double > Normal() const noexcept
Gets the normal vector of the plane.
Definition plane_3d.hpp:58
static PlanePtr FromHandle(HandleGuard< Plane > &&guard)
Creates a plane from a classic API handle.
Definition decl_plane.hpp:76
void * Handle() const noexcept override
Classic API image handle.
Definition decl_plane.hpp:98
Multi-purpose 3D vector class with confidence.
Definition point_3d_c.hpp:23
Multi-purpose 3D vector class (homogeneous).
Definition point_3d_h.hpp:22
Multi-purpose 3D vector class.
Definition point_3d.hpp:22
T X() const noexcept
Get the x component of the point.
Definition point_3d.hpp:74
T Y() const noexcept
Get the y component of the point.
Definition point_3d.hpp:94
T Z() const noexcept
Get the z component of the point.
Definition point_3d.hpp:114
A point cloud object.
Definition decl_point_cloud.hpp:62
PlanePtr Plane(int index) const
Index based plane access.
Definition decl_point_cloud.hpp:625
Plane3D FitPlane(const Cuboid &aoi) const
Fits a plane in the points of the point cloud for a specified area of interest.
Definition decl_point_cloud.hpp:297
std::size_t Points(Point3D< T > *&points) const
Gets the 3D points from the given point cloud.
Definition decl_point_cloud.hpp:217
static PointCloudPtr FromHandle(HandleGuard< PointCloud > &&guard)
Creates a point cloud from a classic API handle.
Definition detail_point_cloud.hpp:15
ComponentsPointers3D PointComponents() const
Tries to get the point components from the given point cloud.
Definition decl_point_cloud.hpp:201
std::shared_ptr< T > PlaneCrop(const Plane3D &plane, const ValueRange< double > &range, CropRange cropRange) const
Creates a new point cloud where points within or outside a range parallel to given plane are cropped.
Definition decl_point_cloud.hpp:391
static PointCloudPtr FromMemory(void *buffer, size_t size, Cvb::PointCloudFileFormat format)
Creates a point cloud reading memory from buffer.
Definition decl_point_cloud.hpp:154
PointCloudPtr Convert(PointCloudFlags flags) const
Creates a new point cloud, which is a copy from this point cloud, but with possibly different data ty...
Definition decl_point_cloud.hpp:513
PointCloudPtr Duplicate() const
Creates a new point cloud which is a copy this point cloud.
Definition decl_point_cloud.hpp:483
std::shared_ptr< T > Crop(const Cuboid &clipBox) const
Creates a new point cloud which only consists of the points inside the clip box.
Definition decl_point_cloud.hpp:316
std::shared_ptr< T > FrustumCrop(const Cuboid &clipBox, Angle theta, Angle phi) const
Creates a new point cloud which only consists of the points inside the clipBox, where the orientation...
Definition decl_point_cloud.hpp:349
int PlaneCount() const noexcept
Gets the number of planes enumerated by this object.
Definition decl_point_cloud.hpp:598
void ToMemory(Cvb::PointCloudFileFormat format, size_t size, std::uint8_t *buffer) const
Saves the point cloud to the memory in the given format.
Definition decl_point_cloud.hpp:754
SparsePointCloudPtr Transform(const AffineMatrix3D &transformation) const
Creates a new point cloud with all points being transformed by the given transformation.
Definition detail_point_cloud.hpp:43
Matrix3D CalculateCovarianceMatrix() const
Calculates the covariance matrix of the point cloud.
Definition decl_point_cloud.hpp:269
class DataType DataType() const
Gets the DataType of the x,y,z(,w) components of the given PointCloud.
Definition decl_point_cloud.hpp:177
PointCloudPtr Downsample(DownSampleMode mode, int value) const
Creates a new point cloud which has several points being removed dependent on the down sample mode an...
Definition decl_point_cloud.hpp:466
std::size_t NumPoints() const
Gets the number of x,y,z(,w) points in the given point cloud.
Definition decl_point_cloud.hpp:189
Plane3D FitPlane() const
Fits a plane in the points of the point cloud without cropping it.
Definition decl_point_cloud.hpp:285
size_t MemorySize(PointCloudFlags flags, Cvb::PointCloudFileFormat format) const
Determines the amount of memory needed for ToMemory.
Definition decl_point_cloud.hpp:661
void ToMemory(PointCloudFlags flags, Cvb::PointCloudFileFormat format, size_t size, void *buffer) const
Saves the point cloud to the memory in the given format.
Definition decl_point_cloud.hpp:720
std::shared_ptr< T > PlaneCrop(const Plane3D &plane, double threshold, CropDirection cropBelowAbove=CropDirection::Below) const
Creates a new point cloud which only consists of the points below or above given plane.
Definition decl_point_cloud.hpp:436
void Save(const String &fileName) const
Saves the given point cloud to the file with the given FileName.
Definition decl_point_cloud.hpp:494
Cuboid CalculateBoundingBox() const
Calculates the minimum and maximum extent of the point cloud.
Definition decl_point_cloud.hpp:239
std::unique_ptr< Cvb::Image > RangeMap(ValueRange< double > xRange, ValueRange< double > yRange, Size2D< int > size, double background) const
Creates a new range map image via linear projection in negative z-direction.
Definition decl_point_cloud.hpp:582
static std::shared_ptr< T > FromComposite(CompositePtr object)
Creates a point cloud from a composite.
Definition detail_point_cloud.hpp:27
std::vector< PlanePtr > Planes() const
Gets all available planes enumerated by this object.
Definition decl_point_cloud.hpp:610
PointCloudLayout Layout() const
Get the layout of the available buffers/planes of the given point cloud.
Definition decl_point_cloud.hpp:165
std::size_t PointsH(Point3DH< T > *&pointsH) const
Tries to get the 3D points from the given point cloud.
Definition decl_point_cloud.hpp:229
size_t MemorySize(Cvb::PointCloudFileFormat format) const
Determines the amount of memory needed for ToMemory.
Definition decl_point_cloud.hpp:690
Point3D< double > CalculateCenterOfGravity() const
Calculates the center of gravity of the point cloud.
Definition decl_point_cloud.hpp:254
static PointCloudPtr FromMemory(void *buffer, size_t size, PointCloudFlags flags, Cvb::PointCloudFileFormat format)
Creates a point cloud reading memory from buffer.
Definition detail_point_cloud.hpp:34
void * Handle() const noexcept
Returns C-API style handle to Node Object.
Definition decl_point_cloud.hpp:764
PointCloudPtr Scale(Factors3D factors) const
Creates a new point cloud with all points being scaled by the given factors.
Definition decl_point_cloud.hpp:526
Stores a pair of numbers that represents the width and the height of a subject, typically a rectangle...
Definition size_2d.hpp:20
T Height() const noexcept
Gets the vertical component of the size.
Definition size_2d.hpp:77
T Width() const noexcept
Gets the horizontal component of the size.
Definition size_2d.hpp:57
An unorganized sparse Cartesian 3D point cloud object.
Definition decl_sparse_point_cloud.hpp:34
Container for range definitions.
Definition value_range.hpp:17
T fabs(T... args)
T generate_n(T... args)
cvbbool_t ReleaseObject(OBJ &Object)
T lowest(T... args)
T max(T... args)
T move(T... args)
const int CVB_INVALIDDIMENSION
Invalid number of dimensions.
Definition exception.hpp:73
std::exception_ptr GetLastError() noexcept
Returns a pointer that points at the exception.
Definition system_info.hpp:181
Root namespace for the Image Manager interface.
Definition c_bayer_to_rgb.h:17
PointCloudFileFormat
Supported point cloud point formats.
Definition core_3d.hpp:141
PointCloudFlags
Flags for creating point clouds.
Definition core_3d.hpp:90
@ Float
Definition core_3d.hpp:94
@ XYZW
Definition core_3d.hpp:109
@ XYZConfidence
Definition core_3d.hpp:114
@ Double
Definition core_3d.hpp:99
@ XYZ
Definition core_3d.hpp:104
std::string String
String for wide characters or unicode characters.
Definition string.hpp:49
std::shared_ptr< PointCloud > PointCloudPtr
Convenience shared pointer for PointCloud.
Definition core_3d.hpp:40
CropRange
Indicates cropping range.
Definition core_3d.hpp:288
@ CropWithinRange
Crops points within given range.
Definition core_3d.hpp:291
PointCloudLayout
Supported point cloud point layouts.
Definition core_3d.hpp:195
std::shared_ptr< SparsePointCloud > SparsePointCloudPtr
Convenience shared pointer for SparsePointCloud.
Definition core_3d.hpp:48
CropDirection
Indicates cropping direction.
Definition core_3d.hpp:301
@ Above
Crop above given plane.
Definition core_3d.hpp:309
@ Below
Crop below given plane.
Definition core_3d.hpp:305
DownSampleMode
Specifies how to remove points from a point cloud.
Definition core_3d.hpp:234
std::shared_ptr< Composite > CompositePtr
Convenience shared pointer for Composite.
Definition global.hpp:102
std::shared_ptr< Plane > PlanePtr
Convenience shared pointer for Plane.
Definition global.hpp:78
T dynamic_pointer_cast(T... args)
T rethrow_exception(T... args)
Factor components to be applied in the 3D domain.
Definition core_3d.hpp:16