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 (fm.Code);
  return String (s.begin (), s.end ());
}
} /* namespace Private */

enum class InterpolationType
{
  None,
  Linear
};


class PolimagoFactoryCreatedObject
{
protected:
  PolimagoFactoryCreatedObject (ReleaseObjectGuard&& guard)
    : handle_(std::move(guard)),
      trainingParameters_(),
      fileName_()
  {}

  PolimagoFactoryCreatedObject (PolimagoFactoryCreatedObject&&) noexcept = default;

  PolimagoFactoryCreatedObject& operator=(PolimagoFactoryCreatedObject&&) noexcept = default;

  virtual ~PolimagoFactoryCreatedObject () = default;

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;

private:
  ReleaseObjectGuard handle_;
protected:
  CExports::TTrainParams trainingParameters_;
  mutable String fileName_;
};

using PolimagoFactoryCreatedObjectPtr = std::shared_ptr<PolimagoFactoryCreatedObject>;


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

  PredictorBase (PredictorBase&&) noexcept = default;

  PredictorBase& operator=(PredictorBase&&) noexcept = default;

  virtual ~PredictorBase () = default;

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:
  PredictorBaseEx (ReleaseObjectGuard&& guard)
    : PredictorBase (std::move (guard))
  {
    CVB_CALL_CAPI(PMGetClfTrainParams(Handle(), trainingParameters_));
  }

  PredictorBaseEx (PredictorBaseEx&&) noexcept = default;

  PredictorBaseEx& operator=(PredictorBaseEx&&) noexcept = default;

  virtual ~PredictorBaseEx () = default;

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 */