sdk/libraries/core/component/Component.h

Go to the documentation of this file.

/*****************************************************************************
 * $CAMITK_LICENCE_BEGIN$
 *
 * CamiTK - Computer Assisted Medical Intervention ToolKit
 * (c) 2001-2021 Univ. Grenoble Alpes, CNRS, Grenoble INP, 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 "AbortException.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) \
foreach (Component *child, childrenComponent) { \
                                                child->METHOD(); \
                                              }
 
#define invokeChildren1(METHOD,PARAM) \
foreach (Component *child, childrenComponent) { \
                                                child->METHOD(PARAM); \
                                              }
 
#define invokeChildren2(METHOD,PARAM1,PARAM2) \
foreach (Component *child, childrenComponent) { \
                                                child->METHOD(PARAM1,PARAM2); \
                                              }
 
#define invokeChildren3(METHOD,PARAM1,PARAM2,PARAM3) \
foreach (Component *child, childrenComponent) { \
                                                child->METHOD(PARAM1,PARAM2,PARAM3); \
                                              }
 
#define invokeChildren4(METHOD,PARAM1,PARAM2,PARAM3,PARAM4) \
foreach (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 Frame;
 
 
class CAMITK_API Component : public InterfaceProperty, public InterfaceNode, public InterfaceGeometry, public InterfaceBitMap, public InterfaceFrame {
    Q_OBJECT
 
public:
    enum Representation {
        GEOMETRY, 
        SLICE, 
        NO_REPRESENTATION      
    };
 
 
    Component(QString file, QString name, Representation rep = NO_REPRESENTATION);
 
    Component(Component* parentComponent, const QString& name, Representation rep = NO_REPRESENTATION);
 
    ~Component() override;
 
    Representation getRepresentation() const;
 
    bool isTopLevel() const;
 
    Component* getParentComponent();
 
    Component* getTopLevelComponent();
 
    InterfaceFrame* getFrame();
 
    virtual void setModified(bool modified = true);
 
    virtual bool getModified() const;
 
 
    CAMITK_API_DEPRECATED("Please use setVisibility(QString viewerName, bool) instead") virtual void setVisibility(Viewer*, bool);
 
    CAMITK_API_DEPRECATED("Please use getVisibility(QString viewerName, bool) instead") virtual bool getVisibility(Viewer*) const;
 
    virtual void setVisibility(QString, bool);
 
    virtual bool getVisibility(QString) const;
 
    virtual void refresh();
 
 
    CAMITK_API_DEPRECATED("refreshInterfaceNode() is not required anymore. Everything should now be done transparently (if it does not work, use setNodeModified(true) to force a specific InterfaceNode refresh instead)")  virtual void refreshInterfaceNode();
 
    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();
 
    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;
    }
 
    void updateProperty(QString name, QVariant value) 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;
 
 
    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() 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;
    }
 
    const QString getLabel() const override;
 
    void setLabel(QString newName) override;
 
    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)
 
    // 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 {}
 
    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]) 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;
 
    delegate1(myGeometry, setLinesAsTubes, bool)
 
    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, setImageWorldTransform, vtkSmartPointer<vtkTransform>)
 
    delegate1(mySlice, setArbitraryTransform, vtkSmartPointer<vtkTransform>)
 
    int getNumberOfSlices() const override;
 
    int getSlice() const override;
 
 
    const QString& getFrameName() const override;
 
    delegate1(myFrame, setFrameName, QString)
 
    InterfaceFrame* getParentFrame() const override;
 
    void setParentFrame(InterfaceFrame* frame, bool keepTransform = true) override;
 
    const QVector<InterfaceFrame*>& getChildrenFrame() const override;
 
    const vtkSmartPointer<vtkTransform> getTransformFromWorld() const override;
 
    const vtkSmartPointer<vtkTransform> getTransform() const override;
 
    const vtkSmartPointer<vtkTransform> getTransformFromFrame(InterfaceFrame* frame) const override;
 
    delegate1(myFrame, setTransform, vtkSmartPointer<vtkTransform>)
 
    delegate0(myFrame, resetTransform)
 
    delegate3(myFrame, translate, double, double, double)
 
    delegate3(myFrame, rotate, double, double, double)
 
    delegate3(myFrame, rotateVTK, double, double, double)
 
    delegate3(myFrame, setTransformTranslation, double, double, double)
 
    delegate3(myFrame, setTransformTranslationVTK, double, double, double)
 
    delegate3(myFrame, setTransformRotation, double, double, double)
 
    delegate3(myFrame, setTransformRotationVTK, double, double, double)
 
    vtkSmartPointer<vtkAxesActor> getFrameAxisActor() override;
 
 
    /*CAMITK_API_DEPRECATED("Please use Component::setFrameVisibility(QString viewerName, bool) instead") */virtual void setFrameVisibility(Viewer*, bool) override;
 
    /*CAMITK_API_DEPRECATED("Please use Component::getFrameVisibility(QString viewerName, bool) instead") */virtual bool getFrameVisibility(Viewer*) const override;
 
    delegate2(myFrame, setFrameVisibility, QString, bool)
 
    bool getFrameVisibility(QString) const override;
 
    delegate1(myFrame, addFrameChild, InterfaceFrame*)
 
    delegate1(myFrame, removeFrameChild, InterfaceFrame*)
 
 
