itkRay.h

Go to the documentation of this file.

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

  NifTK: A software platform for medical image computing.

  Copyright (c) University College London (UCL). All rights reserved.

  This software is distributed WITHOUT ANY WARRANTY; without even
  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  PURPOSE.

  See LICENSE.txt in the top level directory for details.

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

#ifndef itkRay_h
#define itkRay_h

#include <itkMatrix.h>

namespace itk {

template <class TInputImage, class TCoordRep = double>
class ITK_EXPORT Ray
{
public:

  Ray();

  virtual ~Ray() {};

  typedef itk::Point<TCoordRep, 3>                   InputPointType;
  typedef itk::Point<TCoordRep, 2>                   OutputPointType;

  typedef TInputImage                                InputImageType;
  typedef typename InputImageType::PixelType         PixelType;
  typedef typename InputImageType::IndexType         IndexType;
  typedef typename InputImageType::SizeType          SizeType;
  typedef typename InputImageType::OffsetValueType   OffsetValueType;

  typedef itk::Matrix<double, 4, 4> ProjectionMatrixType;

  void SetProjectionMatrix(const ProjectionMatrixType input) { m_ProjectionMatrix = input; }


  void SetImage(const InputImageType *input) { 
    m_Image = input; 
    Initialise();
  }

  bool SetRay(OutputPointType RayPosn);

  void SetProjectionResolution2Dmm(double xRes, double yRes) {
    m_ProjectionResolution2Dmm[0] = xRes;
    m_ProjectionResolution2Dmm[1] = yRes;
  }

  double GetCurrentIntensity(void) const;

  double GetRayPointSpacing(void) const {
    typename InputImageType::SpacingType spacing=this->m_Image->GetSpacing();

    if (m_ValidRay)
      return vcl_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.;
  };

  int GetNumberOfRayPoints(void) {return m_TotalRayVoxelPlanes;}

  void GetBilinearCoefficients(double &y, double &z) const;

  PixelType **GetRayIntersectionVoxels(void) {return m_RayIntersectionVoxels;}

  const int *GetRayIntersectionVoxelIndex(void) const {return m_RayIntersectionVoxelIndex;}

  int GetTraversalDirection(void) {return m_TraversalDirection;}

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


  bool IntegrateAboveThreshold(double &integral, double threshold);

  bool IncrementRayVoxelIntensities(double increment);

  void IncrementIntensities(double increment);

  void IncrementIntensities(void);

  void Reset(void);

  bool NextPoint(void);


protected:

  void ZeroState();

  void Initialise(void);

  void EndPointsInVoxels(void);

  void CalcDirnVector(void);

  bool AdjustRayLength(void);

  void InitialiseVoxelPointers(void);

  void IncrementVoxelPointers(void);

  void RecordVolumeDimensions(void);

  void DefineCorners(void);

  void CalcPlanesAndCorners(void);

  bool CalcRayIntercepts(void);

  void Line3D(double x2D, double y2D, double r[3], double u[3]);

  

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

  // Cache the image in the structure. Skip the smart pointer for
  // efficiency. This inner class will go in/out of scope with every
  // call to Evaluate()
  const InputImageType *m_Image;

  bool m_ValidRay;

  double m_RayPosition2Dmm[2];

  double m_ProjectionResolution2Dmm[2];

  double m_RayVoxelStartPosition[3];

  double m_RayVoxelEndPosition[3];


  double m_Position3Dvox[3];

  double m_VoxelIncrement[3];

  TraversalDirection m_TraversalDirection;

  int m_TotalRayVoxelPlanes;

  int m_NumVoxelPlanesTraversed;

  PixelType *m_RayIntersectionVoxels[4];

  int m_RayIntersectionVoxelIndex[3];

  int m_NumberOfVoxelsInX;
  int m_NumberOfVoxelsInY;
  int m_NumberOfVoxelsInZ;

  double m_VoxelDimensionInX;
  double m_VoxelDimensionInY;
  double m_VoxelDimensionInZ;

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


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

  double m_CurrentRayPositionInMM[3];

  double m_RayDirectionInMM[3];

  ProjectionMatrixType m_ProjectionMatrix;
};

} // end namespace itk

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

#endif