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;
 
 
 
 
  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"));
 
    std::array<CExports::cvbval_t, 256> retval = {}; 
    CExports::SFGradHistogram(plane.Parent().Handle(), plane.Plane(), aoi.Left(), aoi.Top(), aoi.Right(), aoi.Bottom(), static_cast<CExports::TSFGradientType>(gradient), retval.data());
    return std::vector<int>(retval.begin(), retval.end());
  }
 
 
  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)
  {
    using namespace std::string_literals;
    if (value < FeatureCountMin)
      throw std::out_of_range(("feature count must be >= "s + std::to_string(FeatureCountMin)).c_str());
    featureCount_ = value;
  }
 
 
  int ContrastThreshold() const noexcept
  {
    return contrastThreshold_;
  }
 
 
  void SetContrastThreshold(int value)
  {
    using namespace std::string_literals;
    if (value < ContrastThresholdMin)
      throw std::out_of_range(("contrast threshold must be >= "s + std::to_string(FeatureCountMin)).c_str());
    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)
      {
        auto identity = Matrix2D::Identity();
        CExports::TransformPixelListMatrix(dontCarePointsNative, *reinterpret_cast<CExports::TMatrix*>(&identity), -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
  {
    return Learn(plane, position, angleOffset, scaleFactor, teachWindow, Point2DToPixelList(dontCarePoints)->Handle());
  }
 
private:
 
 
 
  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 = { 0 };
    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 std::unique_ptr<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)));
    }
    return Internal::PixelList::FromPoints (tmp);
  }
 
 
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
 
}