otbMarkovRandomFieldFilter.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 otbMarkovRandomFieldFilter_h
#define otbMarkovRandomFieldFilter_h
 
#include "otbMacro.h"
 
#include "vnl/vnl_vector.h"
#include "vnl/vnl_matrix.h"
#include "itkMersenneTwisterRandomVariateGenerator.h"
 
#include "itkImageToImageFilter.h"
#include "itkImageRegionIterator.h"
 
#include "itkNeighborhoodAlgorithm.h"
#include "itkNeighborhood.h"
#include "itkSize.h"
#include "otbMRFOptimizer.h"
#include "otbMRFSampler.h"
 
namespace otb
{
 
template <class TInputImage, class TClassifiedImage>
class ITK_EXPORT MarkovRandomFieldFilter : public itk::ImageToImageFilter<TInputImage, TClassifiedImage>
{
public:
  typedef MarkovRandomFieldFilter Self;
  typedef itk::ImageToImageFilter<TInputImage, TClassifiedImage> Superclass;
  typedef itk::SmartPointer<Self>                 Pointer;
  typedef itk::SmartPointer<const Self>           ConstPointer;
  typedef typename Superclass::OutputImagePointer OutputImagePointer;
 
  itkTypeMacro(MarkovRandomFieldFilter, itk::ImageToImageFilter);
 
  itkNewMacro(Self);
 
  typedef TInputImage                        InputImageType;
  typedef typename TInputImage::Pointer      InputImagePointer;
  typedef typename TInputImage::ConstPointer InputImageConstPointer;
 
  typedef typename TInputImage::PixelType InputImagePixelType;
 
  typedef typename TInputImage::RegionType InputImageRegionType;
 
  typedef itk::ImageRegionIterator<TInputImage>      InputImageRegionIterator;
  typedef itk::ImageRegionConstIterator<TInputImage> InputImageRegionConstIterator;
 
  itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension);
 
  typedef TClassifiedImage                   TrainingImageType;
  typedef typename TClassifiedImage::Pointer TrainingImagePointer;
 
  typedef typename TClassifiedImage::PixelType TrainingImagePixelType;
 
  typedef TClassifiedImage                   LabelledImageType;
  typedef typename TClassifiedImage::Pointer LabelledImagePointer;
 
  typedef typename TClassifiedImage::PixelType LabelledImagePixelType;
 
  typedef typename TClassifiedImage::RegionType LabelledImageRegionType;
 
  typedef typename TClassifiedImage::IndexType            LabelledImageIndexType;
  typedef typename LabelledImageIndexType::IndexValueType IndexValueType;
 
  typedef typename TClassifiedImage::OffsetType LabelledImageOffsetType;
 
  typedef itk::ImageRegionIterator<TClassifiedImage> LabelledImageRegionIterator;
 
  typedef itk::ImageRegionConstIterator<TClassifiedImage> LabelledImageRegionConstIterator;
 
  itkStaticConstMacro(ClassifiedImageDimension, unsigned int, TClassifiedImage::ImageDimension);
 
  typedef typename TInputImage::SizeType SizeType;
 
  typedef typename TInputImage::SizeType NeighborhoodRadiusType;
 
  typedef itk::ConstNeighborhoodIterator<TInputImage> InputImageNeighborhoodIterator;
 
  typedef typename InputImageNeighborhoodIterator::RadiusType InputImageNeighborhoodRadiusType;
 
  typedef itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator<TInputImage> InputImageFacesCalculator;
 
  typedef typename InputImageFacesCalculator::FaceListType InputImageFaceListType;
 
  typedef typename InputImageFaceListType::iterator InputImageFaceListIterator;
 
  typedef itk::NeighborhoodIterator<TClassifiedImage> LabelledImageNeighborhoodIterator;
 
  typedef typename LabelledImageNeighborhoodIterator::RadiusType LabelledImageNeighborhoodRadiusType;
 
  typedef itk::NeighborhoodAlgorithm::ImageBoundaryFacesCalculator<TClassifiedImage> LabelledImageFacesCalculator;
 
  typedef typename LabelledImageFacesCalculator::FaceListType LabelledImageFaceListType;
 
  typedef typename LabelledImageFaceListType::iterator LabelledImageFaceListIterator;
 
  typedef itk::Statistics::MersenneTwisterRandomVariateGenerator RandomGeneratorType;
 
  typedef MRFEnergy<TClassifiedImage, TClassifiedImage> EnergyRegularizationType;
  typedef MRFEnergy<TInputImage, TClassifiedImage>      EnergyFidelityType;
 
  typedef typename EnergyRegularizationType::Pointer EnergyRegularizationPointer;
  typedef typename EnergyFidelityType::Pointer       EnergyFidelityPointer;
 
  typedef MRFSampler<TInputImage, TClassifiedImage> SamplerType;
  typedef typename SamplerType::Pointer SamplerPointer;
 
  typedef MRFOptimizer                    OptimizerType;
  typedef typename OptimizerType::Pointer OptimizerPointer;
 
  itkSetObjectMacro(EnergyRegularization, EnergyRegularizationType);
  itkGetObjectMacro(EnergyRegularization, EnergyRegularizationType);
 
