sdk/libraries/core/component/Component.h

Go to the documentation of this file.

/*****************************************************************************
 * $CAMITK_LICENCE_BEGIN$
 *
 * CamiTK - Computer Assisted Medical Intervention ToolKit
 * (c) 2001-2014 UJF-Grenoble 1, 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"
#include "Log.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(const QString & file, const QString & name, Representation rep = NO_REPRESENTATION);

    Component(Component *parentComponent, const QString & name, Representation rep = NO_REPRESENTATION) throw(AbortException);

    virtual ~Component();

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

    QMenu * getActionMenu();

    QStringList getHierarchy();

    bool isInstanceOf(QString className);

    // TODO CAMITK_DEPRECATED. This section list all the methods marked as deprecated. They are to be removed in CamiTK 4.0
    virtual QWidget * getPropertyWidget(QWidget* parent = 0) {
        return NULL;
    }

    virtual unsigned int getNumberOfPropertyWidget() {
        if (this->getPropertyWidget())
            return 1;
        else
            return 0;
    }

    virtual QWidget * getPropertyWidgetAt(unsigned int i, QWidget* parent = 0) {
        if (this->getPropertyWidget() && (i==0))
            return this->getPropertyWidget();
        else
            return NULL;
    }

    virtual QObject * getPropertyObject() {
        return this;
    }

    void updateProperty(QString name, QVariant value);

    // TODO CAMITK_DEPRECATED. This section list all the methods marked as deprecated. They are to be removed in CamiTK 4.0
    virtual bool setDynamicProperty(const char *name, const QVariant &value, const char *description = "", bool isReadOnly=false);

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

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

    QMenu * getActionAndPopupMenu();

    Q_INVOKABLE virtual Property* getProperty(QString name);

    virtual bool addProperty(Property*);

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

    virtual void setParent(InterfaceNode *);

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

    virtual bool inItalic() const;

    virtual QMenu * getPopupMenu(QWidget* parent = 0) {
        return NULL;
    }

    const QString getLabel() const;

    void setLabel(QString newName);

    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
    virtual vtkSmartPointer<vtkProp> getProp(const QString &param) {
        if (myGeometry)
            return myGeometry->getProp(param);
        else if(mySlice)
            return mySlice->getProp(param);
        return NULL;
    }

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

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

    virtual 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;
    }


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


    virtual void pointPicked(vtkIdType, bool) {}

    virtual void cellPicked(vtkIdType, bool) {}

    // --

    virtual void getBounds(double *bounds);

    virtual double getBoundingRadius();

    delegate4(myGeometry, setPointPosition, const unsigned int, const double, const double, const double)

    delegateAndInvokeChildren1(myGeometry, setRenderingModes, const RenderingModes)

    virtual const InterfaceGeometry::RenderingModes getRenderingModes() const;

    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)

    virtual void getActorColor(const RenderingModes, double [4]);

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

    virtual void setGlyphType(const GlyphTypes type, const double size = 0.0);

    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)

    delegate1(mySlice, setRotationX, double)

    delegate1(mySlice, setRotationY, double)

    delegate1(mySlice, setRotationZ, double)

    delegateConstGet0(mySlice, getNumberOfColors, int)

    delegate3(mySlice, setPixelRealPosition, double, double, double)

    delegate1(mySlice, setImageWorldTransform, vtkSmartPointer<vtkTransform>)

    virtual double getRotationX() const;

    virtual double getRotationY() const;

    virtual double getRotationZ() const;

    virtual int getNumberOfSlices() const;

    virtual int getSlice() const;


    const QString & getFrameName() const {
        if(!myFrame)
            CAMITK_ERROR("Component", "getFrameName", "Delegate myFrame is not instanciated.")
            return myFrame->getFrameName();
    }

    delegate1(myFrame, setFrameName, QString)

    InterfaceFrame* getParentFrame() const {
        if(!myFrame)
            CAMITK_ERROR("Component", "getParentFrame", "Delegate myFrame is not instanciated.")
            return myFrame->getParentFrame();
    }

    void setParentFrame(InterfaceFrame* frame, bool keepTransform = true) {
        if(!myFrame)
            CAMITK_ERROR("Component", "setParentFrame", "Delegate myFrame is not instanciated.")
            return myFrame->setParentFrame(frame, keepTransform);
    }

    const QVector<InterfaceFrame *> & getChildrenFrame() const {
        if(!myFrame)
            CAMITK_ERROR("Component", "getChildrenFrame", "Delegate myFrame is not instanciated.")
            return myFrame->getChildrenFrame();
    }

    const vtkSmartPointer<vtkTransform> getTransformFromWorld() const {
        if(!myFrame)
            CAMITK_ERROR("Component", "getTransformFromWorld", "Delegate myFrame is not instanciated.")
            return myFrame->getTransformFromWorld();
    }

    const vtkSmartPointer<vtkTransform> getTransform() const {
        if(!myFrame)
            CAMITK_ERROR("Component", "getTransform", "Delegate myFrame is not instanciated.")
            return myFrame->getTransform();
    }

    const vtkSmartPointer<vtkTransform> getTransformFromFrame(InterfaceFrame * frame) const {
        if(!myFrame)
            CAMITK_ERROR("Component", "getTransformFromFrame", "Delegate myFrame is not instanciated.")
            return myFrame->getTransformFromFrame(frame);
    }

    delegate1(myFrame, setTransform, vtkSmartPointer<vtkTransform>)

    delegate0(myFrame, resetTransform)

    delegate3(myFrame, translate, double, double, double)

    delegate3(myFrame, rotate, double, double, double)

    delegate3(myFrame, setTransformTranslation, double, double, double)

    delegate3(myFrame, setTransformRotation, double, double, double)

    vtkSmartPointer<vtkAxesActor> getFrameAxisActor() {
        if(!myFrame)
            CAMITK_ERROR("Component", "getFrameAxisActor", "Delegate myFrame is not instanciated.")
            return myFrame->getFrameAxisActor();
    }

    delegate2(myFrame, setFrameVisibility, Viewer *, bool)

    bool getFrameVisibility(Viewer * viewer) const {
        if(!myFrame)
            CAMITK_ERROR("Component", "getFrameVisibility", "Delegate myFrame is not instanciated.")
            return myFrame->getFrameVisibility(viewer);
    }

    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 NULL;
}

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