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
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
|
/*=========================================================================
*
* Copyright NumFOCUS
*
* 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
*
* https://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 itkGaussianBlurImageFunction_h
#define itkGaussianBlurImageFunction_h
#include "itkNeighborhoodOperatorImageFunction.h"
#include "itkGaussianOperator.h"
#include "itkGaussianSpatialFunction.h"
namespace itk
{
/**
* \class GaussianBlurImageFunction
* \brief Compute the convolution of a neighborhood operator with the image
* at a specific location in space, i.e. point, index or continuous
* index.
* This class is templated over the input image type.
* \sa NeighborhoodOperator
* \sa ImageFunction
* \ingroup ITKImageFunction
*
*/
template <typename TInputImage, typename TOutput = double>
class ITK_TEMPLATE_EXPORT GaussianBlurImageFunction : public ImageFunction<TInputImage, TOutput>
{
public:
ITK_DISALLOW_COPY_AND_MOVE(GaussianBlurImageFunction);
/**Standard "Self" type alias */
using Self = GaussianBlurImageFunction;
/** Standard "Superclass" type alias */
using Superclass = ImageFunction<TInputImage, TOutput>;
/** Smart pointer type alias support */
using Pointer = SmartPointer<Self>;
using ConstPointer = SmartPointer<const Self>;
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** \see LightObject::GetNameOfClass() */
itkOverrideGetNameOfClassMacro(GaussianBlurImageFunction);
/** InputImageType type alias support */
using InputImageType = TInputImage;
using InputPixelType = typename InputImageType::PixelType;
using typename Superclass::IndexType;
using typename Superclass::ContinuousIndexType;
/** Dimension of the underlying image. */
static constexpr unsigned int ImageDimension = InputImageType::ImageDimension;
using GaussianOperatorType = GaussianOperator<TOutput, Self::ImageDimension>;
using NeighborhoodType = Neighborhood<TOutput, Self::ImageDimension>;
using OperatorArrayType = FixedArray<NeighborhoodType, Self::ImageDimension>;
using GaussianFunctionType = GaussianSpatialFunction<TOutput, 1>;
using GaussianFunctionPointer = typename GaussianFunctionType::Pointer;
using InputPixelRealType = typename NumericTraits<InputPixelType>::RealType;
using InternalImageType = itk::Image<InputPixelRealType, Self::ImageDimension>;
using InternalImagePointer = typename InternalImageType::Pointer;
using OperatorImageFunctionType = NeighborhoodOperatorImageFunction<InputImageType, TOutput>;
using OperatorImageFunctionPointer = typename OperatorImageFunctionType::Pointer;
using OperatorInternalImageFunctionType = NeighborhoodOperatorImageFunction<InternalImageType, TOutput>;
using OperatorInternalImageFunctionPointer = typename OperatorInternalImageFunctionType::Pointer;
using ErrorArrayType = itk::FixedArray<double, Self::ImageDimension>;
using ExtentArrayType = itk::FixedArray<double, Self::ImageDimension>;
using SigmaArrayType = itk::FixedArray<double, Self::ImageDimension>;
/** Point type alias support */
using typename Superclass::PointType;
/** Evaluate the function in the given dimension at specified point */
TOutput
Evaluate(const PointType & point) const override;
/** Evaluate the function at specified Index position */
TOutput
EvaluateAtIndex(const IndexType & index) const override;
/** Evaluate the function at specified ContinuousIndex position. */
TOutput
EvaluateAtContinuousIndex(const ContinuousIndexType & cindex) const override;
/** The standard deviation for the discrete Gaussian kernel. Sets the
* standard deviation independently for each dimension.
* The default is 1.0 in each dimension.
* If UseImageSpacing is true (default), the units are the physical units
* of your image. If UseImageSpacing is false then the units are pixels.
*/
void
SetSigma(const double * sigma);
void
SetSigma(const float * sigma);
void
SetSigma(const double sigma);
itkSetMacro(Sigma, SigmaArrayType);
itkGetConstReferenceMacro(Sigma, SigmaArrayType);
/** Set the input image.
* \warning this method caches BufferedRegion information.
* If the BufferedRegion has changed, user must call
* SetInputImage again to update cached values. */
void
SetInputImage(const InputImageType * ptr) override;
/** Set/Get the Extent of the array holding the coefficients
* of the Gaussian kernel computed by the GaussianOperator.
*/
itkSetMacro(Extent, ExtentArrayType);
itkGetConstReferenceMacro(Extent, ExtentArrayType);
void
SetExtent(const double * extent);
void
SetExtent(const double extent);
/** Set/Get the maximum error acceptable for the approximation
* of the Gaussian kernel with the GaussianOperator.
*/
itkSetMacro(MaximumError, ErrorArrayType);
itkGetConstReferenceMacro(MaximumError, ErrorArrayType);
/** Set/GetMaximumKernelWidth() This value is used by the underling
* GaussianOperator for computing the number of coefficients to be
* used in the Gaussian kernel
*/
itkSetMacro(MaximumKernelWidth, int);
itkGetConstMacro(MaximumKernelWidth, int);
/** Set/GetUseImageSpacing() This flag is used by the underling
* GaussianOperator to decide if the image spacing should be used
* to scale the value of sigma or not. The methods UseImageSpacingOn()
* and UseImageSpacingOff() provide a similar functionality.
*/
itkSetMacro(UseImageSpacing, bool);
itkGetConstMacro(UseImageSpacing, bool);
itkBooleanMacro(UseImageSpacing);
protected:
GaussianBlurImageFunction();
~GaussianBlurImageFunction() override = default;
void
PrintSelf(std::ostream & os, Indent indent) const override;
void
RecomputeGaussianKernel();
void
RecomputeContinuousGaussianKernel(const double * offset) const;
private:
virtual TOutput
EvaluateAtIndex(const IndexType & index, const OperatorArrayType & operatorArray) const;
SigmaArrayType m_Sigma{};
OperatorImageFunctionPointer m_OperatorImageFunction{};
OperatorInternalImageFunctionPointer m_OperatorInternalImageFunction{};
mutable OperatorArrayType m_OperatorArray{};
mutable OperatorArrayType m_ContinuousOperatorArray{};
InternalImagePointer m_InternalImage{};
/** The maximum error of the gaussian blurring kernel in each dimensional
* direction. For definition of maximum error, see GaussianOperator.
* \sa GaussianOperator */
ErrorArrayType m_MaximumError{};
ExtentArrayType m_Extent{};
/** Maximum allowed kernel width for any dimension of the discrete Gaussian
approximation */
int m_MaximumKernelWidth{};
/** Number of dimensions to process. Default is all dimensions */
unsigned int m_FilterDimensionality{};
/** Flag to indicate whether to use image spacing */
bool m_UseImageSpacing{ true };
/** Neighborhood Image Function */
GaussianFunctionPointer m_GaussianFunction{};
};
} // end namespace itk
#ifndef ITK_MANUAL_INSTANTIATION
# include "itkGaussianBlurImageFunction.hxx"
#endif
#endif
|
