decl_sparse_point_cloud.hpp

#pragma once
 
#include <type_traits>
#include <stdexcept>
 
#include "decl_point_cloud.hpp"
 
#include "../sparse_components_pointers_3d.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS

  class SparsePointCloud : public PointCloud
  {
    friend class PointCloud;
 
  public:
    static SparsePointCloudPtr FromHandle(HandleGuard<PointCloud> &&guard)
    {
      if (IsDense(guard.Handle()))
        throw std::runtime_error("handle is not a sparse point cloud");
      return std::make_shared<SparsePointCloud>(std::move(guard), PrivateTag{});
    }
 
    template <class T>
    static SparsePointCloudPtr FromHandle(HandleGuard<PointCloud> &&guard)
    {
      return FromHandle(std::move(guard));
    }
 
    SparsePointCloud(HandleGuard<PointCloud> &&guard, PrivateTag) noexcept
        : PointCloud(std::move(guard))
    {
    }


    static SparsePointCloudPtr FromDensePointCloud(const DensePointCloud &densePointCloud);


    static SparsePointCloudPtr FromComposite(CompositePtr object)
    {
      return PointCloud::FromComposite<SparsePointCloud>(object);
    }
    static SparsePointCloudPtr FromComposite(CompositePtr object) {…}


    DensePointCloudPtr ToDensePointCloud(size_t &numDroppedPoints,
                                         ConversionMode conversionMode = ConversionMode::Automatic) const
    {
      (void)conversionMode;  // just to suppress warning 4100, unreferenced formal parameter
 
      return Internal::DoResCallShareOut<DensePointCloud>([&](void *&handle) {
        return CVB_CALL_CAPI(CVC3DConvertSparseToDensePointCloudAutomatic(Handle(), handle, numDroppedPoints);)
      });
    }
    DensePointCloudPtr ToDensePointCloud(size_t &numDroppedPoints, {…}


    DensePointCloudPtr ToDensePointCloud(ConversionMode conversionMode = ConversionMode::Automatic) const
    {
      size_t numDroppedPoints = 0;
      return ToDensePointCloud(numDroppedPoints, conversionMode);
    }
    DensePointCloudPtr ToDensePointCloud(ConversionMode conversionMode = ConversionMode::Automatic) const {…}

    SparsePointCloudPtr Crop(const Cuboid &clipBox) const
    {
      return Internal::DoResCallShareOut<SparsePointCloud>([&](void *&handle) {
        return CVB_CALL_CAPI(
            CVC3DCreateCroppedPointCloud(Handle(), *reinterpret_cast<const CExports::CVC3DCuboid *>(&clipBox), handle));
      });
    }
    SparsePointCloudPtr Crop(const Cuboid &clipBox) const {…}

    SparsePointCloudPtr FrustumCrop(const Cuboid &clipBox, Angle theta, Angle phi) const
    {
      return Internal::DoResCallShareOut<SparsePointCloud>([&](void *&handle) {
        return CVB_CALL_CAPI(CVC3DCreateFrustumCroppedPointCloud(
            Handle(), *reinterpret_cast<const CExports::CVC3DCuboid *>(&clipBox), theta.Deg(), phi.Deg(), handle));
      });
    }
    SparsePointCloudPtr FrustumCrop(const Cuboid &clipBox, Angle theta, Angle phi) const {…}


    SparsePointCloudPtr PlaneCrop(const Plane3D &plane, const ValueRange<double> &range, CropRange cropRange) const
    {
      return PointCloud::PlaneCrop<SparsePointCloud>(plane, range, cropRange);
    }
    SparsePointCloudPtr PlaneCrop(const Plane3D &plane, const ValueRange<double> &range, CropRange cropRange) const {…}


    SparsePointCloudPtr PlaneCrop(const Plane3D &plane, double threshold,
                                  CropDirection cropBelowAbove = CropDirection::Below) const
    {
      return PointCloud::PlaneCrop<SparsePointCloud>(plane, threshold, cropBelowAbove);
    }
    SparsePointCloudPtr PlaneCrop(const Plane3D &plane, double threshold, {…}


    template <class T>
    SparseComponentsPointers3D<T> PointComponents() const
    {
      ComponentsPointers3D rawComponents;
      auto error = PointCloud::TryPointComponents<T>(rawComponents);
      if (error)
        std::rethrow_exception(error);
      return SparseComponentsPointers3D<T>(rawComponents);
    }
    SparseComponentsPointers3D<T> PointComponents() const {…}


    template <class T>
    bool TryPointComponents(SparseComponentsPointers3D<T> &components) const noexcept
    {
      ComponentsPointers3D rawComponents;
      auto error = PointCloud::TryPointComponents<T>(rawComponents);
      if (error)
        return false;
      components = SparseComponentsPointers3D<T>(rawComponents);
      return true;
    }
    bool TryPointComponents(SparseComponentsPointers3D<T> &components) const noexcept {…}
  };
  class SparsePointCloud : public PointCloud {…};
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb