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> Create(const String & fileName)
  {
    return std::unique_ptr<Classifier>(new Classifier(fileName));
  }


  explicit Classifier(const String & fileName)
    : Classifier(std::move(*Load(fileName)))
  {
    fileName_ = fileName;
    Init();
  }

  virtual ~Classifier() = default;


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


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


  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));
  }


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


  String FileName() const noexcept
  {
    return fileName_;
  }


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


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


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


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


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


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


  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);
  }


  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();
  }


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


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


  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, 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);
  }


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


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


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


  int CoarseScale() const noexcept
  {
    return coarseScale_;
  }


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


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


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


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


  double ScaleStep()
  {
    return CExports::GetSF2RSteps(Handle());
  }


private:

  Classifier(HandleGuard<Classifier>&& guard) noexcept
    : handle_(std::move(guard))
  {
  }

  Classifier(Classifier && other) noexcept
    : handle_(std::move(other.handle_))
  {
  }

  Classifier & operator=(Classifier && other) = default;

  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;
    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;
    p.Precision = (int)precision;
    p.LocXY = coarseLocality;
    p.LocA = 0x7FFFFFFF;
    p.LocR = 0x7FFFFFFF;
    p.RelativeThreshold = (int)(relativeThreshold * 100 + 0.5);
    p.MinimalThreshold = minimumThreshold;
    p.MaxNumSolutions = SearchAllResultCountMax;
    return p;
  }

  static CExports::TSymmetryParams GetSymmetryParameters(ValueRange<Angle> rotationRange, ValueRange<double> scaleRange)
  {
    CExports::TSymmetryParams p;
    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_;
  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_;

};

}

using ShapeFinder2::Classifier;

CVB_END_INLINE_NS

}