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:
#if ITK_VERSION_MAJOR == 5 && ITK_VERSION_MINOR == 1
  ITK_DISALLOW_COPY_AND_ASSIGN(ThreeDCircularProjectionGeometry);
#else
  ITK_DISALLOW_COPY_AND_MOVE(ThreeDCircularProjectionGeometry);
#endif

  using Self = ThreeDCircularProjectionGeometry;
  using Superclass = ProjectionGeometry<3>;
  using Pointer = itk::SmartPointer<Self>;
  using ConstPointer = itk::SmartPointer<const Self>;

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

  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() 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;

  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();
  ~ThreeDCircularProjectionGeometry() override = default;

  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 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{ 0. };

  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;
};
} // namespace rtk


#endif // __rtkThreeDCircularProjectionGeometry_h