diff --git a/Modules/Core/TestingHelper/src/mitkRenderingTestHelper.cpp b/Modules/Core/TestingHelper/src/mitkRenderingTestHelper.cpp
index ac0d4f036e..db6186d3e3 100644
--- a/Modules/Core/TestingHelper/src/mitkRenderingTestHelper.cpp
+++ b/Modules/Core/TestingHelper/src/mitkRenderingTestHelper.cpp
@@ -1,292 +1,292 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 // VTK
 #include <vtkCamera.h>
 #include <vtkOpenGLRenderWindow.h>
 #include <vtkPNGWriter.h>
 #include <vtkRenderLargeImage.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderWindowInteractor.h>
 
 // MITK
 #include <mitkNodePredicateDataType.h>
 #include <mitkRenderWindow.h>
 #include <mitkRenderingTestHelper.h>
 #include <mitkSliceNavigationController.h>
 #include <mitkStandaloneDataStorage.h>
 #include <mitkException.h>
 #include <mitkTestNotRunException.h>
 #include <mitkTestingMacros.h>
 
 #if defined _MSC_VER
 #if _MSC_VER >= 1700
 #define RESIZE_WORKAROUND
 #endif
 #endif
 
 #ifdef RESIZE_WORKAROUND
 #include "vtkWin32OpenGLRenderWindow.h"
 #endif
 
 // VTK Testing to compare the rendered image pixel-wise against a reference screen shot
 #include "vtkTesting.h"
 
 mitk::RenderingTestHelper::RenderingTestHelper(int width,
                                                int height,
                                                AntiAliasing antiAliasing)
   : m_AutomaticallyCloseRenderWindow(true)
 {
   this->Initialize(width, height, antiAliasing);
 }
 
 mitk::RenderingTestHelper::RenderingTestHelper(
   int width, int height, int argc, char *argv[], AntiAliasing antiAliasing)
   : m_AutomaticallyCloseRenderWindow(true)
 {
   this->Initialize(width, height, antiAliasing);
   this->SetInputFileNames(argc, argv);
 }
 
 void mitk::RenderingTestHelper::Initialize(int width, int height, AntiAliasing antiAliasing)
 {
   RenderingManager::GetInstance()->SetAntiAliasing(antiAliasing);
 
-  mitk::UIDGenerator uidGen = mitk::UIDGenerator("UnnamedRenderer_", 8);
+  mitk::UIDGenerator uidGen = mitk::UIDGenerator("UnnamedRenderer_");
   m_RenderWindow = mitk::RenderWindow::New(nullptr, uidGen.GetUID().c_str());
 
   auto renderWindow = m_RenderWindow->GetVtkRenderWindow();
 
   if (0 == renderWindow->SupportsOpenGL())
   {
     auto openGLRenderWindow = dynamic_cast<vtkOpenGLRenderWindow*>(renderWindow);
 
     auto message = nullptr != openGLRenderWindow
       ? openGLRenderWindow->GetOpenGLSupportMessage()
       : std::string("No details available.");
 
     mitkThrowException(mitk::TestNotRunException) << "OpenGL not supported: " << message;
   }
 
   m_DataStorage = mitk::StandaloneDataStorage::New();
 
   m_RenderWindow->GetRenderer()->SetDataStorage(m_DataStorage);
   this->SetMapperIDToRender2D();
   this->GetVtkRenderWindow()->SetSize(width, height);
 
 #ifdef RESIZE_WORKAROUND
 
   HWND hWnd = static_cast<vtkWin32OpenGLRenderWindow *>(this->GetVtkRenderWindow())->GetWindowId();
 
   RECT r;
   r.left = 10;
   r.top = 10;
   r.right = r.left + width;
   r.bottom = r.top + height;
 
   LONG style = GetWindowLong(hWnd, GWL_STYLE);
   AdjustWindowRect(&r, style, FALSE);
 
   MITK_INFO << "WANTED:";
   MITK_INFO << r.right - r.left;
   MITK_INFO << r.bottom - r.top;
 
   RECT rect;
   if (GetWindowRect(hWnd, &rect))
   {
     int width = rect.right - rect.left;
     int height = rect.bottom - rect.top;
 
     MITK_INFO << "ACTUAL:";
     MITK_INFO << width;
     MITK_INFO << height;
   }
 
   SetWindowPos(hWnd, HWND_TOP, 0, 0, r.right - r.left, r.bottom - r.top, SWP_NOZORDER);
 
   GetWindowRect(hWnd, &rect);
 
   int width2 = rect.right - rect.left;
   int height2 = rect.bottom - rect.top;
 
   MITK_INFO << "ACTUAL2:";
   MITK_INFO << width2;
   MITK_INFO << height2;
 
   SetWindowPos(hWnd, HWND_TOP, 0, 0, 2 * (r.right - r.left) - width2, 2 * (r.bottom - r.top) - height2, SWP_NOZORDER);
 
 #endif
 
   m_RenderWindow->GetRenderer()->Resize(width, height);
 }
 
 mitk::RenderingTestHelper::~RenderingTestHelper()
 {
 }
 
 void mitk::RenderingTestHelper::SetMapperID(mitk::BaseRenderer::StandardMapperSlot id)
 {
   m_RenderWindow->GetRenderer()->SetMapperID(id);
 }
 
 void mitk::RenderingTestHelper::SetMapperIDToRender3D()
 {
   this->SetMapperID(mitk::BaseRenderer::Standard3D);
   mitk::RenderingManager::GetInstance()->InitializeViews(
     this->GetDataStorage()->ComputeBoundingGeometry3D(this->GetDataStorage()->GetAll()));
 }
 
 void mitk::RenderingTestHelper::SetMapperIDToRender2D()
 {
   this->SetMapperID(mitk::BaseRenderer::Standard2D);
 }
 
 void mitk::RenderingTestHelper::Render()
 {
   // if the datastorage is initialized and at least 1 image is loaded render it
   if (m_DataStorage.IsNotNull() || m_DataStorage->GetAll()->Size() >= 1)
   {
     // Prepare the VTK camera before rendering.
     m_RenderWindow->GetRenderer()->PrepareRender();
 
     this->GetVtkRenderWindow()->Render();
     this->GetVtkRenderWindow()->WaitForCompletion();
     if (m_AutomaticallyCloseRenderWindow == false)
     {
       // Use interaction to stop the test
       this->GetVtkRenderWindow()->GetInteractor()->Start();
     }
   }
   else
   {
     MITK_ERROR << "No images loaded in data storage!";
   }
 }
 
 mitk::DataStorage::Pointer mitk::RenderingTestHelper::GetDataStorage()
 {
   return m_DataStorage;
 }
 
 void mitk::RenderingTestHelper::SetInputFileNames(int argc, char *argv[])
 {
   // i is set 1, because 0 is the testname as string
   // parse parameters
   for (int i = 1; i < argc; ++i)
   {
     // add everything to a list but -T and -V
     std::string tmp = argv[i];
     if ((tmp.compare("-T")) && (tmp.compare("-V")))
     {
       this->AddToStorage(tmp);
     }
     else
     {
       break;
     }
   }
 }
 
 void mitk::RenderingTestHelper::SetViewDirection(mitk::SliceNavigationController::ViewDirection viewDirection)
 {
   mitk::BaseRenderer::GetInstance(m_RenderWindow->GetVtkRenderWindow())
     ->GetSliceNavigationController()
     ->SetDefaultViewDirection(viewDirection);
   mitk::RenderingManager::GetInstance()->InitializeViews(
     m_DataStorage->ComputeBoundingGeometry3D(m_DataStorage->GetAll()));
 }
 
 void mitk::RenderingTestHelper::ReorientSlices(mitk::Point3D origin, mitk::Vector3D rotation)
 {
   mitk::SliceNavigationController::Pointer sliceNavigationController =
     mitk::BaseRenderer::GetInstance(m_RenderWindow->GetVtkRenderWindow())->GetSliceNavigationController();
   sliceNavigationController->ReorientSlices(origin, rotation);
 }
 
 vtkRenderer *mitk::RenderingTestHelper::GetVtkRenderer()
 {
   return m_RenderWindow->GetRenderer()->GetVtkRenderer();
 }
 
 void mitk::RenderingTestHelper::SetImageProperty(const char *propertyKey, mitk::BaseProperty *property)
 {
   this->m_DataStorage->GetNode(mitk::NodePredicateDataType::New("Image"))->SetProperty(propertyKey, property);
 }
 
 vtkRenderWindow *mitk::RenderingTestHelper::GetVtkRenderWindow()
 {
   return m_RenderWindow->GetVtkRenderWindow();
 }
 
 bool mitk::RenderingTestHelper::CompareRenderWindowAgainstReference(int argc, char *argv[], double threshold)
 {
   this->Render();
   // retVal meanings: (see VTK/Rendering/vtkTesting.h)
   // 0 = test failed
   // 1 = test passed
   // 2 = test not run
   // 3 = something with vtkInteraction
   if (vtkTesting::Test(argc, argv, this->GetVtkRenderWindow(), threshold) == 1)
     return true;
   else
     return false;
 }
 
 // method to save a screenshot of the renderwindow (e.g. create a reference screenshot)
 void mitk::RenderingTestHelper::SaveAsPNG(std::string fileName)
 {
   vtkSmartPointer<vtkRenderer> renderer = this->GetVtkRenderer();
   bool doubleBuffering(renderer->GetRenderWindow()->GetDoubleBuffer());
   renderer->GetRenderWindow()->DoubleBufferOff();
 
   vtkSmartPointer<vtkRenderLargeImage> magnifier = vtkSmartPointer<vtkRenderLargeImage>::New();
   magnifier->SetInput(renderer);
   magnifier->SetMagnification(1);
 
   vtkSmartPointer<vtkImageWriter> fileWriter = vtkSmartPointer<vtkPNGWriter>::New();
   fileWriter->SetInputConnection(magnifier->GetOutputPort());
   fileWriter->SetFileName(fileName.c_str());
 
   fileWriter->Write();
   renderer->GetRenderWindow()->SetDoubleBuffer(doubleBuffering);
 }
 
 void mitk::RenderingTestHelper::SetAutomaticallyCloseRenderWindow(bool automaticallyCloseRenderWindow)
 {
   m_AutomaticallyCloseRenderWindow = automaticallyCloseRenderWindow;
 }
 
 void mitk::RenderingTestHelper::SaveReferenceScreenShot(std::string fileName)
 {
   this->SaveAsPNG(fileName);
 }
 
 void mitk::RenderingTestHelper::AddToStorage(const std::string &filename)
 {
   try
   {
     mitk::IOUtil::Load(filename, *m_DataStorage.GetPointer());
     mitk::RenderingManager::GetInstance()->InitializeViews(
       m_DataStorage->ComputeBoundingGeometry3D(m_DataStorage->GetAll()));
   }
   catch ( const itk::ExceptionObject &e )
   {
     MITK_ERROR << "Failed loading test data '" << filename << "': " << e.what();
   }
 }
 
 void mitk::RenderingTestHelper::AddNodeToStorage(mitk::DataNode::Pointer node)
 {
   this->m_DataStorage->Add(node);
   mitk::RenderingManager::GetInstance()->InitializeViews(
     m_DataStorage->ComputeBoundingGeometry3D(m_DataStorage->GetAll()));
 }
diff --git a/Modules/Core/include/mitkUIDGenerator.h b/Modules/Core/include/mitkUIDGenerator.h
index f05a241f2c..0b7931f039 100644
--- a/Modules/Core/include/mitkUIDGenerator.h
+++ b/Modules/Core/include/mitkUIDGenerator.h
@@ -1,49 +1,44 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef MITK_UID_GENERATOR_INDCLUDED_FASAWE
 #define MITK_UID_GENERATOR_INDCLUDED_FASAWE
 
 #include <MitkCoreExports.h>
-#include <iostream>
-#include <random>
 #include <string>
 
 namespace mitk
 {
   /*!
     \brief Generated unique IDs
 
-    Creates unique IDs from a given prefix, the current date/time and a random part. Be aware that, a length of one or
-    two might not be sufficient.
+    Creates unique IDs.
 
-    The prefix is given to the constructor, together with the desired
-    length of the random part.
-
-    The current implementation uses the time in seconds in combination with an a random part.
+    The current implementation uses the UUID specification (https://www.ietf.org/rfc/rfc4122.txt) and
+    random generator.
+    One may define a prefix for the UID string. But it is not needed to guarantee uniquness. It is
+    just a human readable addition, e.g. to see for which purpose the UID was generated.
   */
   class MITKCORE_EXPORT UIDGenerator
   {
   public:
-    UIDGenerator(const char *prefix = "UID_", unsigned int lengthOfRandomPart = 8);
+    explicit UIDGenerator(const char * prefix = "");
 
     /** @return Returns a unique ID as string. You will get another unique ID each time you call GetUID. */
     std::string GetUID();
 
   private:
     std::string m_Prefix;
-    unsigned int m_LengthOfRandomPart;
-    std::uniform_int_distribution<unsigned long int> m_Distribution;
   };
 } // namespace mitk
 
 #endif
diff --git a/Modules/Core/src/Algorithms/mitkUIDGenerator.cpp b/Modules/Core/src/Algorithms/mitkUIDGenerator.cpp
index a0e5158bc6..8cf27eacd2 100644
--- a/Modules/Core/src/Algorithms/mitkUIDGenerator.cpp
+++ b/Modules/Core/src/Algorithms/mitkUIDGenerator.cpp
@@ -1,55 +1,42 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
-#include <mitkLogMacros.h>
 #include <mitkUIDGenerator.h>
 
-#include <iomanip>
 #include <sstream>
 
-mitk::UIDGenerator::UIDGenerator(const char *prefix, unsigned int lengthOfRandomPart)
-  : m_Prefix(prefix),
-    m_LengthOfRandomPart(lengthOfRandomPart),
-    m_Distribution(std::uniform_int_distribution<unsigned long>(0, std::numeric_limits<unsigned long>::max()))
+#include <mutex>
+
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_io.hpp>
+#include <boost/uuid/uuid_generators.hpp>
+
+boost::uuids::random_generator uuidGen;
+std::mutex uuidGen_mutex;
+
+mitk::UIDGenerator::UIDGenerator(const char *prefix)
+  : m_Prefix(prefix)
 {
 }
 
 std::string mitk::UIDGenerator::GetUID()
 {
   std::ostringstream s;
-  s << m_Prefix;
-  auto time = std::time(nullptr);
-  auto tm = std::localtime(&time);
-
-  s << std::put_time(tm, "%Y%m%d%H%M%S");
-
-  std::ostringstream rs;
-
-  static std::random_device rd;        // Will be used to obtain a seed for the random number engine
-  static std::mt19937 generator(rd()); // Standard mersenne_twister_engine seeded with rd()
 
-  while (rs.str().length() < m_LengthOfRandomPart)
   {
-    rs << m_Distribution(generator);
+    std::lock_guard<std::mutex> guard(uuidGen_mutex);
+    auto uuid = uuidGen();
+    s << m_Prefix << uuid;
   }
 
-  auto randomString = rs.str();
-
-  if (randomString.length() > m_LengthOfRandomPart)
-  {
-    randomString = randomString.substr(randomString.length() - m_LengthOfRandomPart);
-  }
-
-  s << randomString;
-
   return s.str();
 }
