itkMRFImageFilter.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkMRFImageFilter.h,v $
  Language:  C++
  Date:      $Date: 2002/12/17 17:50:35 $
  Version:   $Revision: 1.35 $

  Copyright (c) 2002 Insight 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);
  itkGetMacro(NumberOfClasses, unsigned int);

  itkSetMacro(MaximumNumberOfIterations, unsigned int);
  itkGetMacro(MaximumNumberOfIterations, unsigned int);

  itkSetMacro(ErrorTolerance, double);
  itkGetMacro(ErrorTolerance, double);

  itkSetMacro(SmoothingFactor, double);
  itkGetMacro(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;
    }
    
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

  LabelStatusImagePointer   m_LabelStatusImage;

  std::vector<double>       m_MRFNeighborhoodWeight;
  std::vector<double>       m_NeighborInfluence;
  std::vector<double>       m_MahalanobisDistance;

 typename ClassifierType::Pointer m_ClassifierPtr;


  virtual void SetMRFNeighborhoodWeight( double* );

  //Function implementing the ICM algorithm to label the images
  void ApplyICMLabeller();


}; // class MRFImageFilter


} // namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkMRFImageFilter.txx"
#endif



#endif

---