Vizkit3DPlugin.hpp

Go to the documentation of this file.

#ifndef __VIZKIT3D_VIZPLUGIN_HPP__
#define __VIZKIT3D_VIZPLUGIN_HPP__

#include <QtCore>
#include <QtGui>

#include <osg/NodeCallback>
#include <osg/Group>
#include <osg/PositionAttitudeTransform>

#include <boost/thread/mutex.hpp>

namespace vizkit3d
{
class VizPluginRubyAdapterBase : public QObject
{
    Q_OBJECT
    
    public slots:
        virtual void update(QVariant&, bool) = 0;
        virtual QString getDataType() = 0;
        virtual QString getRubyMethod() = 0;
};

class VizPluginRubyAdapterCollection : public QObject
{
    Q_OBJECT

    public:
        void addAdapter(VizPluginRubyAdapterBase* adapter) 
        {
            adapterList.push_back(adapter);
        };

        void removeAdapter(VizPluginRubyAdapterBase* adapter)
        {
            std::vector<VizPluginRubyAdapterBase*>::iterator it = std::find(adapterList.begin(), adapterList.end(), adapter);
            if (it != adapterList.end()) adapterList.erase(it);
        };

        const std::vector<VizPluginRubyAdapterBase*> &getAdapterList() const
        {
            return adapterList;
        }

    public slots:
        QStringList* getListOfAvailableAdapter()
        {
            QStringList* adapterStringList = new QStringList();
            for(std::vector<VizPluginRubyAdapterBase*>::iterator it = adapterList.begin(); it != adapterList.end(); it++)
            {
                adapterStringList->push_back((*it)->getRubyMethod());
            }
            return adapterStringList;
        };

        QObject* getAdapter(QString rubyMethodName)
        {
            for(std::vector<VizPluginRubyAdapterBase*>::iterator it = adapterList.begin(); it != adapterList.end(); it++)
            {
                if ((*it)->getRubyMethod() == rubyMethodName) 
                    return *it; 
            }
            return NULL;
        };

    protected:
        std::vector<VizPluginRubyAdapterBase*> adapterList;
};
class Vizkit3DWidget;

class VizPluginBase : public QObject
{
    friend class PickHandler;

    Q_OBJECT
    Q_PROPERTY(QString vizkit3d_plugin_name READ getPluginName)
    Q_PROPERTY(bool enabled READ isPluginEnabled WRITE setPluginEnabled)
    Q_PROPERTY(bool KeepOldData READ isKeepOldDataEnabled WRITE setKeepOldData)
    Q_PROPERTY(int MaxOldData READ getMaxOldData WRITE setMaxOldData)
    Q_PROPERTY(QStringList frame READ getVisualizationFrames WRITE setVisualizationFrameFromList)
    Q_PROPERTY(double scale READ getScale WRITE setScale)

    public:
        VizPluginBase(QObject *parent=NULL);
        virtual ~VizPluginBase();

        Vizkit3DWidget* getWidget() const;

        virtual bool isDirty() const;
        void setDirty();

        osg::ref_ptr<osg::Group> getVizNode() const;
        osg::ref_ptr<osg::Group> getRootNode() const;

        std::vector<QDockWidget*> getDockWidgets();

    public slots:
        virtual bool isPluginEnabled();

        virtual void setPluginEnabled(bool enabled);

        virtual const QString getPluginName() const;
        virtual void setPluginName(const QString &name);

        virtual void click(float x,float y);

        QObject* getRubyAdapterCollection();

        void setKeepOldData(bool value);
        bool isKeepOldDataEnabled();

        virtual void clearVisualization();
        
        void deleteOldData();

        int getMaxOldData()const {return max_old_data;};
        void setMaxOldData(int value);

        void setPose(const QVector3D &position, const QQuaternion &orientation);

        QStringList getVisualizationFrames() const;

        QString getVisualizationFrame() const;

        void setVisualizationFrameFromList(const QStringList &frames);

        void setVisualizationFrame(const QString &frame);

        double getScale() const;

        void setScale(double scale);

    signals:
        void propertyChanged(QString property_name);

        void childrenChanged();

        void pluginActivityChanged(bool);

        void clicked(float x, float y);

        void picked(float x, float y,float z);

    protected:
        virtual void updateMainNode(osg::Node* node) = 0;

        virtual osg::ref_ptr<osg::Node> createMainNode();

        virtual void createDockWidgets();

        virtual osg::ref_ptr<osg::Node> cloneCurrentViz();

        boost::mutex updateMutex;

        std::vector<QDockWidget*> dockWidgets;
        QString vizkit3d_plugin_name;
        VizPluginRubyAdapterCollection adapterCollection;

    private:
        class CallbackAdapter;
        osg::ref_ptr<osg::NodeCallback> nodeCallback;
        void updateCallback(osg::Node* node);