diff --git a/Modules/Core/src/Rendering/mitkAnnotation.cpp b/Modules/Core/src/Rendering/mitkAnnotation.cpp
index 3da8a601d1..8c7e1e092c 100644
--- a/Modules/Core/src/Rendering/mitkAnnotation.cpp
+++ b/Modules/Core/src/Rendering/mitkAnnotation.cpp
@@ -1,348 +1,348 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkAnnotation.h"
 #include "usGetModuleContext.h"
 
 const std::string mitk::Annotation::US_INTERFACE_NAME = "org.mitk.services.Annotation";
 const std::string mitk::Annotation::US_PROPKEY_AnnotationNAME = US_INTERFACE_NAME + ".name";
 const std::string mitk::Annotation::US_PROPKEY_ID = US_INTERFACE_NAME + ".id";
 const std::string mitk::Annotation::US_PROPKEY_MODIFIED = US_INTERFACE_NAME + ".modified";
 const std::string mitk::Annotation::US_PROPKEY_RENDERER_ID = US_INTERFACE_NAME + ".rendererId";
 const std::string mitk::Annotation::US_PROPKEY_AR_ID = US_INTERFACE_NAME + ".arId";
 
 mitk::Annotation::Annotation() : m_PropertyListModifiedObserverTag(0)
 {
   m_PropertyList = mitk::PropertyList::New();
   itk::MemberCommand<mitk::Annotation>::Pointer _PropertyListModifiedCommand =
     itk::MemberCommand<mitk::Annotation>::New();
   _PropertyListModifiedCommand->SetCallbackFunction(this, &mitk::Annotation::PropertyListModified);
   m_PropertyListModifiedObserverTag = m_PropertyList->AddObserver(itk::ModifiedEvent(), _PropertyListModifiedCommand);
   this->SetName(this->GetNameOfClass());
   this->SetVisibility(true);
   this->SetOpacity(1.0);
 }
 
 void mitk::Annotation::PropertyListModified(const itk::Object * /*caller*/, const itk::EventObject &)
 {
   AnnotationModified();
 }
 
 mitk::Annotation::~Annotation()
 {
   this->UnRegisterMicroservice();
 }
 
 void mitk::Annotation::SetUSProperty(const std::string &propertyKey, us::Any value)
 {
   if (this->m_ServiceRegistration)
   {
     us::ServiceProperties props;
     std::vector<std::string> propertyKeys;
     m_ServiceRegistration.GetReference().GetPropertyKeys(propertyKeys);
     for (std::string key : propertyKeys)
     {
       props[key] = m_ServiceRegistration.GetReference().GetProperty(key);
     }
     props[propertyKey] = value;
     m_ServiceRegistration.SetProperties(props);
   }
 }
 
 void mitk::Annotation::SetProperty(const std::string &propertyKey, const BaseProperty::Pointer &propertyValue)
 {
   this->m_PropertyList->SetProperty(propertyKey, propertyValue);
 }
 
 void mitk::Annotation::ReplaceProperty(const std::string &propertyKey, const BaseProperty::Pointer &propertyValue)
 {
   this->m_PropertyList->ReplaceProperty(propertyKey, propertyValue);
 }
 
 void mitk::Annotation::AddProperty(const std::string &propertyKey,
                                    const BaseProperty::Pointer &propertyValue,
                                    bool overwrite)
 {
   if ((overwrite) || (GetProperty(propertyKey) == nullptr))
   {
     SetProperty(propertyKey, propertyValue);
   }
 }
 
 void mitk::Annotation::ConcatenatePropertyList(PropertyList *pList, bool replace)
 {
   m_PropertyList->ConcatenatePropertyList(pList, replace);
 }
 
 mitk::BaseProperty *mitk::Annotation::GetProperty(const std::string &propertyKey) const
 {
   mitk::BaseProperty::Pointer property = m_PropertyList->GetProperty(propertyKey);
   if (property.IsNotNull())
     return property;
 
   // only to satisfy compiler!
   return nullptr;
 }
 
 bool mitk::Annotation::GetBoolProperty(const std::string &propertyKey, bool &boolValue) const
 {
   mitk::BoolProperty::Pointer boolprop = dynamic_cast<mitk::BoolProperty *>(GetProperty(propertyKey));
   if (boolprop.IsNull())
     return false;
 
   boolValue = boolprop->GetValue();
   return true;
 }
 
 bool mitk::Annotation::GetIntProperty(const std::string &propertyKey, int &intValue) const
 {
   mitk::IntProperty::Pointer intprop = dynamic_cast<mitk::IntProperty *>(GetProperty(propertyKey));
   if (intprop.IsNull())
     return false;
 
   intValue = intprop->GetValue();
   return true;
 }
 
 bool mitk::Annotation::GetFloatProperty(const std::string &propertyKey, float &floatValue) const
 {
   mitk::FloatProperty::Pointer floatprop = dynamic_cast<mitk::FloatProperty *>(GetProperty(propertyKey));
   if (floatprop.IsNull())
     return false;
 
   floatValue = floatprop->GetValue();
   return true;
 }
 
 bool mitk::Annotation::GetStringProperty(const std::string &propertyKey, std::string &string) const
 {
   mitk::StringProperty::Pointer stringProp = dynamic_cast<mitk::StringProperty *>(GetProperty(propertyKey));
   if (stringProp.IsNull())
   {
     return false;
   }
   else
   {
     // memcpy((void*)string, stringProp->GetValue(), strlen(stringProp->GetValue()) + 1 ); // looks dangerous
     string = stringProp->GetValue();
     return true;
   }
 }
 
 void mitk::Annotation::SetIntProperty(const std::string &propertyKey, int intValue)
 {
   this->m_PropertyList->SetProperty(propertyKey, mitk::IntProperty::New(intValue));
   Modified();
 }
 void mitk::Annotation::SetBoolProperty(const std::string &propertyKey, bool boolValue)
 {
   this->m_PropertyList->SetProperty(propertyKey, mitk::BoolProperty::New(boolValue));
   Modified();
 }
 
 void mitk::Annotation::SetFloatProperty(const std::string &propertyKey, float floatValue)
 {
   this->m_PropertyList->SetProperty(propertyKey, mitk::FloatProperty::New(floatValue));
   Modified();
 }
 
 void mitk::Annotation::SetDoubleProperty(const std::string &propertyKey, double doubleValue)
 {
   this->m_PropertyList->SetProperty(propertyKey, mitk::DoubleProperty::New(doubleValue));
   Modified();
 }
 
 void mitk::Annotation::SetStringProperty(const std::string &propertyKey, const std::string &stringValue)
 {
   this->m_PropertyList->SetProperty(propertyKey, mitk::StringProperty::New(stringValue));
   Modified();
 }
 
 std::string mitk::Annotation::GetName() const
 {
   mitk::StringProperty *sp = dynamic_cast<mitk::StringProperty *>(this->GetProperty("name"));
   if (sp == nullptr)
     return "";
   return sp->GetValue();
 }
 
 void mitk::Annotation::SetName(const std::string &name)
 {
   this->SetStringProperty("name", name);
 }
 
 bool mitk::Annotation::GetName(std::string &nodeName, const std::string &propertyKey) const
 {
   return GetStringProperty(propertyKey, nodeName);
 }
 
 void mitk::Annotation::SetText(std::string text)
 {
   SetStringProperty("Text", text.c_str());
 }
 
 std::string mitk::Annotation::GetText() const
 {
   std::string text;
   GetStringProperty("Text", text);
   return text;
 }
 
 void mitk::Annotation::SetFontSize(int fontSize)
 {
   SetIntProperty("FontSize", fontSize);
 }
 
 int mitk::Annotation::GetFontSize() const
 {
   int fontSize = 1;
   GetIntProperty("FontSize", fontSize);
   return fontSize;
 }
 
 bool mitk::Annotation::GetVisibility(bool &visible, const std::string &propertyKey) const
 {
   return GetBoolProperty(propertyKey, visible);
 }
 
 bool mitk::Annotation::IsVisible(const std::string &propertyKey, bool defaultIsOn) const
 {
   return IsOn(propertyKey, defaultIsOn);
 }
 
 bool mitk::Annotation::GetColor(float rgb[], const std::string &propertyKey) const
 {
   mitk::ColorProperty::Pointer colorprop = dynamic_cast<mitk::ColorProperty *>(GetProperty(propertyKey));
   if (colorprop.IsNull())
     return false;
 
   memcpy(rgb, colorprop->GetColor().GetDataPointer(), 3 * sizeof(float));
   return true;
 }
 
 void mitk::Annotation::SetColor(const mitk::Color &color, const std::string &propertyKey)
 {
   mitk::ColorProperty::Pointer prop;
   prop = mitk::ColorProperty::New(color);
   this->m_PropertyList->SetProperty(propertyKey, prop);
 }
 
 void mitk::Annotation::SetColor(float red, float green, float blue, const std::string &propertyKey)
 {
   float color[3];
   color[0] = red;
   color[1] = green;
   color[2] = blue;
   SetColor(color, propertyKey);
 }
 
 void mitk::Annotation::SetColor(const float rgb[], const std::string &propertyKey)
 {
   mitk::ColorProperty::Pointer prop;
   prop = mitk::ColorProperty::New(rgb);
   this->m_PropertyList->SetProperty(propertyKey, prop);
 }
 
 bool mitk::Annotation::GetOpacity(float &opacity, const std::string &propertyKey) const
 {
   mitk::FloatProperty::Pointer opacityprop = dynamic_cast<mitk::FloatProperty *>(GetProperty(propertyKey));
   if (opacityprop.IsNull())
     return false;
 
   opacity = opacityprop->GetValue();
   return true;
 }
 
 void mitk::Annotation::SetOpacity(float opacity, const std::string &propertyKey)
 {
   mitk::FloatProperty::Pointer prop;
   prop = mitk::FloatProperty::New(opacity);
   this->m_PropertyList->SetProperty(propertyKey, prop);
 }
 
 void mitk::Annotation::SetVisibility(bool visible, const std::string &propertyKey)
 {
   mitk::BoolProperty::Pointer prop;
   prop = mitk::BoolProperty::New(visible);
   this->m_PropertyList->SetProperty(propertyKey, prop);
   Modified();
 }
 
 bool mitk::Annotation::BaseLocalStorage::IsGenerateDataRequired(mitk::BaseRenderer *renderer,
                                                                 mitk::Annotation *Annotation)
 {
   if (m_LastGenerateDataTime < Annotation->GetMTime())
     return true;
 
   if (m_LastGenerateDataTime < Annotation->GetPropertyList()->GetMTime())
     return true;
 
   if (renderer && m_LastGenerateDataTime < renderer->GetTimeStepUpdateTime())
     return true;
 
   return false;
 }
 
 mitk::Annotation::Bounds mitk::Annotation::GetBoundsOnDisplay(mitk::BaseRenderer *) const
 {
   mitk::Annotation::Bounds bounds;
   bounds.Position[0] = bounds.Position[1] = bounds.Size[0] = bounds.Size[1] = 0;
   return bounds;
 }
 
 void mitk::Annotation::SetBoundsOnDisplay(mitk::BaseRenderer *, const mitk::Annotation::Bounds &)
 {
 }
 
 void mitk::Annotation::SetForceInForeground(bool forceForeground)
 {
   m_ForceInForeground = forceForeground;
 }
 
 bool mitk::Annotation::IsForceInForeground() const
 {
   return m_ForceInForeground;
 }
 
 mitk::PropertyList *mitk::Annotation::GetPropertyList() const
 {
   return m_PropertyList;
 }
 
 std::string mitk::Annotation::GetMicroserviceID()
 {
   return this->m_ServiceRegistration.GetReference().GetProperty(US_PROPKEY_ID).ToString();
 }
 
 void mitk::Annotation::RegisterAsMicroservice(us::ServiceProperties props)
 {
   if (m_ServiceRegistration != nullptr)
     m_ServiceRegistration.Unregister();
   us::ModuleContext *context = us::GetModuleContext();
   // Define ServiceProps
-  mitk::UIDGenerator uidGen = mitk::UIDGenerator("org.mitk.services.Annotation.id_", 16);
+  mitk::UIDGenerator uidGen = mitk::UIDGenerator("org.mitk.services.Annotation.id_");
   props[US_PROPKEY_ID] = uidGen.GetUID();
   m_ServiceRegistration = context->RegisterService(this, props);
 }
 
 void mitk::Annotation::UnRegisterMicroservice()
 {
   if (m_ServiceRegistration != nullptr)
     m_ServiceRegistration.Unregister();
   m_ServiceRegistration = 0;
 }
 
 void mitk::Annotation::AnnotationModified()
 {
   Modified();
   this->SetUSProperty(US_PROPKEY_MODIFIED, this->GetMTime());
 }
diff --git a/Modules/Core/test/mitkUIDGeneratorTest.cpp b/Modules/Core/test/mitkUIDGeneratorTest.cpp
index 12dd6aa337..b2b735beae 100644
--- a/Modules/Core/test/mitkUIDGeneratorTest.cpp
+++ b/Modules/Core/test/mitkUIDGeneratorTest.cpp
@@ -1,65 +1,55 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 // Testing
 #include "mitkTestFixture.h"
 #include "mitkTestingMacros.h"
 // std includes
 #include <string>
 // MITK includes
 #include "mitkUIDGenerator.h"
 #include <mitkLogMacros.h>
 #include <mitkTestFixture.h>
 #include <mitkTestingMacros.h>
 
 class mitkUIDGeneratorTestSuite : public mitk::TestFixture
 {
   CPPUNIT_TEST_SUITE(mitkUIDGeneratorTestSuite);
   MITK_TEST(UIDGeneratorInstanceRenewalSucceed);
   MITK_TEST(UIDGeneratorMultipleInstancesSucceed);
 
   CPPUNIT_TEST_SUITE_END();
 
-  unsigned short m_UidLengthStart = 5;
-  unsigned short m_UidLengthEnd = 20;
-
-
   void UIDGeneratorInstanceRenewalSucceed()
   {
-    for (auto k = m_UidLengthStart; k < m_UidLengthEnd; ++k)
-    {
-      mitk::UIDGenerator uidGen1("UID_", k);
-      auto uid1_1 = uidGen1.GetUID();
+    mitk::UIDGenerator uidGen1("UID_");
+    auto uid1_1 = uidGen1.GetUID();
 
-      uidGen1 = mitk::UIDGenerator("UID_", k);
-      auto uid2_1 = uidGen1.GetUID();
+    uidGen1 = mitk::UIDGenerator("UID_");
+    auto uid2_1 = uidGen1.GetUID();
 
-      CPPUNIT_ASSERT_MESSAGE("Different UIDs are not allowed to be equal", uid1_1 != uid2_1);
-    }
+    CPPUNIT_ASSERT_MESSAGE("Different UIDs are not allowed to be equal", uid1_1 != uid2_1);
   }
 
   void UIDGeneratorMultipleInstancesSucceed()
   {
-    for (auto k = m_UidLengthStart; k < m_UidLengthEnd; ++k)
-    {
-      mitk::UIDGenerator uidGen1("UID_", k);
-      mitk::UIDGenerator uidGen2("UID_", k);
+    mitk::UIDGenerator uidGen1("UID_");
+    mitk::UIDGenerator uidGen2("UID_");
 
-      auto uid1_1 = uidGen1.GetUID();
-      auto uid2_1 = uidGen2.GetUID();
+    auto uid1_1 = uidGen1.GetUID();
+    auto uid2_1 = uidGen2.GetUID();
 
-      CPPUNIT_ASSERT_MESSAGE("Different UIDs are not allowed to be equal", uid1_1 != uid2_1);
-    }
+    CPPUNIT_ASSERT_MESSAGE("Different UIDs are not allowed to be equal", uid1_1 != uid2_1);
   }
 };
 
 MITK_TEST_SUITE_REGISTRATION(mitkUIDGenerator)
