Projection/itkForwardAndBackwardProjectionMatrix.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 itkForwardAndBackwardProjectionMatrix_h
#define itkForwardAndBackwardProjectionMatrix_h

#include "itkRay.h"
#include <itkImage.h>

#include <vnl/vnl_math.h>
#include <vnl/vnl_vector.h>
#include <vnl/vnl_sparse_matrix.h>

#include "itkProjectionGeometry.h"
#include <itkEulerAffineTransform.h>
#include <itkPerspectiveProjectionTransform.h>

namespace itk
{

  template <class TScalarType = double, class IntensityType = float>
    class ITK_EXPORT ForwardAndBackwardProjectionMatrix : public Object
  {
    public:
      typedef ForwardAndBackwardProjectionMatrix            Self;
      typedef Object                                        Superclass;
      typedef SmartPointer<Self>                            Pointer;
      typedef SmartPointer<const Self>                      ConstPointer;

      itkNewMacro(Self);

      itkTypeMacro(ForwardAndBackwardProjectionMatrix, Object);

      typedef typename itk::Size<3>                                   VolumeSizeType;

      typedef Image<IntensityType, 3>                                 InputImageType;
      typedef typename InputImageType::Pointer                        InputImagePointer;
      typedef typename InputImageType::ConstPointer                   InputImageConstPointer;
      typedef typename InputImageType::RegionType                     InputImageRegionType;
      typedef typename InputImageType::PixelType                      InputImagePixelType;
      typedef typename InputImageType::SizeType                       InputImageSizeType;
      typedef typename InputImageType::SpacingType                    InputImageSpacingType;
      typedef typename InputImageType::PointType                      InputImagePointType;
      typedef typename InputImageType::IndexType                      InputImageIndexType;

      typedef Image<IntensityType, 2>                                 OutputImageType;
      typedef typename OutputImageType::Pointer                       OutputImagePointer;
      typedef typename OutputImageType::ConstPointer                  OutputImageConstPointer;
      typedef typename OutputImageType::RegionType                    OutputImageRegionType;
      typedef typename OutputImageType::PixelType                     OutputImagePixelType;
      typedef typename OutputImageType::SizeType                      OutputImageSizeType;
      typedef typename OutputImageType::SpacingType                   OutputImageSpacingType;
      typedef typename OutputImageType::PointType                     OutputImagePointType;
      typedef typename OutputImageType::IndexType                     OutputImageIndexType;

      typedef itk::ProjectionGeometry<IntensityType>                  ProjectionGeometryType;
      typedef typename ProjectionGeometryType::Pointer                ProjectionGeometryPointer;

      typedef itk::EulerAffineTransform<double, 3, 3>                 EulerAffineTransformType;
      typedef typename EulerAffineTransformType::Pointer              EulerAffineTransformPointer;

      typedef itk::PerspectiveProjectionTransform<double>             PerspectiveProjectionTransformType;
      typedef typename PerspectiveProjectionTransformType::Pointer    PerspectiveProjectionTransformPointer;

      itkSetObjectMacro( ProjectionGeometry, ProjectionGeometryType );
      itkGetObjectMacro( ProjectionGeometry, ProjectionGeometryType );
      itkSetObjectMacro( AffineTransform, EulerAffineTransformType );
      itkGetObjectMacro( AffineTransform, EulerAffineTransformType );
      itkSetObjectMacro( PerspectiveTransform, PerspectiveProjectionTransformType );
      itkGetObjectMacro( PerspectiveTransform, PerspectiveProjectionTransformType );


      void SetProjectedImageSize(OutputImageSizeType &outImageSize) {m_OutputImageSize = outImageSize;};
      void SetProjectedImageSpacing(OutputImageSpacingType &outImageSpacing) {
        m_OutputImageSpacing = outImageSpacing;
        this->GetOutput()->SetSpacing(m_OutputImageSpacing);
      };
      void SetProjectedImageOrigin(OutputImagePointType &outImageOrigin) {
        m_OutputImageOrigin = outImageOrigin;
        this->GetOutput()->SetOrigin(m_OutputImageOrigin);
      };


      typedef vnl_sparse_matrix<TScalarType>                    SparseMatrixType;
      typedef vnl_matrix<TScalarType>                           FullMatrixType;
      typedef vnl_vector<TScalarType>                           VectorType;

      void SetVolumeSize(const VolumeSizeType &r) {m_VolumeSize = r; m_FlagInitialised = false;}

      void GetForwardProjectionSparseMatrix(SparseMatrixType &R, InputImageConstPointer inImage, OutputImagePointer outImage,
          VolumeSizeType &inSize, OutputImageSizeType &outSize, const unsigned int &projNum);

      void GetForwardProjectionSparseMatrix(SparseMatrixType &R, InputImagePointer inImage, OutputImagePointer outImage,
          VolumeSizeType &inSize, OutputImageSizeType &outSize, const unsigned int &projNum);

      void GetBackwardProjectionSparseMatrix(SparseMatrixType &R, SparseMatrixType &RTrans, 
          VolumeSizeType &inSize, OutputImageSizeType &outSize, const unsigned int &projNum);

      void CalculteMatrixVectorMultiplication(SparseMatrixType &R, VectorType const &inputImageVector, VectorType &outputImageVector);


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

      VolumeSizeType        m_VolumeSize;
      unsigned long int     m_input3DImageTotalSize;
      unsigned long int     m_output2DImageTotalSize;

      bool m_FlagInitialised;

      OutputImageSizeType     m_OutputImageSize;
      OutputImageSpacingType  m_OutputImageSpacing;
      OutputImagePointType    m_OutputImageOrigin;

      double m_Threshold;

      ProjectionGeometryPointer m_ProjectionGeometry;

      EulerAffineTransformType::Pointer m_AffineTransform; 

      PerspectiveProjectionTransformType::Pointer m_PerspectiveTransform;

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

      // SparseMatrixType const*                        pSparseForwardProjMatrix;

      // SparseMatrixType const*                        pSparseBackwardProjMatrix;


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

  };

} // end namespace itk

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

#endif