search_predictor_factory.hpp

#pragma once
 
#include "../_cexports/c_polimago.h"
 
#include "../global.hpp"
#include "../value_range.hpp"
#include "../angle.hpp"
#include "predictor_factory_base.hpp"
#include "search_predictor.hpp"
#include "../minos/training_set.hpp"
#include "../sample_database/sample_regression_image_list.hpp"
 
#include <memory>
 
namespace Cvb
{
CVB_BEGIN_INLINE_NS
 
namespace Polimago
{
namespace Training
{
 
 
class SearchPredictorFactory : public PredictorFactoryBase
{
public:
 
  SearchPredictorFactory ()
    : PredictorFactoryBase (),
      searchTrainingParameters_(), scaleFactorRange_(ScaleFactorRangeDefault()), singularValueRange_(SingularValueRangeDefault())
  {
    searchTrainingParameters_.NumClfs = 6;
    searchTrainingParameters_.SampleSize = 2000;
  }
 
  SearchPredictorFactory (const SearchPredictorFactory&) = default;
 
  SearchPredictorFactory& operator=(const SearchPredictorFactory&) = default;
 
  virtual ~SearchPredictorFactory () {};
 
public:
  static ValueRange<double> ScaleFactorRangeDefault ()
  {
    return ValueRange<double> (1.0, 1.0);
  }
 
  static ValueRange<double> SingularValueRangeDefault ()
  {
    return ValueRange<double> (1.0, 1.0);
  }
 
  static ValueRange<double> ScaleFactorRange ()
  {
    return ValueRange<double> (0.25, 10);
  }
 
  static constexpr int NumClassificationStepsMin = 3;
 