diff --git a/Modules/IGT/DataManagement/mitkNavigationDataSource.cpp b/Modules/IGT/DataManagement/mitkNavigationDataSource.cpp
index 68d1636143..20bcf5d235 100644
--- a/Modules/IGT/DataManagement/mitkNavigationDataSource.cpp
+++ b/Modules/IGT/DataManagement/mitkNavigationDataSource.cpp
@@ -1,165 +1,165 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkNavigationDataSource.h"
 #include "mitkUIDGenerator.h"
 
 
 //Microservices
 #include <usGetModuleContext.h>
 #include <usModule.h>
 #include <usServiceProperties.h>
 #include <usModuleContext.h>
 
 const std::string mitk::NavigationDataSource::US_INTERFACE_NAME = "org.mitk.services.NavigationDataSource";
 const std::string mitk::NavigationDataSource::US_PROPKEY_DEVICENAME = US_INTERFACE_NAME + ".devicename";
 const std::string mitk::NavigationDataSource::US_PROPKEY_ID = US_INTERFACE_NAME + ".id";
 const std::string mitk::NavigationDataSource::US_PROPKEY_ISACTIVE = US_INTERFACE_NAME + ".isActive";
 
 mitk::NavigationDataSource::NavigationDataSource()
 : itk::ProcessObject(), m_Name("NavigationDataSource (no defined type)"), m_IsFrozen(false), m_ToolMetaDataCollection(mitk::NavigationToolStorage::New())
 {
 }
 
 mitk::NavigationDataSource::~NavigationDataSource()
 {
 }
 
 mitk::NavigationData* mitk::NavigationDataSource::GetOutput()
 {
   if (this->GetNumberOfIndexedOutputs() < 1)
     return nullptr;
 
   return static_cast<NavigationData*>(this->ProcessObject::GetPrimaryOutput());
 }
 
 mitk::NavigationData* mitk::NavigationDataSource::GetOutput(DataObjectPointerArraySizeType idx)
 {
   NavigationData* out = dynamic_cast<NavigationData*>( this->ProcessObject::GetOutput(idx) );
   if ( out == nullptr && this->ProcessObject::GetOutput(idx) != nullptr )
   {
     itkWarningMacro (<< "Unable to convert output number " << idx << " to type " <<  typeid( NavigationData ).name () );
   }
   return out;
 }
 
 mitk::NavigationData* mitk::NavigationDataSource::GetOutput(const std::string& navDataName)
 {
   DataObjectPointerArray outputs = this->GetOutputs();
   for (DataObjectPointerArray::iterator it = outputs.begin(); it != outputs.end(); ++it)
     if (navDataName == (static_cast<NavigationData*>(it->GetPointer()))->GetName())
       return static_cast<NavigationData*>(it->GetPointer());
   return nullptr;
 }
 
 itk::ProcessObject::DataObjectPointerArraySizeType mitk::NavigationDataSource::GetOutputIndex( std::string navDataName )
 {
   DataObjectPointerArray outputs = this->GetOutputs();
   for (DataObjectPointerArray::size_type i = 0; i < outputs.size(); ++i)
     if (navDataName == (static_cast<NavigationData*>(outputs.at(i).GetPointer()))->GetName())
       return i;
   throw std::invalid_argument("output name does not exist");
 }
 
 void mitk::NavigationDataSource::RegisterAsMicroservice(){
   // Get Context
   us::ModuleContext* context = us::GetModuleContext();
 
   // Define ServiceProps
   us::ServiceProperties props;
-  mitk::UIDGenerator uidGen = mitk::UIDGenerator ("org.mitk.services.NavigationDataSource.id_", 16);
+  mitk::UIDGenerator uidGen = mitk::UIDGenerator ("org.mitk.services.NavigationDataSource.id_");
   props[ US_PROPKEY_ID ] = uidGen.GetUID();
   props[ US_PROPKEY_DEVICENAME ] = m_Name;
   m_ServiceRegistration = context->RegisterService(this, props);
 }
 
 void mitk::NavigationDataSource::UnRegisterMicroservice(){
   if (m_ServiceRegistration != nullptr) m_ServiceRegistration.Unregister();
   m_ServiceRegistration = 0;
 }
 
 std::string mitk::NavigationDataSource::GetMicroserviceID(){
   return this->m_ServiceRegistration.GetReference().GetProperty(US_PROPKEY_ID).ToString();
 }
 
 void mitk::NavigationDataSource::GraftOutput(itk::DataObject *graft)
 {
   this->GraftNthOutput(0, graft);
 }
 
 void mitk::NavigationDataSource::GraftNthOutput(unsigned int idx, itk::DataObject *graft)
 {
   if ( idx >= this->GetNumberOfIndexedOutputs() )
   {
     itkExceptionMacro(<<"Requested to graft output " << idx <<
       " but this filter only has " << this->GetNumberOfIndexedOutputs() << " Outputs.");
   }
 
   if ( !graft )
   {
     itkExceptionMacro(<<"Requested to graft output with a nullptr pointer object" );
   }
 
   itk::DataObject* output = this->GetOutput(idx);
   if ( !output )
   {
     itkExceptionMacro(<<"Requested to graft output that is a nullptr pointer" );
   }
   // Call Graft on NavigationData to copy member data
   output->Graft( graft );
 }
 
 itk::DataObject::Pointer mitk::NavigationDataSource::MakeOutput ( DataObjectPointerArraySizeType /*idx*/ )
 {
   return mitk::NavigationData::New().GetPointer();
 }
 
 itk::DataObject::Pointer mitk::NavigationDataSource::MakeOutput( const DataObjectIdentifierType & name )
 {
   itkDebugMacro("MakeOutput(" << name << ")");
   if( this->IsIndexedOutputName(name) )
   {
     return this->MakeOutput( this->MakeIndexFromOutputName(name) );
   }
   return static_cast<itk::DataObject *>(mitk::NavigationData::New().GetPointer());
 }
 
 mitk::PropertyList::ConstPointer mitk::NavigationDataSource::GetParameters() const
 {
   mitk::PropertyList::Pointer p = mitk::PropertyList::New();
   // add properties to p like this:
   //p->SetProperty("MyFilter_MyParameter", mitk::PropertyDataType::New(m_MyParameter));
   return mitk::PropertyList::ConstPointer(p);
 }
 
 void mitk::NavigationDataSource::Freeze()
 {
   m_IsFrozen = true;
 }
 
 void mitk::NavigationDataSource::UnFreeze()
 {
   m_IsFrozen = false;
 }
 
 mitk::NavigationTool::Pointer mitk::NavigationDataSource::GetToolMetaData(DataObjectPointerArraySizeType idx)
 {
   if (idx >= this->GetNumberOfIndexedOutputs()) { return mitk::NavigationTool::New(); }
   else { return GetToolMetaData(this->GetOutput(idx)->GetName()); }
 }
 
 mitk::NavigationTool::Pointer mitk::NavigationDataSource::GetToolMetaData(const std::string& navDataName)
 {
   mitk::NavigationTool::Pointer returnValue = m_ToolMetaDataCollection->GetToolByName(navDataName);
   if (returnValue == nullptr) { returnValue = mitk::NavigationTool::New(); }
   return returnValue;
 }
diff --git a/Modules/OpenIGTLink/mitkIGTLDeviceSource.cpp b/Modules/OpenIGTLink/mitkIGTLDeviceSource.cpp
index 04ffe4ae02..f6e48f7dcc 100644
--- a/Modules/OpenIGTLink/mitkIGTLDeviceSource.cpp
+++ b/Modules/OpenIGTLink/mitkIGTLDeviceSource.cpp
@@ -1,308 +1,308 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkIGTLDeviceSource.h"
 
 #include "mitkIGTLDevice.h"
 #include "mitkIGTLMessage.h"
 
 //#include "mitkIGTTimeStamp.h"
 //#include "mitkIGTException.h"
 
 //Microservices
 #include <usGetModuleContext.h>
 #include <usModule.h>
 #include <usServiceProperties.h>
 #include <usModuleContext.h>
 
 //itk
 #include <itkCommand.h>
 
 const std::string mitk::IGTLDeviceSource::US_PROPKEY_IGTLDEVICENAME =
 mitk::IGTLMessageSource::US_INTERFACE_NAME + ".igtldevicename";
 
 mitk::IGTLDeviceSource::IGTLDeviceSource()
   : mitk::IGTLMessageSource(), m_IGTLDevice(nullptr)
 {
   this->SetName("IGTLDeviceSource (no defined type)");
 }
 
 mitk::IGTLDeviceSource::~IGTLDeviceSource()
 {
   if (m_IGTLDevice.IsNotNull())
   {
     if (m_IGTLDevice->GetState() == mitk::IGTLDevice::Running)
     {
       this->StopCommunication();
     }
     if (m_IGTLDevice->GetState() == mitk::IGTLDevice::Ready)
     {
       this->Disconnect();
     }
     this->RemoveObservers();
     m_IGTLDevice = nullptr;
   }
 }
 
 void mitk::IGTLDeviceSource::GenerateData()
 {
   if (m_IGTLDevice.IsNull())
     return;
 
   /* update output with message from the device */
   IGTLMessage* msgOut = this->GetOutput();
   assert(msgOut);
   igtl::MessageBase::Pointer msgIn = dynamic_cast<igtl::MessageBase*>(m_IGTLDevice->GetNextImage2dMessage().GetPointer());
   if (msgIn.IsNotNull())
   {
     assert(msgIn);
 
     msgOut->SetMessage(msgIn);
     msgOut->SetName(msgIn->GetDeviceName());
   }
   //  else
   //  {
   //    MITK_ERROR("IGTLDeviceSource") << "Could not get the latest message.";
   //  }
 }
 
 void mitk::IGTLDeviceSource::RemoveObservers()
 {
   if (this->m_IGTLDevice.IsNotNull())
   {
     this->m_IGTLDevice->RemoveObserver(m_IncomingMessageObserverTag);
     this->m_IGTLDevice->RemoveObserver(m_IncomingCommandObserverTag);
     this->m_IGTLDevice->RemoveObserver(m_LostConnectionObserverTag);
   }
 }
 
 void mitk::IGTLDeviceSource::SetIGTLDevice(mitk::IGTLDevice* igtlDevice)
 {
   MITK_DEBUG << "Setting IGTLDevice to " << igtlDevice;
   if (this->m_IGTLDevice.GetPointer() != igtlDevice)
   {
     //check if we want to override the device
     if (this->m_IGTLDevice.IsNotNull())
     {
       //the device was set previously => we need to reset the observers
       this->RemoveObservers();
     }
     //set the device
     this->m_IGTLDevice = igtlDevice;
     this->CreateOutputs();
     std::stringstream name; // create a human readable name for the source
     name << "OIGTL Device Source ( " << igtlDevice->GetName() << " )";
     this->SetName(name.str());
 
     //setup a observer that listens to new messages and new commands
     typedef itk::SimpleMemberCommand<IGTLDeviceSource> DeviceSrcCommand;
 
     DeviceSrcCommand::Pointer msgReceivedCommand = DeviceSrcCommand::New();
     msgReceivedCommand->SetCallbackFunction(this, &IGTLDeviceSource::OnIncomingMessage);
     this->m_IncomingMessageObserverTag =
       this->m_IGTLDevice->AddObserver(mitk::MessageReceivedEvent(), msgReceivedCommand);
 
     DeviceSrcCommand::Pointer cmdReceivedCommand = DeviceSrcCommand::New();
     cmdReceivedCommand->SetCallbackFunction(this, &IGTLDeviceSource::OnIncomingCommand);
     this->m_IncomingCommandObserverTag =
       this->m_IGTLDevice->AddObserver(mitk::CommandReceivedEvent(), cmdReceivedCommand);
 
     DeviceSrcCommand::Pointer connectionLostCommand = DeviceSrcCommand::New();
     connectionLostCommand->SetCallbackFunction(this, &IGTLDeviceSource::OnLostConnection);
     this->m_LostConnectionObserverTag =
       this->m_IGTLDevice->AddObserver(mitk::LostConnectionEvent(), connectionLostCommand);
   }
 }
 
 void mitk::IGTLDeviceSource::CreateOutputs()
 {
   //if outputs are set then delete them
   if (this->GetNumberOfOutputs() > 0)
   {
     for (int numOP = this->GetNumberOfOutputs() - 1; numOP >= 0; numOP--)
       this->RemoveOutput(numOP);
     this->Modified();
   }
 
   //fill the outputs if a valid OpenIGTLink device is set
   if (m_IGTLDevice.IsNull())
     return;
 
   this->SetNumberOfIndexedOutputs(1);
   if (this->GetOutput(0) == nullptr)
   {
     DataObjectPointer newOutput = this->MakeOutput(0);
     this->SetNthOutput(0, newOutput);
     this->Modified();
   }
 }
 
 void mitk::IGTLDeviceSource::Connect()
 {
   if (m_IGTLDevice.IsNull())
   {
     throw std::invalid_argument("mitk::IGTLDeviceSource: "
       "No OpenIGTLink device set");
   }
   if (this->IsConnected())
   {
     return;
   }
   try
   {
     m_IGTLDevice->OpenConnection();
   }
   catch (mitk::Exception &e)
   {
     throw std::runtime_error(std::string("mitk::IGTLDeviceSource: Could not open"
       "connection to OpenIGTLink device. Error: ") + e.GetDescription());
   }
 }
 
 void mitk::IGTLDeviceSource::StartCommunication()
 {
   if (m_IGTLDevice.IsNull())
     throw std::invalid_argument("mitk::IGTLDeviceSource: "
     "No OpenIGTLink device set");
   if (m_IGTLDevice->GetState() == mitk::IGTLDevice::Running)
     return;
   if (m_IGTLDevice->StartCommunication() == false)
     throw std::runtime_error("mitk::IGTLDeviceSource: "
     "Could not start communication");
 }
 
 void mitk::IGTLDeviceSource::Disconnect()
 {
   if (m_IGTLDevice.IsNull())
     throw std::invalid_argument("mitk::IGTLDeviceSource: "
     "No OpenIGTLink device set");
   if (m_IGTLDevice->CloseConnection() == false)
     throw std::runtime_error("mitk::IGTLDeviceSource: Could not close connection"
     " to OpenIGTLink device");
 }
 
 void mitk::IGTLDeviceSource::StopCommunication()
 {
   if (m_IGTLDevice.IsNull())
     throw std::invalid_argument("mitk::IGTLDeviceSource: "
     "No OpenIGTLink device set");
   if (m_IGTLDevice->StopCommunication() == false)
     throw std::runtime_error("mitk::IGTLDeviceSource: "
     "Could not stop communicating");
 }
 
 void mitk::IGTLDeviceSource::UpdateOutputInformation()
 {
   this->Modified();  // make sure that we need to be updated
   Superclass::UpdateOutputInformation();
 }
 
 void mitk::IGTLDeviceSource::SetInput(unsigned int idx, const IGTLMessage* msg)
 {
   if (msg == nullptr) // if an input is set to nullptr, remove it
   {
     this->RemoveInput(idx);
   }
   else
   {
     // ProcessObject is not const-correct so a const_cast is required here
     this->ProcessObject::SetNthInput(idx, const_cast<IGTLMessage*>(msg));
   }
   //  this->CreateOutputsForAllInputs();
 }
 
 bool mitk::IGTLDeviceSource::IsConnected()
 {
   if (m_IGTLDevice.IsNull())
     return false;
 
   return (m_IGTLDevice->GetState() == mitk::IGTLDevice::Ready) ||
     (m_IGTLDevice->GetState() == mitk::IGTLDevice::Running);
 }
 
 bool mitk::IGTLDeviceSource::IsCommunicating()
 {
   if (m_IGTLDevice.IsNull())
     return false;
 
   return m_IGTLDevice->GetState() == mitk::IGTLDevice::Running;
 }
 
 void mitk::IGTLDeviceSource::RegisterAsMicroservice()
 {
   // Get Context
   us::ModuleContext* context = us::GetModuleContext();
 
   // Define ServiceProps
   us::ServiceProperties props;
   mitk::UIDGenerator uidGen =
-    mitk::UIDGenerator("org.mitk.services.IGTLDeviceSource.id_", 16);
+    mitk::UIDGenerator("org.mitk.services.IGTLDeviceSource.id_");
   props[US_PROPKEY_ID] = uidGen.GetUID();
   props[US_PROPKEY_DEVICENAME] = this->GetName();
   props[US_PROPKEY_IGTLDEVICENAME] = m_Name;
   props[US_PROPKEY_DEVICETYPE] = m_Type;
   m_ServiceRegistration = context->RegisterService(this, props);
 
   MITK_INFO << "Registered new DeviceSource as microservice: " << uidGen.GetUID();
 }
 
 void mitk::IGTLDeviceSource::OnIncomingMessage()
 {
 }
 
 void mitk::IGTLDeviceSource::OnIncomingCommand()
 {
 }
 
 void mitk::IGTLDeviceSource::OnLostConnection()
 {
 }
 
 const mitk::IGTLMessage* mitk::IGTLDeviceSource::GetInput(void) const
 {
   if (this->GetNumberOfInputs() < 1)
     return nullptr;
 
   return static_cast<const IGTLMessage*>(this->ProcessObject::GetInput(0));
 }
 
 const mitk::IGTLMessage*
 mitk::IGTLDeviceSource::GetInput(unsigned int idx) const
 {
   if (this->GetNumberOfInputs() < 1)
     return nullptr;
 
   return static_cast<const IGTLMessage*>(this->ProcessObject::GetInput(idx));
 }
 
 const mitk::IGTLMessage*
 mitk::IGTLDeviceSource::GetInput(std::string msgName) const
 {
   const DataObjectPointerArray& inputs = const_cast<Self*>(this)->GetInputs();
   for (DataObjectPointerArray::const_iterator it = inputs.begin();
     it != inputs.end(); ++it)
     if (std::string(msgName) ==
       (static_cast<IGTLMessage*>(it->GetPointer()))->GetName())
       return static_cast<IGTLMessage*>(it->GetPointer());
   return nullptr;
 }
 
 itk::ProcessObject::DataObjectPointerArraySizeType
 mitk::IGTLDeviceSource::GetInputIndex(std::string msgName)
 {
   DataObjectPointerArray outputs = this->GetInputs();
   for (DataObjectPointerArray::size_type i = 0; i < outputs.size(); ++i)
     if (msgName ==
       (static_cast<IGTLMessage*>(outputs.at(i).GetPointer()))->GetName())
       return i;
   throw std::invalid_argument("output name does not exist");
 }
diff --git a/Modules/OpenIGTLink/mitkIGTLMessageSource.cpp b/Modules/OpenIGTLink/mitkIGTLMessageSource.cpp
index 0e7ccfbfc0..f42dedd4dd 100644
--- a/Modules/OpenIGTLink/mitkIGTLMessageSource.cpp
+++ b/Modules/OpenIGTLink/mitkIGTLMessageSource.cpp
@@ -1,198 +1,198 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkIGTLMessageSource.h"
 #include "mitkUIDGenerator.h"
 
 //Microservices
 #include <usGetModuleContext.h>
 #include <usModule.h>
 #include <usServiceProperties.h>
 #include <usModuleContext.h>
 
 const std::string mitk::IGTLMessageSource::US_INTERFACE_NAME =
     "org.mitk.services.IGTLMessageSource";
 const std::string mitk::IGTLMessageSource::US_PROPKEY_DEVICENAME =
     US_INTERFACE_NAME + ".devicename";
 const std::string mitk::IGTLMessageSource::US_PROPKEY_DEVICETYPE =
     US_INTERFACE_NAME + ".devicetype";
 const std::string mitk::IGTLMessageSource::US_PROPKEY_ID =
     US_INTERFACE_NAME + ".id";
 const std::string mitk::IGTLMessageSource::US_PROPKEY_ISACTIVE =
     US_INTERFACE_NAME + ".isActive";
 
 mitk::IGTLMessageSource::IGTLMessageSource()
   : itk::ProcessObject(), m_Name("IGTLMessageSource (no defined type)"),
     m_Type("NONE"), m_StreamingFPS(0)
 {
   m_StreamingFPSMutex = itk::FastMutexLock::New();
 }
 
 mitk::IGTLMessageSource::~IGTLMessageSource()
 {
   //this->UnRegisterMicroservice();
 }
 
 mitk::IGTLMessage* mitk::IGTLMessageSource::GetOutput()
 {
   if (this->GetNumberOfIndexedOutputs() < 1)
   {
     MITK_WARN << "IGTLMessageSource contained no outputs. Returning nullptr.";
     return nullptr;
   }
 
   return static_cast<IGTLMessage*>(this->ProcessObject::GetPrimaryOutput());
 }
 
 mitk::IGTLMessage* mitk::IGTLMessageSource::GetOutput(
     DataObjectPointerArraySizeType idx)
 {
   IGTLMessage* out =
       dynamic_cast<IGTLMessage*>( this->ProcessObject::GetOutput(idx) );
   if ( out == nullptr && this->ProcessObject::GetOutput(idx) != nullptr )
   {
     itkWarningMacro (<< "Unable to convert output number " << idx << " to type "
                      <<  typeid( IGTLMessage ).name () );
   }
   return out;
 }
 
 mitk::IGTLMessage* mitk::IGTLMessageSource::GetOutput(
     const std::string& messageName)
 {
   DataObjectPointerArray outputs = this->GetOutputs();
   for (DataObjectPointerArray::iterator it = outputs.begin();
        it != outputs.end();
        ++it)
   {
     if (messageName ==
         (static_cast<IGTLMessage*>(it->GetPointer()))->GetName())
     {
       return static_cast<IGTLMessage*>(it->GetPointer());
     }
   }
   return nullptr;
 }
 
 itk::ProcessObject::DataObjectPointerArraySizeType
 mitk::IGTLMessageSource::GetOutputIndex( std::string messageName )
 {
   DataObjectPointerArray outputs = this->GetOutputs();
   for (DataObjectPointerArray::size_type i = 0; i < outputs.size(); ++i)
   {
     if (messageName ==
         (static_cast<IGTLMessage*>(outputs.at(i).GetPointer()))->GetName())
     {
       return i;
     }
   }
   throw std::invalid_argument("output name does not exist");
 }
 
 void mitk::IGTLMessageSource::RegisterAsMicroservice()
 {
   // Get Context
   us::ModuleContext* context = us::GetModuleContext();
 
   // Define ServiceProps
   us::ServiceProperties props;
   mitk::UIDGenerator uidGen =
-      mitk::UIDGenerator ("org.mitk.services.IGTLMessageSource.id_", 16);
+      mitk::UIDGenerator ("org.mitk.services.IGTLMessageSource.id_");
   props[ US_PROPKEY_ID ] = uidGen.GetUID();
   props[ US_PROPKEY_DEVICENAME ] = m_Name;
   props[ US_PROPKEY_DEVICETYPE ] = m_Type;
   m_ServiceRegistration = context->RegisterService(this, props);
 }
 
 void mitk::IGTLMessageSource::UnRegisterMicroservice()
 {
   if (m_ServiceRegistration != nullptr)
   {
     m_ServiceRegistration.Unregister();
   }
   m_ServiceRegistration = 0;
 }
 
 std::string mitk::IGTLMessageSource::GetMicroserviceID()
 {
   us::Any referenceProperty =
       this->m_ServiceRegistration.GetReference().GetProperty(US_PROPKEY_ID);
   return referenceProperty.ToString();
 }
 
 void mitk::IGTLMessageSource::GraftOutput(itk::DataObject *graft)
 {
   this->GraftNthOutput(0, graft);
 }
 
 void mitk::IGTLMessageSource::GraftNthOutput(unsigned int idx,
                                              itk::DataObject *graft)
 {
   if ( idx >= this->GetNumberOfIndexedOutputs() )
   {
     itkExceptionMacro(<<"Requested to graft output " << idx << " but this filter"
                 "only has " << this->GetNumberOfIndexedOutputs() << " Outputs.");
   }
 
   if ( !graft )
   {
     itkExceptionMacro(<<"Requested to graft output with a nullptr pointer object" );
   }
 
   itk::DataObject* output = this->GetOutput(idx);
   if ( !output )
   {
     itkExceptionMacro(<<"Requested to graft output that is a nullptr pointer" );
   }
   // Call Graft on IGTLMessage to copy member data
   output->Graft( graft );
 }
 
 itk::DataObject::Pointer mitk::IGTLMessageSource::MakeOutput ( DataObjectPointerArraySizeType /*idx*/ )
 {
   return IGTLMessage::New().GetPointer();
 }
 
 itk::DataObject::Pointer mitk::IGTLMessageSource::MakeOutput( const DataObjectIdentifierType & name )
 {
   itkDebugMacro("MakeOutput(" << name << ")");
   if( this->IsIndexedOutputName(name) )
   {
     return this->MakeOutput( this->MakeIndexFromOutputName(name) );
   }
   return static_cast<itk::DataObject *>(IGTLMessage::New().GetPointer());
 }
 
 mitk::PropertyList::ConstPointer mitk::IGTLMessageSource::GetParameters() const
 {
   mitk::PropertyList::Pointer p = mitk::PropertyList::New();
   // add properties to p like this:
   //p->SetProperty("MyFilter_MyParameter", mitk::PropertyDataType::New(m_MyParameter));
   return mitk::PropertyList::ConstPointer(p);
 }
 
 void mitk::IGTLMessageSource::SetFPS(unsigned int fps)
 {
   this->m_StreamingFPSMutex->Lock();
   this->m_StreamingFPS = fps;
   this->m_StreamingFPSMutex->Unlock();
 }
 
 
 unsigned int mitk::IGTLMessageSource::GetFPS()
 {
   unsigned int fps = 0;
   this->m_StreamingFPSMutex->Lock();
   fps = this->m_StreamingFPS;
   this->m_StreamingFPSMutex->Unlock();
   return fps;
 }
diff --git a/Modules/PhotoacousticsLib/MitkPAPhantomGenerator/PAPhantomGenerator.cpp b/Modules/PhotoacousticsLib/MitkPAPhantomGenerator/PAPhantomGenerator.cpp
index e309d04de7..1f81720dbb 100644
--- a/Modules/PhotoacousticsLib/MitkPAPhantomGenerator/PAPhantomGenerator.cpp
+++ b/Modules/PhotoacousticsLib/MitkPAPhantomGenerator/PAPhantomGenerator.cpp
@@ -1,226 +1,225 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <mitkCommon.h>
 #include <chrono>
 #include <mitkPATissueGeneratorParameters.h>
 #include <mitkPATissueGenerator.h>
 #include <mitkPAPhantomTissueGenerator.h>
 #include <mitkIOUtil.h>
 #include <mitkCommandLineParser.h>
 #include <mitkUIDGenerator.h>
 #include <mitkException.h>
 
 #include <itksys/SystemTools.hxx>
 
 using namespace mitk::pa;
 
 TissueGeneratorParameters::Pointer CreatePhantom_04_04_18_Parameters()
 {
   auto returnParameters = TissueGeneratorParameters::New();
   returnParameters->SetAirThicknessInMillimeters(12);
   returnParameters->SetMinBackgroundAbsorption(0.1);
   returnParameters->SetMaxBackgroundAbsorption(0.1);
   returnParameters->SetBackgroundAnisotropy(0.9);
   returnParameters->SetBackgroundScattering(15);
   returnParameters->SetCalculateNewVesselPositionCallback(&VesselMeanderStrategy::CalculateNewDirectionVectorInStraightLine);
   returnParameters->SetDoPartialVolume(true);
   returnParameters->SetMinNumberOfVessels(1);
   returnParameters->SetMaxNumberOfVessels(8);
   returnParameters->SetMinVesselAbsorption(1);
   returnParameters->SetMaxVesselAbsorption(10);
   returnParameters->SetMinVesselAnisotropy(0.9);
   returnParameters->SetMaxVesselAnisotropy(0.9);
   returnParameters->SetMinVesselBending(0.1);
   returnParameters->SetMaxVesselBending(0.3);
   returnParameters->SetMinVesselRadiusInMillimeters(0.25);
   returnParameters->SetMaxVesselRadiusInMillimeters(4);
   returnParameters->SetMinVesselScattering(15);
   returnParameters->SetMaxVesselScattering(15);
   returnParameters->SetMinVesselZOrigin(1.6);
   returnParameters->SetMaxVesselZOrigin(4);
   returnParameters->SetVesselBifurcationFrequency(5000);
   returnParameters->SetRandomizePhysicalProperties(false);
   returnParameters->SetSkinThicknessInMillimeters(0);
   returnParameters->SetUseRngSeed(false);
   returnParameters->SetVoxelSpacingInCentimeters(0.03);
   returnParameters->SetXDim(140);
   returnParameters->SetYDim(100);
   returnParameters->SetZDim(180);
   //returnParameters->SetVoxelSpacingInCentimeters(0.015);
   //returnParameters->SetXDim(280);
   //returnParameters->SetYDim(200);
   //returnParameters->SetZDim(360);
   returnParameters->SetForceVesselsMoveAlongYDirection(true);
   //returnParameters->SetVoxelSpacingInCentimeters(0.0075);
   //returnParameters->SetXDim(560);
   //returnParameters->SetYDim(400);
   //returnParameters->SetZDim(720);
   return returnParameters;
 }
 
 struct InputParameters
 {
   std::string saveFolderPath;
   std::string identifyer;
   std::string exePath;
   std::string probePath;
   bool empty;
   bool verbose;
 };
 
 InputParameters parseInput(int argc, char* argv[])
 {
   MITK_INFO << "Parsing arguments...";
   mitkCommandLineParser parser;
 
   parser.setCategory("MITK-Photoacoustics");
   parser.setTitle("Mitk Tissue Batch Generator");
   parser.setDescription("Creates in silico tissue in batch processing and automatically calculates fluence values for the central slice of the volume.");
   parser.setContributor("Computer Assisted Medical Interventions, DKFZ");
 
   parser.setArgumentPrefix("--", "-");
 
   parser.beginGroup("Required parameters");
   parser.addArgument(
     "savePath", "s", mitkCommandLineParser::Directory,
     "Input save folder (directory)", "input save folder",
     us::Any(), false, false, false, mitkCommandLineParser::Input);
   parser.addArgument(
     "mitkMcxyz", "m", mitkCommandLineParser::File,
     "MitkMcxyz binary (file)", "path to the MitkMcxyz binary",
     us::Any(), false, false, false, mitkCommandLineParser::Output);
   parser.endGroup();
 
   parser.beginGroup("Optional parameters");
   parser.addArgument(
     "probe", "p", mitkCommandLineParser::File,
     "xml probe file (file)", "file to the definition of the used probe (*.xml)",
     us::Any(), true, false, false, mitkCommandLineParser::Output);
   parser.addArgument(
     "verbose", "v", mitkCommandLineParser::Bool,
     "Verbose Output", "Whether to produce verbose, or rather debug output");
   parser.addArgument(
     "identifyer", "i", mitkCommandLineParser::String,
     "Generator identifyer (string)", "A unique identifyer for the calculation instance");
   parser.addArgument(
     "empty-volume", "e", mitkCommandLineParser::Bool,
     "omit vessel structures (boolean flag)", "Whether to create an empty volume with no structures inside.");
   parser.endGroup();
 
   InputParameters input;
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size() == 0)
     exit(-1);
 
   if (parsedArgs.count("empty-volume"))
   {
     input.empty = us::any_cast<bool>(parsedArgs["empty-volume"]);
   }
   else
   {
     input.empty = false;
   }
 
   if (parsedArgs.count("verbose"))
   {
     input.verbose = us::any_cast<bool>(parsedArgs["verbose"]);
   }
   else
   {
     input.verbose = false;
   }
 
   if (parsedArgs.count("savePath"))
   {
     input.saveFolderPath = us::any_cast<std::string>(parsedArgs["savePath"]);
   }
 
   if (parsedArgs.count("mitkMcxyz"))
   {
     input.exePath = us::any_cast<std::string>(parsedArgs["mitkMcxyz"]);
   }
 
   if (parsedArgs.count("probe"))
   {
     input.probePath = us::any_cast<std::string>(parsedArgs["probe"]);
   }
 
   if (parsedArgs.count("identifyer"))
   {
     input.identifyer = us::any_cast<std::string>(parsedArgs["identifyer"]);
   }
   else
   {
-    auto uid = mitk::UIDGenerator("", 8);
-    input.identifyer = uid.GetUID();
+    input.identifyer = mitk::UIDGenerator().GetUID();
   }
   MITK_INFO << "Parsing arguments...[Done]";
   return input;
 }
 
 int main(int argc, char * argv[])
 {
   auto input = parseInput(argc, argv);
   auto parameters = CreatePhantom_04_04_18_Parameters();
   if (input.empty)
   {
     parameters->SetMaxNumberOfVessels(0);
     parameters->SetMinNumberOfVessels(0);
   }
   MITK_INFO(input.verbose) << "Generating tissue..";
   auto resultTissue = InSilicoTissueGenerator::GenerateInSilicoData(parameters);
   MITK_INFO(input.verbose) << "Generating tissue..[Done]";
 
   auto inputfolder = std::string(input.saveFolderPath + "input/");
   auto outputfolder = std::string(input.saveFolderPath + "output/");
   if (!itksys::SystemTools::FileIsDirectory(inputfolder))
   {
     itksys::SystemTools::MakeDirectory(inputfolder);
   }
   if (!itksys::SystemTools::FileIsDirectory(outputfolder))
   {
     itksys::SystemTools::MakeDirectory(outputfolder);
   }
 
   std::string savePath = input.saveFolderPath + "input/Phantom_" + input.identifyer +
     ".nrrd";
   mitk::IOUtil::Save(resultTissue->ConvertToMitkImage(), savePath);
   std::string outputPath = input.saveFolderPath + "output/Phantom_" + input.identifyer +
     "/";
 
   resultTissue = nullptr;
 
   if (!itksys::SystemTools::FileIsDirectory(outputPath))
   {
     itksys::SystemTools::MakeDirectory(outputPath);
   }
 
   outputPath = outputPath + "Fluence_Phantom_" + input.identifyer;
 
   MITK_INFO(input.verbose) << "Simulating fluence..";
 
   int result = -4;
 
   std::string cmdString = std::string(input.exePath + " -i " + savePath + " -o " +
     (outputPath + ".nrrd") +
     " -yo " + "0" + " -p " + input.probePath +
     " -n 10000000");
 
   MITK_INFO << "Executing: " << cmdString;
 
   result = std::system(cmdString.c_str());
 
   MITK_INFO << result;
   MITK_INFO(input.verbose) << "Simulating fluence..[Done]";
 }
