diff --git a/etc/cmake/ArmarXPackageVersion.cmake b/etc/cmake/ArmarXPackageVersion.cmake
index 72326b8999df7273c6a90294c8739449bc9e5280..46287a285b0c05f5307a33ead03dd540d0e6b84a 100644
--- a/etc/cmake/ArmarXPackageVersion.cmake
+++ b/etc/cmake/ArmarXPackageVersion.cmake
@@ -1,7 +1,7 @@
 # armarx version file
 set(ARMARX_PACKAGE_LIBRARY_VERSION_MAJOR "0")
 set(ARMARX_PACKAGE_LIBRARY_VERSION_MINOR "3")
-set(ARMARX_PACKAGE_LIBRARY_VERSION_PATCH "2")
+set(ARMARX_PACKAGE_LIBRARY_VERSION_PATCH "3")
 
 set(ARMARX_PACKAGE_LIBRARY_VERSION "${ARMARX_PACKAGE_LIBRARY_VERSION_MAJOR}.${ARMARX_PACKAGE_LIBRARY_VERSION_MINOR}.${ARMARX_PACKAGE_LIBRARY_VERSION_PATCH}")
 
diff --git a/etc/doxygen/pages/SensorActorUnits.dox b/etc/doxygen/pages/SensorActorUnits.dox
index f0c6731cdc79b47601db8d948eeebe0b1c15c92a..bfff40b5809a5c897ee72551f9784b9a615a7cd3 100644
--- a/etc/doxygen/pages/SensorActorUnits.dox
+++ b/etc/doxygen/pages/SensorActorUnits.dox
@@ -1,6 +1,6 @@
 /**
   \defgroup RobotAPI-SensorActorUnits RobotAPI Sensor-Actor Units
-  \ingroup RobotAPI
+  \ingroup RobotAPI RobotAPI-Components
 
     * @brief Sensor-Actor Units are Armarx \ref armarx::Component "Components" that communicate usually directly with their
     * associated hardware and feed the topic for their connected \ref armarx::Observer. They always implement
diff --git a/source/RobotAPI/components/DebugDrawer/DebugDrawerComponent.cpp b/source/RobotAPI/components/DebugDrawer/DebugDrawerComponent.cpp
index 5bc4618273788950f036ab7f619b7bf63c9be53d..f0df3989462c072aa1e13f2ddbcffedfe0454043 100644
--- a/source/RobotAPI/components/DebugDrawer/DebugDrawerComponent.cpp
+++ b/source/RobotAPI/components/DebugDrawer/DebugDrawerComponent.cpp
@@ -415,6 +415,7 @@ void DebugDrawerComponent::removeLine(const std::string& layerName, const std::s
     {
         return;
     }
+
     layer.mainNode->removeChild(layer.addedLineVisualizations[name]);
     layer.addedLineVisualizations.erase(name);
 }
@@ -943,6 +944,8 @@ void DebugDrawerComponent::clearLayer(const std::string &layerName, const Ice::C
     layer.addedTextVisualizations.clear();
     layer.addedSphereVisualizations.clear();
     layer.addedPointCloudVisualizations.clear();
+    layer.addedPolygonVisualizations.clear();
+    layer.addedArrowVisualizations.clear();
     layer.mainNode->removeAllChildren();
 }
 
diff --git a/source/RobotAPI/libraries/core/remoterobot/RemoteRobot.cpp b/source/RobotAPI/libraries/core/remoterobot/RemoteRobot.cpp
index 44f79520f9de6fefb25e46915b49b1b5b88cffff..2812e0782a59fad31cbccd09dc3b617888a8253a 100644
--- a/source/RobotAPI/libraries/core/remoterobot/RemoteRobot.cpp
+++ b/source/RobotAPI/libraries/core/remoterobot/RemoteRobot.cpp
@@ -293,20 +293,25 @@ VirtualRobot::RobotPtr RemoteRobot::createLocalClone()
 }
 
 VirtualRobot::RobotPtr RemoteRobot::createLocalClone(RobotStateComponentInterfacePrx robotStatePrx, const string &filename)
+{
+    return createLocalClone(robotStatePrx->getSynchronizedRobot(), filename);
+}
+
+RobotPtr RemoteRobot::createLocalClone(SharedRobotInterfacePrx sharedRobotPrx, const string &filename)
 {
     boost::recursive_mutex::scoped_lock cloneLock(m);
     ARMARX_VERBOSE_S << "Creating local clone of remote robot (filename:" << filename << ")" << endl;
     VirtualRobot::RobotPtr result;
 
-    if (!robotStatePrx)
+    if (!sharedRobotPrx)
     {
-        ARMARX_ERROR_S << "NULL robotStatePrx. Aborting..." << endl;
+        ARMARX_ERROR_S << "NULL sharedRobotPrx. Aborting..." << endl;
         return result;
     }
 
     if (filename.empty())
     {
-        RemoteRobotPtr rob(new RemoteRobot(robotStatePrx->getSynchronizedRobot()));
+        RemoteRobotPtr rob(new RemoteRobot(sharedRobotPrx));
         result = rob->createLocalClone();
         if (!result)
         {
@@ -322,20 +327,24 @@ VirtualRobot::RobotPtr RemoteRobot::createLocalClone(RobotStateComponentInterfac
             return result;
         }
     }
-    synchronizeLocalClone(result,robotStatePrx);
+    synchronizeLocalClone(result,sharedRobotPrx);
     return result;
 }
 
 bool RemoteRobot::synchronizeLocalClone(VirtualRobot::RobotPtr robot, RobotStateComponentInterfacePrx robotStatePrx)
 {
-    if (!robotStatePrx || !robot)
+    return synchronizeLocalClone(robot, robotStatePrx->getSynchronizedRobot());
+}
+
+bool RemoteRobot::synchronizeLocalClone(VirtualRobot::RobotPtr robot, SharedRobotInterfacePrx sharedRobotPrx)
+{
+    if (!sharedRobotPrx || !robot)
     {
         ARMARX_ERROR_S << "NULL data. Aborting..." << endl;
         return false;
     }
     RobotConfigPtr c(new RobotConfig(robot,"synchronizeLocalClone"));
-    auto robotProxy = robotStatePrx->getSynchronizedRobot();
-    NameValueMap jv = robotProxy->getConfig();
+    NameValueMap jv = sharedRobotPrx->getConfig();
     for ( NameValueMap::const_iterator it = jv.begin(); it!=jv.end(); it++ )
     {
         // joint values
@@ -347,7 +356,7 @@ bool RemoteRobot::synchronizeLocalClone(VirtualRobot::RobotPtr robot, RobotState
         }
     }
     robot->setConfig(c);
-    auto pose = PosePtr::dynamicCast(robotProxy->getGlobalPose());
+    auto pose = PosePtr::dynamicCast(sharedRobotPrx->getGlobalPose());
     robot->setGlobalPose(pose->toEigen());
     return true;
 }
diff --git a/source/RobotAPI/libraries/core/remoterobot/RemoteRobot.h b/source/RobotAPI/libraries/core/remoterobot/RemoteRobot.h
index bbe6f70b96938faa938666c52776dba25aa77964..7c30f1f0104fb621e0761241c8841ecfa5588f09 100644
--- a/source/RobotAPI/libraries/core/remoterobot/RemoteRobot.h
+++ b/source/RobotAPI/libraries/core/remoterobot/RemoteRobot.h
@@ -188,16 +188,21 @@ namespace armarx
             */
         static VirtualRobot::RobotPtr createLocalClone(RobotStateComponentInterfacePrx robotStatePrx, const std::string &filename=std::string());
 
+        static VirtualRobot::RobotPtr createLocalClone(SharedRobotInterfacePrx sharedRobotPrx, const std::string &filename=std::string());
+
         /*!
                 Use this method to synchronize (i.e. copy the joint values) from the remote robot to the local clone.
                 The local clone must have the identical structure as the remote robot model, otherwise an error will be reported.
               */
         static bool synchronizeLocalClone(VirtualRobot::RobotPtr robot, RobotStateComponentInterfacePrx robotStatePrx);
 
+        static bool synchronizeLocalClone(VirtualRobot::RobotPtr robot, SharedRobotInterfacePrx sharedRobotPrx);
+
         // VirtualRobot::RobotPtr getRobotPtr() { return shared_from_this();} // only for debugging
 
         //! Clones the structure of this remote robot to a local instance
         VirtualRobot::RobotPtr createLocalClone();
+
     protected:
 
         /// Not implemented yet