text: /*=========================================================================
  
    Program:   Insight Segmentation & Registration Toolkit
    Module:    itkGrayscaleDilateImageFilter.h
    Language:  C++
    Date:      $Date$
    Version:   $Revision$
  
    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 __itkGrayscaleDilateImageFilter_h
  #define __itkGrayscaleDilateImageFilter_h
  
  // First make sure that the configuration is available.
  // This line can be removed once the optimized versions
  // gets integrated into the main directories.
  #include "itkConfigure.h"
  
  #ifdef ITK_USE_CONSOLIDATED_MORPHOLOGY
  #include "itkOptGrayscaleDilateImageFilter.h"
  #else
  
  
  #include "itkMorphologyImageFilter.h"
  
  namespace itk {
  
  /**
   * \class GrayscaleDilateImageFilter
   * \brief gray scale dilation of an image
   *
   * Dilate an image using grayscale morphology. Dilation takes the
   * maximum of all the pixels identified by the structuring element.
   *
   * The structuring element is assumed to be composed of binary
   * values (zero or one). Only elements of the structuring element
   * having values > 0 are candidates for affecting the center pixel.
   * 
   * For the each input image pixel, 
   *   - NeighborhoodIterator gives neighbors of the pixel. 
   *   - Evaluate() member function returns the maximum value among 
   *     the image neighbors where the kernel has elements > 0.
   *   - Replace the original value with the max value
   *
   * \sa MorphologyImageFilter, GrayscaleFunctionDilateImageFilter, BinaryDilateImageFilter
   * \ingroup ImageEnhancement  MathematicalMorphologyImageFilters
   */
  
  template<class TInputImage, class TOutputImage, class TKernel>
  class ITK_EXPORT GrayscaleDilateImageFilter : 
      public MorphologyImageFilter<TInputImage, TOutputImage, TKernel>
  {
  public:
    /** Standard class typedefs. */
    typedef GrayscaleDilateImageFilter Self;
    typedef MorphologyImageFilter<TInputImage, TOutputImage, TKernel>
                                       Superclass;
    typedef SmartPointer<Self>         Pointer;
    typedef SmartPointer<const Self>   ConstPointer;
    
    /** Standard New method. */
    itkNewMacro(Self);  
  
    /** Runtime information support. */
    itkTypeMacro(GrayscaleDilateImageFilter, 
                 MorphologyImageFilter);
    
    /** Declaration of pixel type. */
    typedef typename Superclass::PixelType PixelType;
  
    /** Kernel (structuring element) iterator. */
    typedef typename Superclass::KernelIteratorType  KernelIteratorType;
  
    /** Neighborhood iterator type. */
    typedef typename Superclass::NeighborhoodIteratorType NeighborhoodIteratorType;
  
    /** Kernel typedef. */
    typedef typename Superclass::KernelType KernelType;
  
    /** Default boundary condition type */
    typedef typename Superclass::DefaultBoundaryConditionType DefaultBoundaryConditionType;
  
    /** ImageDimension constants */
    itkStaticConstMacro(InputImageDimension, unsigned int,
                        TInputImage::ImageDimension);
    itkStaticConstMacro(OutputImageDimension, unsigned int,
                        TOutputImage::ImageDimension);
    itkStaticConstMacro(KernelDimension, unsigned int,
                        TKernel::NeighborhoodDimension);
  
    /** Type of the pixels in the Kernel. */
    typedef typename TKernel::PixelType            KernelPixelType;
  
  #ifdef ITK_USE_CONCEPT_CHECKING
    /** Begin concept checking */
    itkConceptMacro(InputConvertibleToOutputCheck,
      (Concept::Convertible<PixelType, typename TOutputImage::PixelType>));
    itkConceptMacro(SameDimensionCheck1,
       (Concept::SameDimension<InputImageDimension, OutputImageDimension>));
    itkConceptMacro(SameDimensionCheck2,
      (Concept::SameDimension<InputImageDimension, KernelDimension>));
    itkConceptMacro(InputGreaterThanComparableCheck,
      (Concept::GreaterThanComparable<PixelType>));
    itkConceptMacro(KernelGreaterThanComparableCheck,
      (Concept::GreaterThanComparable<KernelPixelType>));
    /** End concept checking */
  #endif
  
  protected:
    GrayscaleDilateImageFilter();
    ~GrayscaleDilateImageFilter() {};
  
    /** Evaluate image neighborhood with kernel to find the new value 
     * for the center pixel value
     *
     * It will return the maximum value of the image pixels whose corresponding
     * element in the structuring element is positive. This version of
     * Evaluate is used for non-boundary pixels. */
    PixelType Evaluate(const NeighborhoodIteratorType &nit,
                       const KernelIteratorType kernelBegin,
                       const KernelIteratorType kernelEnd);
  
  private:
    GrayscaleDilateImageFilter(const Self&); //purposely not implemented
    void operator=(const Self&); //purposely not implemented
  
    // Default boundary condition for dilation filter, defaults to
    // NumericTraits<PixelType>::NonpositiveMin()
    DefaultBoundaryConditionType m_DilateBoundaryCondition;
  
  }; // end of class
  
  } // end namespace itk
    
  #ifndef ITK_MANUAL_INSTANTIATION
  #include "itkGrayscaleDilateImageFilter.txx"
  #endif
  
  #endif
  
  #endif
  