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
|
/*=========================================================================
*
* 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 itkNeighborhoodOperatorImageFunction_h
#define itkNeighborhoodOperatorImageFunction_h
#include "itkImageFunction.h"
#include "itkNeighborhood.h"
namespace itk
{
/**
* \class NeighborhoodOperatorImageFunction
* \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
*
* \sphinx
* \sphinxexample{Core/ImageFunction/MultiplyKernelWithAnImageAtLocation,Multiply Kernel With An Image At Location}
* \endsphinx
*/
template <typename TInputImage, typename TOutput>
class ITK_TEMPLATE_EXPORT NeighborhoodOperatorImageFunction : public ImageFunction<TInputImage, TOutput>
{
public:
/**Standard "Self" type alias */
using Self = NeighborhoodOperatorImageFunction;
/** 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);
/** InputImageType type alias support */
using InputImageType = TInputImage;
using InputPixelType = typename InputImageType::PixelType;
using typename Superclass::IndexType;
using typename Superclass::ContinuousIndexType;
/** \see LightObject::GetNameOfClass() */
itkOverrideGetNameOfClassMacro(NeighborhoodOperatorImageFunction);
/** Dimension of the underlying image. */
static constexpr unsigned int ImageDimension = InputImageType::ImageDimension;
using NeighborhoodType = Neighborhood<TOutput, Self::ImageDimension>;
/** Point type alias support */
using typename Superclass::PointType;
/** Set the input image. */
// virtual void SetInputImage( InputImageType * ptr );
/** Sets the operator that is used to filter the image. Note
* that the operator is stored as an internal COPY (it
* is not part of the pipeline). */
void
SetOperator(const NeighborhoodType & p) const
{
m_Operator = p;
this->Modified();
}
/** Evaluate the function in the given dimension at specified point
* Subclasses should override this method. */
TOutput
Evaluate(const PointType &) const override
{
std::cout << "NeighborhoodOperatorImageFunction::Evaluate(): Not implemented!" << std::endl;
TOutput out;
out = 0;
return out;
}
/** Evaluate the function at specified Index position */
TOutput
EvaluateAtIndex(const IndexType & index) const override;
/** Evaluate the function at specified ContinuousIndex position.
* Subclasses should override this method. */
TOutput
EvaluateAtContinuousIndex(const ContinuousIndexType &) const override
{
std::cout << "NeighborhoodOperatorImageFunction::EvaluateAtContinuousIndex():Not implemented!" << std::endl;
TOutput out;
out = 0;
return out;
}
protected:
NeighborhoodOperatorImageFunction() = default;
NeighborhoodOperatorImageFunction(const Self &) {}
~NeighborhoodOperatorImageFunction() override = default;
void
operator=(const Self &)
{}
void
PrintSelf(std::ostream & os, Indent indent) const override;
private:
mutable NeighborhoodType m_Operator{};
};
} // end namespace itk
#ifndef ITK_MANUAL_INSTANTIATION
# include "itkNeighborhoodOperatorImageFunction.hxx"
#endif
/*
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkNeighborhoodOperatorImageFunction.hxx"
#endif
*/
#endif
|
