TransformationManager.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 TRANSFORMATIONMANAGER_H
#define TRANSFORMATIONMANAGER_H
 
// -- Core stuff
#include "CamiTKAPI.h"
 
#include "FrameOfReference.h"
#include "Transformation.h"
 
// -- QT stuff
#include <QHash>
#include <QString>
#include <QVector>
#include <QPalette>
#include <QVariant>
 
#include <vtkSmartPointer.h>
#include <vtkTransform.h>
 
#include <memory>
#include <unordered_set>
 
namespace camitk {
 
class Transformation;
class FrameOfReference;
class Application;

class CAMITK_API TransformationManager {
public:

    static QString toString();


    static std::shared_ptr<FrameOfReference> getFrameOfReferenceOwnership(const QUuid& uuid);

    static std::shared_ptr<FrameOfReference> getFrameOfReferenceOwnership(const FrameOfReference*);

    static std::shared_ptr<FrameOfReference> addFrameOfReference(QString name, QString description = "");

    static std::shared_ptr<FrameOfReference> addFrameOfReference(const FrameOfReference&);

    static QVector<FrameOfReference*> getFramesOfReference();


    static bool hasPath(const FrameOfReference* from, const FrameOfReference* to);

    static bool isDefaultIdentityToWorld(const Transformation*);

    static Transformation* getTransformation(const FrameOfReference* from, const FrameOfReference* to);

    static std::shared_ptr<Transformation> getTransformationOwnership(const Transformation*);

    static std::shared_ptr<Transformation> getTransformationOwnership(const QUuid& uuid);

    static std::shared_ptr<Transformation> getTransformationOwnership(const FrameOfReference* from, const FrameOfReference* to);

    static void ensurePathToWorld(const FrameOfReference* frame);

    static bool preferredDefaultIdentityToWorldLink(const FrameOfReference* frame);

    static const FrameOfReference* getWorldFrame();

    static QVector<Transformation*> getDirectTransformations();

    static QVector<Transformation*> getTransformations();

    static std::shared_ptr<Transformation> addTransformation(const QVariant&);

    static std::shared_ptr<Transformation> addTransformation(const FrameOfReference* from, const FrameOfReference* to);

    static std::shared_ptr<Transformation> addTransformation(const std::shared_ptr<FrameOfReference>& from, const std::shared_ptr<FrameOfReference>& to);

    static std::shared_ptr<Transformation> addTransformation(const FrameOfReference* from, const FrameOfReference* to, vtkSmartPointer<vtkTransform> vtkTr);

    static std::shared_ptr<Transformation> addTransformation(const std::shared_ptr<FrameOfReference>& from, const std::shared_ptr<FrameOfReference>& to, vtkSmartPointer<vtkTransform> vtkTr);

    static std::shared_ptr<Transformation> addTransformation(const FrameOfReference* from, const FrameOfReference* to, const vtkMatrix4x4* matrix);

    static std::shared_ptr<Transformation> addTransformation(const std::shared_ptr<FrameOfReference>& from, const std::shared_ptr<FrameOfReference>& to, const vtkMatrix4x4* matrix);
 

    static void cleanupFramesAndTransformations();

    static bool removeTransformation(std::shared_ptr<Transformation>& tr);

    static bool removeTransformation(const FrameOfReference* from, const FrameOfReference* to);



    static bool updateTransformation(const FrameOfReference* from, const FrameOfReference* to, vtkSmartPointer<vtkTransform> vtkTr);

    static bool updateTransformation(const FrameOfReference* from, const FrameOfReference* to, vtkMatrix4x4* matrix);

    static bool updateTransformation(Transformation* tr, vtkSmartPointer<vtkTransform> vtkTr);

    static bool updateTransformation(Transformation* tr, vtkMatrix4x4* matrix);


    static bool hasSources(const Transformation*);

    static QVector<Transformation*> getSources(const Transformation*);

    static bool isInverseTransformation(const Transformation*);

    static Transformation* getInverseTransformation(const Transformation* tr);

    static bool isCompositeTransformation(const Transformation* tr);


    static QVariant toVariant();

    static void fromVariant(const QVariant&);
 
private:


    static std::shared_ptr<FrameOfReference> worldFrame;

    static std::vector<std::shared_ptr<FrameOfReference>> frames;

    static std::vector<std::shared_ptr<Transformation>> transformations;

    static QHash<QUuid, FrameOfReference*> frameMap;

    static QHash<QUuid, Transformation*> transformationMap;

    static QHash<const Transformation*, QVector<std::shared_ptr<Transformation>>> transformationSources;

    static QHash<const FrameOfReference*, QHash<const FrameOfReference*, Transformation*>> transformationFromTo;

    static std::unordered_set<const Transformation*> defaultIdentityToWorldTransformations;

    static std::shared_ptr<Transformation> registerTransformation(Transformation* tr, const QVector<std::shared_ptr<Transformation>>& sources = {});

    static QVector<std::shared_ptr<Transformation>> getPath(const FrameOfReference* from, const FrameOfReference* to);
 

    static std::shared_ptr<Transformation> addCompositeTransformation(QVector<std::shared_ptr<Transformation>> transforms);

    static std::shared_ptr<FrameOfReference> addFrameOfReference(QUuid uuid, QString name, QString description, int dimensions = 3, const AnatomicalOrientation& ao = {}, std::vector<Unit> units = {"", "", "", "", ""});

    static std::shared_ptr<FrameOfReference> addFrameOfReference(const QVariant&);


    static bool removeDefaultPaths(const FrameOfReference* from, const FrameOfReference* to);

    static void removeTransformationFromInternalStructures(const Transformation* trToDelete);

    static void cleanupCompositeTransformations();

    static std::shared_ptr<Transformation> getTransformationSharedPtr(const Transformation*);
};
}
#endif // TRANSFORMATIONMANAGER_H