Add more visualizers: Sphere, Cylinder

scenarios/ArVizExample/ArVizExample.scx

+<?xml version="1.0" encoding="utf-8"?>
+<scenario name="ArVizExample" creation="2019-05-21.14:52:29" globalConfigName="./config/global.cfg" package="RobotAPI" deploymentType="local" nodeName="NodeMain">
+	<application name="ArVizExample" instance="" package="RobotAPI" nodeName="" enabled="true" iceAutoRestart="false"/>
+	<application name="ArVizStorage" instance="" package="RobotAPI" nodeName="" enabled="true" iceAutoRestart="false"/>
+</scenario>
+

scenarios/ArVizExample/config/ArVizExample.cfg

+# ==================================================================
+# ArVizExample properties
+# ==================================================================
+
+# ArmarX.AdditionalPackages:  List of additional ArmarX packages which should be in the list of default packages. If you have custom packages, which should be found by the gui or other apps, specify them here. Comma separated List.
+#  Attributes:
+#  - Default:            Default value not mapped.
+#  - Case sensitivity:   yes
+#  - Required:           no
+# ArmarX.AdditionalPackages = Default value not mapped.
+
+
+# ArmarX.ApplicationName:  Application name
+#  Attributes:
+#  - Default:            ""
+#  - Case sensitivity:   yes
+#  - Required:           no
+# ArmarX.ApplicationName = ""
+
+
+# ArmarX.ArVizExample.EnableProfiling:  enable profiler which is used for logging performance events
+#  Attributes:
+#  - Default:            false
+#  - Case sensitivity:   yes
+#  - Required:           no
+#  - Possible values: {0, 1, false, no, true, yes}
+# ArmarX.ArVizExample.EnableProfiling = false
+
+
+# ArmarX.ArVizExample.MinimumLoggingLevel:  Local logging level only for this component
+#  Attributes:
+#  - Default:            Undefined
+#  - Case sensitivity:   yes
+#  - Required:           no
+#  - Possible values: {Debug, Error, Fatal, Important, Info, Undefined, Verbose, Warning}
+# ArmarX.ArVizExample.MinimumLoggingLevel = Undefined
+
+
+# ArmarX.ArVizExample.ObjectName:  Name of IceGrid well-known object
+#  Attributes:
+#  - Default:            ""
+#  - Case sensitivity:   yes
+#  - Required:           no
+# ArmarX.ArVizExample.ObjectName = ""
+
+
+# ArmarX.ArVizExample.TopicName:  Layer updates are sent over this topic.
+#  Attributes:
+#  - Default:            ArVizTopic
+#  - Case sensitivity:   yes
+#  - Required:           no
+# ArmarX.ArVizExample.TopicName = ArVizTopic
+
+
+# ArmarX.CachePath:  Path for cache files. If relative path AND env. variable ARMARX_USER_CONFIG_DIR is set, the cache path will be made relative to ARMARX_USER_CONFIG_DIR. Otherwise if relative it will be relative to the default ArmarX config dir (${HOME}/.armarx)
+#  Attributes:
+#  - Default:            mongo/.cache
+#  - Case sensitivity:   yes
+#  - Required:           no
+# ArmarX.CachePath = mongo/.cache
+
+
+# ArmarX.Config:  Comma-separated list of configuration files 
+#  Attributes:
+#  - Default:            ""
+#  - Case sensitivity:   yes
+#  - Required:           no
+# ArmarX.Config = ""
+
+
+# ArmarX.DataPath:  Semicolon-separated search list for data files
+#  Attributes:
+#  - Default:            ""
+#  - Case sensitivity:   yes
+#  - Required:           no
+# ArmarX.DataPath = ""
+
+
+# ArmarX.DefaultPackages:  List of ArmarX packages which are accessible by default. Comma separated List. If you want to add your own packages and use all default ArmarX packages, use the property 'AdditionalPackages'.
+#  Attributes:
+#  - Default:            Default value not mapped.
+#  - Case sensitivity:   yes
+#  - Required:           no
+# ArmarX.DefaultPackages = Default value not mapped.
+
+
+# ArmarX.DependenciesConfig:  Path to the (usually generated) config file containing all data paths of all dependent projects. This property usually does not need to be edited.
+#  Attributes:
+#  - Default:            ./config/dependencies.cfg
+#  - Case sensitivity:   yes
+#  - Required:           no
+# ArmarX.DependenciesConfig = ./config/dependencies.cfg
+
+
+# ArmarX.DisableLogging:  Turn logging off in whole application
+#  Attributes:
+#  - Default:            false
+#  - Case sensitivity:   yes
+#  - Required:           no
+#  - Possible values: {0, 1, false, no, true, yes}
+# ArmarX.DisableLogging = false
+
+
+# ArmarX.EnableProfiling:  Enable profiling of CPU load produced by this application
+#  Attributes:
+#  - Default:            false
+#  - Case sensitivity:   yes
+#  - Required:           no
+#  - Possible values: {0, 1, false, no, true, yes}
+# ArmarX.EnableProfiling = false
+
+
+# ArmarX.LoadLibraries:  Libraries to load at start up of the application. Must be enabled by the Application with enableLibLoading(). Format: PackageName:LibraryName;... or /absolute/path/to/library;...
+#  Attributes:
+#  - Default:            ""
+#  - Case sensitivity:   yes
+#  - Required:           no
+# ArmarX.LoadLibraries = ""
+
+
+# ArmarX.LoggingGroup:  The logging group is transmitted with every ArmarX log message over Ice in order to group the message in the GUI.
+#  Attributes:
+#  - Default:            ""
+#  - Case sensitivity:   yes
+#  - Required:           no
+# ArmarX.LoggingGroup = ""
+
+
+# ArmarX.RedirectStdout:  Redirect std::cout and std::cerr to ArmarXLog
+#  Attributes:
+#  - Default:            true
+#  - Case sensitivity:   yes
+#  - Required:           no
+#  - Possible values: {0, 1, false, no, true, yes}
+# ArmarX.RedirectStdout = true
+
+
+# ArmarX.RemoteHandlesDeletionTimeout:  The timeout (in ms) before a remote handle deletes the managed object after the use count reached 0. This time can be used by a client to increment the count again (may be required when transmitting remote handles)
+#  Attributes:
+#  - Default:            3000
+#  - Case sensitivity:   yes
+#  - Required:           no
+# ArmarX.RemoteHandlesDeletionTimeout = 3000
+
+
+# ArmarX.SecondsStartupDelay:  The startup will be delayed by this number of seconds (useful for debugging)
+#  Attributes:
+#  - Default:            0
+#  - Case sensitivity:   yes
+#  - Required:           no
+# ArmarX.SecondsStartupDelay = 0
+
+
+# ArmarX.StartDebuggerOnCrash:  If this application crashes (segmentation fault) qtcreator will attach to this process and start the debugger.
+#  Attributes:
+#  - Default:            false
+#  - Case sensitivity:   yes
+#  - Required:           no
+#  - Possible values: {0, 1, false, no, true, yes}
+# ArmarX.StartDebuggerOnCrash = false
+
+
+# ArmarX.ThreadPoolSize:  Size of the ArmarX ThreadPool that is always running.
+#  Attributes:
+#  - Default:            1
+#  - Case sensitivity:   yes
+#  - Required:           no
+# ArmarX.ThreadPoolSize = 1
+
+
+# ArmarX.TopicSuffix:  Suffix appended to all topic names for outgoing topics. This is mainly used to direct all topics to another name for TopicReplaying purposes.
+#  Attributes:
+#  - Default:            ""
+#  - Case sensitivity:   yes
+#  - Required:           no
+# ArmarX.TopicSuffix = ""
+
+
+# ArmarX.UseTimeServer:  Enable using a global Timeserver (e.g. from ArmarXSimulator)
+#  Attributes:
+#  - Default:            false
+#  - Case sensitivity:   yes
+#  - Required:           no
+#  - Possible values: {0, 1, false, no, true, yes}
+# ArmarX.UseTimeServer = false
+
+
+# ArmarX.Verbosity:  Global logging level for whole application
+#  Attributes:
+#  - Default:            Info
+#  - Case sensitivity:   yes
+#  - Required:           no
+#  - Possible values: {Debug, Error, Fatal, Important, Info, Undefined, Verbose, Warning}
+# ArmarX.Verbosity = Info
+
+

