itkImageFunction.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkImageFunction.h,v $
  Language:  C++
  Date:      $Date: 2008-04-19 22:31:03 $
  Version:   $Revision: 1.46 $

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

#include "itkFunctionBase.h"
#include "itkPoint.h"
#include "itkIndex.h"
#include "itkContinuousIndex.h"
#include "itkImageBase.h"

namespace itk
{


template <
class TInputImage, 
class TOutput,
class TCoordRep = float 
>
class ITK_EXPORT ImageFunction : 
    public FunctionBase< Point<TCoordRep,
                               ::itk::GetImageDimension<TInputImage>::ImageDimension>, 
                       TOutput > 
{
public:
  itkStaticConstMacro(ImageDimension, unsigned int,
                      TInputImage::ImageDimension);

  typedef ImageFunction Self;
  typedef FunctionBase< Point<TCoordRep,
                              itkGetStaticConstMacro(ImageDimension)>,
                        TOutput > Superclass;
  typedef SmartPointer<Self>  Pointer;
  typedef SmartPointer<const Self>  ConstPointer;

  itkTypeMacro(ImageFunction, FunctionBase);

  typedef TInputImage InputImageType;

  typedef typename InputImageType::PixelType InputPixelType;

  typedef typename InputImageType::ConstPointer InputImageConstPointer;

  typedef TOutput OutputType;

  typedef TCoordRep CoordRepType;

  typedef typename InputImageType::IndexType IndexType;

  typedef ContinuousIndex<TCoordRep,itkGetStaticConstMacro(ImageDimension)>
          ContinuousIndexType;

  typedef Point<TCoordRep,itkGetStaticConstMacro(ImageDimension)> PointType;

  virtual void SetInputImage( const InputImageType * ptr );

  const InputImageType * GetInputImage() const
    { return m_Image.GetPointer(); }

  virtual TOutput Evaluate( const PointType& point ) const = 0;

  virtual TOutput EvaluateAtIndex( const IndexType & index ) const = 0;

  virtual TOutput EvaluateAtContinuousIndex( 
    const ContinuousIndexType & index ) const = 0;

  virtual bool IsInsideBuffer( const IndexType & index ) const
    { 
      for ( unsigned int j = 0; j < ImageDimension; j++ )
        {
        if ( index[j] < m_StartIndex[j] ) { return false; };
        if ( index[j] > m_EndIndex[j] ) { return false; };
        }
      return true;
    }

  virtual bool IsInsideBuffer( const ContinuousIndexType & index ) const
    { 
      for ( unsigned int j = 0; j < ImageDimension; j++ )
        {
        if ( index[j] < m_StartContinuousIndex[j] ) { return false; };
        if ( index[j] > m_EndContinuousIndex[j] ) { return false; };
        }
      return true;
    }

  virtual bool IsInsideBuffer( const PointType & point ) const
    { 
    ContinuousIndexType index;
    m_Image->TransformPhysicalPointToContinuousIndex( point, index );
    return this->IsInsideBuffer( index );
    }

  void ConvertPointToNearestIndex( const PointType & point,
    IndexType & index ) const
    {
    ContinuousIndexType cindex;
    m_Image->TransformPhysicalPointToContinuousIndex( point, cindex );
    this->ConvertContinuousIndexToNearestIndex( cindex, index );
    }

   void ConvertPointToContinousIndex( const PointType & point,
    ContinuousIndexType & cindex ) const
    {
    itkWarningMacro("Please change your code to use ConvertPointToContinuousIndex rather than ConvertPointToContinousIndex. The latter method name was mispelled and the ITK developers failed to correct it before it was released. The mispelled method name is retained in order to maintain backward compatibility.");
    this->ConvertPointToContinuousIndex( point, cindex );
    }

   void ConvertPointToContinuousIndex( const PointType & point,
    ContinuousIndexType & cindex ) const
    {
    m_Image->TransformPhysicalPointToContinuousIndex( point, cindex );
    }

  inline void ConvertContinuousIndexToNearestIndex( const ContinuousIndexType & cindex,
    IndexType & index ) const
    {
    index.CopyWithRound( cindex );
    }

  itkGetConstReferenceMacro(StartIndex, IndexType);
  itkGetConstReferenceMacro(EndIndex, IndexType);

  itkGetConstReferenceMacro(StartContinuousIndex, ContinuousIndexType);
  itkGetConstReferenceMacro(EndContinuousIndex, ContinuousIndexType);

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

  InputImageConstPointer  m_Image;

  IndexType               m_StartIndex;
  IndexType               m_EndIndex;
  ContinuousIndexType     m_StartContinuousIndex;
  ContinuousIndexType     m_EndContinuousIndex;

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

} // end namespace itk

// Define instantiation macro for this template.
#define ITK_TEMPLATE_ImageFunction(_, EXPORT, x, y) namespace itk { \
  _(3(class EXPORT ImageFunction< ITK_TEMPLATE_3 x >)) \
  namespace Templates { typedef ImageFunction< ITK_TEMPLATE_3 x > ImageFunction##y; } \
  }

#if ITK_TEMPLATE_EXPLICIT
# include "Templates/itkImageFunction+-.h"
#endif

#if ITK_TEMPLATE_TXX
# include "itkImageFunction.txx"
#endif

#endif

---