itkRGBGibbsPriorFilter.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkRGBGibbsPriorFilter.h,v $
  Language:  C++
  Date:      $Date: 2009-01-26 21:45:56 $
  Version:   $Revision: 1.30 $

  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;

  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;

  typename ClassifierType::Pointer m_ClassifierPtr;

  unsigned int      m_ImageHeight;
  unsigned int      m_ImageDepth;

  void  GibbsTotalEnergy(int i); 

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

  double m_ObjectThreshold;

};

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