classification_predictor.hpp

#pragma once

#include "../_cexports/c_polimago.h"

#include "../global.hpp"
#include "../string.hpp"
#include "predictor_base.hpp"
#include "classification_result.hpp"

#include <utility>
#include <vector>

namespace Cvb
{
CVB_BEGIN_INLINE_NS


namespace Polimago
{

enum class ClassificationType
{
  None,
  OneVersusAll,
  OneVersusOne
};


class ClassificationPredictor : public PredictorBaseEx
{
private:
  // Internal helper constructor version
  ClassificationPredictor (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_);
    }

    auto numClasses = NumClasses ();
    for (int i = 0; i < numClasses; ++i)
    {
      Char lbl[classNameMaxLength_];
      CVB_CALL_CAPI_CHECKED(PMGetClfClassLabelTyped(Handle(), i, lbl));
      classes_.push_back (lbl);
    }
  }

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

  ClassificationPredictor (const String & fileName)
    : ClassificationPredictor (ReleaseObjectGuard(LoadInternal (fileName)))
  {
    fileName_ = fileName;
  }

  ClassificationPredictor (ClassificationPredictor&&) noexcept = default;

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

  virtual ~ClassificationPredictor ()
  {}


  static std::unique_ptr<ClassificationPredictor> FromHandle (ReleaseObjectGuard&& guard)
  {
    if (!guard.Handle ())
    {
      throw std::invalid_argument ("invalid classification predictor native handle");
    }
    return std::unique_ptr<ClassificationPredictor>(new ClassificationPredictor(std::move(guard)));
  }


  static std::unique_ptr<ClassificationPredictor> Load (const String & fileName)
  {
    return std::unique_ptr<ClassificationPredictor>(new ClassificationPredictor(fileName));
  }



  std::vector<String> Classes() const
  {
    return classes_;
  }


  ClassificationType Classification() const
  {
    if (trainingParameters_.Usage == CExports::TClassifierUsage::CU_ClassifyOneVersusAll)
    {
      return ClassificationType::OneVersusAll;
    }
    else if (trainingParameters_.Usage == CExports::TClassifierUsage::CU_ClassifyOneVersusOne)
    {
      return ClassificationType::OneVersusOne;
    }
    else
    {
      throw std::runtime_error ("invalid classification type");
    }
  }


  int OutputDimension() const
  {
    return CVB_CALL_CAPI(PMGetOutputDimension(Handle()));
  }


  int NumClasses() const
  {
    return static_cast<int>(CVB_CALL_CAPI(PMGetNumClasses(Handle())));
  }


  ClassificationResult Classify (const Image & img, Point2D<int> pos, std::vector<double> &confidences)
  {
    VerifyCompatibility(img, pos);

    Char lbl[classNameMaxLength_];
    double confidence = 0.0;
    confidences.assign (NumClasses (), 0.0);
    CVB_CALL_CAPI_CHECKED(PMClassifyTyped(Handle(), img.Handle(), pos.X(), pos.Y(), lbl, classNameMaxLength_, confidence, &confidences[0]));

    return ClassificationResult (lbl, confidence);
  }


  ClassificationResult Classify (const Image & img, Point2D<int> pos)
  {
    std::vector<double> confidences;
    return Classify (img, pos, confidences);
  }

private:
  std::vector<String> classes_;
  static const int classNameMaxLength_ = 256;
  const std::string thisObjectName_ = "Polimago Classification Predictor";
};

using ClassificationPredictorPtr = std::shared_ptr<ClassificationPredictor>;



} /* namespace Polimago */
CVB_END_INLINE_NS
} /* namespace Cvb */