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());
      }
      std::vector<int> GradientHistogram(const ImagePlane &plane, Rect<int> aoi, {…}


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


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


      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;
      }
      void SetRotationRange(ValueRange<Angle> value) {…}


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


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


      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;
      }
      void SetScaleRange(ValueRange<double> value) {…}


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


      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;
      }
      void SetFeatureCount(int value) {…}


      int ContrastThreshold() const noexcept
      {
        return contrastThreshold_;
      }
      int ContrastThreshold() const noexcept {…}


      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;
      }
      void SetContrastThreshold(int value) {…}


      int MaxCoarseLayerScale() const noexcept
      {
        return maxCoarseScale_;
      }
      int MaxCoarseLayerScale() const noexcept {…}


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


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


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


      int ProfileSize() const noexcept
      {
        return profileSize_;
      }
      int ProfileSize() const noexcept {…}


      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;
      }
      void SetProfileSize(int value) {…}


      int ProfileDelta() const noexcept
      {
        return profileDelta_;
      }
      int ProfileDelta() const noexcept {…}


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


      std::unique_ptr<Classifier> Learn(const ImagePlane &plane, Point2D<int> 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<int> position, Rect<int> teachWindow, {…}


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


      std::unique_ptr<Classifier> Learn(const ImagePlane &plane, Point2D<int> 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<int> position, Angle angleOffset, {…}


      std::unique_ptr<Classifier> Learn(const ImagePlane &plane, Point2D<int> 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());
      }
      std::unique_ptr<Classifier> Learn(const ImagePlane &plane, Point2D<int> position, Angle angleOffset, {…}
 
    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<int> 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(), position.X(), 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(), position.X(), 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;
    };
    class ClassifierFactory final {…};
 
  }  // namespace ShapeFinder2
 
  using ShapeFinder2::ClassifierFactory;
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb