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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
|
/*=========================================================================
Program: Insight Segmentation & Registration Toolkit
Module: $RCSfile: itkMorphologyImageFilter.h,v $
Language: C++
Date: $Date: 2004-04-30 21:02:04 $
Version: $Revision: 1.17 $
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 __itkMorphologyImageFilter_h
#define __itkMorphologyImageFilter_h
#include "itkImageToImageFilter.h"
#include "itkNeighborhoodIterator.h"
#include "itkConstNeighborhoodIterator.h"
#include "itkNeighborhood.h"
#include "itkConstSliceIterator.h"
#include "itkImageBoundaryCondition.h"
#include "itkConstantBoundaryCondition.h"
#include "itkImageRegionIterator.h"
namespace itk {
/** \class MorphologyImageFilter
* \brief Base class for the morphological operations such as erosion and dialation
*
* This class provides the infrastructure to support most
* morphological operations. Subclasses of MorphologyImageFilter
* implement specific "binary" and "grayscale" operations. The
* "binary" subclasses can operate on gray level data, where a
* specified a pixel value is consider the "foreground" and every
* other pixel value is considered the background. This is useful for
* operating on segment masks where all pixels assigned to segment #1
* have value 1, all pixels assigned to segment #2 have value 2, etc.
* Here, a given segment can be dilated (expanded) while treating all
* other segment identifiers are background.
*
* The "kernel" specified represents a morphology structuring element.
* The structuring element is a small Neighborhood with values
* indicating an element is "on" (value > 0) or "off" (value <=0).
* Morphological operations are defined by placing the structuring
* element over a pixel, and calculating a nonlinear function (min,
* max) over the pixels of the image that are under pixels in the
* structuring element that are "on". The result of this calculation
* is the value of the pixel in the output image. Under most
* circumstances, the "center pixel" of the structuring element -- or
* structuring element pixel over the input pixel under consideration
* -- is prescribed to be "on". This is not a strict requirement but
* the subclasses of this filter are not guarenteed to produce the
* correct result if the "center pixel" is not part of the structuring
* element.
*
* Subclasses of this class can define their own operations by simply
* providing their own Evaluate() protected member function.
*
* \sa BinaryErodeImageFilter
* \sa BinaryDilateImageFilter
* \sa GrayScaleErodeImageFilter
* \sa GrayScaleDilateImageFilter
* \sa NeighborhoodIterator
* \sa Neighborhood
* \ingroup ImageEnhancement MathematicalMorphologyImageFilters
*/
template<class TInputImage, class TOutputImage, class TKernel>
class ITK_EXPORT MorphologyImageFilter :
public ImageToImageFilter<TInputImage, TOutputImage>
{
public:
/** Standard Self typedef */
typedef MorphologyImageFilter Self;
typedef ImageToImageFilter<TInputImage,TOutputImage> Superclass;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
/** Runtime information support. */
itkTypeMacro(MorphologyImageFilter, ImageToImageFilter);
/** Image related typedefs. */
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 Superclass::OutputImageRegionType OutputImageRegionType;
/** Image related typedefs. */
itkStaticConstMacro(ImageDimension, unsigned int,
TInputImage::ImageDimension);
/** Typedef for boundary conditions. */
typedef ImageBoundaryCondition<InputImageType> *ImageBoundaryConditionPointerType;
typedef ImageBoundaryCondition<InputImageType> const *ImageBoundaryConditionConstPointerType;
typedef ConstantBoundaryCondition<InputImageType> DefaultBoundaryConditionType;
/** Neighborhood iterator type. */
typedef ConstNeighborhoodIterator<TInputImage>
NeighborhoodIteratorType ;
/** Kernel typedef. */
typedef TKernel KernelType;
/** Kernel (structuring element) iterator. */
typedef typename KernelType::ConstIterator KernelIteratorType ;
/** n-dimensional Kernel radius. */
typedef typename KernelType::SizeType RadiusType ;
/** Set kernel (structuring element). */
itkSetMacro(Kernel, KernelType);
/** Get the kernel (structuring element). */
itkGetConstReferenceMacro(Kernel, KernelType);
/** MorphologyImageFilters need to make sure they request enough of an
* input image to account for the structuring element size. The input
* requested region is expanded by the radius of the structuring element.
* If the request extends past the LargestPossibleRegion for the input,
* the request is cropped by the LargestPossibleRegion. */
void GenerateInputRequestedRegion() ;
/** Allows a user to override the internal boundary condition. Care should be
* be taken to ensure that the overriding boundary condition is a persistent
* object during the time it is referenced. The overriding condition
* can be of a different type than the default type as long as it is
* a subclass of ImageBoundaryCondition. */
void OverrideBoundaryCondition(const ImageBoundaryConditionPointerType i)
{ m_BoundaryCondition = i; }
/** Rest the boundary condition to the default */
void ResetBoundaryCondition()
{ m_BoundaryCondition = &m_DefaultBoundaryCondition; }
/** Get the current boundary condition. */
itkGetMacro(BoundaryCondition, ImageBoundaryConditionPointerType);
protected:
MorphologyImageFilter();
~MorphologyImageFilter() {};
void PrintSelf(std::ostream& os, Indent indent) const;
/** Multi-thread version GenerateData. */
void ThreadedGenerateData (const OutputImageRegionType&
outputRegionForThread,
int threadId) ;
/** Evaluate image neighborhood with kernel to find the new value
* for the center pixel value. */
virtual PixelType Evaluate(const NeighborhoodIteratorType &nit,
const KernelIteratorType kernelBegin,
const KernelIteratorType kernelEnd)=0;
private:
MorphologyImageFilter(const Self&); //purposely not implemented
void operator=(const Self&); //purposely not implemented
/** kernel or structuring element to use. */
KernelType m_Kernel ;
/** Pointer to a persistent boundary condition object used
* for the image iterator. */
ImageBoundaryConditionPointerType m_BoundaryCondition;
/** Default boundary condition */
DefaultBoundaryConditionType m_DefaultBoundaryCondition;
} ; // end of class
} // end namespace itk
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkMorphologyImageFilter.txx"
#endif
#endif
|
