itkWindowedSincInterpolateImageFunction.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkWindowedSincInterpolateImageFunction.h,v $
  Language:  C++
  Date:      $Date: 2009-10-29 11:18:58 $
  Version:   $Revision: 1.10 $

  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 __itkWindowedSincInterpolateImageFunction_h
#define __itkWindowedSincInterpolateImageFunction_h

#include "itkConstNeighborhoodIterator.h"
#include "itkConstantBoundaryCondition.h"
#include "itkInterpolateImageFunction.h"

namespace itk
{

namespace Function {

template< unsigned int VRadius, 
  class TInput=double, class TOutput=double>
class CosineWindowFunction
{
public:
  inline TOutput operator()( const TInput & A ) const
    { return (TOutput) vcl_cos(A * m_Factor ); }
private:
  static const double m_Factor;
}; 

template< unsigned int VRadius, 
  class TInput=double, class TOutput=double>
class HammingWindowFunction
{
public:
  inline TOutput operator()( const TInput & A ) const
   { return (TOutput) 0.54 + 0.46 * vcl_cos(A * m_Factor ); }
private:
  static const double m_Factor;
}; 

template< unsigned int VRadius, 
  class TInput=double, class TOutput=double>
class WelchWindowFunction
{
public:
  inline TOutput operator()( const TInput & A ) const
   { return (TOutput) (1.0 - A * m_Factor * A); }
private:
  static const double m_Factor;
}; 

template< unsigned int VRadius, 
  class TInput=double, class TOutput=double>
class LanczosWindowFunction
{
public:
  inline TOutput operator()( const TInput & A ) const
    {
    if(A == 0.0) return (TOutput) 1.0;
    double z = m_Factor * A;
    return (TOutput) ( vcl_sin(z) / z ); 
    }
private:
  static const double m_Factor;
}; 

template< unsigned int VRadius, 
  class TInput=double, class TOutput=double>
class BlackmanWindowFunction
{
public:
  inline TOutput operator()( const TInput & A ) const
    {
    return (TOutput)
      (0.42 + 0.5 * vcl_cos(A * m_Factor1) + 0.08 * vcl_cos(A * m_Factor2));
    }
private:
  static const double m_Factor1;
  
  static const double m_Factor2;
}; 

} // namespace Function

template <
  class TInputImage, 
  unsigned int VRadius, 
  class TWindowFunction = Function::HammingWindowFunction<VRadius>,
  class TBoundaryCondition = ConstantBoundaryCondition<TInputImage>,
  class TCoordRep=double >
class ITK_EXPORT WindowedSincInterpolateImageFunction : 
  public InterpolateImageFunction<TInputImage, TCoordRep>
{
public:
  typedef WindowedSincInterpolateImageFunction            Self;
  typedef InterpolateImageFunction<TInputImage,TCoordRep> Superclass;

  typedef SmartPointer<Self>        Pointer;
  typedef SmartPointer<const Self>  ConstPointer;
  
  itkTypeMacro(WindowedSincInterpolateImageFunction, 
    InterpolateImageFunction);

  itkNewMacro(Self);  

  typedef typename Superclass::OutputType OutputType;

  typedef typename Superclass::InputImageType InputImageType;

  typedef typename Superclass::RealType RealType;

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

  typedef typename Superclass::IndexType      IndexType;
  typedef typename Superclass::IndexValueType IndexValueType;
  
  typedef TInputImage ImageType;

  typedef typename Superclass::ContinuousIndexType ContinuousIndexType;

  virtual void SetInputImage(const ImageType *image);

  virtual OutputType EvaluateAtContinuousIndex( 
    const ContinuousIndexType & index ) const;

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

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

  // Internal typedefs
  typedef ConstNeighborhoodIterator<
    ImageType, TBoundaryCondition> IteratorType;

  // Constant to store twice the radius
  static const unsigned int m_WindowSize;

  TWindowFunction m_WindowFunction;
  
  unsigned int *m_OffsetTable;

  unsigned int m_OffsetTableSize;

  unsigned int **m_WeightOffsetTable;

  inline double Sinc(double x) const
    { 
    double px = vnl_math::pi * x;
    return (x == 0.0) ? 1.0 : vcl_sin(px) / px;
    }
};

} // namespace itk

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

#endif // _itkWindowedSincInterpolateImageFunction_h