classifier_factory.hpp

#pragma once

#include "../angle.hpp"
#include "../value_range.hpp"
#include "../point_2d.hpp"
#include "../_detail/detail_pixel_list.hpp"
#include "../image.hpp"

#include "shapefinder2.hpp"
#include "classifier.hpp"


namespace Cvb
{
CVB_BEGIN_INLINE_NS



namespace ShapeFinder2
{



class ClassifierFactory final
{
public:


  ClassifierFactory() noexcept = default;
  virtual ~ClassifierFactory() = default;



  std::vector<int> GradientHistogram(const ImagePlane & plane, Rect<int> aoi, ShapeFinder2::GradientType gradient) const
  {
    if ((plane.DataType().BitsPerPixel() != 8) || (!plane.DataType().IsUnsignedInteger()))
      std::rethrow_exception(CvbException::FromCvbResult(ErrorCodes::CVB_INVALIDDATATYPE, "invalid plane datatype"));

    CExports::cvbval_t retval[256];
    CExports::SFGradHistogram(plane.Parent().Handle(), plane.Plane(), aoi.Left(), aoi.Top(), aoi.Right(), aoi.Bottom(), static_cast<CExports::TSFGradientType>(gradient), &retval[0]);
    return std::vector<int>(retval, retval + sizeof retval / sizeof retval[0]);
  }


  ValueRange<Angle> RotationRangeMax() const noexcept
  {
    return ValueRange<Angle>(Angle::FromDegrees(-180.0), Angle::FromDegrees(180.0));
  }


  ValueRange<Angle> RotationRange() const noexcept
  {
    return rotationRange_;
  }


  void SetRotationRange(ValueRange<Angle> value)
  {
    if (value.Min() < RotationRangeMax().Min() || value.Max() > RotationRangeMax().Max())
      throw std::out_of_range("rotation range must be in [-180.0, 180.0]");
    rotationRange_ = value;
  }


  ValueRange<double> ScaleRangeMax() const noexcept
  {
    return ValueRange<double>(0.66, 1.50);
  }


  ValueRange<double> ScaleRange() const noexcept
  {
    return scaleRange_;
  }


  void SetScaleRange(ValueRange<double> value)
  {
    if (value.Min() < ScaleRangeMax().Min() || value.Max() > ScaleRangeMax().Max())
      throw std::out_of_range("scale range must be in [0.66, 1.50]");
    scaleRange_ = value;
  }


  int FeatureCount() const noexcept // Function exists twice
  {
    return featureCount_;
  }


  void SetFeatureCount(int value)
  {
    if (value < FeatureCountMin)
      throw std::out_of_range("feature count must be >= " + FeatureCountMin);
    featureCount_ = value;
  }


  int ContrastThreshold() const noexcept
  {
    return contrastThreshold_;
  }


  void SetContrastThreshold(int value)
  {
    if (value < ContrastThresholdMin)
      throw std::out_of_range("contrast threshold must be >= " + FeatureCountMin);
    contrastThreshold_ = value;
  }


  int MaxCoarseLayerScale() const noexcept
  {
    return maxCoarseScale_;
  }


  void SetMaxCoarseLayerScale(int value)
  {
    if (value < -1)
      throw std::out_of_range("maximum coarse layer scale must be >= -1");
    maxCoarseScale_ = value;
  }


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


  void SetContrastMode(Cvb::ShapeFinder2::ContrastMode mode) noexcept
  {
    contrastMode_ = mode;
  }


  int ProfileSize() const noexcept
  {
    return profileSize_;
  }


  void SetProfileSize(int value)
  {
    if (value < 1)
      throw std::out_of_range("profile size must be >= 1");
    if ((value % 2) == 0)
      throw std::invalid_argument("profile size must be %2 != 0");
    profileSize_ = value;
  }


  int ProfileDelta() const noexcept
  {
    return profileDelta_;
  }


  void SetProfileDelta(int value)
  {
    if (value < 1)
      throw std::out_of_range("profile delta must be >= 1");
      profileDelta_ = value;
  }


  std::unique_ptr<Classifier> Learn(const ImagePlane & plane, Point2D<double> position, Rect<int> teachWindow, const std::vector<Point2D<int>>& dontCarePoints) const
  {
    return Learn(plane, position, Angle(), 0.0, teachWindow, dontCarePoints);
  }


  std::unique_ptr<Classifier> Learn(const ImagePlane & plane, Point2D<double> position, Rect<int> teachWindow) const
  {
    return Learn(plane, position, Angle(), 0.0, teachWindow);
  }


