abstractgantry.h

Go to the documentation of this file.

#ifndef CTL_ABSTRACTGANTRY_H
#define CTL_ABSTRACTGANTRY_H

#include "mat/matrix_utils.h"
#include "systemcomponent.h"

/*
 * NOTE: This is header only.
 */

namespace CTL {

class GenericGantry;

class AbstractGantry : public SystemComponent
{
    CTL_TYPE_ID(200)
    DECLARE_ELEMENTAL_TYPE

    // abstract interface
    protected:virtual mat::Location nominalDetectorLocation() const = 0;
    protected:virtual mat::Location nominalSourceLocation() const = 0;

public:
    // virtual methods
    QString info() const override;
    void fromVariant(const QVariant& variant) override; // de-serialization
    QVariant toVariant() const override; // serialization

    // getter methods
    mat::Location sourceLocation() const;
    mat::Location detectorLocation() const;
    const mat::Location& detectorDisplacement() const;
    const mat::Location& gantryDisplacement() const;
    const mat::Location& sourceDisplacement() const;

    // setter methods
    void setDetectorDisplacement(const mat::Location& displacement);
    void setGantryDisplacement(const mat::Location& displacement);
    void setSourceDisplacement(const mat::Location& displacement);

    // convenience getter
    Vector3x1 sourcePosition() const;
    Matrix3x3 sourceRotation() const;
    Vector3x1 detectorPosition() const;
    Matrix3x3 detectorRotation() const;

    // convenience setter
    void setDetectorDisplacementAngles(double rollAngle, double tiltAngle, double twistAngle);
    void setDetectorDisplacementPosition(const Vector3x1& position);
    void setDetectorDisplacementPosition(double x, double y, double z);
    void setGantryDisplacementPosition(const Vector3x1& position);
    void setGantryDisplacementPosition(double x, double y, double z);
    void setSourceDisplacementPosition(const Vector3x1& position);
    void setSourceDisplacementPosition(double x, double y, double z);

    // converter
    std::unique_ptr<GenericGantry> toGeneric() const;

    ~AbstractGantry() override = default;

protected:
    AbstractGantry() = default;
    AbstractGantry(const QString& name);