protected:
    InterfaceGeometry* myGeometry;
 
    InterfaceBitMap* mySlice;
 
    InterfaceNode* myParentNode;
 
    InterfaceFrame* myFrame;
 
    ComponentList childrenComponent;
 
    bool isSelectedFlag;
 
    bool modifiedFlag;
 
    QString myFileName;
 
    unsigned int indexOfPropertyExplorerTab;
 
 
private:
 
    void init();
 
    Representation myService;
 
    QString myName;
 
    virtual void initRepresentation() = 0;
 
    QMap<QString, bool> myViewers;
 
    QMenu* actionsMenu;
 
    QMenu* visibilityMenu;
 
    QMap<QString, Property*> propertyMap;
 
    bool interfaceNodeModifiedFlag;
 
 
};
 
 
// -------------------- isSelected --------------------
inline bool Component::isSelected() const {
    return isSelectedFlag;
}
 
// -------------------- doubleClicked --------------------
inline bool Component::doubleClicked() {
    return false;
}
 
// -------------------- getChildren --------------------
inline const ComponentList& Component::getChildren() {
    return childrenComponent;
}
 
// -------------------- getName --------------------
inline QString Component::getName() const {
    return myName;
}
 
// -------------------- getParent --------------------
inline InterfaceNode* Component::getParent() {
    return ((Component*) myParentNode);
}
 
// -------------------- getFrame --------------------
inline InterfaceFrame* Component::getFrame() {
    return myFrame;
}
 
// -------------------- getPixmap ------------------
inline QPixmap Component::getIcon() {
    return QPixmap(0, 0); // this is a NULL QPixmap in the Qt sense. QPixmap::isNull will then return true;
}
 
// -------------------- inItalic --------------------
inline bool Component::inItalic() const {
    return false;
}
 
// -------------------- setName --------------------
inline void Component::setName(const QString& n) {
    myName = n;
 
    if (myGeometry) {
        myGeometry->setLabel(n);
    }
 
    setNodeModified(true);
}
 
// -------------------- setModified --------------------
inline void Component::setModified(bool modification) {
    modifiedFlag = modification;
}
 
// -------------------- getModified --------------------
inline bool Component::getModified() const {
    return modifiedFlag;
}
 
// -------------------- getModified --------------------
inline const QString Component::getLabel() const {
    return getName();
}
 
// -------------------- getModified --------------------
inline void Component::setLabel(QString newName) {
    setName(newName);
}
 
// -------------------- setNodeModified --------------------
inline void Component::setNodeModified(bool nodeModified) {
    interfaceNodeModifiedFlag = nodeModified;
}
 
// -------------------- getNodeModified --------------------
inline bool Component::getNodeModified() const {
    return interfaceNodeModifiedFlag;
}
 
}
 
#endif