decl_metric_segmentor_dense_point_cloud.hpp

#pragma once
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  namespace Foundation
  {
    namespace Metric
    {
      class DensePointCloudSegmentor;
    }
  }  // namespace Foundation
 
  template <>
  inline HandleGuard<Foundation::Metric::DensePointCloudSegmentor>::HandleGuard(void *handle) noexcept
      : HandleGuard<Foundation::Metric::DensePointCloudSegmentor>(
            handle, [](void *handle) { CVB_CALL_CAPI(ReleaseObject(handle)); })
  {
  }
 
  namespace Foundation
  {
    namespace Metric
    {
      enum class CalibrationPiece;
      enum class SegmentationMethod;

      class DensePointCloudSegmentor
      {
      protected:
        struct PrivateTag
        {
        };
 
        explicit DensePointCloudSegmentor(HandleGuard<DensePointCloudSegmentor> &&guard) noexcept
            : handle_(std::move(guard))
        {
        }
 
      public:
        using GuardType = HandleGuard<DensePointCloudSegmentor>;
 
        DensePointCloudSegmentor(const DensePointCloudSegmentor &other)            = delete;
        DensePointCloudSegmentor &operator=(const DensePointCloudSegmentor &other) = delete;
        DensePointCloudSegmentor(DensePointCloudSegmentor &&other)                 = delete;
        DensePointCloudSegmentor &operator=(DensePointCloudSegmentor &&other)      = delete;
        virtual ~DensePointCloudSegmentor()                                        = default;


        int WindowSize() const
        {
          return static_cast<int>(Internal::DoResCallValueOut<CExports::cvbdim_t>([&](CExports::cvbdim_t &value) {
            return CVB_CALL_CAPI(CVMAQS12SegmentorDensePointCloudGetWindowSize(Handle(), value));
          }));
        }
        int WindowSize() const {…}


        void SetWindowSize(int windowSize) const
        {
          CVB_CALL_CAPI_CHECKED(
              CVMAQS12SegmentorDensePointCloudSetWindowSize(Handle(), static_cast<CExports::cvbdim_t>(windowSize)));
        }
        void SetWindowSize(int windowSize) const {…}
 
        virtual std::unique_ptr<Image> FaceSegmentationFromPiece(const DensePointCloud &cloud)                = 0;
        virtual std::unique_ptr<Image> FaceSegmentationFromPiece(const DensePointCloud &cloud, Rect<int> aoi) = 0;
 
        virtual std::vector<Point3D<double>> ExtractProjectedPointsFromPiece(const DensePointCloud &cloud) = 0;
        virtual std::vector<Point3D<double>> ExtractProjectedPointsFromPiece(const DensePointCloud &cloud,
                                                                             Rect<int> aoi)                = 0;


        static std::shared_ptr<DensePointCloudSegmentor> FromHandle(HandleGuard<DensePointCloudSegmentor> &&guard);
 
        template <class T>
        static std::shared_ptr<DensePointCloudSegmentor> FromHandle(HandleGuard<DensePointCloudSegmentor> &&guard)
        {
          return FromHandle(std::move(guard));
        }


        void *Handle() const noexcept
        {
          return handle_.Handle();
        }
        void *Handle() const noexcept {…}
 
      private:
        HandleGuard<DensePointCloudSegmentor> handle_;
      };
      class DensePointCloudSegmentor {…};
 
    }  // namespace Metric
  }  // namespace Foundation
 
  CVB_END_INLINE_NS
}  // namespace Cvb