rtkThreeDCircularProjectionGeometry.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright RTK 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.
 *
 *=========================================================================*/

#ifndef rtkThreeDCircularProjectionGeometry_h
#define rtkThreeDCircularProjectionGeometry_h

#include "RTKExport.h"
#include "rtkProjectionGeometry.h"

namespace rtk
{
class RTK_EXPORT ThreeDCircularProjectionGeometry : public ProjectionGeometry<3>
{
public:
  typedef ThreeDCircularProjectionGeometry Self;
  typedef ProjectionGeometry<3>            Superclass;
  typedef itk::SmartPointer< Self >        Pointer;
  typedef itk::SmartPointer< const Self >  ConstPointer;

  typedef itk::Vector<double, 3>           VectorType;
  typedef itk::Vector<double, 4>           HomogeneousVectorType;
  typedef itk::Matrix<double, 3, 3 >       TwoDHomogeneousMatrixType;
  typedef itk::Matrix<double, 4, 4 >       ThreeDHomogeneousMatrixType;
  typedef itk::Point<double, 3>            PointType;
  typedef itk::Matrix<double, 3, 3>        Matrix3x3Type;
  typedef Superclass::MatrixType           HomogeneousProjectionMatrixType;

  itkNewMacro( Self );

  void AddProjection(const double sid, const double sdd, const double gantryAngle,
                     const double projOffsetX=0., const double projOffsetY=0.,
                     const double outOfPlaneAngle=0., const double inPlaneAngle=0.,
                     const double sourceOffsetX=0., const double sourceOffsetY=0.);

  virtual void AddProjectionInRadians(const double sid, const double sdd, const double gantryAngle,
                                      const double projOffsetX=0., const double projOffsetY=0.,
                                      const double outOfPlaneAngle=0., const double inPlaneAngle=0.,
                                      const double sourceOffsetX=0., const double sourceOffsetY=0.);

  bool AddProjection(const PointType &sourcePosition,
                     const PointType &detectorPosition,
                     const VectorType &detectorRowVector,
                     const VectorType &detectorColumnVector);


  bool AddProjection(const HomogeneousProjectionMatrixType &pMat);

  void Clear() ITK_OVERRIDE;

  const std::vector<double> &GetGantryAngles() const {
    return this->m_GantryAngles;
  }
  const std::vector<double> &GetOutOfPlaneAngles() const {
    return this->m_OutOfPlaneAngles;
  }
  const std::vector<double> &GetInPlaneAngles() const {
    return this->m_InPlaneAngles;
  }
  const std::vector<double> &GetSourceToIsocenterDistances() const {
    return this->m_SourceToIsocenterDistances;
  }
  const std::vector<double> &GetSourceOffsetsX() const {
    return this->m_SourceOffsetsX;
  }
  const std::vector<double> &GetSourceOffsetsY() const {
    return this->m_SourceOffsetsY;
  }
  const std::vector<double> &GetSourceToDetectorDistances() const {
    return this->m_SourceToDetectorDistances;
  }
  const std::vector<double> &GetProjectionOffsetsX() const {
    return this->m_ProjectionOffsetsX;
  }
  const std::vector<double> &GetProjectionOffsetsY() const {
    return this->m_ProjectionOffsetsY;
  }

  const std::vector<double> &GetSourceAngles() const {
    return this->m_SourceAngles;
  }

  const std::vector<double> GetTiltAngles();

  const std::multimap<double,unsigned int> GetSortedAngles(const std::vector<double> &angles) const;

  const std::map<double,unsigned int> GetUniqueSortedAngles(const std::vector<double> &angles) const;

  const std::vector<double> GetAngularGapsWithNext(const std::vector<double> &angles) const;

  const std::vector<double> GetAngularGaps(const std::vector<double> &angles);

  static ThreeDHomogeneousMatrixType
  ComputeRotationHomogeneousMatrix(double angleX,
                                   double angleY,
                                   double angleZ);

  static TwoDHomogeneousMatrixType
  ComputeTranslationHomogeneousMatrix(double transX,
                                      double transY);
  static ThreeDHomogeneousMatrixType
  ComputeTranslationHomogeneousMatrix(double transX,
                                      double transY,
                                      double transZ);

  static Superclass::MatrixType ComputeProjectionMagnificationMatrix(double sdd,
                                                                     double sid);

  const std::vector<TwoDHomogeneousMatrixType> &GetProjectionTranslationMatrices() const {
    return this->m_ProjectionTranslationMatrices;
  }
  TwoDHomogeneousMatrixType GetProjectionTranslationMatrix(const unsigned int i) const {
    return this->m_ProjectionTranslationMatrices[i];
  }

