Implementation of a labeller object that uses Markov Random Fields to classify pixels in an image data set. More...

#include <itkMRFImageFilter.h>

Inheritance diagram for itk::MRFImageFilter< TInputImage, TClassifiedImage >:

Collaboration diagram for itk::MRFImageFilter< TInputImage, TClassifiedImage >:

Public Types
typedef ImageClassifierBase < TInputImage, TClassifiedImage >	ClassifierType
typedef SmartPointer< const Self >	ConstPointer
typedef LabelledImageIndexType::IndexValueType	IndexValueType
typedef TInputImage::ConstPointer	InputImageConstPointer
typedef InputImageFaceListType::iterator	InputImageFaceListIterator
typedef InputImageFacesCalculator::FaceListType	InputImageFaceListType
typedef NeighborhoodAlgorithm::ImageBoundaryFacesCalculator < TInputImage >	InputImageFacesCalculator
typedef ConstNeighborhoodIterator < TInputImage >	InputImageNeighborhoodIterator
typedef InputImageNeighborhoodIterator::RadiusType	InputImageNeighborhoodRadiusType
typedef TInputImage::PixelType	InputImagePixelType
typedef TInputImage::Pointer	InputImagePointer
typedef ImageRegionConstIterator < TInputImage >	InputImageRegionConstIterator
typedef ImageRegionIterator < TInputImage >	InputImageRegionIterator
typedef TInputImage::RegionType	InputImageRegionType
typedef TInputImage	InputImageType
typedef LabelledImageFaceListType::iterator	LabelledImageFaceListIterator
typedef LabelledImageFacesCalculator::FaceListType	LabelledImageFaceListType
typedef NeighborhoodAlgorithm::ImageBoundaryFacesCalculator < TClassifiedImage >	LabelledImageFacesCalculator
typedef TClassifiedImage::IndexType	LabelledImageIndexType
typedef NeighborhoodIterator < TClassifiedImage >	LabelledImageNeighborhoodIterator
typedef LabelledImageNeighborhoodIterator::RadiusType	LabelledImageNeighborhoodRadiusType
typedef TClassifiedImage::OffsetType	LabelledImageOffsetType
typedef TClassifiedImage::PixelType	LabelledImagePixelType
typedef TClassifiedImage::Pointer	LabelledImagePointer
typedef ImageRegionIterator < TClassifiedImage >	LabelledImageRegionIterator
typedef TClassifiedImage::RegionType	LabelledImageRegionType
typedef TInputImage::SizeType	NeighborhoodRadiusType
typedef Superclass::OutputImagePointer	OutputImagePointer
typedef SmartPointer< Self >	Pointer
typedef MRFImageFilter	Self
typedef TInputImage::SizeType	SizeType
enum	StopConditionType { MaximumNumberOfIterations = 1, ErrorTolerance }
typedef ImageToImageFilter < TInputImage, TClassifiedImage >	Superclass
typedef TClassifiedImage::PixelType	TrainingImagePixelType
typedef TClassifiedImage::Pointer	TrainingImagePointer
Public Member Functions
virtual ::itk::LightObject::Pointer	CreateAnother (void) const
virtual std::vector< double >	GetMRFNeighborhoodWeight ()
virtual const char *	GetNameOfClass () const
const NeighborhoodRadiusType	GetNeighborhoodRadius () const
virtual const unsigned int &	GetNumberOfIterations ()
virtual const StopConditionType &	GetStopCondition ()
void	SetClassifier (typename ClassifierType::Pointer ptrToClassifier)
virtual void	SetMRFNeighborhoodWeight (std::vector< double > BetaMatrix)
void	SetNeighborhoodRadius (const NeighborhoodRadiusType &)
void	SetNeighborhoodRadius (const SizeValueType)
void	SetNeighborhoodRadius (const SizeValueType *radiusArray)
	typedef (Concept::Convertible< int, LabelledImagePixelType >) IntConvertibleToClassifiedCheck
	typedef (Concept::SameDimension< InputImageDimension, ClassifiedImageDimension >) SameDimensionCheck
	typedef (Concept::Convertible< LabelledImagePixelType, unsigned int >) ClassifiedConvertibleToUnsignedIntCheck
	typedef (Concept::Convertible< LabelledImagePixelType, int >) ClassifiedConvertibleToIntCheck
	typedef (Concept::Convertible< unsigned int, LabelledImagePixelType >) UnsignedIntConvertibleToClassifiedCheck

