ITK  6.0.0
Insight Toolkit
itkBSplineTransform.h
Go to the documentation of this file.
1/*=========================================================================
2 *
3 * Copyright NumFOCUS
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * https://www.apache.org/licenses/LICENSE-2.0.txt
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 *=========================================================================*/
18#ifndef itkBSplineTransform_h
19#define itkBSplineTransform_h
20
22
23namespace itk
24{
102template <typename TParametersValueType = double, unsigned int VDimension = 3, unsigned int VSplineOrder = 3>
103class ITK_TEMPLATE_EXPORT BSplineTransform : public BSplineBaseTransform<TParametersValueType, VDimension, VSplineOrder>
104{
105public:
106 ITK_DISALLOW_COPY_AND_MOVE(BSplineTransform);
107
113
115 itkNewMacro(Self);
116
118 itkOverrideGetNameOfClassMacro(BSplineTransform);
119
121 static constexpr unsigned int SpaceDimension = VDimension;
122
124 static constexpr unsigned int SplineOrder = VSplineOrder;
125
127 using typename Superclass::ScalarType;
128
130 using typename Superclass::ParametersType;
131 using typename Superclass::ParametersValueType;
132 using typename Superclass::FixedParametersType;
134
136 using typename Superclass::JacobianType;
139
142
144 using typename Superclass::InputVectorType;
145 using typename Superclass::OutputVectorType;
146
150
152 using typename Superclass::InputVnlVectorType;
153 using typename Superclass::OutputVnlVectorType;
154
156 using typename Superclass::InputPointType;
157 using typename Superclass::OutputPointType;
158
159
160 std::string
161 GetTransformTypeAsString() const override;
162
185 void
186 SetFixedParameters(const FixedParametersType & passedParameters) override;
190 using typename Superclass::ImageType;
191 using typename Superclass::ImagePointer;
193
205 void
207
209 using typename Superclass::RegionType;
210
211 using typename Superclass::IndexType;
212 using typename Superclass::SizeType;
213 using typename Superclass::SpacingType;
214 using typename Superclass::DirectionType;
215 using typename Superclass::OriginType;
216
218 using typename Superclass::WeightsFunctionType;
219
220 using typename Superclass::WeightsType;
221 using typename Superclass::ContinuousIndexType;
222
225
234 using Superclass::TransformPoint;
235 void
237 OutputPointType & outputPoint,
238 WeightsType & weights,
239 ParameterIndexArrayType & indices,
240 bool & inside) const override;
244 void
246
249 GetNumberOfParameters() const override;
250
254
256 using typename Superclass::PixelType;
257
258 using typename Superclass::MeshSizeType;
259
261 virtual void
263
265 virtual OriginType
267
269 virtual void
271
275
277 virtual void
279
281 virtual DirectionType
283
285 virtual void
287
289 virtual MeshSizeType
291
292protected:
294 void
295 PrintSelf(std::ostream & os, Indent indent) const override;
296
298 ~BSplineTransform() override = default;
299
300private:
302 void
304
306 void
308 {}
309 void
311 {}
312 void
314 {}
315 void
317 {}
321 bool
323
324 void
326
327 void
329 const PhysicalDimensionsType & meshPhysical,
330 const DirectionType & meshDirection,
331 const MeshSizeType & meshSize);
332
333}; // class BSplineTransform
334} // namespace itk
335
336#ifndef ITK_MANUAL_INSTANTIATION
337# include "itkBSplineTransform.hxx"
338#endif
339
340#endif /* itkBSplineTransform_h */
Array2D class representing a 2D array.
Definition: itkArray2D.h:43
A base class with common elements of BSplineTransform and BSplineDeformableTransform.
typename ImageType::PixelType PixelType
typename ImageType::Pointer ImagePointer
typename ImageType::PointType OriginType
typename WeightsFunctionType::ContinuousIndexType ContinuousIndexType
vnl_vector_fixed< TParametersValueType, SpaceDimension > OutputVnlVectorType
typename ImageType::SpacingType SpacingType
vnl_vector_fixed< TParametersValueType, SpaceDimension > InputVnlVectorType
typename WeightsFunctionType::WeightsType WeightsType
typename ParametersType::ValueType ParametersValueType
Returns the weights over the support region used for B-spline interpolation/reconstruction.
Deformable transform using a BSpline representation.
std::string GetTransformTypeAsString() const override
virtual OriginType GetTransformDomainOrigin() const
typename ImageType::PointType OriginType
typename WeightsFunctionType::ContinuousIndexType ContinuousIndexType
void SetFixedParametersGridSpacingFromTransformDomainInformation() const override
void SetFixedParametersFromTransformDomainInformation(const OriginType &meshOrigin, const PhysicalDimensionsType &meshPhysical, const DirectionType &meshDirection, const MeshSizeType &meshSize)
virtual MeshSizeType GetTransformDomainMeshSize() const
virtual DirectionType GetTransformDomainDirection() const
typename Superclass::SpacingType PhysicalDimensionsType
virtual void SetTransformDomainMeshSize(const MeshSizeType &)
void SetFixedParameters(const FixedParametersType &passedParameters) override
void SetFixedParametersGridOriginFromTransformDomainInformation() const override
virtual void SetTransformDomainPhysicalDimensions(const PhysicalDimensionsType &)
void SetFixedParametersFromCoefficientImageInformation()
void TransformPoint(const InputPointType &point, OutputPointType &outputPoint, WeightsType &weights, ParameterIndexArrayType &indices, bool &inside) const override
NumberOfParametersType GetNumberOfParameters() const override
virtual void SetTransformDomainOrigin(const OriginType &)
bool InsideValidRegion(ContinuousIndexType &) const override
void SetCoefficientImages(const CoefficientImageArray &images) override
virtual PhysicalDimensionsType GetTransformDomainPhysicalDimensions() const
void SetFixedParametersGridDirectionFromTransformDomainInformation() const override
NumberOfParametersType GetNumberOfParametersPerDimension() const override
virtual void SetTransformDomainDirection(const DirectionType &)
void ComputeJacobianWithRespectToParameters(const InputPointType &, JacobianType &) const override
void PrintSelf(std::ostream &os, Indent indent) const override
typename WeightsFunctionType::WeightsType WeightsType
~BSplineTransform() override=default
typename ImageType::DirectionType DirectionType
void SetFixedParametersGridSizeFromTransformDomainInformation() const override
void SetCoefficientImageInformationFromFixedParameters() override
A templated class holding a n-Dimensional covariant vector.
Templated n-dimensional image class.
Definition: itkImage.h:89
Control indentation during Print() invocation.
Definition: itkIndent.h:50
Class to hold and manage different parameter types used during optimization.
A templated class holding a geometric point in n-Dimensional space.
Definition: itkPoint.h:54
vnl_matrix_fixed< ParametersValueType, VOutputDimension, VInputDimension > JacobianPositionType
Definition: itkTransform.h:131
vnl_matrix_fixed< ParametersValueType, VInputDimension, VOutputDimension > InverseJacobianPositionType
Definition: itkTransform.h:132
ParametersValueType ScalarType
Definition: itkTransform.h:127
A templated class holding a n-Dimensional vector.
Definition: itkVector.h:63
The "itk" namespace contains all Insight Segmentation and Registration Toolkit (ITK) classes....
*par Constraints *The filter image with at least two dimensions and a vector *length of at least The theory supports extension to scalar but *the implementation of the itk vector classes do not **The template parameter TRealType must be floating point(float or double) or *a user-defined "real" numerical type with arithmetic operations defined *sufficient to compute derivatives. **\par Performance *This filter will automatically multithread if run with *SetUsePrincipleComponents
*par Constraints *The filter image with at least two dimensions and a vector *length of at least The theory supports extension to scalar images