scenarios/ArVizExample/config/ArVizStorage.cfg

+# ==================================================================
+# ArVizStorage properties
+# ==================================================================
+
+# ArmarX.AdditionalPackages:  List of additional ArmarX packages which should be in the list of default packages. If you have custom packages, which should be found by the gui or other apps, specify them here. Comma separated List.
+#  Attributes:
+#  - Default:            Default value not mapped.
+#  - Case sensitivity:   yes
+#  - Required:           no
+# ArmarX.AdditionalPackages = Default value not mapped.
+
+
+# ArmarX.ApplicationName:  Application name
+#  Attributes:
+#  - Default:            ""
+#  - Case sensitivity:   yes
+#  - Required:           no
+# ArmarX.ApplicationName = ""
+
+
+# ArmarX.ArVizStorage.EnableProfiling:  enable profiler which is used for logging performance events
+#  Attributes:
+#  - Default:            false
+#  - Case sensitivity:   yes
+#  - Required:           no
+#  - Possible values: {0, 1, false, no, true, yes}
+# ArmarX.ArVizStorage.EnableProfiling = false
+
+
+# ArmarX.ArVizStorage.MaxHistorySize:  How many layer updates are saved in the history until they are compressed
+#  Attributes:
+#  - Default:            100
+#  - Case sensitivity:   yes
+#  - Required:           no
+# ArmarX.ArVizStorage.MaxHistorySize = 100
+
+
+# ArmarX.ArVizStorage.MinimumLoggingLevel:  Local logging level only for this component
+#  Attributes:
+#  - Default:            Undefined
+#  - Case sensitivity:   yes
+#  - Required:           no
+#  - Possible values: {Debug, Error, Fatal, Important, Info, Undefined, Verbose, Warning}
+# ArmarX.ArVizStorage.MinimumLoggingLevel = Undefined
+
+
+# ArmarX.ArVizStorage.ObjectName:  Name of IceGrid well-known object
+#  Attributes:
+#  - Default:            ""
+#  - Case sensitivity:   yes
+#  - Required:           no
+# ArmarX.ArVizStorage.ObjectName = ""
+
+
+# ArmarX.ArVizStorage.TopicName:  Layer updates are sent over this topic.
+#  Attributes:
+#  - Default:            ArVizTopic
+#  - Case sensitivity:   yes
+#  - Required:           no
+# ArmarX.ArVizStorage.TopicName = ArVizTopic
+
+
+# ArmarX.CachePath:  Path for cache files. If relative path AND env. variable ARMARX_USER_CONFIG_DIR is set, the cache path will be made relative to ARMARX_USER_CONFIG_DIR. Otherwise if relative it will be relative to the default ArmarX config dir (${HOME}/.armarx)
+#  Attributes:
+#  - Default:            mongo/.cache
+#  - Case sensitivity:   yes
+#  - Required:           no
+# ArmarX.CachePath = mongo/.cache
+
+
+# ArmarX.Config:  Comma-separated list of configuration files 
+#  Attributes:
+#  - Default:            ""
+#  - Case sensitivity:   yes
+#  - Required:           no
+# ArmarX.Config = ""
+
+
+# ArmarX.DataPath:  Semicolon-separated search list for data files
+#  Attributes:
+#  - Default:            ""
+#  - Case sensitivity:   yes
+#  - Required:           no
+# ArmarX.DataPath = ""
+
+
+# ArmarX.DefaultPackages:  List of ArmarX packages which are accessible by default. Comma separated List. If you want to add your own packages and use all default ArmarX packages, use the property 'AdditionalPackages'.
+#  Attributes:
+#  - Default:            Default value not mapped.
+#  - Case sensitivity:   yes
+#  - Required:           no
+# ArmarX.DefaultPackages = Default value not mapped.
+
+
+# ArmarX.DependenciesConfig:  Path to the (usually generated) config file containing all data paths of all dependent projects. This property usually does not need to be edited.
+#  Attributes:
+#  - Default:            ./config/dependencies.cfg
+#  - Case sensitivity:   yes
+#  - Required:           no
+# ArmarX.DependenciesConfig = ./config/dependencies.cfg
+
+
+# ArmarX.DisableLogging:  Turn logging off in whole application
+#  Attributes:
+#  - Default:            false
+#  - Case sensitivity:   yes
+#  - Required:           no
+#  - Possible values: {0, 1, false, no, true, yes}
+# ArmarX.DisableLogging = false
+
+
+# ArmarX.EnableProfiling:  Enable profiling of CPU load produced by this application
+#  Attributes:
+#  - Default:            false
+#  - Case sensitivity:   yes
+#  - Required:           no
+#  - Possible values: {0, 1, false, no, true, yes}
+# ArmarX.EnableProfiling = false
+
+
+# ArmarX.LoadLibraries:  Libraries to load at start up of the application. Must be enabled by the Application with enableLibLoading(). Format: PackageName:LibraryName;... or /absolute/path/to/library;...
+#  Attributes:
+#  - Default:            ""
+#  - Case sensitivity:   yes
+#  - Required:           no
+# ArmarX.LoadLibraries = ""
+
+
+# ArmarX.LoggingGroup:  The logging group is transmitted with every ArmarX log message over Ice in order to group the message in the GUI.
+#  Attributes:
+#  - Default:            ""
+#  - Case sensitivity:   yes
+#  - Required:           no
+# ArmarX.LoggingGroup = ""
+
+
+# ArmarX.RedirectStdout:  Redirect std::cout and std::cerr to ArmarXLog
+#  Attributes:
+#  - Default:            true
+#  - Case sensitivity:   yes
+#  - Required:           no
+#  - Possible values: {0, 1, false, no, true, yes}
+# ArmarX.RedirectStdout = true
+
+
+# ArmarX.RemoteHandlesDeletionTimeout:  The timeout (in ms) before a remote handle deletes the managed object after the use count reached 0. This time can be used by a client to increment the count again (may be required when transmitting remote handles)
+#  Attributes:
+#  - Default:            3000
+#  - Case sensitivity:   yes
+#  - Required:           no
+# ArmarX.RemoteHandlesDeletionTimeout = 3000
+
+
+# ArmarX.SecondsStartupDelay:  The startup will be delayed by this number of seconds (useful for debugging)
+#  Attributes:
+#  - Default:            0
+#  - Case sensitivity:   yes
+#  - Required:           no
+# ArmarX.SecondsStartupDelay = 0
+
+
+# ArmarX.StartDebuggerOnCrash:  If this application crashes (segmentation fault) qtcreator will attach to this process and start the debugger.
+#  Attributes:
+#  - Default:            false
+#  - Case sensitivity:   yes
+#  - Required:           no
+#  - Possible values: {0, 1, false, no, true, yes}
+# ArmarX.StartDebuggerOnCrash = false
+
+
+# ArmarX.ThreadPoolSize:  Size of the ArmarX ThreadPool that is always running.
+#  Attributes:
+#  - Default:            1
+#  - Case sensitivity:   yes
+#  - Required:           no
+# ArmarX.ThreadPoolSize = 1
+
+
+# ArmarX.TopicSuffix:  Suffix appended to all topic names for outgoing topics. This is mainly used to direct all topics to another name for TopicReplaying purposes.
+#  Attributes:
+#  - Default:            ""
+#  - Case sensitivity:   yes
+#  - Required:           no
+# ArmarX.TopicSuffix = ""
+
+
+# ArmarX.UseTimeServer:  Enable using a global Timeserver (e.g. from ArmarXSimulator)
+#  Attributes:
+#  - Default:            false
+#  - Case sensitivity:   yes
+#  - Required:           no
+#  - Possible values: {0, 1, false, no, true, yes}
+# ArmarX.UseTimeServer = false
+
+
+# ArmarX.Verbosity:  Global logging level for whole application
+#  Attributes:
+#  - Default:            Info
+#  - Case sensitivity:   yes
+#  - Required:           no
+#  - Possible values: {Debug, Error, Fatal, Important, Info, Undefined, Verbose, Warning}
+# ArmarX.Verbosity = Info
+
+

scenarios/ArVizExample/config/global.cfg

+# ==================================================================
+# Global Config from Scenario ArVizExample
+# ==================================================================
+

source/RobotAPI/components/ArViz/ArVizStorage.cpp

+/*
+ * This file is part of ArmarX.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @package    RobotAPI::ArmarXObjects::ArViz
+ * @author     Fabian Paus ( fabian dot paus at kit dot edu )
+ * @date       2019
+ * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
+ *             GNU General Public License
+ */
+
+#include "ArVizStorage.h"
+
+#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
+
+
+using namespace armarx;
+
+
+void ArVizStorage::onInitComponent()
+{
+    topicName = getProperty<std::string>("TopicName").getValue();
+    maxHistorySize = getProperty<int>("MaxHistorySize").getValue();
+
+    usingTopic(topicName);
+}
+
+
+void ArVizStorage::onConnectComponent()
+{
+    updateCounterBase = 0;
+    updateHistory.clear();
+}
+
+
+void ArVizStorage::onDisconnectComponent()
+{
+
+}
+
+
+void ArVizStorage::onExitComponent()
+{
+
+}
+
+armarx::PropertyDefinitionsPtr ArVizStorage::createPropertyDefinitions()
+{
+    return armarx::PropertyDefinitionsPtr(new ArVizPropertyDefinitions(
+            getConfigIdentifier()));
+}
+
+void ArVizStorage::updateLayers(viz::LayerUpdateSeq const& updates, const Ice::Current&)
+{
+    std::unique_lock<std::mutex> lock(historyMutex);
+
+    updateHistory.insert(updateHistory.end(), updates.begin(), updates.end());
+
+    long currentHistorySize = updateHistory.size();
+    if (currentHistorySize >= maxHistorySize)
+    {
+        compressHistory();
+    }
+}
+
+
+
+viz::LayerUpdates armarx::ArVizStorage::pullUpdatesSince(Ice::Long updateCounter, const Ice::Current&)
+{
+    viz::LayerUpdates result;
+
+    long updateIndex = updateCounter - updateCounterBase;
+
+    if (updateIndex < 0)
+    {
+        updateIndex = 0;
+    }
+
+    std::unique_lock<std::mutex> lock(historyMutex);
+
+    long nextUpdateIndex = (long)updateHistory.size();
+    result.updateCounter = updateCounterBase + nextUpdateIndex;
+    if (updateIndex >= nextUpdateIndex)
+    {
+        // No new updates since last pull
+        return result;
+    }
+
+    // Some new updates since last pull
+    result.updates.reserve(nextUpdateIndex - updateIndex);
+    for (long index = updateIndex; index < nextUpdateIndex; ++index)
+    {
+        result.updates.push_back(updateHistory[index]);
+    }
+
+    return result;
+}
+
+void ArVizStorage::compressHistory()
+{
+    long currentHistorySize = updateHistory.size();
+    long updateCounterBeforeCompression = updateCounterBase + currentHistorySize;
+    // Compress history to one element
+    // TODO (Later): Save this history (to the disk?)
+
+    using LayerID = std::pair<std::string, std::string>;
+    std::map<LayerID, viz::LayerUpdate> compressed;
+
+    for (viz::LayerUpdate& update : updateHistory)
+    {
+        LayerID layerID(update.component, update.name);
+        auto iter = compressed.find(layerID);
+        if (update.action == viz::Layer_CREATE_OR_UPDATE)
+        {
+            if (iter == compressed.end())
+            {
+                // Layer does not exist, so we create it
+                compressed.emplace(layerID, update);
+                continue;
+            }
+
+            // Layer does exist, so we need to merge the update
+            viz::LayerUpdate& existing = iter->second;
+            for (viz::ElementPtr const& updateElement : update.elements)
+            {
+                std::string const& updateID = updateElement->id;
+                auto matchingIter = std::find_if(existing.elements.begin(), existing.elements.end(),
+                                                 [updateID](viz::ElementPtr const & element)
+                {
+                    return element->id == updateID;
+                });
+
+                if (matchingIter == existing.elements.end())
+                {
+                    // Element does not exist, so we create it
+                    existing.elements.push_back(updateElement);
+                    continue;
+                }
+
+                // Update existing element
+                switch (updateElement->action)
+                {
+                    case viz::Element_ADD:
+                    case viz::Element_UPDATE:
+                        *matchingIter = updateElement;
+                        break;
+
+                    case viz::Element_DELETE:
+                        existing.elements.erase(matchingIter);
+                        break;
+                }
+            }
+        }
+        else if (update.action == viz::Layer_DELETE)
+        {
+            compressed.erase(iter);
+        }
+    }
+
+    // Newest update counter should point to the same index
+    long newHistorySize = (long)compressed.size();
+    updateCounterBase += currentHistorySize - newHistorySize;
+    // Add a single merged update for each layer
+    updateHistory.clear();
+    updateHistory.reserve(newHistorySize);
+    for (auto& [id, layer] : compressed)
+    {
+        updateHistory.push_back(std::move(layer));
+    }
+
+    ARMARX_INFO << "Compressed history from " << currentHistorySize
+                << " to " << newHistorySize;
+
+    long updateCounterAfterCompression = updateCounterBase + newHistorySize;
+
+    ARMARX_CHECK_EQUAL(updateCounterAfterCompression, updateCounterBeforeCompression)
+            << "The update counters before and after history compression should not change";
+}

source/RobotAPI/components/ArViz/ArVizStorage.h

+/*
+ * This file is part of ArmarX.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @package    RobotAPI::ArmarXObjects::ArViz
+ * @author     Fabian Paus ( fabian dot paus at kit dot edu )
+ * @date       2019
+ * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
+ *             GNU General Public License
+ */
+
+#pragma once
+
+#include "Coin/Visualizer.h"
+
+#include <RobotAPI/interface/ArViz.h>
+#include <ArmarXCore/core/Component.h>
+
+#include <mutex>
+#include <atomic>
+
+
+namespace armarx
+{
+    /**
+     * @class ArVizPropertyDefinitions
+     * @brief
+     */
+    class ArVizPropertyDefinitions:
+        public armarx::ComponentPropertyDefinitions
+    {
+    public:
+        ArVizPropertyDefinitions(std::string prefix):
+            armarx::ComponentPropertyDefinitions(prefix)
+        {
+            defineOptionalProperty<std::string>("TopicName", "ArVizTopic", "Layer updates are sent over this topic.");
+            defineOptionalProperty<int>("MaxHistorySize", 100, "How many layer updates are saved in the history until they are compressed")
+            .setMin(0);
+        }
+    };
+
+    /**
+     * @defgroup Component-ArViz ArViz
+     * @ingroup RobotAPI-Components
+     * A description of the component ArViz.
+     *
+     * @class ArViz
+     * @ingroup Component-ArViz
+     * @brief Brief description of class ArViz.
+     *
+     * Detailed description of class ArViz.
+     */
+    class ArVizStorage
+        : virtual public armarx::Component
+        , virtual public armarx::viz::StorageAndTopicInterface
+    {
+    public:
+        /**
+         * @see armarx::ManagedIceObject::getDefaultName()
+         */
+        std::string getDefaultName() const override
+        {
+            return "ArVizStorage";
+        }
+
+        /**
+         * @see armarx::ManagedIceObject::onInitComponent()
+         */
+        void onInitComponent() override;
+
+        /**
+         * @see armarx::ManagedIceObject::onConnectComponent()
+         */
+        void onConnectComponent() override;
+
+        /**
+         * @see armarx::ManagedIceObject::onDisconnectComponent()
+         */
+        void onDisconnectComponent() override;
+
+        /**
+         * @see armarx::ManagedIceObject::onExitComponent()
+         */
+        void onExitComponent() override;
+
+        /**
+         * @see PropertyUser::createPropertyDefinitions()
+         */
+        armarx::PropertyDefinitionsPtr createPropertyDefinitions() override;
+
+        // Topic interface
+        void updateLayers(viz::LayerUpdateSeq const& updates, const Ice::Current&) override;
+
+        // StorageInterface interface
+        viz::LayerUpdates pullUpdatesSince(Ice::Long updateCounter, const Ice::Current&) override;
+
+    private:
+        void compressHistory();
+
+    private:
+        std::string topicName;
+        int maxHistorySize = 100;
+
+        std::mutex historyMutex;
+        long updateCounterBase = 0;
+        std::vector<viz::LayerUpdate> updateHistory;
+
+    };
+}

