classification_predictor_factory.hpp

#pragma once
 
#include "../_cexports/c_polimago.h"
 
#include "../global.hpp"
#include "predictor_factory_base.hpp"
#include "classification_predictor.hpp"
#include "classification_test_result.hpp"
#include "../minos/training_set.hpp"
#include "../sample_database/sample_classification_image_list.hpp"
 
#include <memory>
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS

  namespace Polimago
  {
    namespace Training
    {
 
      namespace Private
      {
        inline CExports::TClassifierUsage ToClassifierUsageType(ClassificationType val)
        {
          switch (val)
          {
            default:
              throw std::invalid_argument("invalid classification type");
            case ClassificationType::OneVersusAll:
              return CExports::CU_ClassifyOneVersusAll;
            case ClassificationType::OneVersusOne:
              return CExports::CU_ClassifyOneVersusOne;
          }
        }
 
        inline ClassificationType ToClassificationType(CExports::TClassifierUsage val) noexcept
        {
          switch (val)
          {
            default:
              return ClassificationType::None;
            case CExports::CU_ClassifyOneVersusAll:
              return ClassificationType::OneVersusAll;
            case CExports::CU_ClassifyOneVersusOne:
              return ClassificationType::OneVersusOne;
          }
        }
      } /* namespace Private */


      class ClassificationPredictorFactory : public PredictorFactoryBaseEx
      {
      public:

        explicit ClassificationPredictorFactory(ClassificationType usageType)
            : PredictorFactoryBaseEx()
            , usage_(Private::ToClassifierUsageType(usageType))
        {
        }
        explicit ClassificationPredictorFactory(ClassificationType usageType) {…}
 
      public:

        ClassificationType Usage() const noexcept
        {
          return Private::ToClassificationType(usage_);
        }
        ClassificationType Usage() const noexcept {…}


        void SetUsage(ClassificationType usage)
        {
          usage_ = Private::ToClassifierUsageType(usage);
        }
        void SetUsage(ClassificationType usage) {…}


        void UseSettingsFromPredictor(const ClassificationPredictor &clf)
        {
          PredictorFactoryBaseEx::UseSettingsFromPredictor(clf);
          SetUsage(clf.Classification());
        }
        void UseSettingsFromPredictor(const ClassificationPredictor &clf) {…}


        void UseSettingsFromTestResult(const ClassificationTestResult &res)
        {
          PredictorFactoryBaseEx::UseSettingsFromTestResult(res);
        }
        void UseSettingsFromTestResult(const ClassificationTestResult &res) {…}
 
#if 0

  std::unique_ptr<ClassificationPredictor> TrainPredictor (const SampleDatabase::SampleClassificationImageList & sil)
  {
    return Internal::DoResCallObjectOut<ClassificatioPredictor>([&](void* & res)
    {
      return CVB_CALL_CAPI(PMTrainClassifierFromSil(sil.Handle(), ..., usage_, preproCode_, featureResolution_, lambda_, interpolation_ == InterpolationType::Linear, res);
    });
  }


  std::unique_ptr<ClassificationPredictor> TrainPredictor (const Minos::TrainingSet & mts)
  {
    return Internal::DoResCallObjectOut<ClassificatioPredictor>([&](void* & res)
    {
      return CVB_CALL_CAPI(PMTrainClassifierFromMts(sil.Handle(), ..., usage_, preproCode_, featureResolution_, lambda_, interpolation_ == InterpolationType::Linear, res);
    });
  }
#endif
 
      private:
        CExports::TClassifierUsage usage_;
      };
      class ClassificationPredictorFactory : public PredictorFactoryBaseEx {…};

      using ClassificationPredictorFactoryPtr = std::shared_ptr<ClassificationPredictorFactory>;
 
    } /* namespace Training */
    namespace Training {…}
 
    using Training::ClassificationPredictorFactory;
    using Training::ClassificationPredictorFactoryPtr;
 
  } /* namespace Polimago */
  CVB_END_INLINE_NS
} /* namespace Cvb */