ITK  4.13.0
Insight Segmentation and Registration Toolkit
itkBSplineInterpolateImageFunction.h
Go to the documentation of this file.
1 /*=========================================================================
2  *
3  * Copyright Insight Software Consortium
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  * http://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 /*=========================================================================
19  *
20  * Portions of this file are subject to the VTK Toolkit Version 3 copyright.
21  *
22  * Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
23  *
24  * For complete copyright, license and disclaimer of warranty information
25  * please refer to the NOTICE file at the top of the ITK source tree.
26  *
27  *=========================================================================*/
28 #ifndef itkBSplineInterpolateImageFunction_h
29 #define itkBSplineInterpolateImageFunction_h
30 
31 #include <vector>
32 
34 #include "vnl/vnl_matrix.h"
35 
37 #include "itkConceptChecking.h"
38 #include "itkCovariantVector.h"
39 
40 namespace itk
41 {
80 template<
81  typename TImageType,
82  typename TCoordRep = double,
83  typename TCoefficientType = double >
84 class ITK_TEMPLATE_EXPORT BSplineInterpolateImageFunction:
85  public InterpolateImageFunction< TImageType, TCoordRep >
86 {
87 public:
93 
96 
98  itkNewMacro(Self);
99 
101  typedef typename Superclass::OutputType OutputType;
102 
104  typedef typename Superclass::InputImageType InputImageType;
105 
107  itkStaticConstMacro(ImageDimension, unsigned int, Superclass::ImageDimension);
108 
111 
113  typedef typename Superclass::ContinuousIndexType ContinuousIndexType;
114 
117 
120 
122  typedef TCoefficientType CoefficientDataType;
123  typedef Image< CoefficientDataType,
124  itkGetStaticConstMacro(ImageDimension) >
126 
130 
132  typedef CovariantVector< OutputType,
133  itkGetStaticConstMacro(ImageDimension) >
135 
144  virtual OutputType Evaluate(const PointType & point) const ITK_OVERRIDE
145  {
146  ContinuousIndexType index;
147 
148  this->GetInputImage()->TransformPhysicalPointToContinuousIndex(point,
149  index);
150  // No thread info passed in, so call method that doesn't need thread ID.
151  return ( this->EvaluateAtContinuousIndex(index) );
152  }
153 
154  virtual OutputType Evaluate(const PointType & point,
155  ThreadIdType threadId) const
156  {
157  ContinuousIndexType index;
158 
159  this->GetInputImage()->TransformPhysicalPointToContinuousIndex(point,
160  index);
161  return ( this->EvaluateAtContinuousIndex(index, threadId) );
162  }
163 
165  index) const ITK_OVERRIDE
166  {
167  // Don't know thread information, make evaluateIndex, weights on the stack.
168  // Slower, but safer.
169  vnl_matrix< long > evaluateIndex( ImageDimension, ( m_SplineOrder + 1 ) );
170  vnl_matrix< double > weights( ImageDimension, ( m_SplineOrder + 1 ) );
171 
172  // Pass evaluateIndex, weights by reference. They're only good as long
173  // as this method is in scope.
174  return this->EvaluateAtContinuousIndexInternal(index,
175  evaluateIndex,
176  weights);
177  }
178 
179  virtual OutputType EvaluateAtContinuousIndex(const ContinuousIndexType &
180  index,
181  ThreadIdType threadId) const;
182 
184  {
185  ContinuousIndexType index;
186 
187  this->GetInputImage()->TransformPhysicalPointToContinuousIndex(point,
188  index);
189  // No thread info passed in, so call method that doesn't need thread ID.
190  return ( this->EvaluateDerivativeAtContinuousIndex(index) );
191  }
192 
194  ThreadIdType threadId) const
195  {
196  ContinuousIndexType index;
197 
198  this->GetInputImage()->TransformPhysicalPointToContinuousIndex(point,
199  index);
200  return ( this->EvaluateDerivativeAtContinuousIndex(index, threadId) );
201  }
202 
204  const ContinuousIndexType & x) const
205  {
206  // Don't know thread information, make evaluateIndex, weights,
207  // weightsDerivative
208  // on the stack.
209  // Slower, but safer.
210  vnl_matrix< long > evaluateIndex( ImageDimension, ( m_SplineOrder + 1 ) );
211  vnl_matrix< double > weights( ImageDimension, ( m_SplineOrder + 1 ) );
212  vnl_matrix< double > weightsDerivative( ImageDimension, ( m_SplineOrder + 1 ) );
213 
214  // Pass evaluateIndex, weights, weightsDerivative by reference. They're only
215  // good
216  // as long as this method is in scope.
217  return this->EvaluateDerivativeAtContinuousIndexInternal(x,
218  evaluateIndex,
219  weights,
220  weightsDerivative);
221  }
222 
223  CovariantVectorType EvaluateDerivativeAtContinuousIndex(
224  const ContinuousIndexType & x,
225  ThreadIdType threadId) const;
226 
228  OutputType & value,
229  CovariantVectorType & deriv) const
230  {
231  ContinuousIndexType index;
232 
233  this->GetInputImage()->TransformPhysicalPointToContinuousIndex(point,
234  index);
235 
236  // No thread info passed in, so call method that doesn't need thread ID.
237  this->EvaluateValueAndDerivativeAtContinuousIndex(index,
238  value,
239  deriv);
240  }
241 
243  OutputType & value,
244  CovariantVectorType & deriv,
245  ThreadIdType threadId) const
246  {
247  ContinuousIndexType index;
248 
249  this->GetInputImage()->TransformPhysicalPointToContinuousIndex(point,
250  index);
251  this->EvaluateValueAndDerivativeAtContinuousIndex(index,
252  value,
253  deriv,
254  threadId);
255  }
256 
258  const ContinuousIndexType & x,
259  OutputType & value,
260  CovariantVectorType & deriv
261  ) const
262  {
263  // Don't know thread information, make evaluateIndex, weights,
264  // weightsDerivative
265  // on the stack.
266  // Slower, but safer.
267  vnl_matrix< long > evaluateIndex( ImageDimension, ( m_SplineOrder + 1 ) );
268  vnl_matrix< double > weights( ImageDimension, ( m_SplineOrder + 1 ) );
269  vnl_matrix< double > weightsDerivative( ImageDimension, ( m_SplineOrder + 1 ) );
270 
271  // Pass evaluateIndex, weights, weightsDerivative by reference. They're only
272  // good
273  // as long as this method is in scope.
274  this->EvaluateValueAndDerivativeAtContinuousIndexInternal(x,
275  value,
276  deriv,
277  evaluateIndex,
278  weights,
279  weightsDerivative);
280  }
281 
282  void EvaluateValueAndDerivativeAtContinuousIndex(
283  const ContinuousIndexType & x,
284  OutputType & value,
285  CovariantVectorType & deriv,
286  ThreadIdType threadId) const;
287 
290  void SetSplineOrder(unsigned int SplineOrder);
291 
292  itkGetConstMacro(SplineOrder, int);
293 
294  void SetNumberOfThreads(ThreadIdType numThreads);
295 
296  itkGetConstMacro(NumberOfThreads, ThreadIdType);
297 
299  virtual void SetInputImage(const TImageType *inputData) ITK_OVERRIDE;
300 
311  itkSetMacro(UseImageDirection, bool);
312  itkGetConstMacro(UseImageDirection, bool);
313  itkBooleanMacro(UseImageDirection);
315 
316 protected:
317 
336  virtual OutputType EvaluateAtContinuousIndexInternal(const ContinuousIndexType & index,
337  vnl_matrix< long > & evaluateIndex,
338  vnl_matrix< double > & weights) const;
339 
340  virtual void EvaluateValueAndDerivativeAtContinuousIndexInternal(const ContinuousIndexType & x,
341  OutputType & value,
342  CovariantVectorType & derivativeValue,
343  vnl_matrix< long > & evaluateIndex,
344  vnl_matrix< double > & weights,
345  vnl_matrix< double > & weightsDerivative
346  ) const;
347 
348  virtual CovariantVectorType EvaluateDerivativeAtContinuousIndexInternal(const ContinuousIndexType & x,
349  vnl_matrix< long > & evaluateIndex,
350  vnl_matrix< double > & weights,
351  vnl_matrix< double > & weightsDerivative
352  ) const;
353 
355  ~BSplineInterpolateImageFunction() ITK_OVERRIDE;
356  void PrintSelf(std::ostream & os, Indent indent) const ITK_OVERRIDE;
357 
358  // These are needed by the smoothing spline routine.
359  // temp storage for processing of Coefficients
360  std::vector< CoefficientDataType > m_Scratch;
361  // Image size
362  typename TImageType::SizeType m_DataLength;
363  // User specified spline order (3rd or cubic is the default)
364  unsigned int m_SplineOrder;
365 
366  // Spline coefficients
367  typename CoefficientImageType::ConstPointer m_Coefficients;
368 
369 private:
370  ITK_DISALLOW_COPY_AND_ASSIGN(BSplineInterpolateImageFunction);
371 
373  void SetInterpolationWeights(const ContinuousIndexType & x,
374  const vnl_matrix< long > & EvaluateIndex,
375  vnl_matrix< double > & weights,
376  unsigned int splineOrder) const;
377 
379  void SetDerivativeWeights(const ContinuousIndexType & x,
380  const vnl_matrix< long > & EvaluateIndex,
381  vnl_matrix< double > & weights,
382  unsigned int splineOrder) const;
383 
386  void GeneratePointsToIndex();
387 
389  void DetermineRegionOfSupport(vnl_matrix< long > & evaluateIndex,
390  const ContinuousIndexType & x,
391  unsigned int splineOrder) const;
392 
395  void ApplyMirrorBoundaryConditions(vnl_matrix< long > & evaluateIndex,
396  unsigned int splineOrder) const;
397 
398  Iterator m_CIterator; // Iterator for
399  // traversing spline
400  // coefficients.
401  unsigned long m_MaxNumberInterpolationPoints; // number of
402  // neighborhood
403  // points used for
404  // interpolation
405  std::vector< IndexType > m_PointsToIndex; // Preallocation of
406  // interpolation
407  // neighborhood
408  // indices
409 
410  CoefficientFilterPointer m_CoefficientFilter;
411 
412  // flag to take or not the image direction into account when computing the
413  // derivatives.
414  bool m_UseImageDirection;
415 
416  ThreadIdType m_NumberOfThreads;
417  vnl_matrix< long > * m_ThreadedEvaluateIndex;
418  vnl_matrix< double > *m_ThreadedWeights;
419  vnl_matrix< double > *m_ThreadedWeightsDerivative;
420 };
421 } // namespace itk
422 
423 #ifndef ITK_MANUAL_INSTANTIATION
424 #include "itkBSplineInterpolateImageFunction.hxx"
425 #endif
426 
427 #endif
virtual OutputType EvaluateAtContinuousIndex(const ContinuousIndexType &index) const override
Image< CoefficientDataType, itkGetStaticConstMacro(ImageDimension) > CoefficientImageType
Light weight base class for most itk classes.
BSplineDecompositionImageFilter< TImageType, CoefficientImageType > CoefficientFilter
CovariantVectorType EvaluateDerivative(const PointType &point) const
CovariantVectorType EvaluateDerivative(const PointType &point, ThreadIdType threadId) const
ImageLinearIteratorWithIndex< TImageType > Iterator
void EvaluateValueAndDerivativeAtContinuousIndex(const ContinuousIndexType &x, OutputType &value, CovariantVectorType &deriv) const
virtual OutputType Evaluate(const PointType &point, ThreadIdType threadId) const
unsigned int ThreadIdType
Definition: itkIntTypes.h:159
Base class for all image interpolaters.
void EvaluateValueAndDerivative(const PointType &point, OutputType &value, CovariantVectorType &deriv, ThreadIdType threadId) const
Calculates the B-Spline coefficients of an image. Spline order may be from 0 to 5.
InterpolateImageFunction< TImageType, TCoordRep > Superclass
void EvaluateValueAndDerivative(const PointType &point, OutputType &value, CovariantVectorType &deriv) const
Control indentation during Print() invocation.
Definition: itkIndent.h:49
virtual OutputType Evaluate(const PointType &point) const override
Evaluates the B-Spline interpolation of an image. Spline order may be from 0 to 5.
CovariantVectorType EvaluateDerivativeAtContinuousIndex(const ContinuousIndexType &x) const
A templated class holding a n-Dimensional covariant vector.
CovariantVector< OutputType, itkGetStaticConstMacro(ImageDimension) > CovariantVectorType
Templated n-dimensional image class.
Definition: itkImage.h:75