diff --git a/Modules/PhotoacousticsLib/MitkTissueBatchGenerator/TissueBatchGenerator.cpp b/Modules/PhotoacousticsLib/MitkTissueBatchGenerator/TissueBatchGenerator.cpp
index b51659f93a..7f2237754d 100644
--- a/Modules/PhotoacousticsLib/MitkTissueBatchGenerator/TissueBatchGenerator.cpp
+++ b/Modules/PhotoacousticsLib/MitkTissueBatchGenerator/TissueBatchGenerator.cpp
@@ -1,390 +1,389 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <mitkCommon.h>
 #include <chrono>
 #include <mitkPATissueGeneratorParameters.h>
 #include <mitkPATissueGenerator.h>
 #include <mitkIOUtil.h>
 #include <mitkCommandLineParser.h>
 #include <mitkUIDGenerator.h>
 #include <mitkException.h>
 
 #include <itksys/SystemTools.hxx>
 
 using namespace mitk::pa;
 
 TissueGeneratorParameters::Pointer CreateMultiHB_13_02_18_Parameters()
 {
   auto returnParameters = TissueGeneratorParameters::New();
   returnParameters->SetAirThicknessInMillimeters(1.8);
   returnParameters->SetMinBackgroundAbsorption(0.001);
   returnParameters->SetMaxBackgroundAbsorption(0.2);
   returnParameters->SetBackgroundAnisotropy(0.9);
   returnParameters->SetBackgroundScattering(15);
   returnParameters->SetCalculateNewVesselPositionCallback(&VesselMeanderStrategy::CalculateNewRandomlyDivergingDirectionVector);
   returnParameters->SetDoPartialVolume(true);
   returnParameters->SetMinNumberOfVessels(1);
   returnParameters->SetMaxNumberOfVessels(7);
   returnParameters->SetMinVesselAbsorption(1);
   returnParameters->SetMaxVesselAbsorption(12);
   returnParameters->SetMinVesselAnisotropy(0.9);
   returnParameters->SetMaxVesselAnisotropy(0.9);
   returnParameters->SetMinVesselBending(0);
   returnParameters->SetMaxVesselBending(0.2);
   returnParameters->SetMinVesselRadiusInMillimeters(0.5);
   returnParameters->SetMaxVesselRadiusInMillimeters(6);
   returnParameters->SetMinVesselScattering(15);
   returnParameters->SetMaxVesselScattering(15);
   returnParameters->SetMinVesselZOrigin(1);
   returnParameters->SetMaxVesselZOrigin(3);
   returnParameters->SetVesselBifurcationFrequency(5000);
   returnParameters->SetRandomizePhysicalProperties(false);
   returnParameters->SetSkinThicknessInMillimeters(0);
   returnParameters->SetUseRngSeed(false);
   returnParameters->SetVoxelSpacingInCentimeters(0.06);
   returnParameters->SetXDim(70);
   returnParameters->SetYDim(100);
   returnParameters->SetZDim(100);
   returnParameters->SetMCflag(4);
   return returnParameters;
 }
 
 TissueGeneratorParameters::Pointer CreateBaselineHB_13_02_18_Parameters()
 {
   auto returnParameters = TissueGeneratorParameters::New();
   returnParameters->SetAirThicknessInMillimeters(1.8);
   returnParameters->SetMinBackgroundAbsorption(0.001);
   returnParameters->SetMaxBackgroundAbsorption(0.2);
   returnParameters->SetBackgroundAnisotropy(0.9);
   returnParameters->SetBackgroundScattering(15);
   returnParameters->SetCalculateNewVesselPositionCallback(&VesselMeanderStrategy::CalculateNewRandomlyDivergingDirectionVector);
   returnParameters->SetDoPartialVolume(true);
   returnParameters->SetMinNumberOfVessels(1);
   returnParameters->SetMaxNumberOfVessels(1);
   returnParameters->SetMinVesselAbsorption(4.73);
   returnParameters->SetMaxVesselAbsorption(4.73);
   returnParameters->SetMinVesselAnisotropy(0.9);
   returnParameters->SetMaxVesselAnisotropy(0.9);
   returnParameters->SetMinVesselBending(0);
   returnParameters->SetMaxVesselBending(0.2);
   returnParameters->SetMinVesselRadiusInMillimeters(3);
   returnParameters->SetMaxVesselRadiusInMillimeters(3);
   returnParameters->SetMinVesselScattering(15);
   returnParameters->SetMaxVesselScattering(15);
   returnParameters->SetMinVesselZOrigin(1);
   returnParameters->SetMaxVesselZOrigin(3);
   returnParameters->SetVesselBifurcationFrequency(5000);
   returnParameters->SetRandomizePhysicalProperties(false);
   returnParameters->SetSkinThicknessInMillimeters(0);
   returnParameters->SetUseRngSeed(false);
   returnParameters->SetVoxelSpacingInCentimeters(0.06);
   returnParameters->SetXDim(70);
   returnParameters->SetYDim(100);
   returnParameters->SetZDim(100);
   returnParameters->SetMCflag(4);
   return returnParameters;
 }
 
 TissueGeneratorParameters::Pointer CreateSingleVesselHeterogeneousBackground_08_02_18_Parameters()
 {
   auto returnParameters = TissueGeneratorParameters::New();
   returnParameters->SetAirThicknessInMillimeters(1.8);
   returnParameters->SetMinBackgroundAbsorption(0.001);
   returnParameters->SetMaxBackgroundAbsorption(0.2);
   returnParameters->SetBackgroundAnisotropy(0.9);
   returnParameters->SetBackgroundScattering(15);
   returnParameters->SetCalculateNewVesselPositionCallback(&VesselMeanderStrategy::CalculateNewRandomlyDivergingDirectionVector);
   returnParameters->SetDoPartialVolume(true);
   returnParameters->SetMinNumberOfVessels(1);
   returnParameters->SetMaxNumberOfVessels(1);
   returnParameters->SetMinVesselAbsorption(1);
   returnParameters->SetMaxVesselAbsorption(12);
   returnParameters->SetMinVesselAnisotropy(0.9);
   returnParameters->SetMaxVesselAnisotropy(0.9);
   returnParameters->SetMinVesselBending(0);
   returnParameters->SetMaxVesselBending(0.2);
   returnParameters->SetMinVesselRadiusInMillimeters(0.5);
   returnParameters->SetMaxVesselRadiusInMillimeters(6);
   returnParameters->SetMinVesselScattering(15);
   returnParameters->SetMaxVesselScattering(15);
   returnParameters->SetMinVesselZOrigin(1);
   returnParameters->SetMaxVesselZOrigin(3);
   returnParameters->SetVesselBifurcationFrequency(5000);
   returnParameters->SetRandomizePhysicalProperties(false);
   returnParameters->SetSkinThicknessInMillimeters(0);
   returnParameters->SetUseRngSeed(false);
   returnParameters->SetVoxelSpacingInCentimeters(0.06);
   returnParameters->SetXDim(70);
   returnParameters->SetYDim(100);
   returnParameters->SetZDim(100);
   returnParameters->SetMCflag(4);
   return returnParameters;
 }
 
 TissueGeneratorParameters::Pointer CreateMultivessel_19_12_17_Parameters()
 {
   auto returnParameters = TissueGeneratorParameters::New();
   returnParameters->SetAirThicknessInMillimeters(12);
   returnParameters->SetMinBackgroundAbsorption(0.1);
   returnParameters->SetMaxBackgroundAbsorption(0.1);
   returnParameters->SetBackgroundAnisotropy(0.9);
   returnParameters->SetBackgroundScattering(15);
   returnParameters->SetCalculateNewVesselPositionCallback(&VesselMeanderStrategy::CalculateNewRandomlyDivergingDirectionVector);
   returnParameters->SetDoPartialVolume(true);
   returnParameters->SetMinNumberOfVessels(1);
   returnParameters->SetMaxNumberOfVessels(7);
   returnParameters->SetMinVesselAbsorption(2);
   returnParameters->SetMaxVesselAbsorption(8);
   returnParameters->SetMinVesselAnisotropy(0.9);
   returnParameters->SetMaxVesselAnisotropy(0.9);
   returnParameters->SetMinVesselBending(0.1);
   returnParameters->SetMaxVesselBending(0.3);
   returnParameters->SetMinVesselRadiusInMillimeters(0.5);
   returnParameters->SetMaxVesselRadiusInMillimeters(4);
   returnParameters->SetMinVesselScattering(15);
   returnParameters->SetMaxVesselScattering(15);
   returnParameters->SetMinVesselZOrigin(2.2);
   returnParameters->SetMaxVesselZOrigin(4);
   returnParameters->SetVesselBifurcationFrequency(5000);
   returnParameters->SetRandomizePhysicalProperties(false);
   returnParameters->SetSkinThicknessInMillimeters(0);
   returnParameters->SetUseRngSeed(false);
   returnParameters->SetVoxelSpacingInCentimeters(0.06);
   returnParameters->SetXDim(70);
   returnParameters->SetYDim(100);
   returnParameters->SetZDim(100);
   return returnParameters;
 }
 
 TissueGeneratorParameters::Pointer CreateMultivessel_19_10_17_Parameters()
 {
   auto returnParameters = TissueGeneratorParameters::New();
   returnParameters->SetAirThicknessInMillimeters(12);
   returnParameters->SetMinBackgroundAbsorption(0.1);
   returnParameters->SetMaxBackgroundAbsorption(0.1);
   returnParameters->SetBackgroundAnisotropy(0.9);
   returnParameters->SetBackgroundScattering(15);
   returnParameters->SetCalculateNewVesselPositionCallback(&VesselMeanderStrategy::CalculateNewRandomlyDivergingDirectionVector);
   returnParameters->SetDoPartialVolume(true);
   returnParameters->SetMinNumberOfVessels(1);
   returnParameters->SetMaxNumberOfVessels(7);
   returnParameters->SetMinVesselAbsorption(2);
   returnParameters->SetMaxVesselAbsorption(8);
   returnParameters->SetMinVesselAnisotropy(0.9);
   returnParameters->SetMaxVesselAnisotropy(0.9);
   returnParameters->SetMinVesselBending(0.1);
   returnParameters->SetMaxVesselBending(0.3);
   returnParameters->SetMinVesselRadiusInMillimeters(0.5);
   returnParameters->SetMaxVesselRadiusInMillimeters(4);
   returnParameters->SetMinVesselScattering(15);
   returnParameters->SetMaxVesselScattering(15);
   returnParameters->SetMinVesselZOrigin(2.2);
   returnParameters->SetMaxVesselZOrigin(4);
   returnParameters->SetVesselBifurcationFrequency(5000);
   returnParameters->SetRandomizePhysicalProperties(false);
   returnParameters->SetSkinThicknessInMillimeters(0);
   returnParameters->SetUseRngSeed(false);
   returnParameters->SetVoxelSpacingInCentimeters(0.03);
   returnParameters->SetXDim(140);
   returnParameters->SetYDim(200);
   returnParameters->SetZDim(180);
   return returnParameters;
 }
 
 TissueGeneratorParameters::Pointer CreateSinglevessel_19_10_17_Parameters()
 {
   auto returnParameters = TissueGeneratorParameters::New();
   returnParameters->SetAirThicknessInMillimeters(12);
   returnParameters->SetMinBackgroundAbsorption(0.1);
   returnParameters->SetMaxBackgroundAbsorption(0.1);
   returnParameters->SetBackgroundAnisotropy(0.9);
   returnParameters->SetBackgroundScattering(15);
   returnParameters->SetCalculateNewVesselPositionCallback(&VesselMeanderStrategy::CalculateNewRandomlyDivergingDirectionVector);
   returnParameters->SetDoPartialVolume(true);
   returnParameters->SetMinNumberOfVessels(1);
   returnParameters->SetMaxNumberOfVessels(1);
   returnParameters->SetMinVesselAbsorption(2);
   returnParameters->SetMaxVesselAbsorption(8);
   returnParameters->SetMinVesselAnisotropy(0.9);
   returnParameters->SetMaxVesselAnisotropy(0.9);
   returnParameters->SetMinVesselBending(0.1);
   returnParameters->SetMaxVesselBending(0.3);
   returnParameters->SetMinVesselRadiusInMillimeters(0.5);
   returnParameters->SetMaxVesselRadiusInMillimeters(4);
   returnParameters->SetMinVesselScattering(15);
   returnParameters->SetMaxVesselScattering(15);
   returnParameters->SetMinVesselZOrigin(2.2);
   returnParameters->SetMaxVesselZOrigin(4);
   returnParameters->SetVesselBifurcationFrequency(5000);
   returnParameters->SetRandomizePhysicalProperties(false);
   returnParameters->SetSkinThicknessInMillimeters(0);
   returnParameters->SetUseRngSeed(false);
   returnParameters->SetVoxelSpacingInCentimeters(0.03);
   returnParameters->SetXDim(140);
   returnParameters->SetYDim(200);
   returnParameters->SetZDim(180);
   return returnParameters;
 }
 
 struct InputParameters
 {
   std::string saveFolderPath;
   std::string identifyer;
   std::string exePath;
   std::string probePath;
   bool verbose;
 };
 
 InputParameters parseInput(int argc, char* argv[])
 {
   MITK_INFO << "Paring arguments...";
   mitkCommandLineParser parser;
   // set general information
   parser.setCategory("MITK-Photoacoustics");
   parser.setTitle("Mitk Tissue Batch Generator");
   parser.setDescription("Creates in silico tissue in batch processing and automatically calculates fluence values for the central slice of the volume.");
   parser.setContributor("Computer Assisted Medical Interventions, DKFZ");
 
   // how should arguments be prefixed
   parser.setArgumentPrefix("--", "-");
   // add each argument, unless specified otherwise each argument is optional
   // see mitkCommandLineParser::addArgument for more information
   parser.beginGroup("Required parameters");
   parser.addArgument(
     "savePath", "s", mitkCommandLineParser::Directory,
     "Input save folder (directory)", "input save folder",
     us::Any(), false, false, false, mitkCommandLineParser::Input);
   parser.addArgument(
     "mitkMcxyz", "m", mitkCommandLineParser::File,
     "MitkMcxyz binary (file)", "path to the MitkMcxyz binary",
     us::Any(), false, false, false, mitkCommandLineParser::Output);
   parser.endGroup();
   parser.beginGroup("Optional parameters");
   parser.addArgument(
     "probe", "p", mitkCommandLineParser::File,
     "xml probe file (file)", "file to the definition of the used probe (*.xml)",
     us::Any(), true, false, false, mitkCommandLineParser::Output);
   parser.addArgument(
     "verbose", "v", mitkCommandLineParser::Bool,
     "Verbose Output", "Whether to produce verbose, or rather debug output");
   parser.addArgument(
     "identifyer", "i", mitkCommandLineParser::String,
     "Generator identifyer (string)", "A unique identifyer for the calculation instance");
 
   InputParameters input;
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size() == 0)
     exit(-1);
 
   if (parsedArgs.count("verbose"))
   {
     MITK_INFO << "verbose";
     input.verbose = us::any_cast<bool>(parsedArgs["verbose"]);
   }
   else
   {
     input.verbose = false;
   }
 
   if (parsedArgs.count("savePath"))
   {
     MITK_INFO << "savePath";
     input.saveFolderPath = us::any_cast<std::string>(parsedArgs["savePath"]);
   }
 
   if (parsedArgs.count("mitkMcxyz"))
   {
     MITK_INFO << "mitkMcxyz";
     input.exePath = us::any_cast<std::string>(parsedArgs["mitkMcxyz"]);
   }
 
   if (parsedArgs.count("probe"))
   {
     MITK_INFO << "probe";
     input.probePath = us::any_cast<std::string>(parsedArgs["probe"]);
   }
 
   if (parsedArgs.count("identifyer"))
   {
     MITK_INFO << "identifyer";
     input.identifyer = us::any_cast<std::string>(parsedArgs["identifyer"]);
   }
   else
   {
     MITK_INFO << "generating identifyer";
-    auto uid = mitk::UIDGenerator("", 8);
-    input.identifyer = uid.GetUID();
+    input.identifyer = mitk::UIDGenerator().GetUID();
   }
   MITK_INFO << "Paring arguments...[Done]";
   return input;
 }
 
 int main(int argc, char * argv[])
 {
   auto input = parseInput(argc, argv);
   unsigned int iterationNumber = 0;
 
   while (true)
   {
     auto parameters = CreateBaselineHB_13_02_18_Parameters();
     MITK_INFO(input.verbose) << "Generating tissue..";
     auto resultTissue = InSilicoTissueGenerator::GenerateInSilicoData(parameters);
     MITK_INFO(input.verbose) << "Generating tissue..[Done]";
 
     auto inputfolder = std::string(input.saveFolderPath + "input/");
     auto outputfolder = std::string(input.saveFolderPath + "output/");
     if (!itksys::SystemTools::FileIsDirectory(inputfolder))
     {
       itksys::SystemTools::MakeDirectory(inputfolder);
     }
     if (!itksys::SystemTools::FileIsDirectory(outputfolder))
     {
       itksys::SystemTools::MakeDirectory(outputfolder);
     }
 
     std::string savePath = input.saveFolderPath + "input/BaselineHB_" + input.identifyer +
             "_" + std::to_string(iterationNumber) + ".nrrd";
     mitk::IOUtil::Save(resultTissue->ConvertToMitkImage(), savePath);
     std::string outputPath = input.saveFolderPath + "output/BaselineHB_" + input.identifyer +
             "_" + std::to_string(iterationNumber) + "/";
 
     if (!itksys::SystemTools::FileIsDirectory(outputPath))
     {
       itksys::SystemTools::MakeDirectory(outputPath);
     }
 
     outputPath = outputPath + "Fluence_BaselineHB_" + input.identifyer + "_" + std::to_string(iterationNumber);
 
     MITK_INFO(input.verbose) << "Simulating fluence..";
     for(double yo = -1.8; yo <= 1.81; yo=yo+0.12)
     {
         std::string yo_string = std::to_string(round(yo*100)/100.0);
         int result = -4;
         if(!input.probePath.empty())
             result = std::system(std::string(input.exePath + " -i " + savePath + " -o " +
                                              (outputPath + "_yo" + yo_string + ".nrrd") +
                                              " -yo " + yo_string + " -p " + input.probePath +
                                              " -n 100000000").c_str());
         else
             result = std::system(std::string(input.exePath + " -i " + savePath + " -o " +
                                              (outputPath + "_yo" + yo_string + ".nrrd") +
                                              " -yo " + yo_string + " -n 100000000").c_str());
         MITK_INFO << "yo: " << yo_string << ": " << result;
     }
 
     MITK_INFO(input.verbose) << "Simulating fluence..[Done]";
 
     iterationNumber++;
   }
 }
diff --git a/Modules/SceneSerialization/src/mitkSceneIO.cpp b/Modules/SceneSerialization/src/mitkSceneIO.cpp
index 55f48ecb2c..d4f9954913 100644
--- a/Modules/SceneSerialization/src/mitkSceneIO.cpp
+++ b/Modules/SceneSerialization/src/mitkSceneIO.cpp
@@ -1,577 +1,577 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <Poco/Delegate.h>
 #include <Poco/Path.h>
 #include <Poco/TemporaryFile.h>
 #include <Poco/Zip/Compress.h>
 #include <Poco/Zip/Decompress.h>
 
 #include "mitkBaseDataSerializer.h"
 #include "mitkPropertyListSerializer.h"
 #include "mitkSceneIO.h"
 #include "mitkSceneReader.h"
 
 #include "mitkBaseRenderer.h"
 #include "mitkProgressBar.h"
 #include "mitkRenderingManager.h"
 #include "mitkStandaloneDataStorage.h"
 #include <mitkLocaleSwitch.h>
 #include <mitkStandardFileLocations.h>
 
 #include <itkObjectFactoryBase.h>
 
 #include <tinyxml.h>
 
 #include <fstream>
 #include <mitkIOUtil.h>
 #include <sstream>
 
 #include "itksys/SystemTools.hxx"
 
 mitk::SceneIO::SceneIO() : m_WorkingDirectory(""), m_UnzipErrors(0)
 {
 }
 
 mitk::SceneIO::~SceneIO()
 {
 }
 
 std::string mitk::SceneIO::CreateEmptyTempDirectory()
 {
-  mitk::UIDGenerator uidGen("UID_", 6);
+  mitk::UIDGenerator uidGen;
 
   // std::string returnValue = mitk::StandardFileLocations::GetInstance()->GetOptionDirectory() +
   // Poco::Path::separator() + "SceneIOTemp" + uidGen.GetUID();
   std::string returnValue = Poco::Path::temp() + "SceneIOTemp" + uidGen.GetUID();
   std::string uniquename = returnValue + Poco::Path::separator();
   Poco::File tempdir(uniquename);
 
   try
   {
     bool existsNot = tempdir.createDirectory();
     if (!existsNot)
     {
       MITK_ERROR << "Warning: Directory already exitsts: " << uniquename << " (choosing another)";
       returnValue = mitk::StandardFileLocations::GetInstance()->GetOptionDirectory() + Poco::Path::separator() +
                     "SceneIOTempDirectory" + uidGen.GetUID();
       uniquename = returnValue + Poco::Path::separator();
       Poco::File tempdir2(uniquename);
       if (!tempdir2.createDirectory())
       {
         MITK_ERROR << "Warning: Second directory also already exitsts: " << uniquename;
       }
     }
   }
   catch (std::exception &e)
   {
     MITK_ERROR << "Could not create temporary directory " << uniquename << ":" << e.what();
     return "";
   }
 
   return returnValue;
 }
 
 mitk::DataStorage::Pointer mitk::SceneIO::LoadScene(const std::string &filename,
                                                     DataStorage *pStorage,
                                                     bool clearStorageFirst)
 {
   mitk::LocaleSwitch localeSwitch("C");
 
   // prepare data storage
   DataStorage::Pointer storage = pStorage;
   if (storage.IsNull())
   {
     storage = StandaloneDataStorage::New().GetPointer();
   }
 
   // test input filename
   if (filename.empty())
   {
     MITK_ERROR << "No filename given. Not possible to load scene.";
     return storage;
   }
 
   // test if filename can be read
   std::ifstream file(filename.c_str(), std::ios::binary);
   if (!file.good())
   {
     MITK_ERROR << "Cannot open '" << filename << "' for reading";
     return storage;
   }
 
   // get new temporary directory
   m_WorkingDirectory = CreateEmptyTempDirectory();
   if (m_WorkingDirectory.empty())
   {
     MITK_ERROR << "Could not create temporary directory. Cannot open scene files.";
     return storage;
   }
 
   // unzip all filenames contents to temp dir
   m_UnzipErrors = 0;
   Poco::Zip::Decompress unzipper(file, Poco::Path(m_WorkingDirectory));
   unzipper.EError += Poco::Delegate<SceneIO, std::pair<const Poco::Zip::ZipLocalFileHeader, const std::string>>(
     this, &SceneIO::OnUnzipError);
   unzipper.EOk += Poco::Delegate<SceneIO, std::pair<const Poco::Zip::ZipLocalFileHeader, const Poco::Path>>(
     this, &SceneIO::OnUnzipOk);
   unzipper.decompressAllFiles();
   unzipper.EError -= Poco::Delegate<SceneIO, std::pair<const Poco::Zip::ZipLocalFileHeader, const std::string>>(
     this, &SceneIO::OnUnzipError);
   unzipper.EOk -= Poco::Delegate<SceneIO, std::pair<const Poco::Zip::ZipLocalFileHeader, const Poco::Path>>(
     this, &SceneIO::OnUnzipOk);
 
   if (m_UnzipErrors)
   {
     MITK_ERROR << "There were " << m_UnzipErrors << " errors unzipping '" << filename
                << "'. Will attempt to read whatever could be unzipped.";
   }
 
   // transcode locale-dependent string
   m_WorkingDirectory = Poco::Path::transcode (m_WorkingDirectory);
 
   auto indexFile = m_WorkingDirectory + mitk::IOUtil::GetDirectorySeparator() + "index.xml";
   storage = LoadSceneUnzipped(indexFile, storage, clearStorageFirst);
 
   // delete temp directory
   try
   {
     Poco::File deleteDir(m_WorkingDirectory);
     deleteDir.remove(true); // recursive
   }
   catch (...)
   {
     MITK_ERROR << "Could not delete temporary directory " << m_WorkingDirectory;
   }
 
   // return new data storage, even if empty or uncomplete (return as much as possible but notify calling method)
   return storage;
 }
 
 mitk::DataStorage::Pointer mitk::SceneIO::LoadSceneUnzipped(const std::string &indexfilename,
   DataStorage *pStorage,
   bool clearStorageFirst)
 {
   mitk::LocaleSwitch localeSwitch("C");
 
   // prepare data storage
   DataStorage::Pointer storage = pStorage;
   if (storage.IsNull())
   {
     storage = StandaloneDataStorage::New().GetPointer();
   }
 
   if (clearStorageFirst)
   {
     try
     {
       storage->Remove(storage->GetAll());
     }
     catch (...)
     {
       MITK_ERROR << "DataStorage cannot be cleared properly.";
     }
   }
 
   // test input filename
   if (indexfilename.empty())
   {
     MITK_ERROR << "No filename given. Not possible to load scene.";
     return storage;
   }
 
   // transcode locale-dependent string
   std::string tempfilename;
   std::string workingDir;
   itksys::SystemTools::SplitProgramPath(indexfilename, workingDir, tempfilename);
 
   // test if index.xml exists
   // parse index.xml with TinyXML
   TiXmlDocument document(indexfilename);
   if (!document.LoadFile())
   {
     MITK_ERROR << "Could not open/read/parse " << workingDir << mitk::IOUtil::GetDirectorySeparator()
       << "index.xml\nTinyXML reports: " << document.ErrorDesc() << std::endl;
     return storage;
   }
 
   SceneReader::Pointer reader = SceneReader::New();
   if (!reader->LoadScene(document, workingDir, storage))
   {
     MITK_ERROR << "There were errors while loading scene file " << indexfilename << ". Your data may be corrupted";
   }
 
   // return new data storage, even if empty or uncomplete (return as much as possible but notify calling method)
   return storage;
 }
 
 bool mitk::SceneIO::SaveScene(DataStorage::SetOfObjects::ConstPointer sceneNodes,
                               const DataStorage *storage,
                               const std::string &filename)
 {
   if (!sceneNodes)
   {
     MITK_ERROR << "No set of nodes given. Not possible to save scene.";
     return false;
   }
   if (!storage)
   {
     MITK_ERROR << "No data storage given. Not possible to save scene."; // \TODO: Technically, it would be possible to
                                                                         // save the nodes without their relation
     return false;
   }
 
   if (filename.empty())
   {
     MITK_ERROR << "No filename given. Not possible to save scene.";
     return false;
   }
 
   mitk::LocaleSwitch localeSwitch("C");
 
   try
   {
     m_FailedNodes = DataStorage::SetOfObjects::New();
     m_FailedProperties = PropertyList::New();
 
     // start XML DOM
     TiXmlDocument document;
     auto *decl = new TiXmlDeclaration(
       "1.0",
       "UTF-8",
       ""); // TODO what to write here? encoding? standalone would mean that we provide a DTD somewhere...
     document.LinkEndChild(decl);
 
     auto *version = new TiXmlElement("Version");
     version->SetAttribute("Writer", __FILE__);
     version->SetAttribute("Revision", "$Revision: 17055 $");
     version->SetAttribute("FileVersion", 1);
     document.LinkEndChild(version);
 
     // DataStorage::SetOfObjects::ConstPointer sceneNodes = storage->GetSubset( predicate );
 
     if (sceneNodes.IsNull())
     {
       MITK_WARN << "Saving empty scene to " << filename;
     }
     else
     {
       if (sceneNodes->size() == 0)
       {
         MITK_WARN << "Saving empty scene to " << filename;
       }
 
       MITK_INFO << "Storing scene with " << sceneNodes->size() << " objects to " << filename;
 
       m_WorkingDirectory = CreateEmptyTempDirectory();
       if (m_WorkingDirectory.empty())
       {
         MITK_ERROR << "Could not create temporary directory. Cannot create scene files.";
         return false;
       }
 
       ProgressBar::GetInstance()->AddStepsToDo(sceneNodes->size());
 
       // find out about dependencies
       typedef std::map<DataNode *, std::string> UIDMapType;
       typedef std::map<DataNode *, std::list<std::string>> SourcesMapType;
 
       UIDMapType nodeUIDs;       // for dependencies: ID of each node
       SourcesMapType sourceUIDs; // for dependencies: IDs of a node's parent nodes
 
       UIDGenerator nodeUIDGen("OBJECT_");
 
       for (auto iter = sceneNodes->begin(); iter != sceneNodes->end(); ++iter)
       {
         DataNode *node = iter->GetPointer();
         if (!node)
           continue; // unlikely event that we get a nullptr pointer as an object for saving. just ignore
 
         // generate UIDs for all source objects
         DataStorage::SetOfObjects::ConstPointer sourceObjects = storage->GetSources(node);
         for (auto sourceIter = sourceObjects->begin();
              sourceIter != sourceObjects->end();
              ++sourceIter)
         {
           if (std::find(sceneNodes->begin(), sceneNodes->end(), *sourceIter) == sceneNodes->end())
             continue; // source is not saved, so don't generate a UID for this source
 
           // create a uid for the parent object
           if (nodeUIDs[*sourceIter].empty())
           {
             nodeUIDs[*sourceIter] = nodeUIDGen.GetUID();
           }
 
           // store this dependency for writing
           sourceUIDs[node].push_back(nodeUIDs[*sourceIter]);
         }
 
         if (nodeUIDs[node].empty())
         {
           nodeUIDs[node] = nodeUIDGen.GetUID();
         }
       }
 
       // write out objects, dependencies and properties
       for (auto iter = sceneNodes->begin(); iter != sceneNodes->end(); ++iter)
       {
         DataNode *node = iter->GetPointer();
 
         if (node)
         {
           auto *nodeElement = new TiXmlElement("node");
           std::string filenameHint(node->GetName());
           filenameHint = itksys::SystemTools::MakeCindentifier(
             filenameHint.c_str()); // escape filename <-- only allow [A-Za-z0-9_], replace everything else with _
 
           // store dependencies
           auto searchUIDIter = nodeUIDs.find(node);
           if (searchUIDIter != nodeUIDs.end())
           {
             // store this node's ID
             nodeElement->SetAttribute("UID", searchUIDIter->second.c_str());
           }
 
           auto searchSourcesIter = sourceUIDs.find(node);
           if (searchSourcesIter != sourceUIDs.end())
           {
             // store all source IDs
             for (auto sourceUIDIter = searchSourcesIter->second.begin();
                  sourceUIDIter != searchSourcesIter->second.end();
                  ++sourceUIDIter)
             {
               auto *uidElement = new TiXmlElement("source");
               uidElement->SetAttribute("UID", sourceUIDIter->c_str());
               nodeElement->LinkEndChild(uidElement);
             }
           }
 
           // store basedata
           if (BaseData *data = node->GetData())
           {
             // std::string filenameHint( node->GetName() );
             bool error(false);
             TiXmlElement *dataElement(SaveBaseData(data, filenameHint, error)); // returns a reference to a file
             if (error)
             {
               m_FailedNodes->push_back(node);
             }
 
             // store basedata properties
             PropertyList *propertyList = data->GetPropertyList();
             if (propertyList && !propertyList->IsEmpty())
             {
               TiXmlElement *baseDataPropertiesElement(
                 SavePropertyList(propertyList, filenameHint + "-data")); // returns a reference to a file
               dataElement->LinkEndChild(baseDataPropertiesElement);
             }
 
             nodeElement->LinkEndChild(dataElement);
           }
 
           // store all renderwindow specific propertylists
           mitk::DataNode::PropertyListKeyNames propertyListKeys = node->GetPropertyListNames();
           for (auto renderWindowName : propertyListKeys)
           {
             PropertyList *propertyList = node->GetPropertyList(renderWindowName);
             if (propertyList && !propertyList->IsEmpty())
             {
               TiXmlElement *renderWindowPropertiesElement(
                 SavePropertyList(propertyList, filenameHint + "-" + renderWindowName)); // returns a reference to a file
               renderWindowPropertiesElement->SetAttribute("renderwindow", renderWindowName);
               nodeElement->LinkEndChild(renderWindowPropertiesElement);
             }
           }
 
           // don't forget the renderwindow independent list
           PropertyList *propertyList = node->GetPropertyList();
           if (propertyList && !propertyList->IsEmpty())
           {
             TiXmlElement *propertiesElement(
               SavePropertyList(propertyList, filenameHint + "-node")); // returns a reference to a file
             nodeElement->LinkEndChild(propertiesElement);
           }
           document.LinkEndChild(nodeElement);
         }
         else
         {
           MITK_WARN << "Ignoring nullptr node during scene serialization.";
         }
 
         ProgressBar::GetInstance()->Progress();
       } // end for all nodes
     }   // end if sceneNodes
 
     std::string defaultLocale_WorkingDirectory = Poco::Path::transcode( m_WorkingDirectory );
 
     if (!document.SaveFile(defaultLocale_WorkingDirectory + Poco::Path::separator() + "index.xml"))
     {
       MITK_ERROR << "Could not write scene to " << defaultLocale_WorkingDirectory << Poco::Path::separator() << "index.xml"
                  << "\nTinyXML reports '" << document.ErrorDesc() << "'";
       return false;
     }
     else
     {
       try
       {
         Poco::File deleteFile(filename.c_str());
         if (deleteFile.exists())
         {
           deleteFile.remove();
         }
 
         // create zip at filename
         std::ofstream file(filename.c_str(), std::ios::binary | std::ios::out);
         if (!file.good())
         {
           MITK_ERROR << "Could not open a zip file for writing: '" << filename << "'";
           return false;
         }
         else
         {
           Poco::Zip::Compress zipper(file, true);
           Poco::Path tmpdir(m_WorkingDirectory);
           zipper.addRecursive(tmpdir);
           zipper.close();
         }
         try
         {
           Poco::File deleteDir(m_WorkingDirectory);
           deleteDir.remove(true); // recursive
         }
         catch (...)
         {
           MITK_ERROR << "Could not delete temporary directory " << m_WorkingDirectory;
           return false; // ok?
         }
       }
       catch (std::exception &e)
       {
         MITK_ERROR << "Could not create ZIP file from " << m_WorkingDirectory << "\nReason: " << e.what();
         return false;
       }
       return true;
     }
   }
   catch (std::exception &e)
   {
     MITK_ERROR << "Caught exception during saving temporary files to disk. Error description: '" << e.what() << "'";
     return false;
   }
 }
 
 TiXmlElement *mitk::SceneIO::SaveBaseData(BaseData *data, const std::string &filenamehint, bool &error)
 {
   assert(data);
   error = true;
 
   // find correct serializer
   // the serializer must
   //  - create a file containing all information to recreate the BaseData object --> needs to know where to put this
   //  file (and a filename?)
   //  - TODO what to do about writers that creates one file per timestep?
   auto *element = new TiXmlElement("data");
   element->SetAttribute("type", data->GetNameOfClass());
 
   // construct name of serializer class
   std::string serializername(data->GetNameOfClass());
   serializername += "Serializer";
 
   std::list<itk::LightObject::Pointer> thingsThatCanSerializeThis =
     itk::ObjectFactoryBase::CreateAllInstance(serializername.c_str());
   if (thingsThatCanSerializeThis.size() < 1)
   {
     MITK_ERROR << "No serializer found for " << data->GetNameOfClass() << ". Skipping object";
   }
 
   for (auto iter = thingsThatCanSerializeThis.begin();
        iter != thingsThatCanSerializeThis.end();
        ++iter)
   {
     if (auto *serializer = dynamic_cast<BaseDataSerializer *>(iter->GetPointer()))
     {
       serializer->SetData(data);
       serializer->SetFilenameHint(filenamehint);
       std::string defaultLocale_WorkingDirectory = Poco::Path::transcode( m_WorkingDirectory );
       serializer->SetWorkingDirectory(defaultLocale_WorkingDirectory);
       try
       {
         std::string writtenfilename = serializer->Serialize();
         element->SetAttribute("file", writtenfilename);
         error = false;
       }
       catch (std::exception &e)
       {
         MITK_ERROR << "Serializer " << serializer->GetNameOfClass() << " failed: " << e.what();
       }
       break;
     }
   }
 
   return element;
 }
 
 TiXmlElement *mitk::SceneIO::SavePropertyList(PropertyList *propertyList, const std::string &filenamehint)
 {
   assert(propertyList);
 
   //  - TODO what to do about shared properties (same object in two lists or behind several keys)?
   auto *element = new TiXmlElement("properties");
 
   // construct name of serializer class
   PropertyListSerializer::Pointer serializer = PropertyListSerializer::New();
 
   serializer->SetPropertyList(propertyList);
   serializer->SetFilenameHint(filenamehint);
   std::string defaultLocale_WorkingDirectory = Poco::Path::transcode( m_WorkingDirectory );
   serializer->SetWorkingDirectory(defaultLocale_WorkingDirectory);
   try
   {
     std::string writtenfilename = serializer->Serialize();
     element->SetAttribute("file", writtenfilename);
     PropertyList::Pointer failedProperties = serializer->GetFailedProperties();
     if (failedProperties.IsNotNull())
     {
       // move failed properties to global list
       m_FailedProperties->ConcatenatePropertyList(failedProperties, true);
     }
   }
   catch (std::exception &e)
   {
     MITK_ERROR << "Serializer " << serializer->GetNameOfClass() << " failed: " << e.what();
   }
 
   return element;
 }
 
 const mitk::SceneIO::FailedBaseDataListType *mitk::SceneIO::GetFailedNodes()
 {
   return m_FailedNodes.GetPointer();
 }
 
 const mitk::PropertyList *mitk::SceneIO::GetFailedProperties()
 {
   return m_FailedProperties;
 }
 
 void mitk::SceneIO::OnUnzipError(const void * /*pSender*/,
                                  std::pair<const Poco::Zip::ZipLocalFileHeader, const std::string> &info)
 {
   ++m_UnzipErrors;
   MITK_ERROR << "Error while unzipping: " << info.second;
 }
 
 void mitk::SceneIO::OnUnzipOk(const void * /*pSender*/,
                               std::pair<const Poco::Zip::ZipLocalFileHeader, const Poco::Path> & /*info*/)
 {
   // MITK_INFO << "Unzipped ok: " << info.second.toString();
 }
diff --git a/Modules/US/USFilters/mitkUSImageLoggingFilter.cpp b/Modules/US/USFilters/mitkUSImageLoggingFilter.cpp
index 32424b4f70..0ec48a98a0 100644
--- a/Modules/US/USFilters/mitkUSImageLoggingFilter.cpp
+++ b/Modules/US/USFilters/mitkUSImageLoggingFilter.cpp
@@ -1,161 +1,161 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkUSImageLoggingFilter.h"
 #include <mitkIOUtil.h>
 #include <mitkUIDGenerator.h>
 #include <Poco/Path.h>
 
 #include <algorithm>
 #include <mitkIOMimeTypes.h>
 #include <mitkCoreServices.h>
 #include <mitkIMimeTypeProvider.h>
 
 
 mitk::USImageLoggingFilter::USImageLoggingFilter() : m_SystemTimeClock(RealTimeClock::New()),
                                                      m_ImageExtension(".nrrd")
 {
 }
 
 mitk::USImageLoggingFilter::~USImageLoggingFilter()
 {
 }
 
 void mitk::USImageLoggingFilter::GenerateData()
 {
   mitk::Image::ConstPointer inputImage = this->GetInput();
   mitk::Image::Pointer outputImage = this->GetOutput();
 
   if(inputImage.IsNull() || inputImage->IsEmpty())
     {
     MITK_WARN << "Input image is not valid. Cannot save image!";
     return;
     }
 
   //a clone is needed for a output and to store it.
   mitk::Image::Pointer inputClone = inputImage->Clone();
 
 
   //simply redirecy the input to the output
   //this->SetNumberOfRequiredOutputs(1);
   //this->SetNthOutput(0, inputClone->Clone());
   //outputImage->Graft(inputImage);
   //this->SetOutput(this->GetInput());
   /*if (!this->GetOutput()->IsInitialized())
     {
     this->SetNumberOfRequiredOutputs(1);
     mitk::Image::Pointer newOutput = mitk::Image::New();
     this->SetNthOutput(0, newOutput);
     }
   memcpy(this->GetOutput(),this->GetInput());*/
 
   //this->SetNthOutput(0,inputImage.);
   //this->AllocateOutputs();
   //this->GraftOutput(inputClone);
 
   /*
   if (!this->GetOutput()->IsInitialized())
     {
     mitk::Image::Pointer newOutput = mitk::Image::New();
     this->SetNthOutput(0, newOutput);
     }
   this->GetOutput()Graft(this->GetInput());
   */
 
 
   m_LoggedImages.push_back(inputClone);
   m_LoggedMITKSystemTimes.push_back(m_SystemTimeClock->GetCurrentStamp());
 
 }
 
 void mitk::USImageLoggingFilter::AddMessageToCurrentImage(std::string message)
 {
   m_LoggedMessages.insert(std::make_pair(static_cast<int>(m_LoggedImages.size()-1),message));
 }
 
 void mitk::USImageLoggingFilter::SaveImages(std::string path)
 {
 std::vector<std::string> dummy1;
 std::string dummy2;
 this->SaveImages(path,dummy1,dummy2);
 }
 
 void mitk::USImageLoggingFilter::SaveImages(std::string path, std::vector<std::string>& filenames, std::string& csvFileName)
 {
   filenames = std::vector<std::string>();
 
   //test if path is valid
   Poco::Path testPath(path);
   if(!testPath.isDirectory())
     {
     mitkThrow() << "Attemting to write to directory " << path << " which is not valid! Aborting!";
     }
 
   //generate a unique ID which is used as part of the filenames, so we avoid to overwrite old files by mistake.
-  mitk::UIDGenerator myGen = mitk::UIDGenerator("",5);
+  mitk::UIDGenerator myGen = mitk::UIDGenerator();
   std::string uniqueID = myGen.GetUID();
 
   //first: write the images
   for(size_t i=0; i<m_LoggedImages.size(); i++)
     {
       std::stringstream name;
       name << path << uniqueID << "_Image_" << i << m_ImageExtension;
       mitk::IOUtil::Save(m_LoggedImages.at(i),name.str());
       filenames.push_back(name.str());
     }
 
   //then: write a csv file which contains comments to all the images
 
   //open file
   std::stringstream csvFilenameStream;
   csvFilenameStream << path << uniqueID << "_ImageMessages.csv";
   csvFileName = csvFilenameStream.str();
   std::filebuf fb;
   fb.open (csvFileName.c_str(),std::ios::out);
   std::ostream os(&fb);
   os.precision(15); //set high precision to avoid loss of digits
 
   //write header
   os << "image filename; MITK system timestamp; message\n";
 
   //write data
   for(size_t i=0; i<m_LoggedImages.size(); i++)
     {
     std::map<int, std::string>::iterator it = m_LoggedMessages.find(i);
     if (m_LoggedMessages.empty() || (it == m_LoggedMessages.end())) os << filenames.at(i) << ";" << m_LoggedMITKSystemTimes.at(i) << ";" << "" << "\n";
     else os << filenames.at(i) << ";" << m_LoggedMITKSystemTimes.at(i) << ";" << it->second << "\n";
     }
 
   //close file
   fb.close();
 }
 
 bool mitk::USImageLoggingFilter::SetImageFilesExtension(std::string extension)
  {
   if(extension.compare(0,1,".") == 0)
     extension = extension.substr(1,extension.size()-1);
 
   CoreServicePointer<IMimeTypeProvider> mimeTypeProvider(CoreServices::GetMimeTypeProvider());
 
   std::vector<MimeType> mimeTypes = mimeTypeProvider->GetMimeTypesForCategory(IOMimeTypes::CATEGORY_IMAGES());
 
   for(std::vector<MimeType>::size_type i = 0 ; i< mimeTypes.size() ; ++i)
   {
     std::vector<std::string> extensions = mimeTypes[i].GetExtensions();
     if (std::find(extensions.begin(), extensions.end(), extension) != extensions.end())
     {
       m_ImageExtension = "."+extension;
       return true;
     }
   }
   return false;
  }
