itkKLMRegionGrowImageFilter.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef __itkKLMRegionGrowImageFilter_h
#define __itkKLMRegionGrowImageFilter_h

#include "itkImage.h"
#include "itkRegionGrowImageFilter.h"
#include "itkKLMSegmentationBorder.h"
#include "itkImageRegionIterator.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 defined(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.hxx"
#endif

#endif