classifier.hpp

#pragma once
 
#include <memory>
 
#include "../global.hpp"
#include "../string.hpp"
#include "../rect.hpp"
#include "../angle.hpp"
#include "../value_range.hpp"
#include "../_detail/detail_pixel_list.hpp"
#include "../image.hpp"
#include "../exception.hpp"
 
#include "search_result.hpp"
#include "shapefinder2.hpp"
 
#include "../_cexports/c_sf_private.h"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  template <>
  inline HandleGuard<ShapeFinder2::Classifier>::HandleGuard(void *handle) noexcept
      : HandleGuard<ShapeFinder2::Classifier>(handle, [](void *handle) { CVB_CALL_CAPI(ReleaseObject(handle)); })
  {
  }
 
  namespace ShapeFinder2
  {


    class Classifier final
    {
    public:

      static std::unique_ptr<Classifier> FromHandle(HandleGuard<Classifier> &&guard)
      {
        if (!guard.Handle())
          throw std::runtime_error("handle must not be null");
 
        auto classifier = std::unique_ptr<Classifier>(new Classifier(std::move(guard)));
        return classifier;
      }
      static std::unique_ptr<Classifier> FromHandle(HandleGuard<Classifier> &&guard) {…}


      static std::unique_ptr<Classifier> Create(const String &fileName)
      {
        return std::make_unique<Classifier>(fileName);
      }
      static std::unique_ptr<Classifier> Create(const String &fileName) {…}


      explicit Classifier(const String &fileName)
          : Classifier(std::move(*Load(fileName)))
      {
        fileName_ = fileName;  // NOLINT(cppcoreguidelines-prefer-member-initializer)
        Init();
      }
      explicit Classifier(const String &fileName) {…}
 
      Classifier(const Classifier &other) noexcept   = delete;
      Classifier &operator=(const Classifier &other) = delete;
      Classifier(Classifier &&other) noexcept        = default;
      Classifier &operator=(Classifier &&other)      = default;
      ~Classifier()                                  = default;


      void *Handle() const noexcept
      {
        return handle_.Handle();
      }
      void *Handle() const noexcept {…}


      void Save(const String &fileName) const
      {
        if (!CVB_CALL_CAPI(StoreSFTyped(Handle(), fileName.c_str())))
          Utilities::SystemInfo::ThrowLastError();
      }
      void Save(const String &fileName) const {…}


      std::unique_ptr<Image> Visualization(int layer = -1) const
      {
        if (layer < -1 || layer >= NumLayers())
          throw std::out_of_range("layer value must be in [-1.0, <NumLayers]");
 
        HandleGuard<Image> guard(CExports::GetSFImage(static_cast<CExports::cvbdim_t>(layer), Handle()));
        return Image::FromHandle<Image>(std::move(guard));
      }
      std::unique_ptr<Image> Visualization(int layer = -1) const {…}


      int NumLayers() const noexcept
      {
        return CExports::GetSFClassNumber(Handle());
      }
      int NumLayers() const noexcept {…}


      String FileName() const
      {
        return fileName_;
      }
      String FileName() const {…}


      void SetComment(const String &comment) noexcept
      {
        CVB_CALL_CAPI(SetSFCommentTyped(Handle(), comment.c_str()));
      }
      void SetComment(const String &comment) noexcept {…}


      String Comment() const noexcept
      {
        Char *strComment = nullptr;
        CVB_CALL_CAPI(GetSFCommentTyped(Handle(), strComment));
        return ((strComment != nullptr) ? String(strComment) : String());
      }
      String Comment() const noexcept {…}


      Cvb::ShapeFinder2::GradientType GradientType() const noexcept
      {
        int val = CExports::GetSFGradienttype(Handle()) & 0xFF;
        return static_cast<ShapeFinder2::GradientType>(val);
      }
      Cvb::ShapeFinder2::GradientType GradientType() const noexcept {…}


      Rect<int> FeatureWindow() const noexcept
      {
        return featureWindow_;
      }
      Rect<int> FeatureWindow() const noexcept {…}


      int ContrastThreshold() const noexcept
      {
        return CExports::GetSFThreshold(Handle());
      }
      int ContrastThreshold() const noexcept {…}


      void SetContrastThreshold(int threshold)
      {
        if (!CExports::SetSFThreshold(Handle(), threshold))
          Utilities::SystemInfo::ThrowLastError();
      }
      void SetContrastThreshold(int threshold) {…}


      Angle AngularTolerance() const noexcept
      {
        auto byteValue = CExports::GetSFAngularTolerance(Handle());
        auto rad       = byteValue < 128 ? static_cast<double>(byteValue) * CVB_M_PI / 127.0
                                         : (static_cast<double>(byteValue) - 255.0) * CVB_M_PI / 127.0;
        return Cvb::Angle::FromRadians(rad);
      }
      Angle AngularTolerance() const noexcept {…}


      void SetAngularTolerance(Angle angularTolerance)
      {
        angularTolerance.SetIsTrimmed(true);  // limit to +/- M_PI
        auto rad = angularTolerance.Rad();
        auto byteValue =
            static_cast<std::uint8_t>(std::round(rad > 0 ? rad * 127.0 / CVB_M_PI : 255.0 - (rad * 127.0 / CVB_M_PI)));
 
        if (!CExports::SetSFAngularTolerance(Handle(), byteValue))
          Utilities::SystemInfo::ThrowLastError();
      }
      void SetAngularTolerance(Angle angularTolerance) {…}


      int FeatureCount() const noexcept
      {
        return CExports::GetSFFeatureNumber(Handle());
      }
      int FeatureCount() const noexcept {…}


      bool UseCuda(CudaStatus status) const noexcept
      {
        return CExports::SF2UseCuda(Handle(), static_cast<CExports::SF2CudaStatus>(status));
      }
      bool UseCuda(CudaStatus status) const noexcept {…}


      std::vector<SearchResult> SearchAll(const ImagePlane &plane, Rect<int> aoi, PrecisionMode precision,
                                          double relativeThreshold, int minimumThreshold, int coarseLocality,
                                          ValueRange<Angle> rotationRange, ValueRange<double> scaleRange)
      {
        CExports::TSearchAllParams searchParams =
            GetSearchAllParameters(precision, relativeThreshold, minimumThreshold, coarseLocality);
        if (!CExports::SetSF2SearchAllPars(Handle(), searchParams))
          Utilities::SystemInfo::ThrowLastError();
        CExports::TSymmetryParams symmetryLimits = GetSymmetryParameters(rotationRange, scaleRange);
 
        CExports::PIXELLIST lst = nullptr;
        if (!CExports::SF2SearchEx(Handle(), plane.Parent().Handle(), plane.Plane(), aoi.Left(), aoi.Top(), aoi.Right(),
                                   aoi.Bottom(), symmetryLimits, lst))
          Utilities::SystemInfo::ThrowLastError();
 
        return ResultListFromPixelList(precision, lst);
      }
      std::vector<SearchResult> SearchAll(const ImagePlane &plane, Rect<int> aoi, PrecisionMode precision, {…}


      std::vector<SearchResult> SearchAll(const ImagePlane &plane, Rect<int> aoi, PrecisionMode precision,
                                          double relativeThreshold, int minimumThreshold, int coarseLocality)
      {
        CExports::TSearchAllParams searchParams =
            GetSearchAllParameters(precision, relativeThreshold, minimumThreshold, coarseLocality);
        if (!CExports::SetSF2SearchAllPars(Handle(), searchParams))
          Utilities::SystemInfo::ThrowLastError();
 
        CExports::PIXELLIST lst = nullptr;
        if (!CExports::SF2Search(Handle(), plane.Parent().Handle(), plane.Plane(), aoi.Left(), aoi.Top(), aoi.Right(),
                                 aoi.Bottom(), lst))
          Utilities::SystemInfo::ThrowLastError();
 
        return ResultListFromPixelList(precision, lst);
      }
      std::vector<SearchResult> SearchAll(const ImagePlane &plane, Rect<int> aoi, PrecisionMode precision, {…}


      Rect<int> TrainingWindow() const noexcept
      {
        return trainingWindow_;
      }
      Rect<int> TrainingWindow() const noexcept {…}


      std::vector<Point2D<double>> FineFeatures() const noexcept
      {
        return fineFeatures_->ToPoints();
      }
      std::vector<Point2D<double>> FineFeatures() const noexcept {…}


      std::vector<Point2D<double>> CoarseFeatures() const noexcept
      {
        return coarseFeatures_->ToPoints();
      }
      std::vector<Point2D<double>> CoarseFeatures() const noexcept {…}


      int CoarseScale() const noexcept
      {
        return coarseScale_;
      }
      int CoarseScale() const noexcept {…}


      ValueRange<Angle> Rotation()
      {
        return rotation_;
      }
      ValueRange<Angle> Rotation() {…}


      ValueRange<double> Scale()
      {
        return scale_;
      }
      ValueRange<double> Scale() {…}


      Cvb::ShapeFinder2::ContrastMode ContrastMode()
      {
        return contrastMode_;
      }
      Cvb::ShapeFinder2::ContrastMode ContrastMode() {…}


      double RotationStep()
      {
        return CExports::GetSF2ASteps(Handle());
      }
      double RotationStep() {…}


      double ScaleStep()
      {
        return CExports::GetSF2RSteps(Handle());
      }
      double ScaleStep() {…}
 
    private:
      explicit Classifier(HandleGuard<Classifier> &&guard) noexcept
          : handle_(std::move(guard))
      {
      }
 
      static ValueRange<Angle> RotationRangeDefault() noexcept
      {
        return ValueRange<Angle>(Angle::FromDegrees(-0.0), Angle::FromDegrees(0.0));
      }
 
      static ValueRange<double> ScaleRangeDefault() noexcept
      {
        return ValueRange<double>(1.0, 1.0);
      }
 
      inline void Init()
      {
        // feature window
        CExports::cvbdim_t left   = 0;
        CExports::cvbdim_t top    = 0;
        CExports::cvbdim_t right  = 0;
        CExports::cvbdim_t bottom = 0;
        CVB_CALL_CAPI_CHECKED(GetSFFeatureWindow(Handle(), left, top, right, bottom));
        featureWindow_ = Cvb::Rect<int>(left, top, right, bottom);
 
        // classifier extent
        left   = 0;
        top    = 0;
        right  = 0;
        bottom = 0;
        CVB_CALL_CAPI_CHECKED(GetSF2TrainingWindow(Handle(), left, top, right, bottom));
        trainingWindow_ = Cvb::Rect<int>(left, top, right, bottom);
 
        // classifier features
        CExports::PIXELLIST fineFeatures   = nullptr;
        CExports::PIXELLIST coarseFeatures = nullptr;
        CExports::cvbval_t coarseScale     = coarseScale_;
        CVB_CALL_CAPI_CHECKED(GetSF2Features(Handle(), fineFeatures, coarseFeatures, coarseScale));
        fineFeatures_   = Internal::PixelList::FromHandle(HandleGuard<Internal::PixelList>(fineFeatures));
        coarseFeatures_ = Internal::PixelList::FromHandle(HandleGuard<Internal::PixelList>(coarseFeatures));
 
        // other classifier properties
        CExports::TSymmetryParams tmp = {0};
        CVB_CALL_CAPI_CHECKED(GetSF2Symmetries(Handle(), tmp));
        rotation_     = Cvb::ValueRange<Angle>(Cvb::Angle::FromDegrees(tmp.A0), Cvb::Angle::FromDegrees(tmp.A1));
        scale_        = Cvb::ValueRange<double>(tmp.R0, tmp.R1);
        contrastMode_ = (Cvb::ShapeFinder2::ContrastMode)tmp.ContrastMode;
      }
 
      static std::vector<Cvb::ShapeFinder2::SearchResult> ResultListFromPixelList(PrecisionMode precision,
                                                                                  CExports::PIXELLIST pixelList)
      {
        auto pl     = Internal::PixelList::FromHandle(HandleGuard<Internal::PixelList>(pixelList));
        int plCount = pl->Count();
        std::vector<Cvb::ShapeFinder2::SearchResult> res(static_cast<std::size_t>(plCount));
        for (int i = 0; i < plCount; i++)
        {
          res[i] = Cvb::ShapeFinder2::SearchResult(precision, pl->ToValues(i));
        }
        return res;
      }
 
      static CExports::TSearchAllParams GetSearchAllParameters(PrecisionMode precision, double relativeThreshold,
                                                               int minimumThreshold, int coarseLocality)
      {
        CExports::TSearchAllParams p = {0};
        p.Precision                  = (int)precision;
        p.LocXY                      = coarseLocality;
        p.LocA                       = 0x7FFFFFFF;
        p.LocR                       = 0x7FFFFFFF;
        p.RelativeThreshold = static_cast<int>(relativeThreshold * 100 + 0.5);  // NOLINT(bugprone-incorrect-roundings)
        p.MinimalThreshold  = minimumThreshold;
        p.MaxNumSolutions   = SearchAllResultCountMax;
        return p;
      }
 
      static CExports::TSymmetryParams GetSymmetryParameters(ValueRange<Angle> rotationRange,
                                                             ValueRange<double> scaleRange)
      {
        CExports::TSymmetryParams p = {0};
        p.ContrastMode              = (int)Cvb::ShapeFinder2::ContrastMode::Normal;
        p.A0                        = rotationRange.Min().Deg();
        p.A1                        = rotationRange.Max().Deg();
        p.R0                        = scaleRange.Min();
        p.R1                        = scaleRange.Max();
        return p;
      }
 
      static inline std::unique_ptr<Classifier> Load(const String &fileName)
      {
        return Internal::DoBoolCallObjectOut<Classifier>(
            [&](void *&handle) { return CVB_CALL_CAPI(LoadSFTyped(handle, fileName.c_str())); });
      }
 
    private:
      static const int SearchAllResultCountMax = 10000;
 
      HandleGuard<Classifier> handle_;
 
      String fileName_;
 
      int coarseScale_ = 0;
      Cvb::Rect<int> featureWindow_;
      Cvb::Rect<int> trainingWindow_;
      std::unique_ptr<Internal::PixelList> fineFeatures_;
      std::unique_ptr<Internal::PixelList> coarseFeatures_;
      Cvb::ValueRange<Cvb::Angle> rotation_;
      Cvb::ValueRange<double> scale_;
      Cvb::ShapeFinder2::ContrastMode contrastMode_ = Cvb::ShapeFinder2::ContrastMode::Normal;
    };
    class Classifier final {…};
 
  }  // namespace ShapeFinder2
  namespace ShapeFinder2 {…}
 
  using ShapeFinder2::Classifier;
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb