sdk/libraries/core/component/Component.h

Go to the documentation of this file.

/*****************************************************************************
 * $CAMITK_LICENCE_BEGIN$
 *
 * CamiTK - Computer Assisted Medical Intervention ToolKit
 * (c) 2001-2018 Univ. Grenoble Alpes, CNRS, TIMC-IMAG UMR 5525 (GMCAO)
 *
 * 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
#include <vtkWindowLevelLookupTable.h>
#include <vtkImageData.h>
#include <vtkPointSet.h>
#include <vtkSmartPointer.h>
#include <vtkAlgorithmOutput.h>
#include <vtkActor.h>
#include <vtkAxesActor.h>
#include <vtkActor2D.h>
#include <vtkImageActor.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() { \
                        invoke0(HANDLER,METHOD) \
                      }

#define delegate1(HANDLER,METHOD,PARAM_TYPE) \
virtual void METHOD(PARAM_TYPE param) { \
                                        invoke1(HANDLER,METHOD,param) \
                                      }

#define delegate2(HANDLER,METHOD,PARAM_TYPE1,PARAM_TYPE2) \
virtual void METHOD(PARAM_TYPE1 param1, PARAM_TYPE2 param2) { \
                                                              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) { \
                                                                                  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) { \
                                                                                                      invoke4(HANDLER,METHOD,param1,param2,param3,param4) \
                                                                                                    }

#define delegateGet0(HANDLER,METHOD,TYPE) \
virtual TYPE METHOD() { \
                        invokeGet0(HANDLER,METHOD) \
                        else \
                        return 0; \
                      }

#define delegateGet1(HANDLER,METHOD,TYPE,PARAM_TYPE) \
virtual TYPE METHOD(PARAM_TYPE param) { \
                                        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) { \
                                        invokeGet2(HANDLER,METHOD,param1,param2) \
                                        else \
                                        return 0; \
                                      }

#define delegateConstGet0(HANDLER,METHOD,TYPE) \
virtual TYPE METHOD() const { \
                              invokeGet0(HANDLER,METHOD) \
                              else \
                              return 0; \
                            }

#define delegateConstGet1(HANDLER,METHOD,TYPE,PARAM_TYPE) \
virtual TYPE METHOD(PARAM_TYPE param) const { \
                                              invokeGet1(HANDLER,METHOD,param) \
                                              else \
                                              return 0; \
                                            }

#define delegateAndInvokeChildren1(HANDLER,METHOD,PARAM_TYPE) \
virtual void METHOD(PARAM_TYPE param) { \
                                        invoke1(HANDLER,METHOD,param) \
                                        invokeChildren1(METHOD,param) \
                                      }

#define delegateAndInvokeChildren2(HANDLER,METHOD,PARAM_TYPE1,PARAM_TYPE2) \
virtual void METHOD(PARAM_TYPE1 param1, PARAM_TYPE2 param2) { \
                                                              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]) { \
                                                                   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) { \
                                                                                  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) { \
                                                                                                     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;

    virtual Component* getParentComponent();

    virtual Component* getTopLevelComponent();

    virtual InterfaceFrame* getFrame();

    virtual void setModified(bool modified = true);

    virtual bool getModified() const;

    virtual void setVisibility(Viewer*, bool);

    virtual bool getVisibility(Viewer*) const;

    virtual void refresh() const;

    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() {
        return 0;
    }

    QWidget* getPropertyWidgetAt(unsigned int i) {
        return nullptr;
    }

    QObject* getPropertyObject() {
        return this;
    }

    void updateProperty(QString name, QVariant value) override;

    inline void setIndexOfPropertyExplorerTab(unsigned int index) {
        this->indexOfPropertyExplorerTab = index;
    }

    inline unsigned int getIndexOfPropertyExplorerTab() {
        return this->indexOfPropertyExplorerTab;
    }

    Q_INVOKABLE Property* getProperty(QString name) override;

    bool addProperty(Property*) override;

    //-- the methods below are commented because the default comment in InterfaceNode lacks some information...
    void addChild(InterfaceNode*) override;
    void attachChild(InterfaceNode*) override;
    void removeChild(InterfaceNode*) override;

    void setParent(InterfaceNode*) override;

    //--not commented because Doxygen automatically use the inherited documentation (set INHERIT_DOCS flag to YES in the Doxyfile)
    void deleteChildren() override;
    QString getName() const override;
    void setName(const QString&) override;
    const ComponentList& getChildren() override;
    bool doubleClicked() override;
    InterfaceNode* getParent() override;
    QPixmap getIcon() override;

    bool inItalic() const override;

    QMenu* getPopupMenu(QWidget* parent = nullptr) {
        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) {
        if (myGeometry) {
            return myGeometry->getProp(param);
        }
        else if (mySlice) {
            return mySlice->getProp(param);
        }
        return nullptr;
    }

    unsigned int getNumberOfProp() const {
        if (myGeometry) {
            return myGeometry->getNumberOfProp();
        }
        else if (mySlice) {
            return mySlice->getNumberOfProp();
        }
        return 0;
    }

    vtkSmartPointer<vtkProp> getProp(unsigned int index) {
        if (myGeometry) {
            return myGeometry->getProp(index);
        }
        else if (mySlice) {
            return mySlice->getProp(index);
        }
        return nullptr;
    }

    bool addProp(const QString& name, vtkSmartPointer<vtkProp> prop) {
        if (myGeometry) {
            return myGeometry->addProp(name, prop);
        }
        else if (mySlice) {
            return mySlice->addProp(name, prop);
        }
        return false;
    }


    bool removeProp(const QString& name) {
        if (myGeometry) {
            return myGeometry->removeProp(name);
        }
        else if (mySlice) {
            return mySlice->removeProp(name);
        }
        return false;
    }
    // END TODO


    void pointPicked(vtkIdType, bool) {}

    void cellPicked(vtkIdType, bool) {}

    // --

    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)

    delegateConstGet0(myGeometry, getEnhancedModes, const 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>)

//    delegateGet0(mySlice, get2DAxesActor, vtkSmartPointer<vtkAxesActor>)

    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>)

    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;

    delegate2(myFrame, setFrameVisibility, Viewer*, bool)

    bool getFrameVisibility(Viewer* viewer) 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<Viewer*, bool> myViewers;

    QMenu* actionsMenu;

    QMap<QString, Property*> propertyMap;

    static QSet<Viewer*> allViewers;

};


// -------------------- isSelected --------------------
inline bool Component::isSelected() const {
    return isSelectedFlag;
}

// -------------------- doubleClicked --------------------
inline bool Component::doubleClicked() {
    // always false by default. You must overload this method in Components to change its behaviour.
    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);
    }
}

// -------------------- 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) {
    setLabel(newName);
}

}

#endif