itkRGBGibbsPriorFilter.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkRGBGibbsPriorFilter.h,v $
  Language:  C++
  Date:      $Date: 2003/09/10 14:28:37 $
  Version:   $Revision: 1.29 $

  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 __itkRGBGibbsPriorFilter_h
#define __itkRGBGibbsPriorFilter_h

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

#include "itkImageToImageFilter.h"
#include "itkImageClassifierBase.h"
#include "itkImageRegionIterator.h"
#include "itkMRFImageFilter.h"

namespace itk
{

template <class TInputImage, class TClassifiedImage>
class ITK_EXPORT RGBGibbsPriorFilter : public MRFImageFilter<TInputImage, 
                                                             TClassifiedImage>
{
public:
  typedef RGBGibbsPriorFilter  Self;

  typedef MRFImageFilter<TInputImage, TClassifiedImage> Superclass;

  typedef SmartPointer<Self>  Pointer;
  typedef SmartPointer<const Self>  ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(RGBGibbsPriorFilter,MRFImageFilter);

  typedef typename Superclass::InputImagePixelType InputImagePixelType;
  typedef typename Superclass::InputImageRegionConstIterator InputImageRegionConstIterator;
  typedef typename Superclass::InputImageRegionIterator InputImageRegionIterator;
  typedef typename Superclass::LabelledImageRegionIterator LabelledImageRegionIterator;
  typedef typename Superclass::LabelledImagePixelType LabelledImagePixelType;
  typedef typename Superclass::IndexValueType IndexValueType;
  
  typedef TInputImage                                InputImageType;  
  typedef typename TInputImage::Pointer              InputImagePointer;  
  typedef typename TInputImage::ConstPointer         InputImageConstPointer;  

  typedef typename TInputImage::PixelType            InputPixelType;

  typedef typename TClassifiedImage::Pointer         TrainingImageType;

  typedef typename TClassifiedImage::Pointer         LabelledImageType;
     
  typedef typename TClassifiedImage::IndexType       LabelledImageIndexType;

  typedef unsigned int                               LabelType;

  typedef ImageClassifierBase<TInputImage,TClassifiedImage> ClassifierType;

  typedef typename TInputImage::PixelType    InputImageVecType;
  typedef typename TInputImage::IndexType    IndexType;

  void SetTrainingImage(TrainingImageType image);

  void SetLabelledImage(LabelledImageType LabelledImage);

  LabelledImageType GetLabelledImage()
  { return m_LabelledImage; }

  void SetClassifier( typename ClassifierType::Pointer ptrToClassifier );

  itkSetMacro(NumberOfClasses, unsigned int);

  itkGetMacro(NumberOfClasses, unsigned int);

  itkSetMacro(MaximumNumberOfIterations, unsigned int);

  itkGetMacro(MaximumNumberOfIterations, unsigned int);

  itkSetMacro(ClusterSize, unsigned int);

  itkSetMacro( ObjectLabel, LabelType );

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

  itkSetMacro(StartPoint, IndexType); 

  itkSetMacro(BoundaryGradient, unsigned int);

  itkSetMacro(ObjectThreshold, double);

  itkSetMacro(CliqueWeight_1, double);
  itkGetMacro(CliqueWeight_1, double);
  itkSetMacro(CliqueWeight_2, double);
  itkGetMacro(CliqueWeight_2, double);
  itkSetMacro(CliqueWeight_3, double);
  itkGetMacro(CliqueWeight_3, double);
  itkSetMacro(CliqueWeight_4, double);
  itkGetMacro(CliqueWeight_4, double);
  itkSetMacro(CliqueWeight_5, double);
  itkGetMacro(CliqueWeight_5, double);
  itkSetMacro(CliqueWeight_6, double);
  itkGetMacro(CliqueWeight_6, double);


  typedef vnl_matrix<double> MatrixType; 

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

  void Allocate(); 
  virtual void MinimizeFunctional();
  virtual void GenerateData();
  virtual void ApplyGibbsLabeller();
  virtual void ApplyGPImageFilter();


private:
  RGBGibbsPriorFilter(const Self&); 
  void operator=(const Self&); 
  
  typedef typename TInputImage::SizeType InputImageSizeType;

  InputImageConstPointer  m_InputImage;    
  TrainingImageType       m_TrainingImage; 
  LabelledImageType       m_LabelledImage; 
  unsigned int        m_NumberOfClasses; 
  unsigned int        m_MaximumNumberOfIterations; 
  typename ClassifierType::Pointer m_ClassifierPtr;
  unsigned int      m_BoundaryGradient; 
  double            m_BoundaryWeight; 
  double            m_GibbsPriorWeight; 
  int               m_StartRadius;  
  int               m_RecursiveNumber;     
  LabelType       * m_LabelStatus; 
  InputImagePointer  m_MediumImage;   
  unsigned int      m_Temp;         
  IndexType m_StartPoint; 
  unsigned int      m_ImageWidth; 
  unsigned int      m_ImageHeight;
  unsigned int      m_ImageDepth;
  unsigned int      m_ClusterSize; 
  LabelType         m_ObjectLabel; 
  unsigned int      m_VecDim;      
  InputPixelType    m_LowPoint;  
  unsigned short    *m_Region;   
  unsigned short    *m_RegionCount;  
  double m_CliqueWeight_1;  
  double m_CliqueWeight_2;  
  double m_CliqueWeight_3;  
  double m_CliqueWeight_4;  
  double m_CliqueWeight_5;  
  double m_CliqueWeight_6;  
  void  GibbsTotalEnergy(int i); 

  double GibbsEnergy(unsigned int i, unsigned int k, unsigned int k1); 

  int Sim(int a, int b);         
  unsigned int LabelRegion(int i, int l, int change);  
  void  RegionEraser();                       
  void  GenerateMediumImage();                
  void  GreyScalarBoundary(LabelledImageIndexType Index3D); 
  double m_ObjectThreshold;

};

} // end namespace itk
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkRGBGibbsPriorFilter.txx"
#endif
#endif

---