itkKLMRegionGrowImageFilter.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkKLMRegionGrowImageFilter.h,v $
  Language:  C++
  Date:      $Date: 2009-01-24 20:02:57 $
  Version:   $Revision: 1.45 $

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

#include "itkImage.h"
#include "itkObject.h"
#include "itkImageToImageFilter.h"
#include "itkRegionGrowImageFilter.h"
#include "itkKLMSegmentationRegion.h"
#include "itkKLMSegmentationBorder.h"
#include "itkImageRegionIterator.h"
#include "itkImageRegionConstIterator.h"
#include "itkConceptChecking.h"
#include <algorithm>
#include <functional>

namespace itk
{

template <class TInputImage, class TOutputImage>
class ITK_EXPORT KLMRegionGrowImageFilter : public RegionGrowImageFilter<TInputImage,TOutputImage>
{
public:
  typedef KLMRegionGrowImageFilter                           Self;
  typedef RegionGrowImageFilter< TInputImage, TOutputImage > Superclass;
  typedef SmartPointer< Self >                               Pointer;
  typedef SmartPointer< const Self >                         ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(KLMRegionGrowImageFilter, RegionGrowImageFilter);

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

  typedef typename TInputImage::PixelType       InputImagePixelType;

  typedef typename TInputImage::PixelType::VectorType InputImageVectorType;

  itkStaticConstMacro(InputImageVectorDimension, unsigned int,
                      InputImagePixelType::Dimension);

  typedef typename TInputImage::IndexType       InputImageIndexType;

  typedef ImageRegionIterator< TInputImage >      InputImageIterator;
  typedef ImageRegionConstIterator< TInputImage > InputImageConstIterator;

  typedef typename TInputImage::RegionType      InputRegionType;

  typedef typename Superclass::GridSizeType     GridSizeType;

  typedef TOutputImage                          OutputImageType;
  typedef typename TOutputImage::Pointer        OutputImagePointer;

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

  itkStaticConstMacro(OutputImageDimension, unsigned int,
                      TOutputImage::ImageDimension);

  typedef typename TOutputImage::PixelType      OutputImagePixelType;

  typedef typename TOutputImage::PixelType::VectorType OutputImageVectorType;

  itkStaticConstMacro(OutputImageVectorDimension, unsigned int,
                      OutputImagePixelType::Dimension);

  typedef typename TOutputImage::IndexType      OutputImageIndexType;

  typedef ImageRegionIterator< TOutputImage >   OutputImageIterator;

  typedef typename KLMSegmentationRegion::RegionLabelType RegionLabelType;

  itkStaticConstMacro(LabelImageDimension, RegionLabelType,
                      InputImageDimension);

  typedef Image< RegionLabelType, itkGetStaticConstMacro(LabelImageDimension) > LabelImageType;

  typedef typename LabelImageType::Pointer      LabelImagePointer;

  typedef typename LabelImageType::PixelType    LabelImagePixelType;

  typedef typename LabelImageType::IndexType    LabelImageIndexType;

  typedef ImageRegionIterator< LabelImageType > LabelImageIterator;

  typedef vnl_vector< double > MeanRegionIntensityType;

  typedef KLMSegmentationBorder                 BorderType;

  typedef KLMDynamicBorderArray< BorderType >   KLMSegmentationBorderArrayPtr;

  itkSetMacro(MaximumLambda, double);
  itkGetConstReferenceMacro(MaximumLambda, double);

  itkSetMacro(NumberOfRegions, unsigned int);
  itkGetConstReferenceMacro(NumberOfRegions, unsigned int);

  LabelImagePointer GetLabelledImage(void);

  void PrintAlgorithmRegionStats(void);

  void PrintAlgorithmBorderStats(void);

#ifdef ITK_USE_CONCEPT_CHECKING

  itkConceptMacro(InputHasNumericTraitsCheck,
    (Concept::HasNumericTraits<typename InputImagePixelType::ValueType>));
  itkConceptMacro(SameDimension,
    (Concept::SameDimension<itkGetStaticConstMacro(InputImageDimension),
                            itkGetStaticConstMacro(OutputImageDimension)>));
#if THIS_CONCEPT_FAILS_ON_GCC

  itkConceptMacro(SameVectorDimension,
    (Concept::SameDimension<itkGetStaticConstMacro(InputImageVectorDimension),
                            itkGetStaticConstMacro(OutputImageVectorDimension)>));
#endif

#endif

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

  virtual void GenerateData();

  virtual void GenerateInputRequestedRegion();

  virtual void EnlargeOutputRequestedRegion( DataObject * );

  void ApplyRegionGrowImageFilter();

  virtual void MergeRegions();

  virtual void GenerateOutputImage();

  void ApplyKLM();

  void InitializeKLM();

  LabelImagePointer GenerateLabelledImage( LabelImageType *labelImagePtr );

  virtual void InitializeRegionParameters( InputRegionType region );

  virtual void ResolveRegions();

private:
  KLMRegionGrowImageFilter(const Self&); // purposely not implemented
  void operator=(const Self&); // purposely not implemented

  typedef typename TInputImage::SizeType           InputImageSizeType;
  typedef typename KLMSegmentationRegion::Pointer  KLMSegmentationRegionPtr;
  typedef typename KLMSegmentationBorder::Pointer  KLMSegmentationBorderPtr;

  double                  m_MaximumLambda;
  unsigned int            m_NumberOfRegions;

  double                  m_InternalLambda;
  unsigned int            m_InitialNumberOfRegions;
  double                  m_TotalBorderLength;

  std::vector< KLMSegmentationRegionPtr >       m_RegionsPointer;
  std::vector< KLMSegmentationBorderPtr >       m_BordersPointer;
  std::vector< KLMSegmentationBorderArrayPtr >  m_BordersDynamicPointer;
  KLMSegmentationBorderArrayPtr                *m_BorderCandidate;

  MeanRegionIntensityType          m_InitialRegionMean;
  double                           m_InitialRegionArea;

}; // class KLMRegionGrowImageFilter

} // namespace itk

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


#endif