otbLearningApplicationBase.h

Go to the documentation of this file.

/*
 * Copyright (C) 2005-2022 Centre National d'Etudes Spatiales (CNES)
 *
 * This file is part of Orfeo Toolbox
 *
 *     https://www.orfeo-toolbox.org/
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef otbLearningApplicationBase_h
#define otbLearningApplicationBase_h
 
#include "otbConfigure.h"
 
#include "otbWrapperApplication.h"
 
 
// ListSample
#include "itkListSample.h"
#include "itkVariableLengthVector.h"
 
// Estimator
#include "otbMachineLearningModelFactory.h"
#include <string>
 
namespace otb
{
namespace Wrapper
{
 
template <class TInputValue, class TOutputValue>
class LearningApplicationBase : public Application
{
public:
  typedef LearningApplicationBase       Self;
  typedef Application                   Superclass;
  typedef itk::SmartPointer<Self>       Pointer;
  typedef itk::SmartPointer<const Self> ConstPointer;
 
  itkTypeMacro(LearningApplicationBase, otb::Application);
 
  typedef TInputValue  InputValueType;
  typedef TOutputValue OutputValueType;
 
  typedef otb::VectorImage<InputValueType>    SampleImageType;
  typedef typename SampleImageType::PixelType PixelType;
 
  // Machine Learning models
  typedef otb::MachineLearningModelFactory<InputValueType, OutputValueType> ModelFactoryType;
  typedef typename ModelFactoryType::MachineLearningModelTypePointer ModelPointerType;
  typedef typename ModelFactoryType::MachineLearningModelType        ModelType;
 
  typedef typename ModelType::InputSampleType     SampleType;
  typedef typename ModelType::InputListSampleType ListSampleType;
 
  typedef typename ModelType::TargetSampleType     TargetSampleType;
  typedef typename ModelType::TargetListSampleType TargetListSampleType;
  typedef typename ModelType::TargetValueType      TargetValueType;
 
  itkGetConstReferenceMacro(SupervisedClassifier, std::vector<std::string>);
  itkGetConstReferenceMacro(UnsupervisedClassifier, std::vector<std::string>);
 
  enum ClassifierCategory
  {
    Supervised,
    Unsupervised
  };
 
  ClassifierCategory GetClassifierCategory();
 
protected:
  LearningApplicationBase();
 
  ~LearningApplicationBase() override;
 
  void Train(typename ListSampleType::Pointer trainingListSample, typename TargetListSampleType::Pointer trainingLabeledListSample, std::string modelPath);
 
  typename TargetListSampleType::Pointer Classify(typename ListSampleType::Pointer validationListSample, std::string modelPath);
 
  void DoInit() override;
 
  bool m_RegressionFlag;
 
private:
  void                     InitSupervisedClassifierParams();
  std::vector<std::string> m_SupervisedClassifier;
 
  void                     InitUnsupervisedClassifierParams();
  std::vector<std::string> m_UnsupervisedClassifier;
 
#ifdef OTB_USE_LIBSVM
  void InitLibSVMParams();
 
  void TrainLibSVM(typename ListSampleType::Pointer trainingListSample, typename TargetListSampleType::Pointer trainingLabeledListSample,
                   std::string modelPath);
#endif
 
#ifdef OTB_USE_OPENCV
  void InitBoostParams();
  void InitSVMParams();
  void InitDecisionTreeParams();
  void InitNeuralNetworkParams();
  void InitNormalBayesParams();
  void InitRandomForestsParams();
  void InitKNNParams();
 
  void TrainBoost(typename ListSampleType::Pointer trainingListSample, typename TargetListSampleType::Pointer trainingLabeledListSample, std::string modelPath);
  void TrainSVM(typename ListSampleType::Pointer trainingListSample, typename TargetListSampleType::Pointer trainingLabeledListSample, std::string modelPath);
  void TrainDecisionTree(typename ListSampleType::Pointer trainingListSample, typename TargetListSampleType::Pointer trainingLabeledListSample,
                         std::string modelPath);
  void TrainNeuralNetwork(typename ListSampleType::Pointer trainingListSample, typename TargetListSampleType::Pointer trainingLabeledListSample,
                          std::string modelPath);
  void TrainNormalBayes(typename ListSampleType::Pointer trainingListSample, typename TargetListSampleType::Pointer trainingLabeledListSample,
                        std::string modelPath);
  void TrainRandomForests(typename ListSampleType::Pointer trainingListSample, typename TargetListSampleType::Pointer trainingLabeledListSample,
                          std::string modelPath);
  void TrainKNN(typename ListSampleType::Pointer trainingListSample, typename TargetListSampleType::Pointer trainingLabeledListSample, std::string modelPath);
#endif
 
#ifdef OTB_USE_SHARK
  void InitSharkRandomForestsParams();
  void TrainSharkRandomForests(typename ListSampleType::Pointer trainingListSample, typename TargetListSampleType::Pointer trainingLabeledListSample,
                               std::string modelPath);
  void InitSharkKMeansParams();
  void TrainSharkKMeans(typename ListSampleType::Pointer trainingListSample, typename TargetListSampleType::Pointer trainingLabeledListSample,
                        std::string modelPath);
#endif
 
};
}
}
 
#ifndef OTB_MANUAL_INSTANTIATION
#include "otbLearningApplicationBase.hxx"
#ifdef OTB_USE_OPENCV
#include "otbTrainBoost.hxx"
#include "otbTrainDecisionTree.hxx"
#include "otbTrainKNN.hxx"
#include "otbTrainNeuralNetwork.hxx"
#include "otbTrainNormalBayes.hxx"
#include "otbTrainRandomForests.hxx"
#include "otbTrainSVM.hxx"
#endif
#ifdef OTB_USE_LIBSVM
#include "otbTrainLibSVM.hxx"
#endif
#ifdef OTB_USE_SHARK
#include "otbTrainSharkRandomForests.hxx"
#include "otbTrainSharkKMeans.hxx"
#endif
#endif
 
#endif