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)
  {
    case ClassificationType::OneVersusAll:
      return CExports::CU_ClassifyOneVersusAll;
    case ClassificationType::OneVersusOne:
      return CExports::CU_ClassifyOneVersusOne;
  }
  throw std::invalid_argument("invalid classification type");
}
 
inline ClassificationType ToClassificationType(CExports::TClassifierUsage val)
{
  switch (val)
  {
    case CExports::CU_ClassifyOneVersusAll:
      return ClassificationType::OneVersusAll;
    case CExports::CU_ClassifyOneVersusOne:
      return ClassificationType::OneVersusOne;
  }
  throw std::invalid_argument("invalid classification type");
}
} /* namespace Private */
 
 
class ClassificationPredictorFactory : public PredictorFactoryBaseEx
{
public:
 
  ClassificationPredictorFactory (ClassificationType usageType)
    : PredictorFactoryBaseEx (),
      usage_(Private::ToClassifierUsageType(usageType))
  {}
 
  ClassificationPredictorFactory (const ClassificationPredictorFactory&) = default;
 
  ClassificationPredictorFactory& operator=(const ClassificationPredictorFactory&) = default;
 
  virtual ~ClassificationPredictorFactory () {};
 
public:
 
  ClassificationType Usage() const noexcept
  {
    return Private::ToClassificationType(usage_);
  }
 
 
  void SetUsage(ClassificationType usage)
  {
    usage_ = Private::ToClassifierUsageType(usage);
  }
 
 
  void UseSettingsFromPredictor (const ClassificationPredictor &clf)
  {
    PredictorFactoryBaseEx::UseSettingsFromPredictor (clf);
    SetUsage (clf.Classification ());
  }
 
 
  void UseSettingsFromTestResult (const ClassificationTestResult &res)
  {
    PredictorFactoryBaseEx::UseSettingsFromTestResult (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_;
};
 
using ClassificationPredictorFactoryPtr = std::shared_ptr<ClassificationPredictorFactory>;
 
 
} /* namespace Training */
 
using Training::ClassificationPredictorFactory;
using Training::ClassificationPredictorFactoryPtr;
 
} /* namespace Polimago */
CVB_END_INLINE_NS
} /* namespace Cvb */