decl_metric_segmentor_range_map.hpp

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

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


        double RangeMapIgnoreValue() const noexcept
        {
          return Internal::DoResCallValueOut<double>([&](double &rangeMapIgnoreValue) {
            return CVB_CALL_CAPI(CVMAQS12SegmentorRangeMapGetIgnoreValue(Handle(), rangeMapIgnoreValue));
          });
        }
        double RangeMapIgnoreValue() const noexcept {…}


        void SetRangeMapIgnoreValue(double rangeMapIgnoreValue) const noexcept
        {
          CVB_CALL_CAPI(CVMAQS12SegmentorRangeMapSetIgnoreValue(Handle(), rangeMapIgnoreValue));
        }
        void SetRangeMapIgnoreValue(double rangeMapIgnoreValue) const noexcept {…}


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


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


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


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