        osg::ref_ptr<osg::Node> mainNode;               //node which is used by the child class
        osg::ref_ptr<osg::Group> rootNode;              //node which is the osg root node of the pluign 
        osg::ref_ptr<osg::PositionAttitudeTransform> vizNode; //node which describes the transformation between rootNode and mainNode
        osg::ref_ptr<osg::Group> oldNodes;              //node which is the root node for all old visualization graphs of the plugin  

        //position of the vizNode
        QVector3D position;

        //orientation of the viznode
        QQuaternion orientation;

        bool isAttached;
        bool dirty;
        bool plugin_enabled;
        bool keep_old_data;
        unsigned int max_old_data;
        QString current_frame;
};

template <typename T> class Vizkit3DPlugin;

template <typename T>
class VizPluginAddType
{
    template <typename Type> friend class Vizkit3DPlugin;

    public:
    virtual ~VizPluginAddType() {}

    protected:
        virtual void updateDataIntern(const T &data) = 0;
};

template <class T>
class Vizkit3DPlugin : public VizPluginBase,
    public VizPluginAddType< T >
{
    public:
        Vizkit3DPlugin(QObject* parent = NULL)
            : VizPluginBase(parent) {}

        virtual ~Vizkit3DPlugin() {}

        template<typename Type>
        void updateData(const Type &data) {
            boost::mutex::scoped_lock lockit(this->updateMutex);
            this->setDirty();
            VizPluginAddType<Type> *type = dynamic_cast<VizPluginAddType<Type>*>(this);
            if(type)
                type->updateDataIntern(data);
            else
            {
                throw std::runtime_error("Wrong type given to visualizer");
            }
        };
};

class VizkitPluginFactory : public QObject
{
    Q_OBJECT
    
    public:
        VizkitPluginFactory(QObject* parent = 0) : QObject(parent){};
    
    public slots:
        virtual QObject* createPlugin(QString const& name) = 0;
        virtual QStringList* getAvailablePlugins() const = 0;
};

#define VizPluginRubyAdapterCommon(pluginName, dataType, methodName, rubyMethodName)\
    class VizPluginRubyAdapter##pluginName##rubyMethodName : public VizPluginRubyAdapterBase {\
        public:\
            VizPluginRubyAdapter##pluginName##rubyMethodName(pluginName* plugin)\
            {\
                vizPlugin = plugin;\
            };\
            void update(QVariant& data, bool pass_ownership)\
            {\
                void* ptr = data.value<void*>();\
                dataType* pluginData = reinterpret_cast<dataType*>(ptr);\
                vizPlugin->methodName(*pluginData);\
                if (pass_ownership) \
                        delete pluginData; \
            }\
        public slots:\
            QString getDataType() \
            {\
                return #dataType;\
            }\
            QString getRubyMethod() \
            {\
                return #rubyMethodName; \
            }\
        private:\
            pluginName* vizPlugin;\
    };\
    adapterCollection.addAdapter(new VizPluginRubyAdapter##pluginName##rubyMethodName(this));

#define VizPluginRubyAdapter(pluginName, dataType, typeName) \
    VizPluginRubyAdapterCommon(pluginName, dataType, updateData, update##typeName)
#define VizPluginRubyMethod(pluginName, dataType, methodName) \
    VizPluginRubyAdapterCommon(pluginName, dataType, methodName, methodName)
#define VizPluginRubyConfig(pluginName, dataType, methodName) \
    VizPluginRubyAdapterCommon(pluginName, dataType, methodName, methodName)


#define VizkitQtPlugin(pluginName)\
    class QtPlugin##pluginName : public vizkit3d::VizkitPluginFactory {\
        public:\
        virtual QStringList* getAvailablePlugins() const\
        {\
            QStringList* result = new QStringList; \
            result->push_back(#pluginName); \
            return result;\
        } \
        virtual QObject* createPlugin(QString const& name)\
        {\
            if (name == #pluginName) \
                return new pluginName;\
            else return 0;\
        };\
    };\
    Q_EXPORT_PLUGIN2(QtPlugin##pluginName, QtPlugin##pluginName)

template <class T>
class VizPluginAdapter : public Vizkit3DPlugin<T>
{
    protected:
        virtual void operatorIntern( osg::Node* node, osg::NodeVisitor* nv ) = 0;

        VizPluginAdapter()
            : groupNode(new osg::Group())
        {
        }

        osg::ref_ptr<osg::Node> createMainNode()
        {
            return groupNode;
        }

        void updateMainNode( osg::Node* node )
        {
            // NULL for nodevisitor is ok here, since its not used anywhere
            operatorIntern( node, NULL );
        }

        void setMainNode( osg::Node* node )
        {
            groupNode->addChild( node );
        }

    protected:
        osg::ref_ptr<osg::Group> groupNode;
        osg::ref_ptr<osg::Node> ownNode;
};

}
#endif