  itkSetObjectMacro(EnergyFidelity, EnergyFidelityType);
  itkGetObjectMacro(EnergyFidelity, EnergyFidelityType);
 
  itkSetObjectMacro(Sampler, SamplerType);
  itkGetObjectMacro(Sampler, SamplerType);
 
  itkSetObjectMacro(Optimizer, OptimizerType);
  itkGetObjectMacro(Optimizer, OptimizerType);
 
  itkSetMacro(NumberOfClasses, unsigned int);
  itkGetMacro(NumberOfClasses, unsigned int);
 
  itkSetMacro(MaximumNumberOfIterations, unsigned int);
  itkGetMacro(MaximumNumberOfIterations, unsigned int);
 
  itkSetMacro(ErrorTolerance, double);
  itkGetMacro(ErrorTolerance, double);
 
  itkSetMacro(SmoothingFactor, double);
  itkGetMacro(SmoothingFactor, double);
 
  itkSetMacro(Lambda, double);
  itkGetMacro(Lambda, double);
 
  void SetNeighborhoodRadius(const NeighborhoodRadiusType&);
 
  void SetNeighborhoodRadius(const unsigned long);
  void SetNeighborhoodRadius(const unsigned long* radiusArray);
 
  const NeighborhoodRadiusType GetNeighborhoodRadius() const
  {
    NeighborhoodRadiusType neighborhoodRadius;
 
    for (int i              = 0; i < InputImageDimension; ++i)
      neighborhoodRadius[i] = m_InputImageNeighborhoodRadius[i];
 
    return neighborhoodRadius;
  }
 
  virtual void SetTrainingInput(const TrainingImageType* trainingImage);
  const TrainingImageType* GetTrainingInput(void);
 
  // Enum to get the stopping condition of the MRF filter
  typedef enum { MaximumNumberOfIterations = 1, ErrorTolerance } StopConditionType;
 
  itkGetConstReferenceMacro(StopCondition, StopConditionType);
 
  itkGetConstReferenceMacro(NumberOfIterations, unsigned int);
 
#ifdef ITK_USE_CONCEPT_CHECKING
 
  itkConceptMacro(UnsignedIntConvertibleToClassifiedCheck, (itk::Concept::Convertible<unsigned int, LabelledImagePixelType>));
  itkConceptMacro(ClassifiedConvertibleToUnsignedIntCheck, (itk::Concept::Convertible<LabelledImagePixelType, unsigned int>));
  itkConceptMacro(ClassifiedConvertibleToIntCheck, (itk::Concept::Convertible<LabelledImagePixelType, int>));
  itkConceptMacro(IntConvertibleToClassifiedCheck, (itk::Concept::Convertible<int, LabelledImagePixelType>));
  itkConceptMacro(SameDimensionCheck, (itk::Concept::SameDimension<InputImageDimension, ClassifiedImageDimension>));
 
#endif
 
  void InitializeSeed(int seed)
  {
    m_Generator->SetSeed(seed);
  }
  void InitializeSeed()
  {
    m_Generator->SetSeed();
  }
 
protected:
  MarkovRandomFieldFilter();
  ~MarkovRandomFieldFilter() override
  {
  }
  void PrintSelf(std::ostream& os, itk::Indent indent) const override;
 
  void Allocate();
 
  void Initialize();
 
  virtual void ApplyMarkovRandomFieldFilter();
 
  void GenerateData() override;
  void GenerateInputRequestedRegion() override;
  void EnlargeOutputRequestedRegion(itk::DataObject*) override;
  void GenerateOutputInformation() override;
 
  MarkovRandomFieldFilter(const Self&) = delete;
  void operator=(const Self&) = delete;
 
  typedef typename TInputImage::SizeType InputImageSizeType;
 
  InputImageNeighborhoodRadiusType    m_InputImageNeighborhoodRadius;
  LabelledImageNeighborhoodRadiusType m_LabelledImageNeighborhoodRadius;
 
  unsigned int m_NumberOfClasses;
  unsigned int m_MaximumNumberOfIterations;
 
  int    m_ErrorCounter;
  double m_ImageDeltaEnergy;
 
  int    m_NeighborhoodRadius;
  int    m_TotalNumberOfValidPixelsInOutputImage;
  int    m_TotalNumberOfPixelsInInputImage;
  double m_ErrorTolerance;
  double m_SmoothingFactor;
 
  unsigned int m_NumberOfIterations;
 
  double            m_Lambda;
  bool              m_ExternalClassificationSet;
  StopConditionType m_StopCondition;
 
  TrainingImagePointer m_TrainingImage;
 
  std::vector<double> m_MRFNeighborhoodWeight;
  std::vector<double> m_NeighborInfluence;
  std::vector<double> m_DummyVector;
 
  RandomGeneratorType::Pointer m_Generator;
 
  EnergyRegularizationPointer m_EnergyRegularization;
  EnergyFidelityPointer       m_EnergyFidelity;
  OptimizerPointer            m_Optimizer;
  SamplerPointer              m_Sampler;
 
  virtual void MinimizeOnce();
 
private:
}; // class MarkovRandomFieldFilter
 
} // namespace otb
 
#ifndef OTB_MANUAL_INSTANTIATION
#include "otbMarkovRandomFieldFilter.hxx"
#endif
 
#endif