sdk/libraries/core/component/Component.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 CAMITK_COMPONENT_H
#define CAMITK_COMPONENT_H
 
// -- Core stuff
#include "InterfaceNode.h"
#include "InterfaceGeometry.h"
#include "InterfaceBitMap.h"
#include "InterfaceProperty.h"
#include "InterfaceFrame.h"
#include "InterfacePersistence.h"
 
// -- QT stuff
#include <QPixmap>
#include <QMenu>
#include <QVector>
 
// -- vtk stuff
// disable warning generated by clang about the surrounded headers
#include "CamiTKDisableWarnings"
#include <vtkWindowLevelLookupTable.h>
#include <vtkActor.h>
#include <vtkAxesActor.h>
#include <vtkImageActor.h>
#include "CamiTKReEnableWarnings"
 
#include <vtkImageData.h>
#include <vtkPointSet.h>
#include <vtkSmartPointer.h>
#include <vtkAlgorithmOutput.h>
#include <vtkActor2D.h>
#include <vtkTransform.h>
 
// -- vtk stuff Classes
class vtkActor;
class vtkTexture;
class vtkPointSet;
class vtkUnstructuredGridAlgorithm;
class vtkDataSetToUnstructuredGridFilter;
class vtkWindowLevelLookupTable;
 
// -----------------------------------------------------------------------
//
//                           Delegation macros
//                     (And your dream comes true)
//
// -----------------------------------------------------------------------
 
#define invoke0(HANDLER,METHOD) \
if (HANDLER) \
    HANDLER->METHOD();
 
#define invoke1(HANDLER,METHOD,PARAM) \
if (HANDLER) \
    HANDLER->METHOD(PARAM);
 
#define invoke2(HANDLER,METHOD,PARAM1,PARAM2) \
if (HANDLER) \
    HANDLER->METHOD(PARAM1,PARAM2);
 
#define invoke3(HANDLER,METHOD,PARAM1,PARAM2,PARAM3) \
if (HANDLER) \
    HANDLER->METHOD(PARAM1,PARAM2,PARAM3);
 
#define invoke4(HANDLER,METHOD,PARAM1,PARAM2,PARAM3,PARAM4) \
if (HANDLER) \
    HANDLER->METHOD(PARAM1,PARAM2,PARAM3,PARAM4);
 
#define invokeGet0(HANDLER,METHOD) \
if (HANDLER) \
    return HANDLER->METHOD();
 
#define invokeGet1(HANDLER,METHOD,PARAM) \
if (HANDLER) \
    return HANDLER->METHOD(PARAM);
 
#define invokeGet2(HANDLER,METHOD,PARAM1,PARAM2) \
if (HANDLER) \
    return HANDLER->METHOD(PARAM1,PARAM2);
 
#define invokeGet3(HANDLER,METHOD,PARAM1,PARAM2,PARAM3) \
if (HANDLER) \
    return HANDLER->METHOD(PARAM1,PARAM2,PARAM3);
 
#define invokeGet4(HANDLER,METHOD,PARAM1,PARAM2,PARAM3,PARAM4) \
if (HANDLER) \
    return HANDLER->METHOD(PARAM1,PARAM2,PARAM3,PARAM4);
 
#define invokeChildren0(METHOD) \
for(Component *child: childrenComponent) { \
                                                child->METHOD(); \
                                              }
 
#define invokeChildren1(METHOD,PARAM) \
for(Component *child: childrenComponent) { \
                                                child->METHOD(PARAM); \
                                              }
 
#define invokeChildren2(METHOD,PARAM1,PARAM2) \
for(Component *child: childrenComponent) { \
                                                child->METHOD(PARAM1,PARAM2); \
                                              }
 
#define invokeChildren3(METHOD,PARAM1,PARAM2,PARAM3) \
for(Component *child: childrenComponent) { \
                                                child->METHOD(PARAM1,PARAM2,PARAM3); \
                                              }
 
#define invokeChildren4(METHOD,PARAM1,PARAM2,PARAM3,PARAM4) \
for(Component *child: childrenComponent) { \
                                                child->METHOD(PARAM1,PARAM2,PARAM3,PARAM4); \
                                              }
 
#define delegate0(HANDLER,METHOD) \
virtual void METHOD() override { \
                        invoke0(HANDLER,METHOD) \
                      }
 
