itkMRFImageFilter.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkMRFImageFilter.h,v $
  Language:  C++
  Date:      $Date: 2009-04-23 03:53:35 $
  Version:   $Revision: 1.44 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __itkMRFImageFilter_h
#define __itkMRFImageFilter_h


#include "vnl/vnl_vector.h"
#include "vnl/vnl_matrix.h"

#include "itkImageClassifierBase.h"

#include "itkImageToImageFilter.h"
#include "itkImageRegionIterator.h"

#include "itkConstNeighborhoodIterator.h"
#include "itkNeighborhoodIterator.h"
#include "itkNeighborhoodAlgorithm.h"
#include "itkNeighborhood.h"
#include "itkSize.h"

namespace itk
{

template <class TInputImage, class TClassifiedImage>
class ITK_EXPORT MRFImageFilter : 
    public ImageToImageFilter<TInputImage,TClassifiedImage>
{
public:
  typedef MRFImageFilter                                   Self;
  typedef ImageToImageFilter<TInputImage,TClassifiedImage> Superclass;
  typedef SmartPointer<Self>                               Pointer;
  typedef SmartPointer<const Self>                         ConstPointer;
  typedef typename Superclass::OutputImagePointer          OutputImagePointer;

  itkNewMacro(Self);

  itkTypeMacro(MRFImageFilter,Object);

  typedef TInputImage                        InputImageType;
  typedef typename TInputImage::Pointer      InputImagePointer;
  typedef typename TInputImage::ConstPointer InputImageConstPointer;  

  typedef typename TInputImage::PixelType            InputImagePixelType;

  typedef typename TInputImage::RegionType           InputImageRegionType;

  typedef ImageRegionIterator<TInputImage>           InputImageRegionIterator;
  typedef ImageRegionConstIterator<TInputImage>      InputImageRegionConstIterator;

  itkStaticConstMacro(InputImageDimension, unsigned int,
                      TInputImage::ImageDimension);

  typedef typename TClassifiedImage::Pointer         TrainingImagePointer;

  typedef typename TClassifiedImage::PixelType       TrainingImagePixelType;

  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 ImageRegionIterator<TClassifiedImage>  
  LabelledImageRegionIterator;

  itkStaticConstMacro(ClassifiedImageDimension, unsigned int,
                      TClassifiedImage::ImageDimension);

  typedef ImageClassifierBase<TInputImage,TClassifiedImage> ClassifierType;

  typedef typename TInputImage::SizeType SizeType;

  typedef typename TInputImage::SizeType NeighborhoodRadiusType;

  typedef ConstNeighborhoodIterator< TInputImage >
  InputImageNeighborhoodIterator;

  typedef typename InputImageNeighborhoodIterator::RadiusType 
  InputImageNeighborhoodRadiusType;

  typedef NeighborhoodAlgorithm::ImageBoundaryFacesCalculator< TInputImage >
  InputImageFacesCalculator;
  
  typedef typename InputImageFacesCalculator::FaceListType
  InputImageFaceListType;

  typedef typename InputImageFaceListType::iterator 
  InputImageFaceListIterator;

  typedef NeighborhoodIterator< TClassifiedImage >
  LabelledImageNeighborhoodIterator;

  typedef typename LabelledImageNeighborhoodIterator::RadiusType 
  LabelledImageNeighborhoodRadiusType;

  typedef NeighborhoodAlgorithm::ImageBoundaryFacesCalculator< TClassifiedImage >
  LabelledImageFacesCalculator;
  
  typedef typename LabelledImageFacesCalculator::FaceListType
  LabelledImageFaceListType;

  typedef typename LabelledImageFaceListType::iterator 
  LabelledImageFaceListIterator;

  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 unsigned long );
  void SetNeighborhoodRadius( const unsigned long *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;
    }

//Enum to get the stopping condition of the MRF filter
  typedef enum{
    MaximumNumberOfIterations=1,
    ErrorTolerance
  } StopConditionType;
  
  itkGetConstReferenceMacro( StopCondition, StopConditionType );

  /* Get macro for number of iterations */
  itkGetConstReferenceMacro( NumberOfIterations, unsigned int );

#ifdef ITK_USE_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>));

#endif

protected:
  MRFImageFilter();
  ~MRFImageFilter();
  void PrintSelf(std::ostream& os, Indent indent) const;

  void Allocate();

  virtual void ApplyMRFImageFilter();  

  virtual void MinimizeFunctional();

  typedef Image<int,itkGetStaticConstMacro(InputImageDimension) > LabelStatusImageType;
  typedef typename LabelStatusImageType::IndexType    LabelStatusIndexType;
  typedef typename LabelStatusImageType::RegionType   LabelStatusRegionType;
  typedef typename LabelStatusImageType::Pointer      LabelStatusImagePointer;
  typedef ImageRegionIterator< LabelStatusImageType > LabelStatusImageIterator;

  typedef NeighborhoodIterator< LabelStatusImageType >
  LabelStatusImageNeighborhoodIterator;
  //Function implementing the neighborhood operation

  virtual void DoNeighborhoodOperation( const InputImageNeighborhoodIterator &imageIter,
                                        LabelledImageNeighborhoodIterator &labelledIter,
                                        LabelStatusImageNeighborhoodIterator &labelStatusIter );

  virtual void GenerateData();
  virtual void GenerateInputRequestedRegion();
  virtual void EnlargeOutputRequestedRegion( DataObject * );
  virtual void GenerateOutputInformation();
  
private:
  MRFImageFilter(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented
  
  typedef typename TInputImage::SizeType InputImageSizeType;

  typedef typename LabelStatusImageNeighborhoodIterator::RadiusType 
  LabelStatusImageNeighborhoodRadiusType;

  typedef NeighborhoodAlgorithm::ImageBoundaryFacesCalculator< LabelStatusImageType >
  LabelStatusImageFacesCalculator;
  
  typedef typename LabelStatusImageFacesCalculator::FaceListType
  LabelStatusImageFaceListType;

  typedef typename LabelStatusImageFaceListType::iterator 
  LabelStatusImageFaceListIterator;

  InputImageNeighborhoodRadiusType       m_InputImageNeighborhoodRadius;
  LabelledImageNeighborhoodRadiusType    m_LabelledImageNeighborhoodRadius;
  LabelStatusImageNeighborhoodRadiusType m_LabelStatusImageNeighborhoodRadius;
 
  unsigned int              m_NumberOfClasses;
  unsigned int              m_MaximumNumberOfIterations;
  unsigned int              m_KernelSize;

  int                       m_ErrorCounter;
  int                       m_NeighborhoodSize;
  int                       m_TotalNumberOfValidPixelsInOutputImage;
  int                       m_TotalNumberOfPixelsInInputImage;
  double                    m_ErrorTolerance;  
  double                    m_SmoothingFactor;
  double                   *m_ClassProbability; //Class liklihood
  unsigned int              m_NumberOfIterations;
  StopConditionType         m_StopCondition;

  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.txx"
#endif

#endif

---