File: itkGaussianDerivativeImageFunction.h

package info (click to toggle)
insighttoolkit5 5.4.3-5
  • links: PTS, VCS
  • area: main
  • in suites: forky, sid, trixie
  • size: 704,384 kB
  • sloc: cpp: 783,592; ansic: 628,724; xml: 44,704; fortran: 34,250; python: 22,874; sh: 4,078; pascal: 2,636; lisp: 2,158; makefile: 464; yacc: 328; asm: 205; perl: 203; lex: 146; tcl: 132; javascript: 98; csh: 81
file content (204 lines) | stat: -rw-r--r-- 6,774 bytes parent folder | download
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
/*=========================================================================
 *
 *  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 itkGaussianDerivativeImageFunction_h
#define itkGaussianDerivativeImageFunction_h

#include "itkContinuousIndex.h"
#include "itkFixedArray.h"
#include "itkGaussianDerivativeSpatialFunction.h"
#include "itkGaussianSpatialFunction.h"
#include "itkImage.h"
#include "itkImageFunction.h"
#include "itkNeighborhood.h"
#include "itkOffset.h"
#include "itkVector.h"

#include <vector>

namespace itk
{
/**
 * \class GaussianDerivativeImageFunction
 * \brief Compute the Gaussian derivatives of an the image
 *        at a specific location in space, i.e. point, index or continuous
 *        index.
 * \note From ITK 5, the Evaluate member functions of this class are concurrent
 * thread safe: It is safe to have multiple simultaneous Evaluate calls on a
 * GaussianDerivativeImageFunction object.
 *
 * 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 GaussianDerivativeImageFunction
  : public ImageFunction<TInputImage, Vector<TOutput, TInputImage::ImageDimension>, TOutput>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(GaussianDerivativeImageFunction);

  /** Standard class type aliases. */
  using Self = GaussianDerivativeImageFunction;
  using Superclass = ImageFunction<TInputImage, Vector<TOutput, TInputImage::ImageDimension>, TOutput>;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;

  /** Method for creation through the object factory. */
  itkNewMacro(Self);

  /** \see LightObject::GetNameOfClass() */
  itkOverrideGetNameOfClassMacro(GaussianDerivativeImageFunction);

  /** InputImageType type alias support */
  using InputImageType = TInputImage;
  using InputPixelType = typename InputImageType::PixelType;
  using IndexType = typename InputImageType::IndexType;

  /** Dimension of the underlying image. */
  static constexpr unsigned int ImageDimension = InputImageType::ImageDimension;

#if !defined(ITK_LEGACY_REMOVE)
  static constexpr unsigned int ImageDimension2 = ImageDimension;
#endif

  using ContinuousIndexType = typename Superclass::ContinuousIndexType;

  using NeighborhoodType = Neighborhood<InputPixelType, Self::ImageDimension>;
  using OperatorNeighborhoodType = Neighborhood<TOutput, Self::ImageDimension>;

  using VectorType = Vector<TOutput, Self::ImageDimension>;
  using typename Superclass::OutputType;
  using OperatorArrayType = FixedArray<OperatorNeighborhoodType, Self::ImageDimension>;

  using GaussianDerivativeSpatialFunctionType = GaussianDerivativeSpatialFunction<TOutput, 1>;
  using GaussianDerivativeSpatialFunctionPointer = typename GaussianDerivativeSpatialFunctionType::Pointer;

#if !defined(ITK_LEGACY_REMOVE)
  using GaussianDerivativeFunctionType = GaussianDerivativeSpatialFunctionType;
  using GaussianDerivativeFunctionPointer = GaussianDerivativeSpatialFunctionPointer;
#endif

  /** Point type alias support */
  // using PointType = Point< TOutput, Self::ImageDimension >;
  using PointType = typename Superclass::PointType;

  /** Evaluate the function at the specified point. */
  OutputType
  Evaluate(const PointType & point) const override;

  /** Evaluate the function at specified Index position. */
  OutputType
  EvaluateAtIndex(const IndexType & index) const override;

  /** Evaluate the function at specified ContinuousIndex position. */
  OutputType
  EvaluateAtContinuousIndex(const ContinuousIndexType & cindex) const override;

  /**
   * UseImageSpacing controls the extent of the computations.
   * Set UseImageSpacing to true to set the units to physical units of the image.
   * Set UseImageSpacing to false to set the units of pixels. */
  void
  SetUseImageSpacing(const bool val)
  {
    if (val != this->m_UseImageSpacing)
    {
      this->m_UseImageSpacing = val;
      this->RecomputeGaussianKernel();
    }
  }
  itkBooleanMacro(UseImageSpacing);
  itkGetMacro(UseImageSpacing, bool);

  /** The variance for the discrete Gaussian kernel. Sets the variance
   * independently for each dimension, but see also
   * SetVariance(const double v). The default is 0.0 in each dimension.
   * The extent of the kernel is controlled by UseImageSpacing.
   */
  void
  SetSigma(const double * sigma);

  void
  SetSigma(const double sigma);

  const double *
  GetSigma() const
  {
    return m_Sigma;
  }

  /** Set the extent of the discrete Gaussian kernel. */
  void
  SetExtent(const double * extent);

  void
  SetExtent(const double extent);

  const double *
  GetExtent() const
  {
    return m_Extent;
  }

  /** 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;

protected:
  GaussianDerivativeImageFunction();
  ~GaussianDerivativeImageFunction() override = default;

  void
  PrintSelf(std::ostream & os, Indent indent) const override;

  /** Recompute the Gaussian kernel used to evaluate indexes. This should use
   * a fastest Derivative Gaussian operator. */
  void
  RecomputeGaussianKernel();

private:
  double m_Sigma[ImageDimension]{};

  /** Array of 1D operators. Contains a derivative kernel for
   * each dimension. Note: A future version of ITK could extend this array
   * to include a Gaussian blurring kernel for each dimension.*/
  OperatorArrayType m_OperatorArray{};

  std::vector<Offset<ImageDimension>> m_ImageNeighborhoodOffsets[ImageDimension]{};

  double m_Extent[ImageDimension]{};

  /** Flag to indicate whether to use image spacing. */
  bool m_UseImageSpacing{ true };

  /** Neighborhood Image Function. */
  const GaussianDerivativeSpatialFunctionPointer m_GaussianDerivativeSpatialFunction{
    GaussianDerivativeSpatialFunctionType::New()
  };
};
} // namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkGaussianDerivativeImageFunction.hxx"
#endif

#endif