itkWindowedSincInterpolateImageFunction.h

Go to the documentation of this file.

#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) 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 * 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 LancosWindowFunction
{
public:
  inline TOutput operator()( const TInput & A ) const
    {
    if(A == 0.0) return (TOutput) 1.0;
    double z = m_Factor * A;
    return (TOutput) ( 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 * cos(A * m_Factor1) + 0.08 * 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 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& ); //purposely 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 : sin(px) / px;
    }
};

} // namespace itk

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

#endif // _itkWindowedSincInterpolateImageFunction_h

---