itkCoxDeBoorBSplineKernelFunction.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkCoxDeBoorBSplineKernelFunction.h,v $
  Language:  C++
  Date:      $Date: 2008-07-05 15:29:26 $
  Version:   $Revision: 1.2 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.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 __itkCoxDeBoorBSplineKernelFunction_h
#define __itkCoxDeBoorBSplineKernelFunction_h

#include "itkKernelFunction.h"
#include "vnl/vnl_math.h"
#include "vnl/vnl_real_polynomial.h"
#include "vnl/vnl_matrix.h"

namespace itk
{

template <unsigned int VSplineOrder = 3>
class ITK_EXPORT CoxDeBoorBSplineKernelFunction
: public KernelFunction
{
public:
  typedef CoxDeBoorBSplineKernelFunction        Self;
  typedef KernelFunction                        Superclass;
  typedef SmartPointer<Self>                    Pointer;
  typedef SmartPointer<const Self>              ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro( CoxDeBoorBSplineKernelFunction, KernelFunction );

  typedef double                                RealType;
  typedef vnl_vector<RealType>                  VectorType;
  typedef vnl_real_polynomial                   PolynomialType;
  typedef vnl_matrix<RealType>                  MatrixType;

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

  inline RealType Evaluate( const RealType & u ) const
    {
    RealType absValue = vnl_math_abs( u );
    unsigned int which;
    if ( this->m_SplineOrder % 2 == 0 )
      {
      which = static_cast<unsigned int>( absValue+0.5 );
      }
    else
      {
      which = static_cast<unsigned int>( absValue );
      }
    if ( which < this->m_BSplineShapeFunctions.rows() )
      {
      return PolynomialType(
        this->m_BSplineShapeFunctions.get_row( which ) ).evaluate( absValue );
      }
    else
      {
      return NumericTraits<RealType>::Zero;
      }
    }

  inline RealType EvaluateDerivative( const double & u ) const
    {
    RealType absValue = vnl_math_abs( u );
    unsigned int which;
    if ( this->m_SplineOrder % 2 == 0 )
      {
      which = static_cast<unsigned int>( absValue+0.5 );
      }
    else
      {
      which = static_cast<unsigned int>( absValue );
      }
    if( which < static_cast<unsigned int>( this->m_BSplineShapeFunctions.rows() ) )
      {
      RealType der = PolynomialType(
        this->m_BSplineShapeFunctions.get_row( which ) ).devaluate( absValue );
      if ( u < NumericTraits<RealType>::Zero )
        {
        return -der;
         }
      else
        {
         return der;
         }
      }
    else
      {
      return NumericTraits<RealType>::Zero;
      }
    }

  MatrixType GetShapeFunctions();

  MatrixType GetShapeFunctionsInZeroToOneInterval();

protected:
  CoxDeBoorBSplineKernelFunction();
  ~CoxDeBoorBSplineKernelFunction();
  void PrintSelf( std::ostream& os, Indent indent ) const;

private:
  CoxDeBoorBSplineKernelFunction( const Self& ); //purposely not implemented
  void operator=( const Self& ); //purposely not implemented

  void GenerateBSplineShapeFunctions( unsigned int );

  PolynomialType CoxDeBoor( unsigned short, VectorType, unsigned int, unsigned int );

  MatrixType    m_BSplineShapeFunctions;
  unsigned int  m_SplineOrder;

};

} // end namespace itk

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

#endif

---