itkBSplineInterpolateImageFunction.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkBSplineInterpolateImageFunction.h,v $
  Language:  C++
  Date:      $Date: 2002/09/17 23:27:16 $
  Version:   $Revision: 1.1 $

  Copyright (c) 2002 Insight Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

  Portions of this code are covered under the VTK copyright.
  See VTKCopyright.txt or http://www.kitware.com/VTKCopyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/

#ifndef __itkBSplineInterpolateImageFunction_h
#define __itkBSplineInterpolateImageFunction_h

#include <vector>

#include "itkImageLinearIteratorWithIndex.h"
#include "itkInterpolateImageFunction.h"
#include "vnl/vnl_matrix.h"

#include "itkBSplineDecompositionImageFilter.h"

namespace itk
{
template <class TImageType, class TCoordRep = float>
class ITK_EXPORT BSplineInterpolateImageFunction : 
  public InterpolateImageFunction<TImageType,TCoordRep> 
{
public:
  typedef BSplineInterpolateImageFunction       Self;
  typedef InterpolateImageFunction<TImageType,TCoordRep>  Superclass;
  typedef SmartPointer<Self>                    Pointer;
  typedef SmartPointer<const Self>              ConstPointer;

  itkTypeMacro(BSplineInterpolateImageFunction, InterpolateImageFunction);

 
  itkNewMacro( Self );

  typedef typename Superclass::OutputType OutputType;

  typedef typename Superclass::InputImageType InputImageType;

  itkStaticConstMacro(ImageDimension, unsigned int,Superclass::ImageDimension);

  typedef typename Superclass::IndexType IndexType;

  typedef typename Superclass::ContinuousIndexType ContinuousIndexType;

  typedef typename Superclass::PointType PointType;

  typedef itk::ImageLinearIteratorWithIndex<TImageType> Iterator;

  /*** TODO:  Need to permit templating over a different output type. */
  typedef itk::BSplineDecompositionImageFilter<TImageType, TImageType> 
    CoefficientFilter;
  typedef typename CoefficientFilter::Pointer CoefficientFilterPointer;

  virtual OutputType EvaluateAtContinuousIndex( 
      const ContinuousIndexType & index ) const; 

  typedef CovariantVector<OutputType,itkGetStaticConstMacro(ImageDimension)>
      CovariantVectorType;

  CovariantVectorType EvaluateDerivative( const PointType & point )
    {    
    ContinuousIndexType index;
    this->ConvertPointToContinuousIndex( point, index );
    return ( this->EvaluateDerivativeAtContinuousIndex( index ) );
    }

  CovariantVectorType EvaluateDerivativeAtContinuousIndex( 
    const ContinuousIndexType & x ) const;


  void SetSplineOrder(unsigned int SplineOrder);
  itkGetMacro(SplineOrder, int);


  virtual void SetInputImage(const TImageType * inputData);

protected:
  BSplineInterpolateImageFunction();
  virtual ~BSplineInterpolateImageFunction() {};
  void PrintSelf(std::ostream& os, Indent indent) const;

    // These are needed by the smoothing spline routine.
  std::vector<double>    m_Scratch;        // temp storage for processing of Coefficients
  typename TImageType::SizeType      m_DataLength;  // Image size
  unsigned int                       m_SplineOrder; // User specified spline order (3rd or cubic is the default)
  //TODO  Should these be double?
  typename TImageType::Pointer       m_Coefficients; // Spline coefficients  

private:
  void SetInterpolationWeights( const ContinuousIndexType & x, 
    const vnl_matrix<long> & EvaluateIndex, 
    vnl_matrix<double> & weights, 
    unsigned int splineOrder ) const;

  void SetDerivativeWeights( const ContinuousIndexType & x, 
    const vnl_matrix<long> & EvaluateIndex, 
    vnl_matrix<double> & weights, 
    unsigned int splineOrder ) const;

  void GeneratePointsToIndex(  );

  void DetermineRegionOfSupport( vnl_matrix<long> & evaluateIndex, 
    const ContinuousIndexType & x, 
    unsigned int splineOrder ) const;

  void ApplyMirrorBoundaryConditions(vnl_matrix<long> & evaluateIndex, 
    unsigned int splineOrder) const;


  Iterator                  m_CIterator;    // Iterator for traversing spline coefficients.
  unsigned long             m_MaxNumberInterpolationPoints; // number of neighborhood points used for interpolation
  std::vector<IndexType>    m_PointsToIndex;  // Preallocation of interpolation neighborhood indicies

  BSplineInterpolateImageFunction( const Self& ); //purposely not implemented
  void operator=( const Self& ); //purposely not implemented
  CoefficientFilterPointer     m_CoefficientFilter;
  
};

} // namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkBSplineInterpolateImageFunction.txx"
#endif

#endif

---