itkKLMRegionGrowImageFilter.h

Go to the documentation of this file.

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

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

  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 <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;

  typedef typename TInputImage::IndexType       InputImageIndexType;

  typedef typename TInputImage::OffsetType      InputImageOffsetType;

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

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

  typedef typename TOutputImage::PixelType      OutputImagePixelType;

  typedef typename TOutputImage::IndexType       OutputImageIndexType;

  typedef typename TOutputImage::OffsetType      OutputImageOffsetType;

  typedef ImageRegionIterator< TOutputImage >   OutputImageIterator;

  typedef typename TOutputImage::PixelType::VectorType OutputImageVectorType;

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

  typedef Image<unsigned short,itkGetStaticConstMacro(LabelImageDimension)> LabelImageType;

  typedef typename LabelImageType::Pointer LabelImagePointer;

  typedef typename LabelImageType::PixelType    LabelImagePixelType;

  typedef typename LabelImageType::IndexType       LabelImageIndexType;

  typedef typename LabelImageType::OffsetType      LabelImageOffsetType;

  typedef ImageRegionIterator< LabelImageType >  LabelImageIterator;

  typedef vnl_matrix<double> VecDblType;

  typedef KLMSegmentationBorder    BorderType;

  typedef KLMDynamicBorderArray<BorderType>  SegmentationBorderPtr;

  itkSetMacro(MaxLambda, unsigned int);

  itkGetMacro(MaxLambda, unsigned int);


  LabelImagePointer GetLabelledImage(void);

  void PrintAlgorithmRegionStats(void);

  void PrintAlgorithmBorderStats(void);

  void PrintAlgorithmBorderStats(bool smartBorderPointerUseFlag);

  virtual void CalculateInitRegionStats( int   regionRowIndex, 
                                         int   regionColIndex, 
                                         int   regionRowGridSize,
                                         int   regionColGridSize );
  
  virtual void CalculateInitRegionStats( int   regionRowIndex, 
                                         int   regionColIndex,
                                         int   regionSliceIndex,
                                         int   regionRowGridSize,
                                         int   regionColGridSize,
                                         int   regionSliceGridSize );

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

  virtual void GenerateData();
  virtual void GenerateInputRequestedRegion();
  virtual void EnlargeOutputRequestedRegion( DataObject * );
  virtual void GenerateOutputInformation();

  void ApplyRegionGrowImageFilter();

  virtual void MergeRegions();

  void GenerateOutputImage(unsigned int imgWidth,
                           unsigned int imgHeight);

  void GenerateOutputImage(unsigned int imgWidth,
                           unsigned int imgHeight,
                           unsigned int imgDepth);


  void ApplyKLM();

  void InitializeKLM(unsigned int imgWidth, 
                     unsigned int imgHeight);

  void InitializeKLM(unsigned int imgWidth,
                     unsigned int imgHeight,
                     unsigned int imgDepth );

  LabelImagePointer localfn_generate_labeled2Dimage(
    LabelImageType *labelImagePtr );

  LabelImagePointer localfn_generate_labeled3Dimage(
    LabelImageType *labelImagePtr );

private:
  KLMRegionGrowImageFilter(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented
  
  typedef typename TInputImage::SizeType InputImageSize;
  typedef typename KLMSegmentationRegion::Pointer  KLMSegmentationRegionPtr;

  typedef typename KLMSegmentationBorder::Pointer  KLMSegmentationBorderPtr;

  typedef std::vector< SegmentationBorderPtr > BordersDynamicPointerType;

  typedef BordersDynamicPointerType::iterator BordersDynamicPointerIterator;


  unsigned int     m_MaxLambda;
  unsigned int     m_NumberOfBorders;
  unsigned int     m_NumRegions;
  unsigned int     m_InitRegionArea;
  SegmentationBorderPtr *m_BordersCandidateDynamicPointer;
  SegmentationBorder *m_BordersCandidatePointer;
  unsigned int     m_ImgWidth;
  unsigned int     m_ImgHeight;
  unsigned int     m_ImgDepth;

  unsigned int     m_TotalBorderLength;
  double           m_RegionLambda;

  VecDblType       m_InitRegionMean;


  std::vector< KLMSegmentationRegionPtr >      m_RegionsPointer;
  std::vector< KLMSegmentationBorderPtr >      m_BordersPointer;
  std::vector< SegmentationBorderPtr >         m_BordersDynamicPointer;


  void UnionBorders(KLMSegmentationRegion *pRegion1,
                    KLMSegmentationRegion *pRegion2);
  
  void UpdateBordersDynamicPointer();

  void ResolveRegionLabels(unsigned int imgWidth, 
                           unsigned int imgHeight);

  void ResolveRegionLabels(unsigned int imgWidth, 
                           unsigned int imgHeight,
                           unsigned int imgDepth);
                                    
}; // class KLMRegionGrowImageFilter

} // namespace itk

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



#endif

---