Main Page   Groups   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members   Concepts

itkBSplineInterpolateImageFunction.h

Go to the documentation of this file.
00001 /*=========================================================================
00002 
00003   Program:   Insight Segmentation & Registration Toolkit
00004   Module:    $RCSfile: itkBSplineInterpolateImageFunction.h,v $
00005   Language:  C++
00006   Date:      $Date: 2008-01-04 12:56:30 $
00007   Version:   $Revision: 1.18 $
00008 
00009   Copyright (c) Insight Software Consortium. All rights reserved.
00010   See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.
00011 
00012   Portions of this code are covered under the VTK copyright.
00013   See VTKCopyright.txt or http://www.kitware.com/VTKCopyright.htm for details.
00014 
00015      This software is distributed WITHOUT ANY WARRANTY; without even 
00016      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
00017      PURPOSE.  See the above copyright notices for more information.
00018 
00019 =========================================================================*/
00020 #ifndef __itkBSplineInterpolateImageFunction_h
00021 #define __itkBSplineInterpolateImageFunction_h
00022 
00023 // First make sure that the configuration is available.
00024 // This line can be removed once the optimized versions
00025 // gets integrated into the main directories.
00026 #include "itkConfigure.h"
00027 
00028 #ifdef ITK_USE_OPTIMIZED_REGISTRATION_METHODS
00029 #include "itkOptBSplineInterpolateImageFunction.h"
00030 #else
00031 
00032 #include <vector>
00033 
00034 #include "itkImageLinearIteratorWithIndex.h"
00035 #include "itkInterpolateImageFunction.h"
00036 #include "vnl/vnl_matrix.h"
00037 
00038 #include "itkBSplineDecompositionImageFilter.h"
00039 #include "itkConceptChecking.h"
00040 #include "itkCovariantVector.h"
00041 
00042 namespace itk
00043 {
00077 template <
00078   class TImageType, 
00079   class TCoordRep = double,
00080   class TCoefficientType = double >
00081 class ITK_EXPORT BSplineInterpolateImageFunction : 
00082     public InterpolateImageFunction<TImageType,TCoordRep> 
00083 {
00084 public:
00086   typedef BSplineInterpolateImageFunction       Self;
00087   typedef InterpolateImageFunction<TImageType,TCoordRep>  Superclass;
00088   typedef SmartPointer<Self>                    Pointer;
00089   typedef SmartPointer<const Self>              ConstPointer;
00090 
00092   itkTypeMacro(BSplineInterpolateImageFunction, InterpolateImageFunction);
00093 
00094 
00096   itkNewMacro( Self );
00097 
00099   typedef typename Superclass::OutputType OutputType;
00100 
00102   typedef typename Superclass::InputImageType InputImageType;
00103 
00105   itkStaticConstMacro(ImageDimension, unsigned int,Superclass::ImageDimension);
00106 
00108   typedef typename Superclass::IndexType IndexType;
00109 
00111   typedef typename Superclass::ContinuousIndexType ContinuousIndexType;
00112 
00114   typedef typename Superclass::PointType PointType;
00115 
00117   typedef ImageLinearIteratorWithIndex<TImageType> Iterator;
00118 
00120   typedef TCoefficientType CoefficientDataType;
00121   typedef Image<CoefficientDataType, 
00122                      itkGetStaticConstMacro(ImageDimension)
00123     > CoefficientImageType;
00124 
00126   typedef BSplineDecompositionImageFilter<TImageType, CoefficientImageType> 
00127   CoefficientFilter;
00128   typedef typename CoefficientFilter::Pointer CoefficientFilterPointer;
00129 
00138   virtual OutputType EvaluateAtContinuousIndex( 
00139     const ContinuousIndexType & index ) const; 
00140 
00142   typedef CovariantVector<OutputType,
00143                           itkGetStaticConstMacro(ImageDimension)
00144     > CovariantVectorType;
00145 
00146   CovariantVectorType EvaluateDerivative( const PointType & point ) const
00147   {    
00148     ContinuousIndexType index;
00149     this->GetInputImage()->TransformPhysicalPointToContinuousIndex( point, index );
00150     return ( this->EvaluateDerivativeAtContinuousIndex( index ) );
00151   } 
00152 
00153   CovariantVectorType EvaluateDerivativeAtContinuousIndex( 
00154     const ContinuousIndexType & x ) const;
00155 
00156 
00159   void SetSplineOrder(unsigned int SplineOrder);
00160   itkGetMacro(SplineOrder, int);
00162 
00163 
00165   virtual void SetInputImage(const TImageType * inputData);
00166 
00167 
00176   itkSetMacro( UseImageDirection, bool );
00177   itkGetMacro( UseImageDirection, bool );
00178   itkBooleanMacro( UseImageDirection );
00180 
00181 
00182 protected:
00183   BSplineInterpolateImageFunction();
00184   virtual ~BSplineInterpolateImageFunction() {};
00185   void operator=( const Self& ); //purposely not implemented
00186   void PrintSelf(std::ostream& os, Indent indent) const;
00187 
00188   // These are needed by the smoothing spline routine.
00189   std::vector<CoefficientDataType>    m_Scratch;        // temp storage for processing of Coefficients
00190   typename TImageType::SizeType       m_DataLength;  // Image size
00191   unsigned int                        m_SplineOrder; // User specified spline order (3rd or cubic is the default)
00192 
00193   typename CoefficientImageType::ConstPointer       m_Coefficients; // Spline coefficients  
00194 
00195 private:
00196   BSplineInterpolateImageFunction( const Self& ); //purposely not implemented
00198   void SetInterpolationWeights( const ContinuousIndexType & x, 
00199                                 const vnl_matrix<long> & EvaluateIndex, 
00200                                 vnl_matrix<double> & weights, 
00201                                 unsigned int splineOrder ) const;
00202 
00204   void SetDerivativeWeights( const ContinuousIndexType & x, 
00205                              const vnl_matrix<long> & EvaluateIndex, 
00206                              vnl_matrix<double> & weights, 
00207                              unsigned int splineOrder ) const;
00208 
00211   void GeneratePointsToIndex(  );
00212 
00214   void DetermineRegionOfSupport( vnl_matrix<long> & evaluateIndex, 
00215                                  const ContinuousIndexType & x, 
00216                                  unsigned int splineOrder ) const;
00217 
00220   void ApplyMirrorBoundaryConditions(vnl_matrix<long> & evaluateIndex, 
00221                                      unsigned int splineOrder) const;
00222 
00223 
00224   Iterator                  m_CIterator;    // Iterator for traversing spline coefficients.
00225   unsigned long             m_MaxNumberInterpolationPoints; // number of neighborhood points used for interpolation
00226   std::vector<IndexType>    m_PointsToIndex;  // Preallocation of interpolation neighborhood indicies
00227 
00228   CoefficientFilterPointer     m_CoefficientFilter;
00229   
00230   // flag to take or not the image direction into account when computing the
00231   // derivatives.
00232   bool m_UseImageDirection;
00233 
00234 };
00235 
00236 } // namespace itk
00237 
00238 #ifndef ITK_MANUAL_INSTANTIATION
00239 #include "itkBSplineInterpolateImageFunction.txx"
00240 #endif
00241 
00242 #endif
00243 
00244 #endif
00245 

Generated at Mon Apr 14 11:52:47 2008 for ITK by doxygen 1.5.1 written by Dimitri van Heesch, © 1997-2000