virtual void	SetNumberOfClasses (unsigned int _arg)
virtual unsigned int	GetNumberOfClasses () const

virtual void	SetMaximumNumberOfIterations (unsigned int _arg)
virtual unsigned int	GetMaximumNumberOfIterations () const

virtual void	SetErrorTolerance (double _arg)
virtual double	GetErrorTolerance () const

virtual void	SetSmoothingFactor (double _arg)
virtual double	GetSmoothingFactor () const
Static Public Member Functions
static Pointer	New ()
Static Public Attributes
static const unsigned int	ClassifiedImageDimension = TClassifiedImage::ImageDimension
static const unsigned int	InputImageDimension = TInputImage::ImageDimension
Protected Types
typedef ImageRegionIterator < LabelStatusImageType >	LabelStatusImageIterator
typedef NeighborhoodIterator < LabelStatusImageType >	LabelStatusImageNeighborhoodIterator
typedef LabelStatusImageType::Pointer	LabelStatusImagePointer
typedef Image< int, itkGetStaticConstMacro(InputImageDimension) >	LabelStatusImageType
typedef LabelStatusImageType::IndexType	LabelStatusIndexType
typedef LabelStatusImageType::RegionType	LabelStatusRegionType
Protected Member Functions
void	Allocate ()
virtual void	ApplyMRFImageFilter ()
virtual void	DoNeighborhoodOperation (const InputImageNeighborhoodIterator &imageIter, LabelledImageNeighborhoodIterator &labelledIter, LabelStatusImageNeighborhoodIterator &labelStatusIter)
virtual void	EnlargeOutputRequestedRegion (DataObject *)
virtual void	GenerateData ()
virtual void	GenerateInputRequestedRegion ()
virtual void	GenerateOutputInformation ()
virtual void	MinimizeFunctional ()

	MRFImageFilter ()
	~MRFImageFilter ()
void	PrintSelf (std::ostream &os, Indent indent) const
Private Types
typedef TInputImage::SizeType	InputImageSizeType
typedef LabelStatusImageFaceListType::iterator	LabelStatusImageFaceListIterator
typedef LabelStatusImageFacesCalculator::FaceListType	LabelStatusImageFaceListType
typedef NeighborhoodAlgorithm::ImageBoundaryFacesCalculator < LabelStatusImageType >	LabelStatusImageFacesCalculator
typedef LabelStatusImageNeighborhoodIterator::RadiusType	LabelStatusImageNeighborhoodRadiusType
Private Member Functions
void	ApplyICMLabeller ()
	MRFImageFilter (const Self &)
void	operator= (const Self &)
virtual void	SetDefaultMRFNeighborhoodWeight ()
Private Attributes
ClassifierType::Pointer	m_ClassifierPtr
double *	m_ClassProbability
std::vector< double >	m_DummyVector
int	m_ErrorCounter
double	m_ErrorTolerance
InputImageNeighborhoodRadiusType	m_InputImageNeighborhoodRadius
unsigned int	m_KernelSize
LabelledImageNeighborhoodRadiusType	m_LabelledImageNeighborhoodRadius
LabelStatusImagePointer	m_LabelStatusImage
LabelStatusImageNeighborhoodRadiusType	m_LabelStatusImageNeighborhoodRadius
std::vector< double >	m_MahalanobisDistance
unsigned int	m_MaximumNumberOfIterations
std::vector< double >	m_MRFNeighborhoodWeight
int	m_NeighborhoodSize
std::vector< double >	m_NeighborInfluence
unsigned int	m_NumberOfClasses
unsigned int	m_NumberOfIterations
double	m_SmoothingFactor
StopConditionType	m_StopCondition
int	m_TotalNumberOfPixelsInInputImage
int	m_TotalNumberOfValidPixelsInOutputImage

