itkMRFImageFilter.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  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.txt
 *
 *  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 itkMRFImageFilter_h
#define itkMRFImageFilter_h
 
#include "vnl/vnl_vector.h"
#include "vnl/vnl_matrix.h"
 
#include "itkImageClassifierBase.h"
 
#include "itkImageToImageFilter.h"
 
#include "itkConstNeighborhoodIterator.h"
#include "itkNeighborhoodAlgorithm.h"
#include "itkSize.h"
#include "ITKMarkovRandomFieldsClassifiersExport.h"
 
namespace itk
{
class MRFImageFilterEnums
{
public:
  enum class MRFStop : uint8_t
  {
    MaximumNumberOfIterations = 1,
    ErrorTolerance
  };
};
 
// Define how to print enumeration
extern ITKMarkovRandomFieldsClassifiers_EXPORT std::ostream &
                                               operator<<(std::ostream & out, const MRFImageFilterEnums::MRFStop value);
template <typename TInputImage, typename TClassifiedImage>
class ITK_TEMPLATE_EXPORT MRFImageFilter : public ImageToImageFilter<TInputImage, TClassifiedImage>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(MRFImageFilter);
 
  using Self = MRFImageFilter;
  using Superclass = ImageToImageFilter<TInputImage, TClassifiedImage>;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;
  using OutputImagePointer = typename Superclass::OutputImagePointer;
 
  itkNewMacro(Self);
 
  itkTypeMacro(MRFImageFilter, Object);
 
  using InputImageType = TInputImage;
  using InputImagePointer = typename TInputImage::Pointer;
  using InputImageConstPointer = typename TInputImage::ConstPointer;
 
  using InputImagePixelType = typename TInputImage::PixelType;
 
  using InputImageRegionType = typename TInputImage::RegionType;
 
  using InputImageRegionIterator = ImageRegionIterator<TInputImage>;
  using InputImageRegionConstIterator = ImageRegionConstIterator<TInputImage>;
 
  static constexpr unsigned int InputImageDimension = TInputImage::ImageDimension;
 
  using TrainingImagePointer = typename TClassifiedImage::Pointer;
 
  using TrainingImagePixelType = typename TClassifiedImage::PixelType;
 
  using LabelledImagePointer = typename TClassifiedImage::Pointer;
 
  using LabelledImagePixelType = typename TClassifiedImage::PixelType;
 
  using LabelledImageRegionType = typename TClassifiedImage::RegionType;
 
  using LabelledImageIndexType = typename TClassifiedImage::IndexType;
  using IndexValueType = typename LabelledImageIndexType::IndexValueType;
 
  using LabelledImageOffsetType = typename TClassifiedImage::OffsetType;
 
  using LabelledImageRegionIterator = ImageRegionIterator<TClassifiedImage>;
 
  static constexpr unsigned int ClassifiedImageDimension = TClassifiedImage::ImageDimension;
 
  using ClassifierType = ImageClassifierBase<TInputImage, TClassifiedImage>;
 
  using SizeType = typename TInputImage::SizeType;
 
  using NeighborhoodRadiusType = typename TInputImage::SizeType;
 
  using InputImageNeighborhoodIterator = ConstNeighborhoodIterator<TInputImage>;
 
  using InputImageNeighborhoodRadiusType = typename InputImageNeighborhoodIterator::RadiusType;
 
  using InputImageFacesCalculator = NeighborhoodAlgorithm::ImageBoundaryFacesCalculator<TInputImage>;
 
  using InputImageFaceListType = typename InputImageFacesCalculator::FaceListType;
 
  using InputImageFaceListIterator = typename InputImageFaceListType::iterator;
 
  using LabelledImageNeighborhoodIterator = NeighborhoodIterator<TClassifiedImage>;
 
  using LabelledImageNeighborhoodRadiusType = typename LabelledImageNeighborhoodIterator::RadiusType;
 
  using LabelledImageFacesCalculator = NeighborhoodAlgorithm::ImageBoundaryFacesCalculator<TClassifiedImage>;
 
  using LabelledImageFaceListType = typename LabelledImageFacesCalculator::FaceListType;
 
  using LabelledImageFaceListIterator = typename LabelledImageFaceListType::iterator;
 
  void
  SetClassifier(typename ClassifierType::Pointer ptrToClassifier);
 
  itkSetMacro(NumberOfClasses, unsigned int);
  itkGetConstMacro(NumberOfClasses, unsigned int);
 
  itkSetMacro(MaximumNumberOfIterations, unsigned int);
  itkGetConstMacro(MaximumNumberOfIterations, unsigned int);
 
  itkSetMacro(ErrorTolerance, double);
  itkGetConstMacro(ErrorTolerance, double);
 
  itkSetMacro(SmoothingFactor, double);
  itkGetConstMacro(SmoothingFactor, double);
 
  void
  SetNeighborhoodRadius(const NeighborhoodRadiusType &);
 
  void
  SetNeighborhoodRadius(const SizeValueType);
 
  void
  SetNeighborhoodRadius(const SizeValueType * radiusArray);
 
  const NeighborhoodRadiusType
  GetNeighborhoodRadius() const
  {
    NeighborhoodRadiusType radius;
 
    for (int i = 0; i < InputImageDimension; ++i)
    {
      radius[i] = m_InputImageNeighborhoodRadius[i];
    }
    return radius;
  }
 
