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..bfe738fb41 100644
--- a/Modules/PhotoacousticsLib/MitkPAPhantomGenerator/PAPhantomGenerator.cpp
+++ b/Modules/PhotoacousticsLib/MitkPAPhantomGenerator/PAPhantomGenerator.cpp
@@ -1,226 +1,226 @@
 /*============================================================================
 
 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);
+    auto uid = mitk::UIDGenerator("");
     input.identifyer = uid.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..943441e1f0 100644
--- a/Modules/PhotoacousticsLib/MitkTissueBatchGenerator/TissueBatchGenerator.cpp
+++ b/Modules/PhotoacousticsLib/MitkTissueBatchGenerator/TissueBatchGenerator.cpp
@@ -1,390 +1,390 @@
 /*============================================================================
 
 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);
+    auto uid = mitk::UIDGenerator("");
     input.identifyer = uid.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/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();
 }