#define delegate1(HANDLER,METHOD,PARAM_TYPE) \
virtual void METHOD(PARAM_TYPE param) override { \
                                        invoke1(HANDLER,METHOD,param) \
                                      }
 
#define delegate2(HANDLER,METHOD,PARAM_TYPE1,PARAM_TYPE2) \
virtual void METHOD(PARAM_TYPE1 param1, PARAM_TYPE2 param2) override { \
                                                              invoke2(HANDLER,METHOD,param1,param2) \
                                                            }
 
#define delegate3(HANDLER,METHOD,PARAM_TYPE1,PARAM_TYPE2,PARAM_TYPE3) \
virtual void METHOD(PARAM_TYPE1 param1, PARAM_TYPE2 param2, PARAM_TYPE3 param3) override { \
                                                                                  invoke3(HANDLER,METHOD,param1,param2,param3) \
                                                                                }
 
#define delegate4(HANDLER,METHOD,PARAM_TYPE1,PARAM_TYPE2,PARAM_TYPE3, PARAM_TYPE4) \
virtual void METHOD(PARAM_TYPE1 param1, PARAM_TYPE2 param2, PARAM_TYPE3 param3, PARAM_TYPE4 param4) override { \
                                                                                                      invoke4(HANDLER,METHOD,param1,param2,param3,param4) \
                                                                                                    }
 
#define delegateGet0(HANDLER,METHOD,TYPE) \
virtual TYPE METHOD() override { \
                        invokeGet0(HANDLER,METHOD) \
                        else \
                        return 0; \
                      }
 
#define delegateGet1(HANDLER,METHOD,TYPE,PARAM_TYPE) \
virtual TYPE METHOD(PARAM_TYPE param) override { \
                                        invokeGet1(HANDLER,METHOD,param) \
                                        else \
                                        return 0; \
                                      }
 
#define delegateGet2(HANDLER,METHOD,TYPE,PARAM1_TYPE,PARAM2_TYPE) \
virtual TYPE METHOD(PARAM1_TYPE param1, PARAM2_TYPE param2) override { \
                                        invokeGet2(HANDLER,METHOD,param1,param2) \
                                        else \
                                        return 0; \
                                      }
#define delegateConstGet0(HANDLER,METHOD,TYPE) \
virtual TYPE METHOD() const override { \
                              invokeGet0(HANDLER,METHOD) \
                              else \
                              return 0; \
                            }
 
#define delegateConstGet1(HANDLER,METHOD,TYPE,PARAM_TYPE) \
virtual TYPE METHOD(PARAM_TYPE param) const override { \
                                              invokeGet1(HANDLER,METHOD,param) \
                                              else \
                                              return 0; \
                                            }
 
#define delegateAndInvokeChildren1(HANDLER,METHOD,PARAM_TYPE) \
virtual void METHOD(PARAM_TYPE param) override { \
                                        invoke1(HANDLER,METHOD,param) \
                                        invokeChildren1(METHOD,param) \
                                      }
 
#define delegateAndInvokeChildren2(HANDLER,METHOD,PARAM_TYPE1,PARAM_TYPE2) \
virtual void METHOD(PARAM_TYPE1 param1, PARAM_TYPE2 param2) override { \
                                                              invoke2(HANDLER,METHOD,param1,param2) \
                                                              invokeChildren2(METHOD,param1,param2) \
                                                            }
 
#define delegateAndInvokeChildren1Array(HANDLER,METHOD,PARAM_TYPE1,PARAM_TYPE2,DIM) \
virtual void METHOD(PARAM_TYPE1 param1, PARAM_TYPE2 param2[DIM]) override { \
                                                                   invoke2(HANDLER,METHOD,param1,param2) \
                                                                   invokeChildren2(METHOD,param1,param2) \
                                                                 }
 
#define delegateAndInvokeChildren3(HANDLER,METHOD,PARAM_TYPE1,PARAM_TYPE2,PARAM_TYPE3) \
virtual void METHOD(PARAM_TYPE1 param1, PARAM_TYPE2 param2, PARAM_TYPE3 param3) override { \
                                                                                  invoke3(HANDLER,METHOD,param1,param2,param3) \
                                                                                  invokeChildren3(METHOD,param1,param2,param3) \
                                                                                }
 
#define delegateAndInvokeChildren4(HANDLER,METHOD,PARAM_TYPE1,PARAM_TYPE2,PARAM_TYPE3,PARAM_TYPE4) \
virtual void METHOD(PARAM_TYPE1 param1, PARAM_TYPE2 param2, PARAM_TYPE3 param3,PARAM_TYPE4 param4) override { \
                                                                                                     invoke4(HANDLER,METHOD,param1,param2,param3,param4) \
                                                                                                     invokeChildren4(METHOD,param1,param2,param3,param4) \
                                                                                                   }
 
 
namespace camitk {
// -- Core stuff classes
class Geometry;
class Slice;
class Viewer;
class FrameOfReference;
class Transformation;
 
 
class CAMITK_API Component : public InterfaceProperty, public InterfaceNode, public InterfaceGeometry, public InterfaceBitMap, public InterfaceFrame, public InterfacePersistence {
    Q_OBJECT
 
public:
    enum Representation {
        GEOMETRY, 
        SLICE, 
        NO_REPRESENTATION      
    };
 
 
    Component(QString file, QString name, Representation rep = NO_REPRESENTATION, bool createDefaultFrame = true);
 
    Component(Component* parentComponent, const QString& name, Representation rep = NO_REPRESENTATION, bool createDefaultFrame = true);
 
    virtual ~Component() override;
 
    Representation getRepresentation() const;
 
    bool isTopLevel() const;
 
    Component* getParentComponent();
 
    Component* getTopLevelComponent();
 
    virtual void setModified(bool modified = true);
 
    virtual bool getModified() const;
 
    virtual void setVisibility(QString, bool);
 
    virtual bool getVisibility(QString) const;
 
    virtual void refresh();
 
    virtual bool isSelected() const;
 
    virtual void setSelected(const bool b, const bool recursive = true);
 
    const QString getFileName() const;
 
    void setFileName(const QString&);
 
    bool event(QEvent* e) override;
 
    QMenu* getActionMenu();
 
 
    virtual QVariant toVariant() const override;
 
    virtual void fromVariant(const QVariant&) override;
 
    virtual QUuid getUuid() const override;
 
    virtual bool setUuid(QUuid) override;
 
 
    QStringList getHierarchy() const override;
 
    bool isInstanceOf(QString className) const override;
 
    unsigned int getNumberOfPropertyWidget() override {
        return 0;
    }
 
    QWidget* getPropertyWidgetAt(unsigned int) override {
        return nullptr;
    }
 
    QObject* getPropertyObject() override {
        return this;
    }
    const QObject* getPropertyObject() const override {
        return this;
    }
 
    void propertyValueChanged(QString name) override;
 
    inline void setIndexOfPropertyExplorerTab(unsigned int index) override final {
        indexOfPropertyExplorerTab = index;
    }
 
    inline unsigned int getIndexOfPropertyExplorerTab() override {
        return indexOfPropertyExplorerTab;
    }
 
    Q_INVOKABLE camitk::Property* getProperty(QString name) override;
 
    bool addProperty(Property*) override;
 
    virtual QVariant getPropertyValue(const QString& name) const override;
 
    virtual bool setPropertyValue(const QString& name, QVariant newValue) override;
 
 
    void removeChild(InterfaceNode*) override;
 
    void setParent(InterfaceNode*) override;
 
    bool doubleClicked() override;
 
    //-- not commented because Doxygen automatically use the inherited documentation (set INHERIT_DOCS flag to YES in the Doxyfile)
    void addChild(InterfaceNode*) override;
    void attachChild(InterfaceNode*) override;
    void deleteChildren() override final;
    QString getName() const override;
    void setName(const QString&) override;
    const ComponentList& getChildren() const override;
    InterfaceNode* getParent() override;
    QPixmap getIcon() override;
    void setNodeModified(bool) override final;
    bool getNodeModified() const override;
 
    bool inItalic() const override;
 
    QMenu* getPopupMenu(QWidget* parent = nullptr) override {
        return nullptr;
    }
 
 
    delegateGet0(myGeometry, getPointSet, vtkSmartPointer<vtkPointSet>)
 
    delegate1(myGeometry, setPointSet, vtkSmartPointer<vtkPointSet>)
 
    delegate1(myGeometry, setPointData, vtkSmartPointer<vtkDataArray>)
 
    delegateConstGet0(myGeometry, getDataPort, vtkSmartPointer<vtkAlgorithmOutput>)
 
    delegate1(myGeometry, setDataConnection, vtkSmartPointer<vtkAlgorithmOutput>)
 
