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
    };
    enum class ClassificationType {…};


    class ClassificationPredictor : public PredictorBaseEx
    {
    private:
      // Internal helper constructor version
      explicit 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)
        {
          std::array<Char, classNameMaxLength_> lbl = {};
          CVB_CALL_CAPI_CHECKED(PMGetClfClassLabelTyped(Handle(), i, lbl.data()));
          classes_.push_back(lbl.data());
        }
      }
 
      // 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:

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


      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> FromHandle(ReleaseObjectGuard &&guard) {…}


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


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


      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");
        }
      }
      ClassificationType Classification() const {…}


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


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


      ClassificationResult Classify(const Image &img, Point2D<int> pos, std::vector<double> &confidences)
      {
        VerifyCompatibility(img, pos);
 
        std::array<Char, classNameMaxLength_> lbl = {};
        double confidence                         = 0.0;
        confidences.assign(NumClasses(), 0.0);
        CVB_CALL_CAPI_CHECKED(PMClassifyTyped(Handle(), img.Handle(), pos.X(), pos.Y(), lbl.data(), classNameMaxLength_,
                                              confidence, confidences.data()));
 
        return ClassificationResult(lbl.data(), confidence);
      }
      ClassificationResult Classify(const Image &img, Point2D<int> pos, std::vector<double> &confidences) {…}


      ClassificationResult Classify(const Image &img, Point2D<int> pos)
      {
        std::vector<double> confidences;
        return Classify(img, pos, confidences);
      }
      ClassificationResult Classify(const Image &img, Point2D<int> pos) {…}
 
    private:
      std::vector<String> classes_;
      static const int classNameMaxLength_ = 256;
      const std::string thisObjectName_    = "Polimago Classification Predictor";
    };
    class ClassificationPredictor : public PredictorBaseEx {…};

    using ClassificationPredictorPtr = std::shared_ptr<ClassificationPredictor>;
 
  } /* namespace Polimago */
  namespace Polimago {…}
  CVB_END_INLINE_NS
} /* namespace Cvb */