decl_dense_point_cloud.hpp

#pragma once
 
#include "decl_point_cloud.hpp"
 
#include "../image_plane.hpp"
#include "../dense_components_pointers_3d.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS

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


    static DensePointCloudPtr FromComposite(CompositePtr object)
    {
      return PointCloud::FromComposite<DensePointCloud>(object);
    }
    static DensePointCloudPtr FromComposite(CompositePtr object) {…}


    SparsePointCloudPtr ToSparsePointCloud() const;


    Cvb::Size2D<int> LatticeSize() const
    {
      CExports::cvbdim_t width  = 0;
      CExports::cvbdim_t height = 0;
      Internal::DoResCall([&]() { return CVB_CALL_CAPI(CVC3DPointCloudGetLatticeSize(Handle(), width, height)); });
      return Size2D<int>(static_cast<int>(width), static_cast<int>(height));
    }
    Cvb::Size2D<int> LatticeSize() const {…}


    DensePointCloudPtr Shrink() const
    {
      return Internal::DoResCallShareOut<DensePointCloud>(
          [&](void *&handle) { return CVB_CALL_CAPI(CVC3DCreateShrinkedDensePointCloud(Handle(), handle)); });
    }
    DensePointCloudPtr Shrink() const {…}


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


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


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


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


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


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