1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
/*=========================================================================
Program: Insight Segmentation & Registration Toolkit
Module: $RCSfile: itkGrayscaleFunctionDilateImageFilter.h,v $
Language: C++
Date: $Date: 2006-03-28 19:59:05 $
Version: $Revision: 1.15 $
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 __itkGrayscaleFunctionDilateImageFilter_h
#define __itkGrayscaleFunctionDilateImageFilter_h
#include "itkMorphologyImageFilter.h"
namespace itk {
/** \class GrayscaleFunctionDilateImageFilter
* \brief gray scale function dilation of an image
*
* Dilate an image using functional grayscale morphology. Function
* dilation takes the maximum of all the pixels identified by the
* structuring element plus the structuring element value.
*
* The structuring element can be composed of arbitrary nonnegative
* values (not restricted to zero or one). Element values greater than
* zero indicate pixels that will be considered during the dilation.
* The function dilation operation is defined as the maxixum over the
* element of the image value PLUS the structuring element value.
*
* For the each input image pixel,
* - NeighborhoodIterator gives neighbors of the pixel.
* - Evaluate() member function returns the maximum value among
* the image neighbors plus the kernel value where the kernel has
* elements > 0.
* - Replace the original value with the max value
*
* \sa MorphologyImageFilter, GrayscaleDilateImageFilter, BinaryDilateImageFilter
* \ingroup ImageEnhancement MathematicalMorphologyImageFilters
*/
template<class TInputImage, class TOutputImage, class TKernel>
class ITK_EXPORT GrayscaleFunctionDilateImageFilter :
public MorphologyImageFilter<TInputImage, TOutputImage, TKernel>
{
public:
/** Standard class typedefs. */
typedef GrayscaleFunctionDilateImageFilter 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(GrayscaleFunctionDilateImageFilter,
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);
#ifdef ITK_USE_CONCEPT_CHECKING
/** Begin concept checking */
itkConceptMacro(SameDimensionCheck1,
(Concept::SameDimension<InputImageDimension, OutputImageDimension>));
itkConceptMacro(SameDimensionCheck2,
(Concept::SameDimension<InputImageDimension, KernelDimension>));
itkConceptMacro(InputConvertibleToOutputCheck,
(Concept::Convertible<PixelType, typename TOutputImage::PixelType>));
itkConceptMacro(KernelConvertibleToInputCheck,
(Concept::Convertible<typename TKernel::PixelType, PixelType>));
itkConceptMacro(InputAdditiveOperatorsCheck,
(Concept::AdditiveOperators<PixelType>));
itkConceptMacro(InputGreaterThanComparableCheck,
(Concept::GreaterThanComparable<PixelType>));
itkConceptMacro(KernelGreaterThanIntCheck,
(Concept::GreaterThanComparable<typename TKernel::PixelType, int>));
/** End concept checking */
#endif
protected:
GrayscaleFunctionDilateImageFilter();
~GrayscaleFunctionDilateImageFilter() {};
/** 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 plus the
* structuring element values 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:
GrayscaleFunctionDilateImageFilter(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 "itkGrayscaleFunctionDilateImageFilter.txx"
#endif
#endif
|
