Visualization.h

Go to the documentation of this file.

/*
 * Copyright (C) 2012 by
 *   MetraLabs GmbH (MLAB), GERMANY
 * and
 *   Neuroinformatics and Cognitive Robotics Labs (NICR) at TU Ilmenau, GERMANY
 * All rights reserved.
 *
 * Contact: info@mira-project.org
 *
 * Commercial Usage:
 *   Licensees holding valid commercial licenses may use this file in
 *   accordance with the commercial license agreement provided with the
 *   software or, alternatively, in accordance with the terms contained in
 *   a written agreement between you and MLAB or NICR.
 *
 * GNU General Public License Usage:
 *   Alternatively, this file may be used under the terms of the GNU
 *   General Public License version 3.0 as published by the Free Software
 *   Foundation and appearing in the file LICENSE.GPL3 included in the
 *   packaging of this file. Please review the following information to
 *   ensure the GNU General Public License version 3.0 requirements will be
 *   met: http://www.gnu.org/copyleft/gpl.html.
 *   Alternatively you may (at your option) use any later version of the GNU
 *   General Public License if such license has been publicly approved by
 *   MLAB and NICR (or its successors, if any).
 *
 * IN NO EVENT SHALL "MLAB" OR "NICR" BE LIABLE TO ANY PARTY FOR DIRECT,
 * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
 * THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF "MLAB" OR
 * "NICR" HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * "MLAB" AND "NICR" SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND "MLAB" AND "NICR" HAVE NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR MODIFICATIONS.
 */

#ifndef _MIRA_VISUALIZATION_H_
#define _MIRA_VISUALIZATION_H_

#include <factory/Factory.h>
#include <utils/Time.h>

#include <visualization/ChannelProperty.h>

#include <visualization/GuiVisualizationExports.h>

namespace mira {


class IVisualizationSite// : public IAuthorityProvider
{
public:
    virtual ~IVisualizationSite() {}
};

class IVisualizationSiteTransformable : public IVisualizationSite
{
public:
    virtual ~IVisualizationSiteTransformable() {}
    
    virtual const std::string& getFixedFrame() const = 0;
    virtual const std::string& getCameraFrame() const = 0;
};


class MIRA_GUI_VISUALIZATION_EXPORT Visualization :
    public Object, public IAuthorityProvider, public Authority
{
    MIRA_ABSTRACT_OBJECT(Visualization)
public:

    Visualization();
    virtual ~Visualization() {};

public:

    template <typename Reflector>
    void reflect(Reflector& r)
    {
        r.roproperty("Status", &getStatusManager(), "The status of this visualization");
        r.member("Enabled", mEnabled, "Is true if the visualization is enabled and visible");
        r.member("Name", mDisplayedName, "The name that is shown to the user");
    }

public:

    virtual void init(IVisualizationSite* site) = 0;

    virtual IVisualizationSite* getSite() = 0;

public:

    virtual void processUpdate(Duration dt);

public:

    bool isEnabled() const { return mEnabled; }

    virtual void setEnabled(bool enabled) { mEnabled = enabled; }

public:

    const std::string& getName() const { return mDisplayedName; }

    void setName(const std::string& name) { mDisplayedName = name; }

protected:

    virtual void update(Duration dt) {
        onUpdate(dt); // for backward compatibility.
    };

    virtual void onUpdate(Duration dt) {};

public:

    struct DataConnection
    {

        DataConnection() : property(NULL) {}

        template<typename T>
        DataConnection(ChannelProperty<T>& iProperty) :
            type(typeName<T>()), property(&iProperty) {}

        Typename type;
        ChannelPropertyBase* property;
    };

    virtual DataConnection getDataConnection() { return DataConnection(); }


    void setupDataConnectionChannel(const std::string& channelID)
    {
        DataConnection connection = getDataConnection();
        if(connection.property==NULL) // if no data connection channel, abort here
            return;

        // set the id
        connection.property->set(channelID, this);
        // and add the property to our property set, for regularl update of the properties
        mChannelProperties.insert(connection.property);
    }

protected:

    enum OptionalMode
    {
        NOT_REQUIRED,
        REQUIRED
    };

    template<typename T, typename Reflector>
    void channelProperty(Reflector& r, const std::string& name,
            ChannelProperty<T>& channel, const std::string& comment, OptionalMode optional=REQUIRED)
    {
        ChannelProperty<T>::channelProperty(r,name, channel,comment,this);
        mChannelProperties.insert(&channel);
        channel.setName(name);
        if(optional==NOT_REQUIRED)
            channel.setOptional();
        r.roproperty(std::string(name+" Updates").c_str(),
                     getter<uint32>(boost::bind(&ChannelProperty<T>::getDataUpdateCount, &channel)),
                     "How many data updates were received");
    }

private:
    std::set<ChannelPropertyBase*> mChannelProperties;
    bool mEnabled;
    std::string mDisplayedName; // the name of this visualization that is shown to the user

public: // implementation of IAuthorityProvider

    virtual Authority& getAuthority();

};


}

#endif