geometrydecoder.h

Go to the documentation of this file.

#ifndef CTL_GEOMETRYDECODER_H
#define CTL_GEOMETRYDECODER_H

#include "acquisitionsetup.h"
#include "viewgeometry.h"
#include "mat/mat.h"
#include <QSizeF>
#include <QPair>

namespace CTL {

class GeometryDecoder
{
public:
    enum PhysicalDimension { PixelWidth, PixelHeight, SourceDetectorDistance };

    GeometryDecoder(const QSize& pixelPerModule, const QSizeF& pixelSize);
    GeometryDecoder(const QSize& pixelPerModule,
                    PhysicalDimension physicalDimension = PixelWidth,
                    double mm = 1.0);

    AcquisitionSetup decodeFullGeometry(const FullGeometry& geometry) const;

    const QPair<PhysicalDimension, double>& dimensionReference() const;
    const QSize& pixelPerModule() const;
    Q_DECL_DEPRECATED_X("Within the CTL 'dimension' is use for a count of something, use pixelSize() instead.")
    const QSizeF& pixelDimensions() const;
    const QSizeF& pixelSize() const;
    void setDimensionReference(PhysicalDimension physicalDimension, double mm);
    void setPixelPerModule(const QSize& value);
    Q_DECL_DEPRECATED_X("Within the CTL 'dimension' is use for a count of something, use setPixelSize() instead.")
    void setPixelDimensions(const QSizeF& value);
    void setPixelSize(const QSizeF& value);
    void setReferenceModuleID(int moduleID);

    static SimpleCTSystem decodeSingleViewGeometry(const SingleViewGeometry& singleViewGeometry,
                                                   const QSize& pixelPerModule,
                                                   PhysicalDimension physicalDimension = PixelWidth,
                                                   double mm = 1.0,
                                                   int referenceModuleID = -1);

    static AcquisitionSetup decodeFullGeometry(const FullGeometry& geometry,
                                               const QSize& pixelPerModule,
                                               const QSizeF& pixelSize,
                                               int referenceModuleID = -1);

    static AcquisitionSetup decodeFullGeometry(const FullGeometry& geometry,
                                               const QSize& pixelPerModule,
                                               PhysicalDimension physicalDimension = PixelWidth,
                                               double mm = 1.0,
                                               int referenceModuleID = -1);

private:
    QSize _pixelPerModule; 
    QSizeF _pixelSize;     
    QPair<PhysicalDimension, double> _physicalDimensionReference = { PixelWidth, 1.0 };
    int _referenceModule = -1;

    static QSizeF computePixelSize(const mat::ProjectionMatrix& pMat,
                                   PhysicalDimension physicalDimension,
                                   double mm);

    static QVector<mat::Location> computeModuleLocations(const SingleViewGeometry& singleViewGeometry,
                                                         const Vector3x1& sourcePosition,
                                                         const QSize& pixelPerModule,
                                                         double pixelWidth);

    static Matrix3x3 computeSourceRotation(const QVector<mat::Location>& moduleLocations,
                                           const Vector3x1& sourcePosition);
    static mat::Location referenceModuleLocation(const QVector<mat::Location>& moduleLocations,
                                                 int referenceModuleID);
    static void adaptModuleLocationsToReference(QVector<mat::Location>& moduleLocations,
                                                const mat::Location& referenceLocation);
};

} // namespace CTL

#endif // CTL_GEOMETRYDECODER_H