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:
  ITK_DISALLOW_COPY_AND_ASSIGN(SiddonJacobsRayCastInterpolateImageFunction);

  using Self = SiddonJacobsRayCastInterpolateImageFunction;
  using Superclass = InterpolateImageFunction<TInputImage,TCoordRep>;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;

  static constexpr unsigned int InputImageDimension = TInputImage::ImageDimension;


  using TransformType = Euler3DTransform<TCoordRep>;

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

  using PixelType = typename Superclass::InputPixelType;

  using SizeType = typename TInputImage::SizeType;

  using DirectionType = Vector<TCoordRep, 3>;

  using InterpolatorType = InterpolateImageFunction<TInputImage,TCoordRep>;

  using InterpolatorPointer = typename InterpolatorType::Pointer;


  itkTypeMacro(SiddonJacobsRayCastInterpolateImageFunction, InterpolateImageFunction);

  itkNewMacro(Self);

  using OutputType = typename Superclass::OutputType;

  using InputImageType = typename Superclass::InputImageType;

  using InputImageConstPointer = typename Superclass::InputImageConstPointer;

  using RealType = typename Superclass::RealType;

  static constexpr unsigned int ImageDimension = Superclass::ImageDimension;

  using PointType = typename Superclass::PointType;

  using IndexType = typename Superclass::IndexType;

  using ContinuousIndexType = typename Superclass::ContinuousIndexType;


  OutputType Evaluate( const PointType& point ) const override;

  OutputType EvaluateAtContinuousIndex(
    const ContinuousIndexType &index ) const override;

  virtual void Initialize(void);

  itkSetObjectMacro( Transform, TransformType );

  itkGetConstObjectMacro( 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 override
  {
    return true;
  }
  bool IsInsideBuffer( const ContinuousIndexType &  ) const override
  {
    return true;
  }
  bool IsInsideBuffer( const IndexType &  ) const override
  {
    return true;
  }

protected:
  SiddonJacobsRayCastInterpolateImageFunction();

  ~SiddonJacobsRayCastInterpolateImageFunction() override{};

  void PrintSelf(std::ostream& os, Indent indent) const 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:
  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