    AbstractGantry(const AbstractGantry&) = default;
    AbstractGantry(AbstractGantry&&) = default;
    AbstractGantry& operator=(const AbstractGantry&) = default;
    AbstractGantry& operator=(AbstractGantry&&) = default;

private:
    mat::Location _globalGantryDisplacement; 
    mat::Location _detectorDisplacement; 
    mat::Location _sourceDisplacement; 
};

inline AbstractGantry::AbstractGantry(const QString& name)
    : SystemComponent(name)
{
}

inline mat::Location AbstractGantry::sourceLocation() const
{
    return { sourcePosition(), sourceRotation() };
}

inline Vector3x1 AbstractGantry::sourcePosition() const
{
    return _globalGantryDisplacement.rotation* nominalSourceLocation().position
            + sourceRotation() * _sourceDisplacement.position
            + _globalGantryDisplacement.position;
}

inline Matrix3x3 AbstractGantry::sourceRotation() const
{
    return _globalGantryDisplacement.rotation
            * nominalSourceLocation().rotation
            * _sourceDisplacement.rotation;
}

inline mat::Location AbstractGantry::detectorLocation() const
{
    return { detectorPosition(), detectorRotation() };
}

inline Vector3x1 AbstractGantry::detectorPosition() const
{
    return _globalGantryDisplacement.rotation * nominalDetectorLocation().position
            + detectorRotation().transposed() * _detectorDisplacement.position
            + _globalGantryDisplacement.position;
}

inline Matrix3x3 AbstractGantry::detectorRotation() const
{
    return _detectorDisplacement.rotation.transposed()
            * nominalDetectorLocation().rotation
            * _globalGantryDisplacement.rotation.transposed();
}

inline const mat::Location& AbstractGantry::detectorDisplacement() const
{
    return _detectorDisplacement;
}

inline const mat::Location& AbstractGantry::gantryDisplacement() const
{
    return _globalGantryDisplacement;
}

inline const mat::Location& AbstractGantry::sourceDisplacement() const
{
    return _sourceDisplacement;
}

inline void AbstractGantry::setDetectorDisplacement(const mat::Location& displacement)
{
    _detectorDisplacement = displacement;
}

inline void AbstractGantry::setGantryDisplacement(const mat::Location& displacement)
{
    _globalGantryDisplacement = displacement;
}

inline void AbstractGantry::setSourceDisplacement(const mat::Location& displacement)
{
    _sourceDisplacement = displacement;
}

inline void AbstractGantry::setDetectorDisplacementPosition(const Vector3x1& position)
{
    _detectorDisplacement.position = position;
}

inline void AbstractGantry::setDetectorDisplacementPosition(double x, double y, double z)
{
    _detectorDisplacement.position = Vector3x1(x, y, z);
}

inline void AbstractGantry::setGantryDisplacementPosition(const Vector3x1& position)
{
    _globalGantryDisplacement.position = position;
}

inline void AbstractGantry::setGantryDisplacementPosition(double x, double y, double z)
{
    _globalGantryDisplacement.position = Vector3x1(x, y, z);
}

inline void AbstractGantry::setSourceDisplacementPosition(const Vector3x1& position)
{
    _sourceDisplacement.position = position;
}

inline void AbstractGantry::setSourceDisplacementPosition(double x, double y, double z)
{
    _sourceDisplacement.position = Vector3x1(x, y, z);
}

inline void
AbstractGantry::setDetectorDisplacementAngles(double rollAngle, double tiltAngle, double twistAngle)
{
    _detectorDisplacement.rotation = mat::rotationMatrix(twistAngle, Qt::ZAxis)
        * mat::rotationMatrix(tiltAngle, Qt::XAxis) * mat::rotationMatrix(rollAngle, Qt::YAxis);
}

inline QString AbstractGantry::info() const
{
    QString ret(SystemComponent::info());

    // clang-format off
    QString srcDisplString = "(" + QString::number(_sourceDisplacement.position(0,0)) + " mm, " +
                                   QString::number(_sourceDisplacement.position(1,0)) + " mm, " +
                                   QString::number(_sourceDisplacement.position(2,0)) + " mm)\n";
    QString detDisplString = "(" + QString::number(_detectorDisplacement.position(0,0)) + " mm, " +
                                   QString::number(_detectorDisplacement.position(1,0)) + " mm, " +
                                   QString::number(_detectorDisplacement.position(2,0)) + " mm)\n";
    QString srcRotString = QString::fromStdString(_sourceDisplacement.rotation.info("\t"));
    QString detRotString = QString::fromStdString(_detectorDisplacement.rotation.info("\t"));

    ret +=
        typeInfoString(typeid(this)) +
        "\tSource Displacement: "    + srcDisplString +
        "\t-Rotation:\n"              + srcRotString +
        "\tDetector Displacement: "  + detDisplString +
        "\t-Rotation:\n"             + detRotString;
    // clang-format on

    ret += (this->type() == AbstractGantry::Type) ? QLatin1String("}\n") : QLatin1String("");

    return ret;
}

// Use SerializationInterface::fromVariant() documentation.
inline void AbstractGantry::fromVariant(const QVariant& variant)
{
    SystemComponent::fromVariant(variant);

    QVariantMap varMap = variant.toMap();
    _detectorDisplacement.fromVariant(varMap.value(QStringLiteral("detector displacement")));
    _globalGantryDisplacement.fromVariant(varMap.value(QStringLiteral("gantry displacement")));
    _sourceDisplacement.fromVariant(varMap.value(QStringLiteral("source displacement")));
}

// Use SerializationInterface::toVariant() documentation.
inline QVariant AbstractGantry::toVariant() const
{
    QVariantMap ret = SystemComponent::toVariant().toMap();

    ret.insert(QStringLiteral("detector displacement"), _detectorDisplacement.toVariant());
    ret.insert(QStringLiteral("gantry displacement"), _globalGantryDisplacement.toVariant());
    ret.insert(QStringLiteral("source displacement"), _sourceDisplacement.toVariant());

    return ret;
}

} // namespace CTL


#endif // CTL_ABSTRACTGANTRY_H