  std::unique_ptr<Classifier> Learn(const ImagePlane & plane, Point2D<double> position, Angle angleOffset, double scaleFactor, Rect<int> teachWindow) const
  {
    CExports::PIXELLIST dontCarePointsNative = nullptr;

    if (plane.Parent().Handle() != nullptr && plane.DataType().HasOverlayBit())
    {
      CExports::CreatePixelListFromOverlay(plane.Parent().Handle(), plane.Plane(), 0, 0, plane.Parent().Width() - 1, plane.Parent().Height() - 1, dontCarePointsNative);
      if (dontCarePointsNative)
      {
        CExports::TMatrix matrix;
        matrix.A11 = Matrix2D::Identity().A11();
        matrix.A12 = Matrix2D::Identity().A12();
        matrix.A21 = Matrix2D::Identity().A21();
        matrix.A22 = Matrix2D::Identity().A22();
        CExports::TransformPixelListMatrix(dontCarePointsNative, matrix, -position.X(), -position.Y());
      }
    }

    return Learn(plane, position, angleOffset, scaleFactor, teachWindow, dontCarePointsNative);
  }


  std::unique_ptr<Classifier> Learn(const ImagePlane & plane, Point2D<double> position, Angle angleOffset, double scaleFactor, Rect<int> teachWindow, const std::vector<Point2D<int>>& dontCarePoints) const
  {
    CExports::PIXELLIST dontCareList = static_cast<CExports::PIXELLIST>(Point2DToPixelList(dontCarePoints));
    return Learn(plane, position, angleOffset, scaleFactor, teachWindow, dontCareList);
  }

private:

  ClassifierFactory(ClassifierFactory & /*other*/) noexcept
  {
  }

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

  static ValueRange<Angle> RotationRangeDefault() noexcept
  {
    return ValueRange<Angle>(Angle::FromDegrees(-180.0), Angle::FromDegrees(180.0));
  }

  static ValueRange<double> ScaleRangeDefault() noexcept
  {
    return ValueRange<double>(1.0, 1.0);
  }

  std::unique_ptr<Classifier> Learn(const ImagePlane & plane, Point2D<double> position, Angle angleOffset, double scaleFactor, Rect<int> teachWindow, CExports::PIXELLIST dontCareList ) const
  {
    CExports::TSymmetryParams symmetries;
    symmetries.ContrastMode = (int)contrastMode_;
    symmetries.A0 = RotationRange().Min().Deg();
    symmetries.A1 = RotationRange().Max().Deg();
    symmetries.R0 = ScaleRange().Min();
    symmetries.R1 = ScaleRange().Max();

    int maxCoarseScale = MaxCoarseLayerScale();
    if (maxCoarseScale < 0)
      maxCoarseScale = 16;

    CExports::SF sf = nullptr;
    if (ProfileSize() > 1)
    {
      sf = CExports::CreateSF2ExEx(plane.Parent().Handle(), plane.Plane(), (CExports::cvbdim_t)position.X(), (CExports::cvbdim_t)position.Y(), angleOffset.Rad(), scaleFactor
        , teachWindow.Left(), teachWindow.Top(), teachWindow.Right(), teachWindow.Bottom(), ContrastThreshold(), FeatureCount()
        , maxCoarseScale, symmetries, dontCareList, true, ProfileSize(), ProfileDelta());
    }
    else
    {
      sf = CExports::CreateSF2Ex(plane.Parent().Handle(), plane.Plane(), (CExports::cvbdim_t)position.X(), (CExports::cvbdim_t)position.Y(), angleOffset.Rad(), scaleFactor
        , teachWindow.Left(), teachWindow.Top(), teachWindow.Right(), teachWindow.Bottom(), ContrastThreshold(), FeatureCount()
        , maxCoarseScale, symmetries, dontCareList);
    }

    if (sf == nullptr)
      Utilities::SystemInfo::ThrowLastError();
    else
      return Classifier::FromHandle(HandleGuard<Classifier>(sf));

    return nullptr;
  }


  static Internal::PixelList* Point2DToPixelList(const std::vector<Point2D<int>>& points)
  {
    std::vector<Point2D<double>> tmp;
    for (std::size_t i = 0; i < points.size(); i++)
    {
      tmp.push_back(static_cast<Point2D<double>>(points.at(i)));
    }
    auto pixelList = Internal::PixelList::FromPoints (tmp);
    return pixelList.get();
  }


public:
  static const int FeatureCountMin = 10;
  static const int ContrastThresholdMin = 1;

private:

  static const int FeatureCountDefault = 100;
  static const int ContrastThresholdDefault = 25;
  static const int MaxCoarseLayerDefault = 8;

  int featureCount_ = FeatureCountDefault;
  int contrastThreshold_ = ContrastThresholdDefault;
  int maxCoarseScale_ = MaxCoarseLayerDefault;
  int profileSize_ = 1;
  int profileDelta_ = 1;

  Cvb::ValueRange<Cvb::Angle> rotationRange_ = RotationRangeDefault();
  Cvb::ValueRange<double> scaleRange_ = ScaleRangeDefault();
  Cvb::ShapeFinder2::ContrastMode contrastMode_ = Cvb::ShapeFinder2::ContrastMode::Normal;

};

}

using ShapeFinder2::ClassifierFactory;

CVB_END_INLINE_NS

}