otbTrainVectorBase.h

Go to the documentation of this file.

/*
 * Copyright (C) 2005-2024 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 otbTrainVectorBase_h
#define otbTrainVectorBase_h
 
#include "otbLearningApplicationBase.h"
#include "otbWrapperApplication.h"
#include "otbWrapperApplicationFactory.h"
 
#include "otbOGRDataSourceWrapper.h"
#include "otbOGRFeatureWrapper.h"
#include "otbStatisticsXMLFileWriter.h"
 
#include "itkVariableLengthVector.h"
#include "otbStatisticsXMLFileReader.h"
 
#include "itkListSample.h"
#include "otbShiftScaleSampleListFilter.h"
 
#include <algorithm>
#include <locale>
#include <string>
 
namespace otb
{
namespace Wrapper
{
 
template <class TInputValue, class TOutputValue>
class TrainVectorBase : public LearningApplicationBase<TInputValue, TOutputValue>
{
public:
  typedef TrainVectorBase Self;
  typedef LearningApplicationBase<TInputValue, TOutputValue> Superclass;
  typedef itk::SmartPointer<Self>       Pointer;
  typedef itk::SmartPointer<const Self> ConstPointer;
 
  itkTypeMacro(Self, Superclass);
 
  typedef typename Superclass::SampleType           SampleType;
  typedef typename Superclass::ListSampleType       ListSampleType;
  typedef typename Superclass::TargetListSampleType TargetListSampleType;
 
  typedef double                               ValueType;
  typedef itk::VariableLengthVector<ValueType> MeasurementType;
 
  typedef otb::StatisticsXMLFileReader<SampleType> StatisticsReader;
 
  typedef otb::Statistics::ShiftScaleSampleListFilter<ListSampleType, ListSampleType> ShiftScaleFilterType;
 
protected:
  class ShiftScaleParameters
  {
  public:
    MeasurementType meanMeasurementVector;
    MeasurementType stddevMeasurementVector;
  };
 
  class SamplesWithLabel
  {
  public:
    typename ListSampleType::Pointer       listSample;
    typename TargetListSampleType::Pointer labeledListSample;
    SamplesWithLabel()
    {
      listSample        = ListSampleType::New();
      labeledListSample = TargetListSampleType::New();
    }
  };
 
  class FeaturesInfo
  {
  public:
 
    std::vector<int> m_SelectedIdx;
 
    std::vector<int> m_SelectedCFieldIdx;
 
    std::string m_SelectedCFieldName;
 
    std::vector<std::string> m_SelectedNames;
    unsigned int             m_NbFeatures;
 
    void SetFieldNames(std::vector<std::string> fieldNames, std::vector<int> selectedIdx)
    {
      m_SelectedIdx   = selectedIdx;
      m_NbFeatures    = static_cast<unsigned int>(selectedIdx.size());
      m_SelectedNames = std::vector<std::string>(m_NbFeatures);
      for (unsigned int i = 0; i < m_NbFeatures; ++i)
      {
        m_SelectedNames[i] = fieldNames[selectedIdx[i]];
      }
    }
    void SetClassFieldNames(std::vector<std::string> cFieldNames, std::vector<int> selectedCFieldIdx)
    {
      m_SelectedCFieldIdx = selectedCFieldIdx;
      // Handle only one class field name, if several are provided only the first one is used.
      if (selectedCFieldIdx.empty())
        m_SelectedCFieldName.clear();
      else
        m_SelectedCFieldName = cFieldNames[selectedCFieldIdx.front()];
    }
  };
 
 
protected:
  virtual void ExtractAllSamples(const ShiftScaleParameters& measurement);
 
  virtual SamplesWithLabel ExtractTrainingSamplesWithLabel(const ShiftScaleParameters& measurement);
 
  virtual SamplesWithLabel ExtractClassificationSamplesWithLabel(const ShiftScaleParameters& measurement);
 
 
  SamplesWithLabel ExtractSamplesWithLabel(std::string parameterName, std::string parameterLayer, const ShiftScaleParameters& measurement);
 
 
  ShiftScaleParameters GetStatistics(unsigned int nbFeatures);
 
  SamplesWithLabel                       m_TrainingSamplesWithLabel;
  SamplesWithLabel                       m_ClassificationSamplesWithLabel;
  typename TargetListSampleType::Pointer m_PredictedList;
  FeaturesInfo                           m_FeaturesInfo;
 
  void DoInit() override;
  void DoUpdateParameters() override;
  void DoExecute() override;
};
}
}
 
#ifndef OTB_MANUAL_INSTANTIATION
#include "otbTrainVectorBase.hxx"
#endif
 
#endif