itkOptGrayscaleErodeImageFilter.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkOptGrayscaleErodeImageFilter.h,v $
  Language:  C++
  Date:      $Date: 2009-04-23 03:43:42 $
  Version:   $Revision: 1.6 $

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

#include "itkKernelImageFilter.h"
#include "itkMovingHistogramErodeImageFilter.h"
#include "itkBasicErodeImageFilter.h"
#include "itkAnchorErodeImageFilter.h"
#include "itkVanHerkGilWermanErodeImageFilter.h"
#include "itkCastImageFilter.h"
#include "itkConstantBoundaryCondition.h"
#include "itkFlatStructuringElement.h"
#include "itkNeighborhood.h"

namespace itk {

template<class TInputImage, class TOutputImage, class TKernel>
class ITK_EXPORT GrayscaleErodeImageFilter : 
    public KernelImageFilter<TInputImage, TOutputImage, TKernel>
{
public:
  typedef GrayscaleErodeImageFilter                             Self;
  typedef KernelImageFilter<TInputImage,TOutputImage, TKernel>  Superclass;
  typedef SmartPointer<Self>                                    Pointer;
  typedef SmartPointer<const Self>                              ConstPointer;

  itkNewMacro(Self);  

  itkTypeMacro(GrayscaleErodeImageFilter, 
               KernelImageFilter);

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

  typedef TInputImage                                           InputImageType;
  typedef TOutputImage                                          OutputImageType;
  typedef typename TInputImage::RegionType                      RegionType;
  typedef typename TInputImage::SizeType                        SizeType;
  typedef typename TInputImage::IndexType                       IndexType;
  typedef typename TInputImage::PixelType                       PixelType;
  typedef typename TInputImage::OffsetType                      OffsetType;
  typedef typename Superclass::OutputImageRegionType            OutputImageRegionType;

  typedef MovingHistogramErodeImageFilter< TInputImage, TOutputImage, TKernel > 
                                                                HistogramFilterType;
  typedef BasicErodeImageFilter< TInputImage, TOutputImage, TKernel >
                                                                BasicFilterType;

  typedef FlatStructuringElement< itkGetStaticConstMacro(ImageDimension) >              FlatKernelType;

  typedef AnchorErodeImageFilter< TInputImage, FlatKernelType > AnchorFilterType;
  typedef VanHerkGilWermanErodeImageFilter< TInputImage, FlatKernelType > 
                                                                VHGWFilterType;
  typedef CastImageFilter< TInputImage, TOutputImage >          CastFilterType;
  
  typedef ImageBoundaryCondition<InputImageType> *ImageBoundaryConditionPointerType;
  typedef ImageBoundaryCondition<InputImageType> const *ImageBoundaryConditionConstPointerType;
  typedef ConstantBoundaryCondition<InputImageType> DefaultBoundaryConditionType;


  typedef TKernel KernelType;
//   typedef typename KernelType::Superclass KernelSuperClass;
//   typedef Neighborhood< typename KernelType::PixelType, ImageDimension > KernelSuperClass;

  void SetKernel( const KernelType& kernel );

  void SetBoundary( const PixelType value );
  itkGetConstMacro(Boundary, PixelType);

  void SetAlgorithm(int algo );
  itkGetConstMacro(Algorithm, int);

  virtual void Modified() const;

  void OverrideBoundaryCondition(const DefaultBoundaryConditionType* i)
    {
    itkLegacyBodyMacro(GrayscaleErodeImageFilter::OverrideBoundaryCondition, 2.8);
    SetBoundary( i->GetConstant() );
    }

  const DefaultBoundaryConditionType* GetBoundaryCondition()
    {
    itkLegacyBodyMacro(GrayscaleErodeImageFilter::GetBoundaryCondition, 2.8);
    return &m_BoundaryCondition;
    }

  void ResetBoundaryCondition()
    {
    itkLegacyBodyMacro(GrayscaleErodeImageFilter::ResetBoundaryCondition, 2.8);
    SetBoundary( NumericTraits< PixelType >::NonpositiveMin() );
    }

  enum {
    BASIC = 0,
    HISTO = 1,
    ANCHOR = 2,
    VHGW = 3
  } AlgorithmChoice;

  void SetNumberOfThreads( int nb );


protected:
  GrayscaleErodeImageFilter();
  ~GrayscaleErodeImageFilter() {};
  void PrintSelf(std::ostream& os, Indent indent) const;
  
  void GenerateData();

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

  PixelType m_Boundary;

  // the filters used internally
  typename HistogramFilterType::Pointer m_HistogramFilter;
  typename BasicFilterType::Pointer     m_BasicFilter;
  typename AnchorFilterType::Pointer    m_AnchorFilter;
  typename VHGWFilterType::Pointer      m_VHGWFilter;

  // and the name of the filter
  int m_Algorithm;

  // the boundary condition need to be stored here
  DefaultBoundaryConditionType m_BoundaryCondition;
  
}; // end of class

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

#endif