  static constexpr int SampleSizeMin = 1;
 
 
  int SampleSize() const noexcept
  {
    return static_cast<int>(searchTrainingParameters_.SampleSize);
  }
 
 
  void SetSampleSize(int sampleSize)
  {
    if (sampleSize < SampleSizeMin)
    {
      throw std::out_of_range ("sample size value must be >=1");
    }
 
    searchTrainingParameters_.SampleSize = sampleSize; 
  }
 
 
  double ExtractionRadius() const noexcept
  {
    return searchTrainingParameters_.InvarianceParams.XYRadius;
  }
 
 
  void SetExtractionRadius(double radius)
  {
    if (radius < 0.0)
    {
      throw std::out_of_range ("extraction radius value must be >=0.0");
    }
 
    searchTrainingParameters_.InvarianceParams.XYRadius = radius;
  }
 
 
  ValueRange<Angle> AngleRange() const
  {
    return ValueRange<Angle>(Angle::FromRadians(searchTrainingParameters_.InvarianceParams.MinAngle), 
                             Angle::FromRadians(searchTrainingParameters_.InvarianceParams.MaxAngle));
  }
 
 
  void SetAngleRange(ValueRange<Angle> range)
  {
    auto diff = range.Max().Rad() - range.Min().Rad();
    if (diff > CVB_M_PI * 2)
    {
      searchTrainingParameters_.InvarianceParams.MinAngle = -CVB_M_PI;
      searchTrainingParameters_.InvarianceParams.MaxAngle = CVB_M_PI;
    }
    else
    {
      searchTrainingParameters_.InvarianceParams.MinAngle = range.Min().Rad();
      searchTrainingParameters_.InvarianceParams.MaxAngle = range.Max().Rad();
    }
    if (searchTrainingParameters_.InvarianceParams.MinAngle > searchTrainingParameters_.InvarianceParams.MaxAngle)
    {
      std::swap (searchTrainingParameters_.InvarianceParams.MinAngle, searchTrainingParameters_.InvarianceParams.MaxAngle);
    }
  }
 
 
  ValueRange<double> ScaleRange() const
  {
    return scaleFactorRange_; 
  }
 
 
  void SetScaleRange(ValueRange<double> range)
  {
    if ((range.Min() < ScaleFactorRange().Min()) || (range.Min() > ScaleFactorRange().Max()))
    {
      throw std::out_of_range ("scale range min value is out of range");
    }
    if ((range.Max() < ScaleFactorRange().Min()) || (range.Max() > ScaleFactorRange().Max()))
    {
      throw std::out_of_range ("scale range max value is out of range");
    }
    scaleFactorRange_ = range;
  }
 
 
  ValueRange<double> SingularValueRange() const
  {
    return singularValueRange_;
  }
 
 
  void SetSingularValueRange(ValueRange<double> range)
  {
    singularValueRange_ = range;
  }
 
 
  InvarianceType Invariances() const noexcept
  {
    return static_cast<InvarianceType>(searchTrainingParameters_.InvarianceParams.InvarianceType);
  }
 
 
  void SetInvariances(InvarianceType invariances)
  {
    switch(invariances)
    {
      case InvarianceType::Translation:
      case InvarianceType::RotationScaleTranslation:
      case InvarianceType::AffineGroup:
        break;
      default:
        throw std::invalid_argument("invalid invariance type");
    }
    searchTrainingParameters_.InvarianceParams.InvarianceType = static_cast<CExports::TInvarianceType>(invariances);
  }
 
 
  int NumClassificationSteps() const noexcept
  {
    return static_cast<int>(searchTrainingParameters_.NumClfs);
  }
 
 
  void SetNumClassificationSteps(int numSteps)
  {
    if (numSteps < NumClassificationStepsMin)
    {
      throw std::out_of_range ("sample size value must be >=3");
    }
    searchTrainingParameters_.NumClfs = numSteps;
  }
 
 
  int FeatureResolutionStep1And2() const noexcept
  {
    return static_cast<int>(searchTrainingParameters_.Resolution12);
  }
 
 
  void SetFeatureResolutionStep1And2(int resolution)
  {
    if ((resolution < FeatureResolutionRange().Min()) || (resolution > FeatureResolutionRange().Max()))
    {
      throw std::out_of_range ("feature resolution step 1&2 value is out of range");
    }
    searchTrainingParameters_.Resolution12 = resolution;
  }
 
 
  int FeatureResolutionRest() const noexcept
  {
    return static_cast<int>(searchTrainingParameters_.ResolutionRest);
  }
 
 
  void SetFeatureResolutionRest(int resolution)
  {
    if ((resolution < FeatureResolutionRange().Min()) || (resolution > FeatureResolutionRange().Max()))
    {
      throw std::out_of_range ("feature resolution step 3+ value is out of range");
    }
    searchTrainingParameters_.ResolutionRest = resolution;
  }
 
 
  void UseSettingsFromPredictor (const SearchPredictor &clf)
  {
    PredictorFactoryBase::UseSettingsFromPredictor (clf);
    scaleFactorRange_ = clf.ScaleRange();
    singularValueRange_ = clf.ScaleRange();
    searchTrainingParameters_ = clf.searchTrainingParameters_;
  }
 
#if 0
 
  std::unique_ptr<SearchPredictor> TrainPredictor (const SampleDatabase::SampleRegressionImageList & sil)
  {
    return Internal::DoResCallObjectOut<SearchPredictor>([&](void* & res)
    {
      return CVB_CALL_CAPI(PMTrainSearchClassifierFromSil(sil.Handle(), ..., preproCode_, lambda_, ..., res);
    });
  }
 
 
  std::unique_ptr<SearchPredictor> TrainPredictor (const Minos::TrainingSet & mts)
  {
    return Internal::DoResCallObjectOut<SearchPredictor>([&](void* & res)
    {
      return CVB_CALL_CAPI(PMTrainSearchClassifierFromMts(mts.Handle(), ..., preproCode_, lambda_, ..., res);
    });
  }
#endif
 
private:
  CExports::TTrainSearchParams searchTrainingParameters_;
  ValueRange<double> scaleFactorRange_;
  ValueRange<double> singularValueRange_;
};
 
using SearchPredictorFactoryPtr = std::shared_ptr<SearchPredictorFactory>;
 
 
} /* namespace Training */
 
using Training::SearchPredictorFactory;
using Training::SearchPredictorFactoryPtr;
 
} /* namespace Polimago */
CVB_END_INLINE_NS
} /* namespace Cvb */