Detailed Description

template<class TInputImage, class TClassifiedImage>
class itk::MRFImageFilter< TInputImage, TClassifiedImage >

Implementation of a labeller object that uses Markov Random Fields to classify pixels in an image data set.

This object classifies pixels based on a Markov Random Field (MRF) model. This implementation uses the maximum a posteriori (MAP) estimates for modeling the MRF. The object traverses the data set and uses the model generated by the Mahalanobis distance classifier to get the distance between each pixel in the data set to a set of known classes, updates the distances by evaluating the influence of its neighboring pixels (based on a MRF model) and finally, classifies each pixel to the class which has the minimum distance to that pixel (taking the neighborhood influence under consideration). DoNeighborhoodOperation is the function that can be modified to achieve different falvors of MRF filters in derived classes.

The classified initial labeled image is needed. It is important that the number of expected classes be set before calling the classifier. In our case we have used the ImageClassifer using a Gaussian model to generate the initial labels. This classifier requires the user to ensure that an appropriate membership function is provided. See the documentation of the image classifier class for more information.

The influence of a neighborhood on a given pixel's classification (the MRF term) is computed by calculating a weighted sum of number of class labels in a three dimensional neighborhood. The basic idea of this neighborhood influence is that if a large number of neighbors of a pixel are of one class, then the current pixel is likely to be of the same class.

The dimensions of the neighborhood are the same as the input image dimensions, and values of the weighting parameters are either specified by the user or through the beta matrix parameter. The default weighting table is generated during object construction. The following table shows an example of a 3 x 3 x 3 neighborhood and the weighting values used. A 3 x 3 x 3 kernel is used where each value is a nonnegative parameter, which encourages neighbors to be of the same class. In this example, the influence of the pixels in the same slice is assigned a weight 1.7. The influence of the pixels in the same location in the previous and next slice is assigned a weight 1.5. A weight of 1.3 is assigned to the influence of the north, south, east, west, and diagonal pixels in the previous and next slices.

$\begin{tabular}{ccc} \begin{tabular}{|c|c|c|} 1.3 & 1.3 & 1.3 \\ 1.3 & 1.5 & 1.3 \\ 1.3 & 1.3 & 1.3 \\ \end{tabular} & \begin{tabular}{|c|c|c|} 1.7 & 1.7 & 1.7 \\ 1.7 & 0 & 1.7 \\ 1.7 & 1.7 & 1.7 \\ \end{tabular} & \begin{tabular}{|c|c|c|} 1.3 & 1.3 & 1.3 \\ 1.5 & 1.5 & 1.3 \\ 1.3 & 1.3 & 1.3 \\ \end{tabular} \\ \end{tabular}$

The user needs to set the neighborhood size using the SetNeighborhoodRadius function. The details on the semantics of a neighborhood can be found in the documentation associated with the itkNeighborhood and related objects. NOTE: The size of the neighborhood must match the size of the neighborhood weighting parameters set by the user.

For minimization of the MRF labeling function the MinimizeFunctional virtual method is called. For our current implementation we use the iterated conditional modes (ICM) algorithm described by Besag in the paper ``On the Statistical Analysis of Dirty Pictures'' in J. Royal Stat. Soc. B, Vol. 48, 1986.

In each iteration, the algorithm visits each pixel in turn and determines whether to update its classification by computing the influence of the classification of the pixel's neighbors and of the intensity data. On each iteration after the first, we reexamine the classification of a pixel only if the classification of some of its neighbors has changed in the previous iteration. The pixels' classification is updated using a synchronous scheme (iteration by iteration) until the error reaches less than the threshold or the number of iteration exceed the maximum set number of iterations. Note: The current implementation supports betaMatrix default weight for two and three dimensional images only. The default for higher dimension is set to unity. This should be overridden by custom weights after filter initialization.

See also:: Neighborhood; ImageIterator; NeighborhoodIterator; Classifier

Definition at line 125 of file itkMRFImageFilter.h.