  virtual void
  SetMRFNeighborhoodWeight(std::vector<double> betaMatrix);
 
  virtual std::vector<double>
  GetMRFNeighborhoodWeight()
  {
    return m_MRFNeighborhoodWeight;
  }
 
  using MRFStopEnum = MRFImageFilterEnums::MRFStop;
#if !defined(ITK_LEGACY_REMOVE)
 
  // We need to expose the enum values at the class level
  // for backwards compatibility
  static constexpr MRFStopEnum MaximumNumberOfIterations = MRFStopEnum::MaximumNumberOfIterations;
  static constexpr MRFStopEnum ErrorTolerance = MRFStopEnum::ErrorTolerance;
#endif
 
  itkGetConstReferenceMacro(StopCondition, MRFStopEnum);
 
  /* Get macro for number of iterations */
  itkGetConstReferenceMacro(NumberOfIterations, unsigned int);
 
#ifdef ITK_USE_CONCEPT_CHECKING
  // Begin concept checking
  itkConceptMacro(UnsignedIntConvertibleToClassifiedCheck,
                  (Concept::Convertible<unsigned int, LabelledImagePixelType>));
  itkConceptMacro(ClassifiedConvertibleToUnsignedIntCheck,
                  (Concept::Convertible<LabelledImagePixelType, unsigned int>));
  itkConceptMacro(ClassifiedConvertibleToIntCheck, (Concept::Convertible<LabelledImagePixelType, int>));
  itkConceptMacro(IntConvertibleToClassifiedCheck, (Concept::Convertible<int, LabelledImagePixelType>));
  itkConceptMacro(SameDimensionCheck, (Concept::SameDimension<InputImageDimension, ClassifiedImageDimension>));
  // End concept checking
#endif
 
protected:
  MRFImageFilter();
  ~MRFImageFilter() override = default;
  void
  PrintSelf(std::ostream & os, Indent indent) const override;
 
  void
  Allocate();
 
  virtual void
  ApplyMRFImageFilter();
 
  virtual void
  MinimizeFunctional();
 
  using LabelStatusImageType = Image<int, Self::InputImageDimension>;
  using LabelStatusIndexType = typename LabelStatusImageType::IndexType;
  using LabelStatusRegionType = typename LabelStatusImageType::RegionType;
  using LabelStatusImagePointer = typename LabelStatusImageType::Pointer;
  using LabelStatusImageIterator = ImageRegionIterator<LabelStatusImageType>;
 
  using LabelStatusImageNeighborhoodIterator = NeighborhoodIterator<LabelStatusImageType>;
  // Function implementing the neighborhood operation
 
  virtual void
  DoNeighborhoodOperation(const InputImageNeighborhoodIterator & imageIter,
                          LabelledImageNeighborhoodIterator &    labelledIter,
                          LabelStatusImageNeighborhoodIterator & labelStatusIter);
 
  void
  GenerateData() override;
 
  void
  GenerateInputRequestedRegion() override;
 
  void
  EnlargeOutputRequestedRegion(DataObject *) override;
 
  void
  GenerateOutputInformation() override;
 
private:
  using InputImageSizeType = typename TInputImage::SizeType;
 
  using LabelStatusImageNeighborhoodRadiusType = typename LabelStatusImageNeighborhoodIterator::RadiusType;
 
  using LabelStatusImageFacesCalculator = NeighborhoodAlgorithm::ImageBoundaryFacesCalculator<LabelStatusImageType>;
 
  using LabelStatusImageFaceListType = typename LabelStatusImageFacesCalculator::FaceListType;
 
  using LabelStatusImageFaceListIterator = typename LabelStatusImageFaceListType::iterator;
 
  InputImageNeighborhoodRadiusType       m_InputImageNeighborhoodRadius;
  LabelledImageNeighborhoodRadiusType    m_LabelledImageNeighborhoodRadius;
  LabelStatusImageNeighborhoodRadiusType m_LabelStatusImageNeighborhoodRadius;
 
  unsigned int m_NumberOfClasses{ 0 };
  unsigned int m_MaximumNumberOfIterations{ 50 };
  unsigned int m_KernelSize;
 
  int          m_ErrorCounter{ 0 };
  int          m_NeighborhoodSize{ 27 };
  int          m_TotalNumberOfValidPixelsInOutputImage{ 1 };
  int          m_TotalNumberOfPixelsInInputImage{ 1 };
  double       m_ErrorTolerance{ 0.2 };
  double       m_SmoothingFactor{ 1 };
  double *     m_ClassProbability{ nullptr }; // Class liklihood
  unsigned int m_NumberOfIterations{ 0 };
  MRFStopEnum  m_StopCondition{ MRFStopEnum::MaximumNumberOfIterations };
 
  LabelStatusImagePointer m_LabelStatusImage;
 
  std::vector<double> m_MRFNeighborhoodWeight;
  std::vector<double> m_NeighborInfluence;
  std::vector<double> m_MahalanobisDistance;
  std::vector<double> m_DummyVector;
 
  typename ClassifierType::Pointer m_ClassifierPtr;
 
  virtual void
  SetDefaultMRFNeighborhoodWeight();
 
  // Function implementing the ICM algorithm to label the images
  void
  ApplyICMLabeller();
}; // class MRFImageFilter
} // namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkMRFImageFilter.hxx"
#endif
 
#endif