itkRayCastInterpolateImageFunction.h

Go to the documentation of this file.

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

Program:   Insight Segmentation & Registration Toolkit
Module:    $RCSfile: itkRayCastInterpolateImageFunction.h,v $
Language:  C++
Date:      $Date: 2003/09/10 14:28:37 $
Version:   $Revision: 1.4 $

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

#include "itkInterpolateImageFunction.h"
#include "itkTransform.h"
#include "itkVector.h"

namespace itk
{

template <class TInputImage, class TCoordRep = float>
class ITK_EXPORT RayCastInterpolateImageFunction : 
    public InterpolateImageFunction<TInputImage,TCoordRep> 
{
public:
  typedef RayCastInterpolateImageFunction Self;
  typedef InterpolateImageFunction<TInputImage,TCoordRep> Superclass;
  typedef SmartPointer<Self> Pointer;
  typedef SmartPointer<const Self>  ConstPointer;

  itkStaticConstMacro(InputImageDimension, unsigned int,
                      TInputImage::ImageDimension);

  typedef Transform<TCoordRep,3,3> TransformType;

  typedef typename TransformType::Pointer            TransformPointer;
  typedef typename TransformType::InputPointType     InputPointType;
  typedef typename TransformType::OutputPointType    OutputPointType;
  typedef typename TransformType::ParametersType     TransformParametersType;
  typedef typename TransformType::JacobianType       TransformJacobianType;

  typedef typename Superclass::InputPixelType        PixelType;

  typedef typename TInputImage::SizeType             SizeType;

  typedef itk::Vector<double, 3>                     DirectionType;

  typedef InterpolateImageFunction<TInputImage,TCoordRep> InterpolatorType;

  typedef typename InterpolatorType::Pointer         InterpolatorPointer;

  
  itkTypeMacro(RayCastInterpolateImageFunction, 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::PointType PointType;

  typedef typename Superclass::IndexType IndexType;

  typedef typename Superclass::ContinuousIndexType ContinuousIndexType;



  virtual OutputType Evaluate( const PointType& point ) const;

  virtual OutputType EvaluateAtContinuousIndex( 
    const ContinuousIndexType & index ) const {return 0; };


  itkSetObjectMacro( Transform, TransformType );
  itkGetObjectMacro( Transform, TransformType );
 
  itkSetObjectMacro( Interpolator, InterpolatorType );
  itkGetObjectMacro( Interpolator, InterpolatorType );

  itkSetMacro( FocalPoint, InputPointType );
  itkGetMacro( FocalPoint, InputPointType );

  itkSetMacro( Threshold, double );
  itkGetMacro( Threshold, double );
 
  inline bool IsInsideBuffer( const PointType & point ) const
    { 
      return true;
    }

  bool SetRay(OutputPointType RayPosn, DirectionType RayDirn) const;


  bool Integrate(double &integral) const {
    return IntegrateAboveThreshold(integral, 0);
  };


  bool IntegrateAboveThreshold(double &integral, double threshold) const;

  void IncrementIntensities(double increment=1) const;


  bool NextPoint(void) const;

  void Reset(void) const;
  
  void GetCurrentCoord3D(double &x, double &y, double &z) const;

  void GetCurrentVoxelCoord3D(double &x, double &y, double &z) const;

  double GetCurrentIntensity(void) const;

  double GetCurrentDensity(double threshold=0.) const;

  void GetCurrentVoxels(PixelType &voxel1, PixelType &voxel2, 
                        PixelType &voxel3, PixelType &voxel4) const;

  int GetNumberOfVoxels(void) const {return m_NumVoxelPlanesTraversed;};

  double GetRayPointSpacing(void) const {
    const double *spacing=m_Image->GetSpacing();

    if (m_ValidRay)
      return sqrt(  m_VoxelIncrement[0]*spacing[0]*m_VoxelIncrement[0]*spacing[0]
                    + m_VoxelIncrement[1]*spacing[1]*m_VoxelIncrement[1]*spacing[1]
                    + m_VoxelIncrement[2]*spacing[2]*m_VoxelIncrement[2]*spacing[2] );
    else
      return 0.;
  };

  void SetBoundingBox(double position[3], double size[3]) const;


protected:

  RayCastInterpolateImageFunction();

  ~RayCastInterpolateImageFunction(){};

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


  typedef enum {
    UNDEFINED_DIRECTION=0,        
    TRANSVERSE_IN_X,              
    TRANSVERSE_IN_Y,              
    TRANSVERSE_IN_Z,              
    LAST_DIRECTION
  } TraversalDirection;
  
  
  TransformPointer m_Transform;

  InputPointType m_FocalPoint;

  double m_Threshold;

  mutable bool m_ValidRay;

  mutable double m_RayVoxelStartPosition[3];

  mutable double m_RayVoxelEndPosition[3];


  mutable double m_Position3Dvox[3];

  mutable double m_VoxelIncrement[3];

  mutable TraversalDirection m_TraversalDirection;

  mutable int m_TotalRayVoxelPlanes;

  mutable int m_NumVoxelPlanesTraversed;

  mutable const PixelType *m_RayIntersectionVoxels[4];

  mutable int m_RayIntersectionVoxelIndex[3];


  mutable int m_NumberOfVoxelsInX;
  mutable int m_NumberOfVoxelsInY;
  mutable int m_NumberOfVoxelsInZ;

  mutable double m_VoxelDimensionInX;
  mutable double m_VoxelDimensionInY;
  mutable double m_VoxelDimensionInZ;

  mutable double m_RayStartCoordInMM[3];
  mutable double m_RayEndCoordInMM[3];


  mutable double m_BoundingPlane[6][4];
  mutable double m_BoundingCorner[8][3];

  mutable double m_CurrentRayPositionInMM[3];
  
  mutable double m_RayDirectionInMM[3];  

  InterpolatorPointer m_Interpolator;


  void EndPointsInVoxels(void) const;

  void CalcDirnVector(void) const;

  bool AdjustRayLength(void) const;

  void InitialiseVoxelPointers(void) const;

  void IncrementVoxelPointers(void) const;

  void Initialise(void) const;

  void RecordVolumeDimensions(void) const;

  void DefineCorners(void) const;

  void CalcPlanesAndCorners(void) const;
      
  bool CalcRayIntercepts(void) const;


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

  void ZeroState() const;
 

};

} // namespace itk

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

#endif

---