regression_predictor.hpp

#pragma once
 
#include "../_cexports/c_polimago.h"
 
#include "../global.hpp"
#include "../string.hpp"
#include "predictor_base.hpp"
 
#include <utility>
#include <vector>
 
namespace Cvb
{
CVB_BEGIN_INLINE_NS
 
namespace Polimago
{
 
 
class RegressionPredictor : public PredictorBaseEx
{
private:
  // Internal helper constructor version 
  RegressionPredictor (ReleaseObjectGuard&& guard)
    : PredictorBaseEx (std::move (guard))
  {
    if (trainingParameters_.Usage != CExports::TClassifierUsage::CU_Regression)
    {
      throw std::runtime_error (std::string("The object is not a ") + thisObjectName_);
    }
  }
 
  // Helper to load a saved predictor from file
  static CExports::TCLF LoadInternal (const String & fileName)
  {
    CExports::TCLF predictor = nullptr;
 
    CVB_CALL_CAPI_CHECKED (PMOpenClfTyped(fileName.c_str(), predictor));
    return predictor;
  }
 
  void SaveFunction (const String &fileName) const override
  {
    CVB_CALL_CAPI_CHECKED (PMSaveClfTyped(fileName.c_str(), Handle()));
  }
 
  std::string ObjectName () const override
  {
    return thisObjectName_;
  }
 
public:
 
  RegressionPredictor (const String & fileName)
    : RegressionPredictor (ReleaseObjectGuard(LoadInternal (fileName)))
  { 
    fileName_ = fileName;
  }
 
  RegressionPredictor (RegressionPredictor&&) noexcept = default;
 
  RegressionPredictor& operator=(RegressionPredictor&&) noexcept = default;
 
  virtual ~RegressionPredictor ()
  {}
 
 
  static std::unique_ptr<RegressionPredictor> FromHandle (ReleaseObjectGuard&& guard)
  {
    if (!guard.Handle ())
    {
      throw std::invalid_argument ("invalid regression predictor native handle");
    }
    return std::unique_ptr<RegressionPredictor>(new RegressionPredictor(std::move(guard)));
  }
 
 
  static std::unique_ptr<RegressionPredictor> Load (const String & fileName)
  {
    return std::unique_ptr<RegressionPredictor>(new RegressionPredictor(fileName));
  }
 
 
  int RegressionDimension() const
  {
    return static_cast<int>(CVB_CALL_CAPI(PMGetOutputDimension(Handle())));
  }
 
 
  std::vector<double> PredictVector(const Image & img, Point2D<int> pos) const
  {
    VerifyCompatibility(img, pos);
 
    std::vector<double> retval (RegressionDimension ());
    CVB_CALL_CAPI_CHECKED (PMPredictVector(Handle(), img.Handle(), pos.X(), pos.Y(), &retval[0]));
    return retval;
  }
 
private:
  const std::string thisObjectName_ = "Polimago Regression Predictor";
};
 
using RegressionPredictorPtr = std::shared_ptr<RegressionPredictor>;
 
 
 
} /* namespace Polimago */
CVB_END_INLINE_NS
} /* namespace Cvb */