source/RobotAPI/components/ArViz/ArVizStorageMain.cpp

+#include <RobotAPI/components/ArViz/ArVizStorage.h>
+
+#include <ArmarXCore/core/application/Application.h>
+#include <ArmarXCore/core/Component.h>
+#include <ArmarXCore/core/logging/Logging.h>
+
+int main(int argc, char* argv[])
+{
+    return armarx::runSimpleComponentApp < armarx::ArVizStorage > (argc, argv, "ArVizStorage");
+}

source/RobotAPI/components/ArViz/CMakeLists.txt

+armarx_component_set_name("ArViz")
+
+set(COMPONENT_LIBS
+    ArmarXCore
+    RobotAPICore
+    RobotAPIInterfaces
+    )
+
+set(SOURCES
+
+Coin/Visualizer.cpp
+)
+
+set(HEADERS
+
+IceConversions.h
+
+Coin/ElementVisualizer.h
+
+Coin/VisualizerBox.h
+Coin/VisualizerCylinder.h
+Coin/VisualizerSphere.h
+
+Coin/Visualizer.h
+)
+
+armarx_add_component("${SOURCES}" "${HEADERS}")
+
+armarx_component_set_name("ArVizStorage")
+
+set(COMPONENT_LIBS
+    ArmarXCore
+    ArViz
+    )
+
+set(SOURCES
+ArVizStorage.cpp
+ArVizStorageMain.cpp
+)
+set(HEADERS
+ArVizStorage.h
+)
+
+armarx_add_component_executable("${SOURCES}" "${HEADERS}")

source/RobotAPI/components/ArViz/Coin/ElementVisualizer.h

+#pragma once
+
+#include <Inventor/nodes/SoSeparator.h>
+
+namespace armarx
+{
+    namespace viz
+    {
+
+        class Element;
+
+        namespace coin
+        {
+
+            class ElementVisualizer
+            {
+            public:
+                virtual ~ElementVisualizer() = default;
+
+                virtual SoSeparator* createNode(Element const& element) = 0;
+            };
+
+        }
+    }
+}

source/RobotAPI/components/ArViz/Coin/Visualizer.cpp

