predictor_base.hpp

#pragma once
 
#include "../_cexports/c_polimago.h"
 
#include "../global.hpp"
#include "../image.hpp"
#include "../string.hpp"
#include "../rect.hpp"
#include "../size_2d.hpp"
#include "../point_2d.hpp"
 
#include <utility>
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS

  namespace Polimago
  {
 
    namespace Private
    {
      inline String GetPreprocessing(CExports::TFeatureMap fm)
      {
        std::string s(std::begin(fm.Code));
        return String(s.begin(), s.end());
      }
    } /* namespace Private */

    enum class InterpolationType
    {
      None,
      Linear
    };
    enum class InterpolationType {…};


    class PolimagoFactoryCreatedObject
    {
    public:
      PolimagoFactoryCreatedObject(const PolimagoFactoryCreatedObject &other)            = delete;
      PolimagoFactoryCreatedObject &operator=(const PolimagoFactoryCreatedObject &other) = delete;
      PolimagoFactoryCreatedObject(PolimagoFactoryCreatedObject &&other)                 = delete;
      PolimagoFactoryCreatedObject &operator=(PolimagoFactoryCreatedObject &&other)      = delete;
      virtual ~PolimagoFactoryCreatedObject()                                            = default;
 
    protected:
      explicit PolimagoFactoryCreatedObject(ReleaseObjectGuard &&guard)
          : handle_(std::move(guard))
          , trainingParameters_()
          , fileName_()
      {
      }
 
    public:

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


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


      void Save(const String &fileName) const
      {
        SaveFunction(fileName);
        fileName_ = fileName;
      }
      void Save(const String &fileName) const {…}


      double Lambda() const noexcept
      {
        return trainingParameters_.Lambda;
      }
      double Lambda() const noexcept {…}


      double Offset() const noexcept
      {
        return trainingParameters_.Offset;
      }
      double Offset() const noexcept {…}


      InterpolationType Interpolation() const noexcept
      {
        if (trainingParameters_.FeatureMap.Interpolate == 0)
        {
          return InterpolationType::None;
        }
        else
        {
          return InterpolationType::Linear;
        }
      }
      InterpolationType Interpolation() const noexcept {…}


      int ImagePlanes() const noexcept
      {
        return trainingParameters_.FeatureMap.NumImgPlanes;
      }
      int ImagePlanes() const noexcept {…}


      Rect<int> FeatureWindowExtent() const noexcept
      {
        return Rect<int>(trainingParameters_.FeatureMap.FWL, trainingParameters_.FeatureMap.FWT,
                         trainingParameters_.FeatureMap.FWR, trainingParameters_.FeatureMap.FWB);
      }
      Rect<int> FeatureWindowExtent() const noexcept {…}


      Size2D<int> RetinaSize() const noexcept
      {
        return Size2D<int>(trainingParameters_.FeatureMap.RetinaW, trainingParameters_.FeatureMap.RetinaH);
      }
      Size2D<int> RetinaSize() const noexcept {…}


      Point2D<double> Correction() const noexcept
      {
        return Point2D<double>(trainingParameters_.FeatureMap.CorrectX, trainingParameters_.FeatureMap.CorrectY);
      }
      Point2D<double> Correction() const noexcept {…}


      String Preprocessing() const
      {
        return Private::GetPreprocessing(trainingParameters_.FeatureMap);
      }
      String Preprocessing() const {…}
 
    protected:
      virtual void SaveFunction(const String &fileName) const = 0;
      virtual std::string ObjectName() const                  = 0;
 
      CExports::TTrainParams &TrainingParameters() noexcept
      {
        return trainingParameters_;
      }
 
      const CExports::TTrainParams &TrainingParameters() const noexcept
      {
        return trainingParameters_;
      }
 
      mutable String fileName_;  // NOLINT(cppcoreguidelines-non-private-member-variables-in-classes)
 
    private:
      ReleaseObjectGuard handle_;
      CExports::TTrainParams trainingParameters_;
    };
    class PolimagoFactoryCreatedObject {…};

    using PolimagoFactoryCreatedObjectPtr = std::shared_ptr<PolimagoFactoryCreatedObject>;


    class PredictorBase : public PolimagoFactoryCreatedObject
    {
    protected:
      explicit PredictorBase(ReleaseObjectGuard &&guard)
          : PolimagoFactoryCreatedObject(std::move(guard))
      {
      }
 
    public:

      bool IsCompatible(const Image &img, Point2D<int> pos) const
      {
        try
        {
          VerifyCompatibility(img, pos);
          return true;
        }
        catch (std::exception &)
        {
          return false;
        }
      }
      bool IsCompatible(const Image &img, Point2D<int> pos) const {…}


      bool IsCompatible(const Image &img) const
      {
        try
        {
          VerifyCompatibility(img);
          return true;
        }
        catch (std::exception &)
        {
          return false;
        }
      }
      bool IsCompatible(const Image &img) const {…}
 
    protected:
      void VerifyCompatibility(const Image &img) const
      {
        if (img.PlanesCount() != ImagePlanes())
        {
          throw std::invalid_argument("The supplied image is not compatible with this classifier.");
        }
        if ((img.Width() < FeatureWindowExtent().Width()) || (img.Height() < FeatureWindowExtent().Height()))
        {
          throw std::invalid_argument("The supplied image is not compatible with this classifier.");
        }
      }
 
      void VerifyCompatibility(const Image &img, Point2D<int> pos) const
      {
        VerifyCompatibility(img);
        if ((pos.X() < abs(FeatureWindowExtent().Left())) || (pos.Y() < abs(FeatureWindowExtent().Top())))
        {
          throw std::invalid_argument(
              "The selected position cannot be evaluated because there is not enough image data available around it.");
        }
        if (((pos.X() + FeatureWindowExtent().Right() >= img.Width()))
            || ((pos.Y() + FeatureWindowExtent().Bottom() >= img.Height())))
        {
          throw std::invalid_argument(
              "The selected position cannot be evaluated because there is not enough image data available around it.");
        }
      }
    };
    class PredictorBase : public PolimagoFactoryCreatedObject {…};

    using PredictorBasePtr = std::shared_ptr<PredictorBase>;


    class PredictorBaseEx : public PredictorBase
    {
    protected:
      explicit PredictorBaseEx(ReleaseObjectGuard &&guard)
          : PredictorBase(std::move(guard))
      {
        CVB_CALL_CAPI(PMGetClfTrainParams(Handle(), TrainingParameters()));
      }
 
    public:

      int FeatureResolution() const noexcept
      {
        return TrainingParameters().FeatureMap.FeatureResolution;
      }
      int FeatureResolution() const noexcept {…}
    };
    class PredictorBaseEx : public PredictorBase {…};

    using PredictorBaseExPtr = std::shared_ptr<PredictorBaseEx>;


    inline int GetGranularity(const String &preproCode)
    {
      std::string asciiCode(Internal::CastToAscii(preproCode));
      return CVB_CALL_CAPI(PMGetGranularity(asciiCode.c_str()));
    }
    inline int GetGranularity(const String &preproCode) {…}
 
  } /* namespace Polimago */
  CVB_END_INLINE_NS
} /* namespace Cvb */