otbSEMClassifier.h

Go to the documentation of this file.

/*
 * Copyright (C) 2005-2022 Centre National d'Etudes Spatiales (CNES)
 * Copyright (C) 2007-2012 Institut Mines Telecom / Telecom Bretagne
 *
 * 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 otbSEMClassifier_h
#define otbSEMClassifier_h
 
#include "itkListSample.h"
#include "itkSampleClassifierFilter.h"
 
 
#include "otbGaussianModelComponent.h"
 
namespace otb
{
 
template <class TInputImage, class TOutputImage>
class ITK_EXPORT SEMClassifier : public itk::Statistics::SampleClassifierFilter<typename itk::Statistics::ListSample<typename TInputImage::PixelType>>
{
public:
  typedef SEMClassifier                                                                                                  Self;
  typedef itk::Statistics::SampleClassifierFilter<typename itk::Statistics::ListSample<typename TInputImage::PixelType>> Superclass;
  typedef itk::SmartPointer<Self>                                                                                        Pointer;
  typedef itk::SmartPointer<const Self>                                                                                  ConstPointer;
 
  itkTypeMacro(SEMClassifier, itk::Object);
  itkNewMacro(Self);
 
  typedef typename itk::Statistics::ListSample<typename TInputImage::PixelType> SampleType;
  typedef typename itk::Statistics::Subsample<SampleType>                       ClassSampleType;
 
  typedef typename SampleType::MeasurementType       MeasurementType;
  typedef typename SampleType::MeasurementVectorType MeasurementVectorType;
 
  typedef unsigned int                ClassLabelType;
  typedef std::vector<ClassLabelType> ClassLabelVectorType;
 
  typedef itk::Statistics::MembershipSample<SampleType> OutputType;
 
  typedef otb::Statistics::ModelComponentBase<ClassSampleType> ComponentType;
  typedef typename ComponentType::Pointer                      ComponentPointerType;
 
  typedef std::vector<ComponentPointerType> ComponentVectorType;
 
  typedef itk::Array<double> ParameterType;
 
  typedef std::vector<ParameterType> ParameterVectorType;
 
  typedef std::vector<double> ProportionVectorType;
  typedef std::vector<double> ProbaVectorType;
 
  typedef std::vector<ProbaVectorType> ProbaByClassVectorType;
 
  void SetSample(const TInputImage* sample);
 
  const TInputImage* GetSample() const;
  SampleType*        GetSampleList() const;
 
  void SetInitialProportions(ProportionVectorType& proportions);
  itkGetConstReferenceMacro(InitialProportions, ProportionVectorType);
 
  itkGetConstReferenceMacro(Proportions, ProportionVectorType);
 
  void SetClassLabels(OutputType* labels);
  void SetClassLabels(TOutputImage* imgLabels);
  ClassLabelVectorType& GetClassLabels();
 
  itkSetMacro(MaximumIteration, int);
  itkGetMacro(MaximumIteration, int);
 
  void SetNeighborhood(int neighborhood);
  int GetNeighborhood();
 
  int GetCurrentIteration();
 
  int AddComponent(int id, ComponentType* component);
 
  void Update() override;
 
  typedef enum { CONVERGED = 0, NOT_CONVERGED = 1 } TerminationCodeType;
 
  itkSetMacro(TerminationThreshold, double);
  itkGetMacro(TerminationThreshold, double);
 
  itkGetMacro(TerminationCode, TerminationCodeType);
 
  /* Return the classification result (as a standard classification result) */
  OutputType* GetOutput();
 
  /* Return the classification result (as an image) */
  TOutputImage* GetOutputImage();
 
  void Modified() const override;
 
protected:
  SEMClassifier();
  ~SEMClassifier() override
  {
  }
  void PrintSelf(std::ostream& os, itk::Indent indent) const override;
 
  void InitParameters();
 
  void PerformStochasticProcess();
 
  void PerformExpectationProcess();
 
  void PerformMaximizationProcess();
 
  void GetMaximumAposterioriLabels();
 
private:
  const TInputImage*           m_Sample;
  int                          m_NbSamples;
  typename SampleType::Pointer m_SampleList;
 
  int    m_MaximumIteration;
  int    m_CurrentIteration;
  int    m_NbChange;
  double m_TerminationThreshold;
  int    m_Neighborhood;
 
  TerminationCodeType         m_TerminationCode;
  mutable ComponentVectorType m_ComponentVector;
  ProportionVectorType        m_InitialProportions;
  ProportionVectorType        m_Proportions;
  ProbaByClassVectorType      m_Proba;
  ClassLabelVectorType        m_ClassLabels;
 
  int         m_ExternalLabels;
  mutable int m_ComponentDeclared;
 
  typename TOutputImage::Pointer m_OutputImage;
  typename OutputType::Pointer   m_Output;
}; // end of class
 
} // end of namespace
 
#ifndef OTB_MANUAL_INSTANTIATION
#include "otbSEMClassifier.hxx"
#endif
 
#endif