AnatomicalOrientation.h

Go to the documentation of this file.

/*****************************************************************************
 * $CAMITK_LICENCE_BEGIN$
 *
 * CamiTK - Computer Assisted Medical Intervention ToolKit
 * (c) 2001-2025 Univ. Grenoble Alpes, CNRS, Grenoble INP - UGA, TIMC, 38000 Grenoble, France
 *
 * Visit http://camitk.imag.fr for more information
 *
 * This file is part of CamiTK.
 *
 * CamiTK is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License version 3
 * only, as published by the Free Software Foundation.
 *
 * CamiTK is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License version 3 for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * version 3 along with CamiTK.  If not, see <http://www.gnu.org/licenses/>.
 *
 * $CAMITK_LICENCE_END$
 ****************************************************************************/
 
#ifndef ANATOMICALORIENTATION_H
#define ANATOMICALORIENTATION_H
 
#include <array>
#include <QVariantList>
#include <QVariantMap>
#include <QVariant>
#include <QString>
#include <QUuid>
 
 
namespace camitk {
 

class AnatomicalOrientation: public InterfacePersistence {
 
public:
    AnatomicalOrientation() {
        setUnkown();
    }

    explicit AnatomicalOrientation(QString threeLetterCode) {
        setOrientation(threeLetterCode);
    }

    AnatomicalOrientation(QString minXLabel, QString maxXLabel, QString minYLabel, QString maxYLabel, QString minZLabel, QString maxZLabel) {
        setOrientation(minXLabel, maxXLabel, minYLabel, maxYLabel, minZLabel, maxZLabel);
    }

    void setUnkown() {
        known = false;
        code = "";
        minLabels.fill("");
        maxLabels.fill("");
    }

    bool isUnknown() const {
        return !known;
    }

    void setOrientation(QString threeLetterCode) {
        if (this->set3LetterCode(threeLetterCode)) {
            known = true;
        }
        else {
            known = false;
        }
 
    }

    void setOrientation(QString minXLabel, QString maxXLabel, QString minYLabel, QString maxYLabel, QString minZLabel, QString maxZLabel) {
        code = "";
        minLabels = {minXLabel, minYLabel, minZLabel};
        maxLabels = {maxXLabel, maxYLabel, maxZLabel};
        known = true;
    }

    void setMinLabel(int axis, QString minLabel) {
        if (axis >= 0 && axis < 3) {
            code = "";
            minLabels[axis] = minLabel;
            known = true;
        }
    }

    void setMaxLabel(int axis, QString maxLabel) {
        if (axis >= 0 && axis < 3) {
            code = "";
            maxLabels[axis] = maxLabel;
            known = true;
        }
    }

    void setLabels(int axis, QString minLabel, QString maxLabel) {
        setMinLabel(axis, minLabel);
        setMaxLabel(axis, maxLabel);
    };

    QString getMinLabel(int axis) const {
        if (axis >= 0 && axis < 3) {
            return minLabels[axis];
        }
        else {
            return "";
        }
    }

    QString getMaxLabel(int axis) const {
        if (axis >= 0 && axis < 3) {
            return maxLabels[axis];
        }
        else {
            return "";
        }
    }

    std::pair<int, bool> getAxisFromName(QString name) const {
        for (unsigned int ax = 0; ax < 3; ++ax) {
            if (minLabels[ax] == name) {
                return {ax, true};
            }
            else if (maxLabels[ax] == name) {
                return {ax, false};
            }
        }
        return {-1, false};
    }

    static QString invert3LetterCode(const QString& code) {
        QString invertedCode = code;
        for (int i = 0; i < code.size(); ++i) {
            if (code[i] == 'R') {
                invertedCode[i] = 'L';
            }
            else if (code[i] == 'L') {
                invertedCode[i] = 'R';
            }
            else if (code[i] == 'A') {
                invertedCode[i] = 'P';
            }
            else if (code[i] == 'P') {
                invertedCode[i] = 'A';
            }
            else if (code[i] == 'I') {
                invertedCode[i] = 'S';
            }
            else if (code[i] == 'S') {
                invertedCode[i] = 'I';
            }
            else if (code[i] == 'F') {
                invertedCode[i] = 'H';
            }
            else if (code[i] == 'H') {
                invertedCode[i] = 'F';
            }
        }
        return invertedCode;
    }

    QString get3LetterCode(bool plus = false) const {
        if (!known || code.isEmpty()) {
            return "";
        }
        if (plus) { // Invert the axis letters and add a '+' at the end
            QString plusCode = AnatomicalOrientation::invert3LetterCode(code);
            plusCode.append('+');
            return plusCode;
        }
        else {
            return code;
        }
    }

    QString getLabel(int axis, bool minDirection) const {
        if (axis >= 0 && axis < 3) {
            return minDirection ? minLabels[axis] : maxLabels[axis];
        }
        return "";
    }


    QVariant toVariant() const override {
        if (known) {
            return QVariantMap {
                {"code", code},
                {"minLabels", QVariantList{minLabels[0], minLabels[1], minLabels[2]}},
                {"maxLabels", QVariantList{maxLabels[0], maxLabels[1], maxLabels[2]}},
            };
        }
        else {
            return QVariantMap();
        }
    }

    void fromVariant(const QVariant& variant) override {
        known = false;
        code = "";
        QVariantMap map = variant.toMap();
        QVariantList list;
        if (map.contains("code")) { // It is known
            known = true;
            code = map.value("code").toString();
        }
 
        if (map.contains("minLabels") && map.contains("maxLabels")) {
            known = true;
 
            list = map.value("minLabels").toList();
            if (list.size() == 3) {
                minLabels[0] = list[0].toString();
                minLabels[1] = list[1].toString();
                minLabels[2] = list[2].toString();
            }
            else {
                minLabels.fill("");
            }
 
            list = map.value("maxLabels").toList();
            if (list.size() == 3) {
                maxLabels[0] = list[0].toString();
                maxLabels[1] = list[1].toString();
                maxLabels[2] = list[2].toString();
            }
            else {
                maxLabels.fill("");
            }
        }
        else { // Unknown
            if (code.isEmpty()) {
                minLabels.fill("");
                maxLabels.fill("");
            }
            else {
                set3LetterCode(code); // Ensure minLabels and maxLabels are filled from the code
            }
 
        }
    }

    bool setUuid(QUuid newid) override {
        return false;
    }

    QUuid getUuid() const override {
        return QUuid();
    }

 
private:
    std::array<QString, 3> minLabels;

    std::array<QString, 3> maxLabels;

    bool known;

    QString code;

    bool set3LetterCode(QString code = "", bool forcePlus = false) {
        if (code.size() < 3 || code.size() > 4) { // Minimum 3 letters, maximum 4 (in case there is a '+' at the end)
            return false;
        }
        if ((code.size() > 3 &&  code[3] == '+') || forcePlus) {
            this->code = AnatomicalOrientation::invert3LetterCode(code);
        }
        else {
            this->code = code;
        }
        this->code.truncate(3); // in case there is an unwanted trailing '+'
        QString invertedCode = AnatomicalOrientation::invert3LetterCode(this->code);
        minLabels[0] = code[0];
        minLabels[1] = code[1];
        minLabels[2] = code[2];
        maxLabels[0] = invertedCode[0];
        maxLabels[1] = invertedCode[1];
        maxLabels[2] = invertedCode[2];
        known = true;
        return true;
    }
 
};
 
} // namespace camitk
 
#endif // ANATOMICALORIENTATION_H