+#include "Visualizer.h"
+
+#include "VisualizerBox.h"
+#include "VisualizerCylinder.h"
+#include "VisualizerSphere.h"
+
+#include <ArmarXCore/core/logging/Logging.h>
+
+#include <Inventor/sensors/SoTimerSensor.h>
+
+namespace armarx
+{
+    namespace viz
+    {
+
+        static const char* toString(CoinVisualizerState state)
+        {
+            switch (state)
+            {
+                case CoinVisualizerState::STOPPED:
+                    return "STOPPED";
+                case CoinVisualizerState::STARTING:
+                    return "STARTING";
+                case CoinVisualizerState::RUNNING:
+                    return "RUNNING";
+                case CoinVisualizerState::STOPPING:
+                    return "STOPPING";
+            }
+            return "UNKNOWN";
+        }
+
+        static void updateVisualizationCB(void* data, SoSensor* sensor)
+        {
+            auto* visu = static_cast<CoinVisualizer*>(data);
+            visu->update();
+        }
+
+        CoinVisualizer::CoinVisualizer()
+        {
+            // Register all available draw types
+            using namespace armarx::viz::coin;
+            elementVisualizers.emplace(typeid(ElementBox), std::make_unique<VisualizerBox>());
+            elementVisualizers.emplace(typeid(ElementCylinder), std::make_unique<VisualizerCylinder>());
+            elementVisualizers.emplace(typeid(ElementSphere), std::make_unique<VisualizerSphere>());
+
+            root = new SoSeparator;
+            timerSensor = new SoTimerSensor(updateVisualizationCB, this);
+
+            float cycleTimeMS = 33.0f;
+            timerSensor->setInterval(SbTime(cycleTimeMS / 1000.0f));
+        }
+
+        CoinVisualizer::~CoinVisualizer()
+        {
+        }
+
+        void CoinVisualizer::startAsync(StorageInterfacePrx const& storage)
+        {
+            std::unique_lock<std::mutex> lock(stateMutex);
+            if (state != CoinVisualizerState::STOPPED)
+            {
+                ARMARX_WARNING << "Unexpected state of visualizer\n"
+                               << "Expected: STOPPED\n"
+                               << "But got: " << toString(state);
+                return;
+            }
+            state = CoinVisualizerState::STARTING;
+            stateStorage = storage;
+
+            SoSensorManager* sensor_mgr = SoDB::getSensorManager();
+            sensor_mgr->insertTimerSensor(timerSensor);
+        }
+
+        void CoinVisualizer::stop()
+        {
+            if (state == CoinVisualizerState::STOPPED)
+            {
+                return;
+            }
+
+            SoSensorManager* sensor_mgr = SoDB::getSensorManager();
+            sensor_mgr->removeTimerSensor(timerSensor);
+
+            state = CoinVisualizerState::STOPPED;
+        }
+
+        void CoinVisualizer::apply(LayerUpdate const& update)
+        {
+            auto layerID = std::make_pair(update.component, update.name);
+            auto layerIt = layers.find(layerID);
+            if (layerIt == layers.end())
+            {
+                // Create a new layer
+                SoSeparator* coinNode = new SoSeparator;
+                coinNode->ref();
+                root->addChild(coinNode);
+
+                CoinLayer newLayer;
+                newLayer.node = coinNode;
+                layerIt = layers.emplace(layerID, newLayer).first;
+            }
+
+            CoinLayer& layer = layerIt->second;
+            for (auto& updatedElementPtr : update.elements)
+            {
+                Element const& updatedElement = *updatedElementPtr;
+
+
+
+                auto oldElementIter = layer.elements.find(updatedElement.id);
+                if (oldElementIter != layer.elements.end())
+                {
+                    // Element already exists
+                    SoSeparator* oldElement = oldElementIter->second;
+
+                    switch (updatedElement.action)
+                    {
+                        case Element_ADD:
+                        {
+                            // Remove old element and create a new one below
+                            layer.node->removeChild(oldElement);
+                        }
+                        break;
+                        case Element_UPDATE:
+                        {
+                            // TODO: Change pose and color
+                            return;
+                        }
+                        break;
+                        case Element_DELETE:
+                        {
+                            layer.elements.erase(oldElementIter);
+                            layer.node->removeChild(oldElement);
+                            return;
+                        }
+                        break;
+                        default:
+                        {
+                            assert(false && "Unexpected case in switch");
+                        }
+                        break;
+                    }
+                }
+
+                std::type_info const& elementType = typeid(updatedElement);
+                auto visualizerIter = elementVisualizers.find(elementType);
+                if (visualizerIter == elementVisualizers.end())
+                {
+                    ARMARX_WARNING << "No visualizer for element type found: " << elementType.name();
+                    return;
+                }
+
+                auto& visualizer = *visualizerIter->second;
+                SoSeparator* sep = visualizer.createNode(updatedElement);
+                if (sep)
+                {
+                    layer.node->addChild(sep);
+                    layer.elements[updatedElement.id] = sep;
+                }
+                else
+                {
+                    ARMARX_WARNING << "CoinElementVisualizer returned null for type: " << elementType.name();
+                }
+            }
+        }
+
+        void CoinVisualizer::update()
+        {
+            {
+                switch (state)
+                {
+                    case CoinVisualizerState::STARTING:
+                    {
+                        std::unique_lock<std::mutex> lock(stateMutex);
+                        storage = stateStorage;
+                        root->removeAllChildren();
+                        updateCounter = 0;
+                        state = CoinVisualizerState::RUNNING;
+                    }
+                    break;
+
+                    case CoinVisualizerState::RUNNING:
+                        break;
+
+                    case CoinVisualizerState::STOPPING:
+                        // After we have reached the STOPPED state, we know that updates are no longer running
+                        state = CoinVisualizerState::STOPPED;
+                        return;
+
+                    case CoinVisualizerState::STOPPED:
+                        return;
+                }
+            }
+
+            LayerUpdates pulledUpdates;
+            try
+            {
+                pulledUpdates = storage->pullUpdatesSince(updateCounter);
+            }
+            catch (Ice::ConnectionRefusedException const& ex)
+            {
+                ARMARX_WARNING << "Lost connection to ArVizStorage\n"
+                               << ex.what();
+                storage = nullptr;
+                state = CoinVisualizerState::STOPPED;
+                return;
+            }
+
+            for (LayerUpdate const& update : pulledUpdates.updates)
+            {
+                apply(update);
+            }
+
+            updateCounter = pulledUpdates.updateCounter;
+        }
+
+    }
+}

source/RobotAPI/components/ArViz/Coin/Visualizer.h

+#pragma once
+
+#include "ElementVisualizer.h"
+
+#include <RobotAPI/interface/ArViz/Component.h>
+
+#include <Inventor/nodes/SoSeparator.h>
+
+#include <map>
+#include <unordered_map>
+#include <memory>
+#include <mutex>
+#include <typeindex>
+
+namespace armarx
+{
+    namespace viz
+    {
+
+        using CoinLayerID = std::pair<std::string, std::string>;
+
+        struct CoinLayer
+        {
+            SoSeparator* node = nullptr;
+            std::map<std::string, SoSeparator*> elements;
+        };
+
+        enum class CoinVisualizerState
+        {
+            STOPPED,
+            STARTING,
+            RUNNING,
+            STOPPING
+        };
+
+        class CoinVisualizer
+        {
+        public:
+            CoinVisualizer();
+
+            ~CoinVisualizer();
+
+            void startAsync(StorageInterfacePrx const& storage);
+
+            void stop();
+
+            void apply(LayerUpdate const& update);
+
+            void update();
+
+            std::mutex storageMutex;
+            viz::StorageInterfacePrx storage;
+            long updateCounter = 0;
+
+            SoTimerSensor* timerSensor = nullptr;
+            std::map<CoinLayerID, CoinLayer> layers;
+            std::unordered_map<std::type_index, std::unique_ptr<coin::ElementVisualizer>> elementVisualizers;
+
+            SoSeparator* root = nullptr;
+
+            std::mutex stateMutex;
+            std::atomic<CoinVisualizerState> state{CoinVisualizerState::STOPPED};
+            viz::StorageInterfacePrx stateStorage;
+
+        };
+
+    }
+}

source/RobotAPI/components/ArViz/Coin/VisualizerBox.h