diff --git a/Modules/US/USNavigation/mitkAbstractUltrasoundTrackerDevice.cpp b/Modules/US/USNavigation/mitkAbstractUltrasoundTrackerDevice.cpp
index 066b3686c3..7c64a04970 100644
--- a/Modules/US/USNavigation/mitkAbstractUltrasoundTrackerDevice.cpp
+++ b/Modules/US/USNavigation/mitkAbstractUltrasoundTrackerDevice.cpp
@@ -1,491 +1,491 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkAbstractUltrasoundTrackerDevice.h"
 #include "mitkImageReadAccessor.h"
 #include "mitkNavigationDataDelayFilter.h"
 #include "mitkNavigationDataDisplacementFilter.h"
 #include "mitkNavigationDataSmoothingFilter.h"
 #include "mitkTrackingDeviceSource.h"
 
 // US Control Interfaces
 #include "mitkUSControlInterfaceBMode.h"
 #include "mitkUSControlInterfaceDoppler.h"
 #include "mitkUSControlInterfaceProbes.h"
 
 // Microservices
 #include <usGetModuleContext.h>
 #include <usModule.h>
 #include <usModuleContext.h>
 #include <usServiceProperties.h>
 
 #include <algorithm>
 
 // TempIncludes
 #include <tinyxml.h>
 
 const std::string mitk::AbstractUltrasoundTrackerDevice::DeviceClassIdentifier =
   "org.mitk.modules.us.AbstractUltrasoundTrackerDevice";
 const char *mitk::AbstractUltrasoundTrackerDevice::DefaultProbeIdentifier = "default";
 const char *mitk::AbstractUltrasoundTrackerDevice::ProbeAndDepthSeperator = "_";
 
 const std::string mitk::AbstractUltrasoundTrackerDevice::US_INTERFACE_NAME =
   "org.mitk.services.AbstractUltrasoundTrackerDevice";
 const std::string mitk::AbstractUltrasoundTrackerDevice::US_PROPKEY_DEVICENAME = US_INTERFACE_NAME + ".devicename";
 const std::string mitk::AbstractUltrasoundTrackerDevice::US_PROPKEY_CLASS = US_INTERFACE_NAME + ".class";
 const std::string mitk::AbstractUltrasoundTrackerDevice::US_PROPKEY_ID = US_INTERFACE_NAME + ".id";
 //____
 
 mitk::AbstractUltrasoundTrackerDevice::AbstractUltrasoundTrackerDevice(USDevice::Pointer usDevice,
                                                                        NavigationDataSource::Pointer trackingDevice,
                                                                        bool trackedUltrasoundActive)
   : m_UltrasoundDevice(usDevice),
     m_TrackingDeviceDataSource(trackingDevice),
     m_SmoothingFilter(mitk::NavigationDataSmoothingFilter::New()),
     m_DelayFilter(mitk::NavigationDataDelayFilter::New(0)),
     m_DisplacementFilter(mitk::NavigationDataDisplacementFilter::New()),
     m_LastFilterOfIGTPipeline(nullptr),
     m_NumberOfSmoothingValues(0),
     m_DelayCount(0),
     m_IsTrackedUltrasoundActive(trackedUltrasoundActive)
 {
   m_DisplacementFilter->SetTransform6DOF(true);
 
   this->RebuildFilterPipeline();
 
   // create a new output (for the image data)
   //___ mitk::Image::Pointer newOutput = mitk::Image::New();
   //___ this->SetNthOutput(0, newOutput);
 
   // Combined Modality should not spawn an own acquire thread, because
   // image acquiring is done by the included us device
   //___ m_UltrasoundDevice->SetSpawnAcquireThread(false);
 }
 
 mitk::AffineTransform3D::Pointer mitk::AbstractUltrasoundTrackerDevice::GetUSPlaneTransform()
 {
   return mitk::AffineTransform3D::New();
 }
 
 void mitk::AbstractUltrasoundTrackerDevice::SetIsFreezed(bool freeze)
 {
   if (m_UltrasoundDevice.IsNull() || m_TrackingDeviceDataSource.IsNull())
   {
     MITK_WARN << "Combined modality not correctly initialized, aborting!";
     return;
   }
 
   if (!m_UltrasoundDevice->GetIsActive())
   {
     MITK_WARN("mitkUSDevice")
       << "Cannot freeze or unfreeze if device is not active.";
     return;
   }
 
   this->OnFreeze(freeze);
 
   if (freeze)
   {
     m_IsFreezed = true;
   }
   else
   {
     m_IsFreezed = false;
   }
 }
 
 bool mitk::AbstractUltrasoundTrackerDevice::GetIsFreezed()
 {
   return m_IsFreezed;
 }
 
 mitk::AbstractUltrasoundTrackerDevice::~AbstractUltrasoundTrackerDevice()
 {
   if (m_ServiceRegistration != nullptr)
   {
     m_ServiceRegistration.Unregister();
   }
   m_ServiceRegistration = 0;
 }
 
 mitk::AffineTransform3D::Pointer mitk::AbstractUltrasoundTrackerDevice::GetCalibration()
 {
   return this->GetCalibration(this->GetCurrentDepthValue(), this->GetIdentifierForCurrentProbe());
 }
 
 mitk::AffineTransform3D::Pointer mitk::AbstractUltrasoundTrackerDevice::GetCalibration(std::string depth)
 {
   return this->GetCalibration(depth, this->GetIdentifierForCurrentProbe());
 }
 
 mitk::AffineTransform3D::Pointer mitk::AbstractUltrasoundTrackerDevice::GetCalibration(std::string depth,
                                                                                        std::string probe)
 {
   // make sure that there is no '/' which would cause problems for TinyXML
   std::replace(probe.begin(), probe.end(), '/', '-');
 
   // create identifier for calibration from probe and depth
   std::string calibrationKey = probe + mitk::AbstractUltrasoundTrackerDevice::ProbeAndDepthSeperator + depth;
 
   // find calibration for combination of probe identifier and depth
   std::map<std::string, mitk::AffineTransform3D::Pointer>::iterator calibrationIterator =
     m_Calibrations.find(calibrationKey);
 
   if (calibrationIterator == m_Calibrations.end())
   {
     return nullptr;
   }
 
   return calibrationIterator->second;
 }
 
 void mitk::AbstractUltrasoundTrackerDevice::SetCalibration(mitk::AffineTransform3D::Pointer calibration)
 {
   if (calibration.IsNull())
   {
     MITK_WARN << "Null pointer passed to SetCalibration of mitk::USDevice. Ignoring call.";
     return;
   }
 
   std::string calibrationKey = this->GetIdentifierForCurrentCalibration();
   if (calibrationKey.empty())
   {
     MITK_WARN << "Could not get a key for the calibration -> Calibration cannot be set.";
     return;
   }
 
   m_Calibrations[calibrationKey] = calibration;
 }
 
 bool mitk::AbstractUltrasoundTrackerDevice::RemoveCalibration()
 {
   return this->RemoveCalibration(this->GetCurrentDepthValue(), this->GetIdentifierForCurrentProbe());
 }
 
 bool mitk::AbstractUltrasoundTrackerDevice::RemoveCalibration(std::string depth)
 {
   return this->RemoveCalibration(depth, this->GetIdentifierForCurrentProbe());
 }
 
 bool mitk::AbstractUltrasoundTrackerDevice::RemoveCalibration(std::string depth, std::string probe)
 {
   // make sure that there is no '/' which would cause problems for TinyXML
   std::replace(probe.begin(), probe.end(), '/', '-');
 
   // create identifier for calibration from probe and depth
   std::string calibrationKey = probe + mitk::AbstractUltrasoundTrackerDevice::ProbeAndDepthSeperator + depth;
 
   return m_Calibrations.erase(calibrationKey) > 0;
 }
 
 std::string mitk::AbstractUltrasoundTrackerDevice::GetDeviceClass()
 {
   return DeviceClassIdentifier;
 }
 
 mitk::USImageSource::Pointer mitk::AbstractUltrasoundTrackerDevice::GetUSImageSource()
 {
   if (m_UltrasoundDevice.IsNull())
   {
     MITK_ERROR("AbstractUltrasoundTrackerDevice")("USDevice") << "UltrasoundDevice must not be null.";
     mitkThrow() << "UltrasoundDevice must not be null.";
   }
 
   return m_UltrasoundDevice->GetUSImageSource();
 }
 
 mitk::NavigationDataSource::Pointer mitk::AbstractUltrasoundTrackerDevice::GetNavigationDataSource()
 {
   if (m_LastFilterOfIGTPipeline.IsNull())
   {
     this->RebuildFilterPipeline();
   }
   m_LastFilterOfIGTPipeline->SetToolMetaDataCollection(this->m_TrackingDeviceDataSource->GetToolMetaDataCollection());
   return m_LastFilterOfIGTPipeline;
 }
 
 bool mitk::AbstractUltrasoundTrackerDevice::GetIsCalibratedForCurrentStatus()
 {
   return m_Calibrations.find(this->GetIdentifierForCurrentCalibration()) != m_Calibrations.end();
 }
 
 bool mitk::AbstractUltrasoundTrackerDevice::GetContainsAtLeastOneCalibration()
 {
   return !m_Calibrations.empty();
 }
 
 std::string mitk::AbstractUltrasoundTrackerDevice::SerializeCalibration()
 {
   std::stringstream result;
   result << "<calibrations>" << std::endl;
   // For each calibration in the set
   for (std::map<std::string, mitk::AffineTransform3D::Pointer>::iterator it = m_Calibrations.begin();
        it != m_Calibrations.end();
        it++)
   {
     mitk::AffineTransform3D::MatrixType matrix = it->second->GetMatrix();
     mitk::AffineTransform3D::TranslationType translation = it->second->GetTranslation();
     TiXmlElement elem(it->first);
     // Serialize Matrix
     elem.SetDoubleAttribute("M00", matrix[0][0]);
     elem.SetDoubleAttribute("M01", matrix[0][1]);
     elem.SetDoubleAttribute("M02", matrix[0][2]);
     elem.SetDoubleAttribute("M10", matrix[1][0]);
     elem.SetDoubleAttribute("M11", matrix[1][1]);
     elem.SetDoubleAttribute("M12", matrix[1][2]);
     elem.SetDoubleAttribute("M20", matrix[2][0]);
     elem.SetDoubleAttribute("M21", matrix[2][1]);
     elem.SetDoubleAttribute("M22", matrix[2][2]);
     // Serialize Offset
     elem.SetDoubleAttribute("T0", translation[0]);
     elem.SetDoubleAttribute("T1", translation[1]);
     elem.SetDoubleAttribute("T2", translation[2]);
 
     result << elem << std::endl;
   }
   result << "</calibrations>" << std::endl;
 
   return result.str();
 }
 
 void mitk::AbstractUltrasoundTrackerDevice::DeserializeCalibration(const std::string &xmlString,
                                                                    bool clearPreviousCalibrations)
 {
   // Sanitize Input
   if (xmlString == "")
   {
     MITK_ERROR << "Empty string passed to Deserialize() method of CombinedModality. Aborting...";
     mitkThrow() << "Empty string passed to Deserialize() method of CombinedModality. Aborting...";
     return;
   }
   // Clear previous calibrations if necessary
   if (clearPreviousCalibrations)
     m_Calibrations.clear();
 
   // Parse Input
   TiXmlDocument doc;
   if (!doc.Parse(xmlString.c_str()))
   {
     MITK_ERROR << "Unable to deserialize calibrations in CombinedModality. Error was: " << doc.ErrorDesc();
     mitkThrow() << "Unable to deserialize calibrations in CombinedModality. Error was: " << doc.ErrorDesc();
     return;
   }
   TiXmlElement *root = doc.FirstChildElement();
   if (root == nullptr)
   {
     MITK_ERROR << "Unable to deserialize calibrations in CombinedModality. String contained no root element.";
     mitkThrow() << "Unable to deserialize calibrations in CombinedModality. String contained no root element.";
     return;
   }
   // Read Calibrations
   for (TiXmlElement *elem = root->FirstChildElement(); elem != nullptr; elem = elem->NextSiblingElement())
   {
     mitk::AffineTransform3D::MatrixType matrix;
     mitk::AffineTransform3D::OffsetType translation;
 
     std::string calibName = elem->Value();
 
     // Deserialize Matrix
     elem->QueryDoubleAttribute("M00", &matrix[0][0]);
     elem->QueryDoubleAttribute("M01", &matrix[0][1]);
     elem->QueryDoubleAttribute("M02", &matrix[0][2]);
     elem->QueryDoubleAttribute("M10", &matrix[1][0]);
     elem->QueryDoubleAttribute("M11", &matrix[1][1]);
     elem->QueryDoubleAttribute("M12", &matrix[1][2]);
     elem->QueryDoubleAttribute("M20", &matrix[2][0]);
     elem->QueryDoubleAttribute("M21", &matrix[2][1]);
     elem->QueryDoubleAttribute("M22", &matrix[2][2]);
 
     // Deserialize Offset
     elem->QueryDoubleAttribute("T0", &translation[0]);
     elem->QueryDoubleAttribute("T1", &translation[1]);
     elem->QueryDoubleAttribute("T2", &translation[2]);
 
     mitk::AffineTransform3D::Pointer calibration = mitk::AffineTransform3D::New();
     calibration->SetMatrix(matrix);
     calibration->SetTranslation(translation);
     m_Calibrations[calibName] = calibration;
   }
 }
 
 void mitk::AbstractUltrasoundTrackerDevice::SetNumberOfSmoothingValues(unsigned int numberOfSmoothingValues)
 {
   unsigned int oldNumber = m_NumberOfSmoothingValues;
   m_NumberOfSmoothingValues = numberOfSmoothingValues;
 
   // if filter should be activated or deactivated
   if ((oldNumber == 0 && numberOfSmoothingValues != 0) || (oldNumber != 0 && numberOfSmoothingValues == 0))
   {
     this->RebuildFilterPipeline();
   }
   m_SmoothingFilter->SetNumerOfValues(numberOfSmoothingValues);
 }
 
 void mitk::AbstractUltrasoundTrackerDevice::SetDelayCount(unsigned int delayCount)
 {
   unsigned int oldCount = m_DelayCount;
   m_DelayCount = delayCount;
 
   // if filter should be activated or deactivated
   if ((oldCount == 0 && delayCount != 0) || (oldCount != 0 && delayCount == 0))
   {
     this->RebuildFilterPipeline();
   }
   m_DelayFilter->SetDelay(delayCount);
 }
 
 void mitk::AbstractUltrasoundTrackerDevice::GenerateData() {}
 
 std::string mitk::AbstractUltrasoundTrackerDevice::GetIdentifierForCurrentCalibration()
 {
   return this->GetIdentifierForCurrentProbe() + mitk::AbstractUltrasoundTrackerDevice::ProbeAndDepthSeperator +
          this->GetCurrentDepthValue();
 }
 
 std::string mitk::AbstractUltrasoundTrackerDevice::GetIdentifierForCurrentProbe()
 {
   us::ServiceProperties usdeviceProperties = m_UltrasoundDevice->GetServiceProperties();
 
   us::ServiceProperties::const_iterator probeIt =
     usdeviceProperties.find(mitk::USDevice::GetPropertyKeys().US_PROPKEY_PROBES_SELECTED);
 
   // get probe identifier from control interface for probes
   std::string probeName = mitk::AbstractUltrasoundTrackerDevice::DefaultProbeIdentifier;
   if (probeIt != usdeviceProperties.end())
   {
     probeName = (probeIt->second).ToString();
   }
 
   // make sure that there is no '/' which would cause problems for TinyXML
   std::replace(probeName.begin(), probeName.end(), '/', '-');
 
   return probeName;
 }
 
 std::string mitk::AbstractUltrasoundTrackerDevice::GetCurrentDepthValue()
 {
   us::ServiceProperties usdeviceProperties = m_UltrasoundDevice->GetServiceProperties();
 
   // get string for depth value from the micro service properties
   std::string depth;
   us::ServiceProperties::iterator depthIterator =
     usdeviceProperties.find(mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_DEPTH);
 
   if (depthIterator != usdeviceProperties.end())
   {
     depth = depthIterator->second.ToString();
   }
   else
   {
     depth = "0";
   }
 
   return depth;
 }
 
 void mitk::AbstractUltrasoundTrackerDevice::RebuildFilterPipeline()
 {
   m_LastFilterOfIGTPipeline = m_TrackingDeviceDataSource;
 
   if (m_NumberOfSmoothingValues > 0)
   {
     m_SmoothingFilter->ConnectTo(m_LastFilterOfIGTPipeline.GetPointer());
     m_LastFilterOfIGTPipeline = m_SmoothingFilter;
   }
 
   if (m_DelayCount > 0)
   {
     m_DelayFilter->ConnectTo(m_LastFilterOfIGTPipeline.GetPointer());
     m_LastFilterOfIGTPipeline = m_DelayFilter;
   }
 
   if (m_IsTrackedUltrasoundActive)
   {
     m_DisplacementFilter->ConnectTo(m_LastFilterOfIGTPipeline.GetPointer());
     m_LastFilterOfIGTPipeline = m_DisplacementFilter;
   }
 }
 
 void mitk::AbstractUltrasoundTrackerDevice::UnregisterOnService()
 {
   if (m_UltrasoundDevice->GetDeviceState() == USDevice::State_Activated)
   {
     m_UltrasoundDevice->Deactivate();
   }
   if (m_UltrasoundDevice->GetDeviceState() == USDevice::State_Connected)
   {
     m_UltrasoundDevice->Disconnect();
   }
 
   if (m_ServiceRegistration != nullptr)
     m_ServiceRegistration.Unregister();
   m_ServiceRegistration = 0;
 }
 
 void mitk::AbstractUltrasoundTrackerDevice::RegisterAsMicroservice()
 {
   // Get Context
   us::ModuleContext *context = us::GetModuleContext();
 
   // Define ServiceProps
   // us::ServiceProperties props;
-  mitk::UIDGenerator uidGen = mitk::UIDGenerator("org.mitk.services.AbstractUltrasoundTrackerDevice", 16);
+  mitk::UIDGenerator uidGen = mitk::UIDGenerator("org.mitk.services.AbstractUltrasoundTrackerDevice");
   m_ServiceProperties[US_PROPKEY_ID] = uidGen.GetUID();
   m_ServiceProperties[US_PROPKEY_DEVICENAME] = m_UltrasoundDevice->GetName();
   m_ServiceProperties[US_PROPKEY_CLASS] = mitk::AbstractUltrasoundTrackerDevice::DeviceClassIdentifier;
 
   m_ServiceRegistration = context->RegisterService(this, m_ServiceProperties);
 }
 
 mitk::USAbstractControlInterface::Pointer mitk::AbstractUltrasoundTrackerDevice::GetControlInterfaceCustom()
 {
   if (m_UltrasoundDevice.IsNull())
   {
     MITK_ERROR("USCombinedModality")("USDevice") << "UltrasoundDevice must not be null.";
     mitkThrow() << "UltrasoundDevice must not be null.";
   }
 
   return m_UltrasoundDevice->GetControlInterfaceCustom();
 }
 
 mitk::USControlInterfaceBMode::Pointer mitk::AbstractUltrasoundTrackerDevice::GetControlInterfaceBMode()
 {
   if (m_UltrasoundDevice.IsNull())
   {
     MITK_ERROR("USCombinedModality")("USDevice") << "UltrasoundDevice must not be null.";
     mitkThrow() << "UltrasoundDevice must not be null.";
   }
 
   return m_UltrasoundDevice->GetControlInterfaceBMode();
 }
 
 mitk::USControlInterfaceProbes::Pointer mitk::AbstractUltrasoundTrackerDevice::GetControlInterfaceProbes()
 {
   if (m_UltrasoundDevice.IsNull())
   {
     MITK_ERROR("USCombinedModality")("USDevice") << "UltrasoundDevice must not be null.";
     mitkThrow() << "UltrasoundDevice must not be null.";
   }
 
   return m_UltrasoundDevice->GetControlInterfaceProbes();
 }
 
 mitk::USControlInterfaceDoppler::Pointer mitk::AbstractUltrasoundTrackerDevice::GetControlInterfaceDoppler()
 {
   if (m_UltrasoundDevice.IsNull())
   {
     MITK_ERROR("USCombinedModality")("USDevice") << "UltrasoundDevice must not be null.";
     mitkThrow() << "UltrasoundDevice must not be null.";
   }
 
   return m_UltrasoundDevice->GetControlInterfaceDoppler();
 }