    delegateGet1(myGeometry, getActor, vtkSmartPointer<vtkActor>, const RenderingModes)
 
    delegate1(myGeometry, setColorMode, int)
 
    delegate1(myGeometry, updateLabel, const QString&);
 
    // TODO : uses an object myRepresentation (which is a Geometry or a Slice)
    // to use a single delegate macro
    vtkSmartPointer<vtkProp> getProp(const QString& param) override {
        if (myGeometry) {
            return myGeometry->getProp(param);
        }
        else if (mySlice) {
            return mySlice->getProp(param);
        }
 
        return nullptr;
    }
 
    unsigned int getNumberOfProp() const override {
        if (myGeometry) {
            return myGeometry->getNumberOfProp();
        }
        else if (mySlice) {
            return mySlice->getNumberOfProp();
        }
 
        return 0;
    }
 
    vtkSmartPointer<vtkProp> getProp(unsigned int index) override {
        if (myGeometry) {
            return myGeometry->getProp(index);
        }
        else if (mySlice) {
            return mySlice->getProp(index);
        }
 
        return nullptr;
    }
 
    bool addProp(const QString& name, vtkSmartPointer<vtkProp> prop) override {
        if (myGeometry) {
            return myGeometry->addProp(name, prop);
        }
        else if (mySlice) {
            return mySlice->addProp(name, prop);
        }
 
        return false;
    }
 
 
    bool removeProp(const QString& name) override {
        if (myGeometry) {
            return myGeometry->removeProp(name);
        }
        else if (mySlice) {
            return mySlice->removeProp(name);
        }
 
        return false;
    }
    // END TODO
 
 
    void pointPicked(vtkIdType, bool) override {}
 
    void cellPicked(vtkIdType, bool) override {}
 
    virtual vtkSmartPointer<vtkActor> get3DCursor() {
        return nullptr;
    }
 
    void getBounds(double* bounds) override;
 
    double getBoundingRadius() override;
 
    delegate4(myGeometry, setPointPosition, const unsigned int, const double, const double, const double)
 
    delegateAndInvokeChildren1(myGeometry, setRenderingModes, const RenderingModes)
 
    const InterfaceGeometry::RenderingModes getRenderingModes() const override;
 
    delegateAndInvokeChildren1(myGeometry, setEnhancedModes, const EnhancedModes)
 
    // cannot use macro here as the return type is a QFlag
    virtual const EnhancedModes getEnhancedModes() const override {
        if (myGeometry) {
            return myGeometry->getEnhancedModes();
        }
        else {
            return EnhancedModes();
        }
    }
 
    delegateAndInvokeChildren1Array(myGeometry, setActorColor, const RenderingModes, double, 4)
 
    delegateAndInvokeChildren4(myGeometry, setActorColor, const RenderingModes, const double, const double, const double)
 
    void getActorColor(const RenderingModes, double [4], bool ignoreEnhancedModes = false) const override;
 
    delegateAndInvokeChildren3(myGeometry, setColor, const double, const double, const double)
 
    delegateAndInvokeChildren4(myGeometry, setColor, const double, const double, const double, const double)
 
    delegateAndInvokeChildren2(myGeometry, setActorOpacity, const RenderingModes, const double)
 
    delegateConstGet1(myGeometry, getActorOpacity, double, const RenderingModes)
 
    delegateAndInvokeChildren1(myGeometry, setOpacity, const double)
 
    delegate2(myGeometry, setMapperScalarRange, double, double)
 
    delegate1(myGeometry, setTexture, vtkSmartPointer<vtkTexture>)
 
    void setGlyphType(const GlyphTypes type, const double size = 0.0) override;
 
    virtual void setLinesAsTubes(bool isTubes = true, bool radiusFromLength = true, double radiusFactor = 1.0 / 40.0, int numberOfSides = 5) override {
        if (myGeometry) {
            myGeometry->setLinesAsTubes(isTubes, radiusFromLength, radiusFactor, numberOfSides);
        }
    }
 
    delegate1(myGeometry, setMeshWorldTransform, vtkSmartPointer<vtkTransform>)
 
    
 
    
    delegateConstGet0(mySlice, getImageData, vtkSmartPointer<vtkImageData>)
 
    delegate1(mySlice, setOriginalVolume, vtkSmartPointer<vtkImageData>)
 