+#pragma once
+
+#include "ElementVisualizer.h"
+
+#include <RobotAPI/interface/ArViz/Elements.h>
+#include <RobotAPI/components/ArViz/IceConversions.h>
+
+#include <VirtualRobot/Visualization/CoinVisualization/CoinVisualizationFactory.h>
+#include <Inventor/nodes/SoCube.h>
+
+namespace armarx
+{
+    namespace viz
+    {
+        namespace coin
+        {
+
+            class VisualizerBox : public ElementVisualizer
+            {
+            public:
+                SoSeparator* createNode(Element const& element) override
+                {
+                    ElementBox const& box = static_cast<ElementBox const&>(element);
+
+                    SoSeparator* newS = new SoSeparator;
+
+                    // TODO: Pose and color can be handled outside?
+                    // TODO: Provide references to SoMatrixTransform and SoMaterial to change/update later
+                    Eigen::Matrix4f m = toEigen(element.pose);
+                    SoMatrixTransform* matrixTransform = VirtualRobot::CoinVisualizationFactory::getMatrixTransform(m);
+                    newS->addChild(matrixTransform);
+
+                    auto color = element.color;
+                    SoMaterial* material = new SoMaterial;
+                    const float conv = 1.0f / 255.0f;
+                    SbColor coinColor(conv * color.r, conv * color.g, conv * color.b);
+                    material->ambientColor.setValue(coinColor);
+                    material->diffuseColor.setValue(coinColor);
+                    material->transparency.setValue(1.0f - conv * color.a);
+                    newS->addChild(material);
+
+                    SoCube* cube = new SoCube;
+                    cube->width = box.size.e0;
+                    cube->height = box.size.e1;
+                    cube->depth = box.size.e2;
+
+                    newS->addChild(cube);
+
+                    return newS;
+                }
+            };
+
+        }
+    }
+}

source/RobotAPI/components/ArViz/Coin/VisualizerCylinder.h

+#pragma once
+
+#include "ElementVisualizer.h"
+
+#include <RobotAPI/interface/ArViz/Elements.h>
+#include <RobotAPI/components/ArViz/IceConversions.h>
+
+#include <VirtualRobot/Visualization/CoinVisualization/CoinVisualizationFactory.h>
+#include <Inventor/nodes/SoCylinder.h>
+
+namespace armarx
+{
+    namespace viz
+    {
+        namespace coin
+        {
+
+            class VisualizerCylinder : public ElementVisualizer
+            {
+            public:
+                SoSeparator* createNode(Element const& element) override
+                {
+                    auto const& concrete = static_cast<ElementCylinder const&>(element);
+
+                    SoSeparator* newS = new SoSeparator;
+
+                    // TODO: Pose and color can be handled outside?
+                    // TODO: Provide references to SoMatrixTransform and SoMaterial to change/update later
+                    Eigen::Matrix4f m = toEigen(element.pose);
+                    SoMatrixTransform* matrixTransform = VirtualRobot::CoinVisualizationFactory::getMatrixTransform(m);
+                    newS->addChild(matrixTransform);
+
+                    auto color = element.color;
+                    SoMaterial* material = new SoMaterial;
+                    const float conv = 1.0f / 255.0f;
+                    SbColor coinColor(conv * color.r, conv * color.g, conv * color.b);
+                    material->ambientColor.setValue(coinColor);
+                    material->diffuseColor.setValue(coinColor);
+                    material->transparency.setValue(1.0f - conv * color.a);
+                    newS->addChild(material);
+
+                    SoCylinder* cylinder = new SoCylinder;
+                    cylinder->radius = concrete.radius;
+                    cylinder->height = concrete.height;
+
+                    newS->addChild(cylinder);
+
+                    return newS;
+                }
+            };
+
+        }
+    }
+}

source/RobotAPI/components/ArViz/Coin/VisualizerSphere.h

+#pragma once
+
+#include "ElementVisualizer.h"
+
+#include <RobotAPI/interface/ArViz/Elements.h>
+#include <RobotAPI/components/ArViz/IceConversions.h>
+
+#include <VirtualRobot/Visualization/CoinVisualization/CoinVisualizationFactory.h>
+#include <Inventor/nodes/SoSphere.h>
+
+namespace armarx
+{
+    namespace viz
+    {
+        namespace coin
+        {
+
+            class VisualizerSphere : public ElementVisualizer
+            {
+            public:
+                SoSeparator* createNode(Element const& element) override
+                {
+                    auto const& concrete = static_cast<ElementSphere const&>(element);
+
+                    SoSeparator* newS = new SoSeparator;
+
+                    // TODO: Pose and color can be handled outside?
+                    // TODO: Provide references to SoMatrixTransform and SoMaterial to change/update later
+                    Eigen::Matrix4f m = toEigen(element.pose);
+                    SoMatrixTransform* matrixTransform = VirtualRobot::CoinVisualizationFactory::getMatrixTransform(m);
+                    newS->addChild(matrixTransform);
+
+                    auto color = element.color;
+                    SoMaterial* material = new SoMaterial;
+                    const float conv = 1.0f / 255.0f;
+                    SbColor coinColor(conv * color.r, conv * color.g, conv * color.b);
+                    material->ambientColor.setValue(coinColor);
+                    material->diffuseColor.setValue(coinColor);
+                    material->transparency.setValue(1.0f - conv * color.a);
+                    newS->addChild(material);
+
+                    SoSphere* sphere = new SoSphere;
+                    sphere->radius = concrete.radius;
+
+                    newS->addChild(sphere);
+                    return newS;
+                }
+            };
+
+        }
+    }
+}

source/RobotAPI/components/ArViz/IceConversions.h

+#pragma once
+
+#include <RobotAPI/interface/ArViz/Elements.h>
+
+#include <Eigen/Core>
+#include <Eigen/Geometry>
+
+namespace armarx
+{
+    namespace viz
+    {
+
+        inline Eigen::Matrix4f toEigen(GlobalPose const& pose)
+        {
+            Eigen::Matrix4f result;
+            result.block<3, 3>(0, 0) = Eigen::Quaternionf(pose.qw, pose.qx, pose.qy, pose.qz).toRotationMatrix();
+            result.block<3, 1>(0, 3) = Eigen::Vector3f(pose.x, pose.y, pose.z);
+            result.block<1, 4>(3, 0) = Eigen::Vector4f(0.0f, 0.0f, 0.0f, 1.0f);
+            return result;
+        }
+
+    }
+}

source/RobotAPI/components/ArVizExample/ArVizExample.cpp

