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
};
 
 
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();
  }
 
 
  String FileName() const
  {
    return fileName_;
  }
 
 
  void Save (const String & fileName) const
  {
    SaveFunction (fileName);
    fileName_ = fileName;
  }
 
 
  double Lambda() const noexcept
  {
    return trainingParameters_.Lambda;
  }
 
 
  double Offset() const noexcept
  {
    return trainingParameters_.Offset;
  }
 
 
  InterpolationType Interpolation() const noexcept
  {
    if (trainingParameters_.FeatureMap.Interpolate == 0)
    {
      return InterpolationType::None;
    }
    else
    {
      return InterpolationType::Linear;
    }
  }
 
 
  int ImagePlanes() const noexcept
  {
    return trainingParameters_.FeatureMap.NumImgPlanes;
  }
 
 
  Rect<int> FeatureWindowExtent() const noexcept
  {
    return Rect<int> (trainingParameters_.FeatureMap.FWL, trainingParameters_.FeatureMap.FWT, trainingParameters_.FeatureMap.FWR, trainingParameters_.FeatureMap.FWB);
  }
 
 
  Size2D<int> RetinaSize() const noexcept
  {
    return Size2D<int> (trainingParameters_.FeatureMap.RetinaW, trainingParameters_.FeatureMap.RetinaH);
  }
 
 
  Point2D<double> Correction() const noexcept
  {
    return Point2D<double> (trainingParameters_.FeatureMap.CorrectX, trainingParameters_.FeatureMap.CorrectY);
  }
 
 
  String Preprocessing() const
  {
    return Private::GetPreprocessing (trainingParameters_.FeatureMap);
  }
 
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_;
  
};
 
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) const
  {
    try
    {
      VerifyCompatibility (img);
      return true;
    }
    catch (std::exception &)
    {
      return false;
    }
  }
 
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.");
    }
  }
};
 
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;
  }
};
 
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()));
}
 
 
} /* namespace Polimago */
CVB_END_INLINE_NS
} /* namespace Cvb */