otbListSampleGenerator.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 otbListSampleGenerator_h
#define otbListSampleGenerator_h
 
#include "itkProcessObject.h"
#include "itkListSample.h"
#include "itkMersenneTwisterRandomVariateGenerator.h"
#include <string>
 
namespace otb
{
template <class TImage, class TVectorData>
class ITK_EXPORT ListSampleGenerator : public itk::ProcessObject
{
public:
  typedef ListSampleGenerator           Self;
  typedef itk::ProcessObject            Superclass;
  typedef itk::SmartPointer<Self>       Pointer;
  typedef itk::SmartPointer<const Self> ConstPointer;
 
  itkTypeMacro(ListSampleGenerator, itk::ProcessObject);
 
  itkNewMacro(Self);
 
  typedef TImage                                             ImageType;
  typedef typename ImageType::Pointer                        ImagePointerType;
  typedef typename ImageType::IndexType                      ImageIndexType;
  typedef typename ImageType::RegionType                     ImageRegionType;
  typedef TVectorData                                        VectorDataType;
  typedef typename VectorDataType::Pointer                   VectorDataPointerType;
  typedef itk::ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType;
 
  typedef typename ImageType::PixelType           SampleType;
  typedef itk::Statistics::ListSample<SampleType> ListSampleType;
  typedef typename ListSampleType::Pointer        ListSamplePointerType;
 
  typedef int ClassLabelType;
  typedef itk::FixedArray<ClassLabelType, 1> LabelType; // note could be templated by an std:::string
  typedef itk::Statistics::ListSample<LabelType> ListLabelType;
  typedef typename ListLabelType::Pointer        ListLabelPointerType;
 
  using Superclass::SetInput;
  void             SetInput(const ImageType*);
  const ImageType* GetInput() const;
 
  void                  SetInputVectorData(const VectorDataType*);
  const VectorDataType* GetInputVectorData() const;
 
  // Build the outputs
  typedef itk::DataObject::Pointer DataObjectPointer;
  DataObjectPointer MakeOutput(DataObjectPointerArraySizeType idx) override;
  using Superclass::MakeOutput;
 
  // virtual void Update();
 
  itkGetConstMacro(MaxTrainingSize, long int);
  itkSetMacro(MaxTrainingSize, long int);
  itkGetConstMacro(PolygonEdgeInclusion, bool);
  itkSetMacro(PolygonEdgeInclusion, bool);
  itkGetConstMacro(MaxValidationSize, long int);
  itkSetMacro(MaxValidationSize, long int);
  itkGetConstMacro(ValidationTrainingProportion, double);
  itkSetClampMacro(ValidationTrainingProportion, double, 0.0, 1.0);
  itkGetConstMacro(BoundByMin, bool);
  itkSetMacro(BoundByMin, bool);
 
  itkGetConstMacro(NumberOfClasses, unsigned short);
  typedef std::map<ClassLabelType, int> SampleNumberType;
 
  SampleNumberType GetClassesSamplesNumberTraining(void) const
  {
    return m_ClassesSamplesNumberTraining;
  }
 
  SampleNumberType GetClassesSamplesNumberValidation(void) const
  {
    return m_ClassesSamplesNumberValidation;
  }
 
  itkGetStringMacro(ClassKey);
  itkSetStringMacro(ClassKey);
  itkGetConstMacro(ClassMinSize, double);
 
  ListSampleType* GetTrainingListSample();
 
  ListLabelType* GetTrainingListLabel();
 
  ListSampleType* GetValidationListSample();
 
  ListLabelType* GetValidationListLabel();
 
  // Get the map size
  std::map<ClassLabelType, double> GetClassesSize() const
  {
    return m_ClassesSize;
  }
 
protected:
  ListSampleGenerator();
  ~ListSampleGenerator() override
  {
  }
  void PrintSelf(std::ostream& os, itk::Indent indent) const override;
 
  void GenerateData(void) override;
 
  void GenerateInputRequestedRegion(void) override;
 
  void GenerateClassStatistics();
 
private:
  ListSampleGenerator(const Self&) = delete;
  void operator=(const Self&) = delete;
 
  typedef typename VectorDataType::DataNodeType                            DataNodeType;
  typedef typename DataNodeType::PolygonType                               PolygonType;
  typedef typename DataNodeType::PolygonPointerType                        PolygonPointerType;
  typedef typename DataNodeType::PolygonListType                           PolygonListType;
  typedef typename DataNodeType::PolygonListPointerType                    PolygonListPointerType;
 
  void ComputeClassSelectionProbability();
 
  // Crop the polygon wrt the image largest region,
  // and return the resulting size in pixel units
  // This does not handle interior rings
  double GetPolygonAreaInPixelsUnits(DataNodeType* polygonDataNode, ImageType* image);
 
  long int m_MaxTrainingSize;              // number of training samples (-1 = no limit)
  long int m_MaxValidationSize;            // number of validation samples (-1 = no limit)
  double   m_ValidationTrainingProportion; // proportion of training vs validation
                                           // (0.0 = all training, 1.0 = all validation)
 
  bool m_BoundByMin;           // Bound the number of samples by the class having the fewer
  bool m_PolygonEdgeInclusion; // if true take into consideration pixel which are on polygon edge
                               //  useful, when dealing with small polygon area (1 or two pixels)
                               // false by default
  unsigned short m_NumberOfClasses;
  std::string    m_ClassKey;
  double         m_ClassMinSize;
 
  std::map<ClassLabelType, double> m_ClassesSize;
  std::map<ClassLabelType, double> m_ClassesProbTraining;
  std::map<ClassLabelType, double> m_ClassesProbValidation;
 
  std::map<ClassLabelType, int> m_ClassesSamplesNumberTraining;   // Just a counter
  std::map<ClassLabelType, int> m_ClassesSamplesNumberValidation; // Just a counter
 
  typedef itk::Statistics::MersenneTwisterRandomVariateGenerator RandomGeneratorType;
  RandomGeneratorType::Pointer                                   m_RandomGenerator;
};
} // end of namespace otb
 
#ifndef OTB_MANUAL_INSTANTIATION
#include "otbListSampleGenerator.hxx"
#endif
 
#endif