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