+/*
+ * This file is part of ArmarX.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @package    RobotAPI::ArmarXObjects::ArVizExample
+ * @author     Fabian Paus ( fabian dot paus at kit dot edu )
+ * @date       2019
+ * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
+ *             GNU General Public License
+ */
+
+#include "ArVizExample.h"
+
+#include <Eigen/Eigen>
+
+#include <ArmarXCore/core/time/TimeUtil.h>
+
+using namespace armarx;
+
+
+void ArVizExample::onInitComponent()
+{
+    topicName = getProperty<std::string>("TopicName").getValue();
+    offeringTopic(topicName);
+}
+
+#if 0
+class BufferedDrawer
+{
+public:
+    void drawBox(Box const& box)
+    {
+
+    }
+
+private:
+    viz::MarkerList buffer;
+};
+#endif
+
+inline viz::GlobalPose makeGlobalPose(Eigen::Vector3f const& pos, Eigen::Quaternionf const& ori)
+{
+    viz::GlobalPose result;
+    result.x = pos.x();
+    result.y = pos.y();
+    result.z = pos.z();
+    result.qw = ori.w();
+    result.qx = ori.x();
+    result.qy = ori.y();
+    result.qz = ori.z();
+    return result;
+}
+
+inline armarx::Vector3f frost(Eigen::Vector3f const& pos)
+{
+    return armarx::Vector3f{pos.x(), pos.y(), pos.z()};
+}
+
+void ArVizExample::onConnectComponent()
+{
+    topic = getTopic<armarx::viz::TopicPrx>(topicName);
+
+    task = new RunningTask<ArVizExample>(this, &ArVizExample::update);
+    task->start();
+}
+
+
+void ArVizExample::onDisconnectComponent()
+{
+    task->stop();
+    task = nullptr;
+}
+
+void ArVizExample::update()
+{
+    Eigen::Vector3f pos = Eigen::Vector3f::Zero();
+    while (!task->isStopped())
+    {
+        double timeInSeconds = TimeUtil::GetTime().toSecondsDouble();
+
+        viz::LayerUpdate layer;
+        layer.component = getName();
+        layer.name = "Example";
+        {
+            viz::ElementBoxPtr box(new viz::ElementBox);
+            box->id = "box";
+            box->action = viz::Element_ADD;
+
+            pos.x() = 1000.0f * std::sin(timeInSeconds);
+            box->pose = makeGlobalPose(pos, Eigen::Quaternionf::Identity());
+            box->color = armarx::viz::Color{255, 255, 0, 0};
+            box->size = frost(Eigen::Vector3f(1000.0f, 1000.0f, 1000.0f));
+
+            layer.elements.push_back(box);
+        }
+
+        topic->updateLayers({layer});
+
+        TimeUtil::SleepMS(10);
+    }
+}
+
+void ArVizExample::onExitComponent()
+{
+
+}
+
+armarx::PropertyDefinitionsPtr ArVizExample::createPropertyDefinitions()
+{
+    return armarx::PropertyDefinitionsPtr(new ArVizExamplePropertyDefinitions(
+            getConfigIdentifier()));
+}
+
+

source/RobotAPI/components/ArVizExample/ArVizExample.h

+/*
+ * This file is part of ArmarX.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @package    RobotAPI::ArmarXObjects::ArVizExample
+ * @author     Fabian Paus ( fabian dot paus at kit dot edu )
+ * @date       2019
+ * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
+ *             GNU General Public License
+ */
+
+#pragma once
+
+#include <RobotAPI/interface/ArViz.h>
+
+#include <ArmarXCore/core/Component.h>
+
+#include <ArmarXCore/core/services/tasks/RunningTask.h>
+
+namespace armarx
+{
+    /**
+     * @class ArVizExamplePropertyDefinitions
+     * @brief
+     */
+    class ArVizExamplePropertyDefinitions:
+        public armarx::ComponentPropertyDefinitions
+    {
+    public:
+        ArVizExamplePropertyDefinitions(std::string prefix):
+            armarx::ComponentPropertyDefinitions(prefix)
+        {
+            defineOptionalProperty<std::string>("TopicName", "ArVizTopic", "Layer updates are sent over this topic.");
+        }
+    };
+
+    /**
+     * @defgroup Component-ArVizExample ArVizExample
+     * @ingroup RobotAPI-Components
+     * A description of the component ArVizExample.
+     *
+     * @class ArVizExample
+     * @ingroup Component-ArVizExample
+     * @brief Brief description of class ArVizExample.
+     *
+     * Detailed description of class ArVizExample.
+     */
+    class ArVizExample :
+        virtual public armarx::Component
+    {
+    public:
+        /**
+         * @see armarx::ManagedIceObject::getDefaultName()
+         */
+        std::string getDefaultName() const override
+        {
+            return "ArVizExample";
+        }
+
+        void onInitComponent() override;
+        void onConnectComponent() override;
+
+        void onDisconnectComponent() override;
+        void onExitComponent() override;
+
+        armarx::PropertyDefinitionsPtr createPropertyDefinitions() override;
+
+    private:
+        void update();
+    private:
+
+        std::string topicName;
+        armarx::viz::TopicPrx topic;
+
+        RunningTask<ArVizExample>::pointer_type task;
+    };
+}

source/RobotAPI/components/ArVizExample/CMakeLists.txt

+armarx_component_set_name("ArVizExample")
+
+set(COMPONENT_LIBS
+    ArmarXCore
+    ArViz
+    )
+
+set(SOURCES
+ArVizExample.cpp
+main.cpp
+)
+set(HEADERS
+ArVizExample.h
+)
+
+armarx_add_component_executable("${SOURCES}" "${HEADERS}")

source/RobotAPI/components/ArVizExample/main.cpp

+#include <RobotAPI/components/ArVizExample/ArVizExample.h>
+
+#include <ArmarXCore/core/application/Application.h>
+#include <ArmarXCore/core/Component.h>
+#include <ArmarXCore/core/logging/Logging.h>
+
+int main(int argc, char* argv[])
+{
+    return armarx::runSimpleComponentApp < armarx::ArVizExample > (argc, argv, "ArVizExample");
+}

source/RobotAPI/components/ArVizExample/test/CMakeLists.txt

+
+# Libs required for the tests
+SET(LIBS ${LIBS} ArmarXCore ArVizExample)
+ 
+armarx_add_test(ArVizExampleTest ArVizExampleTest.cpp "${LIBS}")
\ No newline at end of file