    delegateConstGet0(mySlice, get2DImageActor, vtkSmartPointer<vtkImageActor>)
 
    delegateConstGet0(mySlice, get3DImageActor, vtkSmartPointer<vtkImageActor>)
 
    delegateConstGet0(mySlice, getPickPlaneActor, vtkSmartPointer<vtkActor>)
 
    delegateGet0(mySlice, getPixelActor, vtkSmartPointer<vtkActor>)
 
    delegate3(mySlice, pixelPicked, double, double, double)
 
    delegate0(mySlice, updatePickPlane)
 
    delegate1(mySlice, setSlice, int)
 
    delegate3(mySlice, setSlice, double, double, double)
 
    delegateConstGet0(mySlice, getNumberOfColors, int)
 
    delegate3(mySlice, setPixelRealPosition, double, double, double)
 
    delegate1(mySlice, setArbitraryTransform, vtkSmartPointer<vtkTransform>)
 
    int getNumberOfSlices() const override;
 
    int getSlice() const override;
 
 
 
 
    virtual void setFrame(const std::shared_ptr<FrameOfReference>& frame) override {
        frameOfReference = frame;
    }
 
    // in conjunction with this method if you need to share the ownership of this frame
    virtual const FrameOfReference* getFrame() const override {
        return frameOfReference.get();
    }
 
    virtual QMultiMap<const FrameOfReference*, Component*> getAllFrames(bool includeChildrenFrames = true) override;
 
    virtual QMultiMap<const Transformation*, Component*> getAllTransformations(bool includeChildrenTransformations = true) override;
 
    virtual void setFrameFrom(const InterfaceFrame*) override;
 
    virtual void resetFrame() override;
 
    vtkSmartPointer<vtkAxesActor> getFrameAxisActor(QString viewerName) override;
 
    virtual bool getFrameVisibility(QString viewerName) const override;
 
    virtual void setFrameVisibility(QString viewerName, bool visibility) override;
 
 
protected:
    InterfaceGeometry* myGeometry;
 
    InterfaceBitMap* mySlice;
 
    InterfaceNode* myParentNode;
 
    ComponentList childrenComponent;
 
    bool isSelectedFlag;
 
    bool modifiedFlag;
 
    QString myFileName;
 
    unsigned int indexOfPropertyExplorerTab;
 
    std::shared_ptr<FrameOfReference> frameOfReference = nullptr;
 
 
private:
 
    void init(const QString& name, bool createDefaultFrame);
 
    Representation myService;
 
    virtual void initRepresentation() = 0;
 
    QMap<QString, bool> myViewers;
 
    QMenu* actionsMenu;
 
    QMenu* visibilityMenu;
 
    QMap<QString, Property*> propertyMap;
 
    bool interfaceNodeModifiedFlag;
 
    QHash<QString, vtkSmartPointer<vtkAxesActor>> frameActors;
 
    QHash<QString, bool> frameVisibilities;
 
 
};
 
 
// -------------------- isSelected --------------------
inline bool Component::isSelected() const {
    return isSelectedFlag;
}
 
// -------------------- doubleClicked --------------------
inline bool Component::doubleClicked() {
    return false;
}
 
// -------------------- getChildren --------------------
inline const ComponentList& Component::getChildren() const {
    return childrenComponent;
}
 
// -------------------- getName --------------------
inline QString Component::getName() const {
    return getPropertyValue("Name").toString();
}
 
// -------------------- getParent --------------------
inline InterfaceNode* Component::getParent() {
    return ((Component*) myParentNode);
}
 
// -------------------- getPixmap ------------------
inline QPixmap Component::getIcon() {
    return QPixmap(0, 0); // this is a nullptr QPixmap in the Qt sense. QPixmap::isNull will then return true;
}
 
// -------------------- inItalic --------------------
inline bool Component::inItalic() const {
    return false;
}
 
// -------------------- setModified --------------------
inline void Component::setModified(bool modification) {
    modifiedFlag = modification;
}
 
// -------------------- getModified --------------------
inline bool Component::getModified() const {
    return modifiedFlag;
}
 
// -------------------- setNodeModified --------------------
inline void Component::setNodeModified(bool nodeModified) {
    interfaceNodeModifiedFlag = nodeModified;
}
 
// -------------------- getNodeModified --------------------
inline bool Component::getNodeModified() const {
    return interfaceNodeModifiedFlag;
}
 
}
 
#endif