  const std::vector<ThreeDHomogeneousMatrixType> &GetRotationMatrices() const {
    return this->m_RotationMatrices;
  }
  ThreeDHomogeneousMatrixType GetRotationMatrix(const unsigned int i) const {
    return this->m_RotationMatrices[i];
  }

  const std::vector<ThreeDHomogeneousMatrixType> &GetSourceTranslationMatrices() const {
    return this->m_SourceTranslationMatrices;
  }
  ThreeDHomogeneousMatrixType GetSourceTranslationMatrices(const unsigned int i) const {
    return this->m_SourceTranslationMatrices[i];
  }

  const std::vector<Superclass::MatrixType> &GetMagnificationMatrices() const {
    return this->m_MagnificationMatrices;
  }
  Superclass::MatrixType GetMagnificationMatrices(const unsigned int i) const {
    return this->m_MagnificationMatrices[i];
  }


  const std::vector<double> &GetCollimationUInf() const {
    return this->m_CollimationUInf;
  }
  const std::vector<double> &GetCollimationUSup() const {
    return this->m_CollimationUSup;
  }
  const std::vector<double> &GetCollimationVInf() const {
    return this->m_CollimationVInf;
  }
  const std::vector<double> &GetCollimationVSup() const {
    return this->m_CollimationVSup;
  }

  void SetCollimationOfLastProjection(const double uinf,
                                      const double usup,
                                      const double vinf,
                                      const double vsup);

  const HomogeneousVectorType GetSourcePosition(const unsigned int i) const;

  const ThreeDHomogeneousMatrixType GetProjectionCoordinatesToDetectorSystemMatrix(const unsigned int i) const;

  const ThreeDHomogeneousMatrixType GetProjectionCoordinatesToFixedSystemMatrix(const unsigned int i) const;

  static double ConvertAngleBetween0And360Degrees(const double a);

  static double ConvertAngleBetween0And2PIRadians(const double a);

  static double ConvertAngleBetweenMinusAndPlusPIRadians(const double a);

  double ToUntiltedCoordinateAtIsocenter(const unsigned int noProj,
                                         const double tiltedCoord) const;

  itkGetConstMacro(RadiusCylindricalDetector, double)
  itkSetMacro(RadiusCylindricalDetector, double)

protected:
  ThreeDCircularProjectionGeometry();
  virtual ~ThreeDCircularProjectionGeometry() ITK_OVERRIDE {}

  virtual void AddProjectionTranslationMatrix(const TwoDHomogeneousMatrixType &m){
    this->m_ProjectionTranslationMatrices.push_back(m);
    this->Modified();
  }
  virtual void AddRotationMatrix(const ThreeDHomogeneousMatrixType &m){
    this->m_RotationMatrices.push_back(m);
    this->Modified();
  }
  virtual void AddSourceTranslationMatrix(const ThreeDHomogeneousMatrixType &m){
    this->m_SourceTranslationMatrices.push_back(m);
    this->Modified();
  }
  virtual void AddMagnificationMatrix(const Superclass::MatrixType &m){
    this->m_MagnificationMatrices.push_back(m);
    this->Modified();
  }

  bool VerifyAngles(const double outOfPlaneAngleRAD, const double gantryAngleRAD,
                    const double inPlaneAngleRAD,
                    const Matrix3x3Type &referenceMatrix) const;

  bool FixAngles(double &outOfPlaneAngleRAD, double &gantryAngleRAD,
                 double &inPlaneAngleRAD,
                 const Matrix3x3Type &referenceMatrix) const;

  itk::LightObject::Pointer InternalClone() const ITK_OVERRIDE;

  std::vector<double> m_GantryAngles;
  std::vector<double> m_OutOfPlaneAngles;
  std::vector<double> m_InPlaneAngles;
  std::vector<double> m_SourceAngles;
  std::vector<double> m_SourceToIsocenterDistances;
  std::vector<double> m_SourceOffsetsX;
  std::vector<double> m_SourceOffsetsY;
  std::vector<double> m_SourceToDetectorDistances;
  std::vector<double> m_ProjectionOffsetsX;
  std::vector<double> m_ProjectionOffsetsY;

  double m_RadiusCylindricalDetector;

  std::vector<double> m_CollimationUInf;
  std::vector<double> m_CollimationUSup;
  std::vector<double> m_CollimationVInf;
  std::vector<double> m_CollimationVSup;

  std::vector<TwoDHomogeneousMatrixType>         m_ProjectionTranslationMatrices;
  std::vector<Superclass::MatrixType>            m_MagnificationMatrices;
  std::vector<ThreeDHomogeneousMatrixType>       m_RotationMatrices;
  std::vector<ThreeDHomogeneousMatrixType>       m_SourceTranslationMatrices;

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


#endif // __rtkThreeDCircularProjectionGeometry_h