itkSiddonJacobsRayCastInterpolateImageFunction.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
/*=========================================================================
Calculate DRR from a CT dataset using incremental ray-tracing algorithm
The algorithm was initially proposed by Robert Siddon and improved by
Filip Jacobs etc.

-------------------------------------------------------------------------
References:

R. L. Siddon, "Fast calculation of the exact radiological path for a
threedimensional CT array," Medical Physics 12, 252-55 (1985).

F. Jacobs, E. Sundermann, B. De Sutter, M. Christiaens, and I. Lemahieu,
"A fast algorithm to calculate the exact radiological path through a pixel
or voxel space," Journal of Computing and Information Technology ?
CIT 6, 89-94 (1998).

=========================================================================*/
#ifndef itkSiddonJacobsRayCastInterpolateImageFunction_h
#define itkSiddonJacobsRayCastInterpolateImageFunction_h

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

namespace itk
{

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

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


  typedef Euler3DTransform<TCoordRep> 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 Vector<TCoordRep, 3>                       DirectionType;

  typedef InterpolateImageFunction<TInputImage,TCoordRep> InterpolatorType;

  typedef typename InterpolatorType::Pointer         InterpolatorPointer;


  itkTypeMacro(SiddonJacobsRayCastInterpolateImageFunction, InterpolateImageFunction);

  itkNewMacro(Self);

  typedef typename Superclass::OutputType OutputType;

  typedef typename Superclass::InputImageType InputImageType;

  typedef typename Superclass::InputImageConstPointer InputImageConstPointer;

  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;

  virtual void Initialize(void);

  itkSetObjectMacro( Transform, TransformType );

  itkGetObjectMacro( Transform, TransformType );

  itkSetMacro(FocalPointToIsocenterDistance, double);
  itkGetMacro(FocalPointToIsocenterDistance, double);

  itkSetMacro(ProjectionAngle, double);
  itkGetMacro(ProjectionAngle, double);

  itkSetMacro(Threshold, double);
  itkGetMacro(Threshold, double);

  inline bool IsInsideBuffer( const PointType & ) const
  {
    return true;
  }
  bool IsInsideBuffer( const ContinuousIndexType &  ) const
  {
    return true;
  }
  bool IsInsideBuffer( const IndexType &  ) const
  {
    return true;
  }

protected:
  SiddonJacobsRayCastInterpolateImageFunction();

  ~SiddonJacobsRayCastInterpolateImageFunction(){};

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

  TransformPointer m_Transform; // Displacement of the volume
  // Overall inverse transform used to calculate the ray position in the input space
  TransformPointer m_InverseTransform;

  // The threshold above which voxels along the ray path are integrated
  double m_Threshold;
  double m_FocalPointToIsocenterDistance; // Focal point to isocenter distance
  double m_ProjectionAngle; // Linac gantry rotation angle in radians

private:
  SiddonJacobsRayCastInterpolateImageFunction( const Self& ); //purposely not implemented
  void operator=( const Self& ); //purposely not implemented
  void ComputeInverseTransform( void ) const;
  TransformPointer m_GantryRotTransform; // Gantry rotation transform
  TransformPointer m_CamShiftTransform; // Camera shift transform camRotTransform
  TransformPointer m_CamRotTransform; // Camera rotation transform
  TransformPointer m_ComposedTransform; // Composed transform
  PointType        m_SourcePoint; // Coordinate of the source in the standard Z projection geometry
  PointType        m_SourceWorld; // Coordinate of the source in the world coordinate system
};

} // namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkSiddonJacobsRayCastInterpolateImageFunction.hxx"
#endif

#endif