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