diff --git a/Modules/IGT/Algorithms/mitkNavigationDataToIGTLMessageFilter.cpp b/Modules/IGT/Algorithms/mitkNavigationDataToIGTLMessageFilter.cpp
index 345fd6ddfe..6d407eb210 100644
--- a/Modules/IGT/Algorithms/mitkNavigationDataToIGTLMessageFilter.cpp
+++ b/Modules/IGT/Algorithms/mitkNavigationDataToIGTLMessageFilter.cpp
@@ -1,344 +1,350 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkNavigationDataToIGTLMessageFilter.h"
 
 #include "igtlQuaternionTrackingDataMessage.h"
 #include "igtlTrackingDataMessage.h"
 #include "igtlTransformMessage.h"
 #include "igtlPositionMessage.h"
 
 #include <mitkInteractionConst.h>
 #include <itksys/SystemTools.hxx>
 
 mitk::NavigationDataToIGTLMessageFilter::NavigationDataToIGTLMessageFilter()
 {
   mitk::IGTLMessage::Pointer output = mitk::IGTLMessage::New();
   this->SetNumberOfRequiredOutputs(1);
   this->SetNthOutput(0, output.GetPointer());
 
   this->SetNumberOfRequiredInputs(1);
 
 //  m_OperationMode = Mode3D;
   m_CurrentTimeStep = 0;
 //  m_RingBufferSize = 50; //the default ring buffer size
 //  m_NumberForMean = 100;
 }
 
 mitk::NavigationDataToIGTLMessageFilter::~NavigationDataToIGTLMessageFilter()
 {
 }
 
 void mitk::NavigationDataToIGTLMessageFilter::GenerateData()
 {
   switch (m_OperationMode)
   {
   case ModeSendQTDataMsg:
     this->GenerateDataModeSendQTDataMsg();
     break;
   case ModeSendTDataMsg:
     this->GenerateDataModeSendTDataMsg();
     break;
   case ModeSendQTransMsg:
     this->GenerateDataModeSendQTransMsg();
     break;
   case ModeSendTransMsg:
     this->GenerateDataModeSendTransMsg();
     break;
   default:
     break;
   }
 }
 
 
 void mitk::NavigationDataToIGTLMessageFilter::SetInput(const NavigationData* nd)
 {
   // Process object is not const-correct so the const_cast is required here
   this->ProcessObject::SetNthInput(0, const_cast<NavigationData*>(nd));
   this->CreateOutputsForAllInputs();
 }
 
 
 void mitk::NavigationDataToIGTLMessageFilter::SetInput(unsigned int idx, const NavigationData* nd)
 {
   // Process object is not const-correct so the const_cast is required here
   this->ProcessObject::SetNthInput(idx, const_cast<NavigationData*>(nd));
   this->CreateOutputsForAllInputs();
 }
 
 
 const mitk::NavigationData* mitk::NavigationDataToIGTLMessageFilter::GetInput( void )
 {
   if (this->GetNumberOfInputs() < 1)
     return NULL;
   return static_cast<const NavigationData*>(this->ProcessObject::GetInput(0));
 }
 
 
 const mitk::NavigationData* mitk::NavigationDataToIGTLMessageFilter::GetInput( unsigned int idx )
 {
   if (this->GetNumberOfInputs() < 1)
     return NULL;
   return static_cast<const NavigationData*>(this->ProcessObject::GetInput(idx));
 }
 
 
 void mitk::NavigationDataToIGTLMessageFilter::CreateOutputsForAllInputs()
 {
   switch (m_OperationMode)
   {
   case ModeSendQTDataMsg:
     // create one message output for all navigation data inputs
     this->SetNumberOfIndexedOutputs(this->GetNumberOfIndexedInputs());
     // set the type for this filter
     this->SetType("QTDATA");
     break;
   case ModeSendTDataMsg:
     // create one message output for all navigation data inputs
     this->SetNumberOfIndexedOutputs(this->GetNumberOfIndexedInputs());
     // set the type for this filter
     this->SetType("TDATA");
     break;
   case ModeSendQTransMsg:
     // create one message output for all navigation data input together
     this->SetNumberOfIndexedOutputs(this->GetNumberOfIndexedInputs());
     // set the type for this filter
     this->SetType("POSITION");
     break;
   case ModeSendTransMsg:
     // create one message output for all navigation data input together
     this->SetNumberOfIndexedOutputs(this->GetNumberOfIndexedInputs());
     // set the type for this filter
     this->SetType("TRANS");
     break;
   default:
     break;
   }
 
   for (unsigned int idx = 0; idx < this->GetNumberOfIndexedOutputs(); ++idx)
   {
     if (this->GetOutput(idx) == NULL)
     {
       DataObjectPointer newOutput = this->MakeOutput(idx);
       this->SetNthOutput(idx, newOutput);
     }
     this->Modified();
   }
 }
 
 
 void ConvertAffineTransformationIntoIGTLMatrix(mitk::AffineTransform3D* trans,
                                                igtl::Matrix4x4 igtlTransform)
 {
   const mitk::AffineTransform3D::MatrixType& matrix = trans->GetMatrix();
   mitk::Vector3D position = trans->GetOffset();
   //copy the data into a matrix type that igtl understands
   for ( unsigned int r = 0; r < 3; r++ )
   {
     for ( unsigned int c = 0; c < 3; c++ )
     {
       igtlTransform[r][c] = matrix(r,c);
     }
     igtlTransform[r][3] = position[r];
   }
   for ( unsigned int c = 0; c < 3; c++ )
   {
     igtlTransform[3][c] = 0.0;
   }
   igtlTransform[3][3] = 1.0;
 }
 
 void mitk::NavigationDataToIGTLMessageFilter::GenerateDataModeSendQTransMsg()
 {
   // for each output message
   for (unsigned int i = 0; i < this->GetNumberOfIndexedOutputs() ; ++i)
   {
     mitk::IGTLMessage* output = this->GetOutput(i);
     assert(output);
     const mitk::NavigationData* input = this->GetInput(i);
     assert(input);
     // do not add navigation data to message if input is invalid
     if (input->IsDataValid() == false)
       continue;
 
     //get the navigation data components
     mitk::NavigationData::PositionType pos = input->GetPosition();
     mitk::NavigationData::OrientationType ori = input->GetOrientation();
 
     //insert this information into the message
     igtl::PositionMessage::Pointer posMsg = igtl::PositionMessage::New();
     posMsg->SetPosition(pos[0], pos[1], pos[2]);
     posMsg->SetQuaternion(ori[0], ori[1], ori[2], ori[3]);
     posMsg->SetTimeStamp((unsigned int)input->GetIGTTimeStamp(), 0);
     posMsg->SetDeviceName(input->GetName());
     posMsg->Pack();
 
     //add the igtl message to the mitk::IGTLMessage
     output->SetMessage(posMsg.GetPointer());
   }
 }
 
 void mitk::NavigationDataToIGTLMessageFilter::GenerateDataModeSendTransMsg()
 {
   // for each output message
   for (unsigned int i = 0; i < this->GetNumberOfIndexedOutputs() ; ++i)
   {
     mitk::IGTLMessage* output = this->GetOutput(i);
     assert(output);
     const mitk::NavigationData* input = this->GetInput(i);
     assert(input);
     // do not add navigation data to message if input is invalid
     if (input->IsDataValid() == false)
       continue;
 
     //get the navigation data components
     mitk::AffineTransform3D::Pointer transform = input->GetAffineTransform3D();
     mitk::NavigationData::PositionType position = transform->GetOffset();
 
     //convert the transform into a igtl type
     igtl::Matrix4x4 igtlTransform;
     ConvertAffineTransformationIntoIGTLMatrix(transform, igtlTransform);
 
     //insert this information into the message
     igtl::TransformMessage::Pointer transMsg = igtl::TransformMessage::New();
     transMsg->SetMatrix(igtlTransform);
     transMsg->SetPosition(position[0], position[1], position[2]);
     transMsg->SetTimeStamp((unsigned int)input->GetIGTTimeStamp(), 0);
     transMsg->SetDeviceName(input->GetName());
     transMsg->Pack();
 
     //add the igtl message to the mitk::IGTLMessage
     output->SetMessage(transMsg.GetPointer());
   }
 }
 
 void mitk::NavigationDataToIGTLMessageFilter::GenerateDataModeSendQTDataMsg()
 {
   mitk::IGTLMessage* output = this->GetOutput();
   assert(output);
 
   //create a output igtl message
   igtl::QuaternionTrackingDataMessage::Pointer qtdMsg =
       igtl::QuaternionTrackingDataMessage::New();
 
   mitk::NavigationData::PositionType pos;
   mitk::NavigationData::OrientationType ori;
 
   for (unsigned int index = 0; index < this->GetNumberOfIndexedInputs(); index++)
   {
     const mitk::NavigationData* nd = GetInput(index);
     assert(nd);
 
     //get the navigation data components
     pos = nd->GetPosition();
     ori = nd->GetOrientation();
 
     //insert the information into the tracking element
     igtl::QuaternionTrackingDataElement::Pointer tde =
         igtl::QuaternionTrackingDataElement::New();
     tde->SetPosition(pos[0], pos[1], pos[2]);
     tde->SetQuaternion(ori[0], ori[1], ori[2], ori[3]);
     tde->SetName(nd->GetName());
 
     //insert this element into the tracking data message
     qtdMsg->AddQuaternionTrackingDataElement(tde);
 
     //copy the time stamp
     //todo find a better way to do that
     qtdMsg->SetTimeStamp((unsigned int)nd->GetIGTTimeStamp(), 0);
   }
   qtdMsg->Pack();
 
   //add the igtl message to the mitk::IGTLMessage
   output->SetMessage(qtdMsg.GetPointer());
 }
 
 void mitk::NavigationDataToIGTLMessageFilter::GenerateDataModeSendTDataMsg()
 {
   bool isValidData = true;
   mitk::IGTLMessage* output = this->GetOutput();
   assert(output);
 
   //create a output igtl message
   igtl::TrackingDataMessage::Pointer tdMsg = igtl::TrackingDataMessage::New();
 
   mitk::AffineTransform3D::Pointer transform;
   Vector3D position;
   igtl::Matrix4x4 igtlTransform;
   vnl_matrix_fixed<ScalarType, 3, 3> rotationMatrix;
   vnl_matrix_fixed<ScalarType, 3, 3> rotationMatrixTransposed;
 
   for (unsigned int index = 0; index < this->GetNumberOfIndexedInputs(); index++)
   {
     const mitk::NavigationData* nd = GetInput(index);
     assert(nd);
 
     //create a new tracking element
     igtl::TrackingDataElement::Pointer tde = igtl::TrackingDataElement::New();
 
     //get the navigation data components
     transform = nd->GetAffineTransform3D();
     position = transform->GetOffset();
 
     //check the rotation matrix
     rotationMatrix = transform->GetMatrix().GetVnlMatrix();
     rotationMatrixTransposed = rotationMatrix.transpose();
     // a quadratic matrix is a rotation matrix exactly when determinant is 1
     // and transposed is inverse
     if (!Equal(1.0, vnl_det(rotationMatrix), 0.1)
         || !((rotationMatrix*rotationMatrixTransposed).is_identity(0.1)))
     {
       //the rotation matrix is not valid! => invalidate the current element
       isValidData = false;
     }
 
     //convert the transform into a igtl type
     ConvertAffineTransformationIntoIGTLMatrix(transform, igtlTransform);
 
     //fill the tracking element with life
     tde->SetMatrix(igtlTransform);
     tde->SetPosition(position[0], position[1], position[2]);
-    tde->SetName(nd->GetName());
+    std::stringstream name;
+    name << nd->GetName();
+    if (name.rdbuf()->in_avail() == 0 )
+    {
+       name << "TrackingTool" << index;
+    }
+    tde->SetName(name.str().c_str());
 
     //insert this element into the tracking data message
     tdMsg->AddTrackingDataElement(tde);
 
     //copy the time stamp
     //todo find a better way to do that
     tdMsg->SetTimeStamp((unsigned int)nd->GetIGTTimeStamp(), 0);
   }
   tdMsg->Pack();
   //add the igtl message to the mitk::IGTLMessage
   output->SetMessage(tdMsg.GetPointer());
   output->SetDataValid(isValidData);
 }
 
 void mitk::NavigationDataToIGTLMessageFilter::SetOperationMode( OperationMode mode )
 {
   m_OperationMode = mode;
   this->Modified();
   this->CreateOutputsForAllInputs();
 }
 
 void mitk::NavigationDataToIGTLMessageFilter::ConnectTo(
     mitk::NavigationDataSource* UpstreamFilter)
 {
   for (DataObjectPointerArraySizeType i = 0;
        i < UpstreamFilter->GetNumberOfOutputs(); i++)
   {
     this->SetInput(i, UpstreamFilter->GetOutput(i));
   }
 }
diff --git a/Modules/IGT/DataManagement/mitkTrackingDeviceSourceConfigurator.cpp b/Modules/IGT/DataManagement/mitkTrackingDeviceSourceConfigurator.cpp
index c7438fc094..695a22b722 100644
--- a/Modules/IGT/DataManagement/mitkTrackingDeviceSourceConfigurator.cpp
+++ b/Modules/IGT/DataManagement/mitkTrackingDeviceSourceConfigurator.cpp
@@ -1,348 +1,348 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkTrackingDeviceSourceConfigurator.h"
 
 #include "mitkNDITrackingDevice.h"
 #include "mitkClaronTrackingDevice.h"
 #include "mitkOptitrackTrackingDevice.h"
 #include "mitkOpenIGTLinkTrackingDevice.h"
 #include "mitkVirtualTrackingDevice.h"
 
 #include <mitkIGTException.h>
 #include <mitkIGTHardwareException.h>
 
 
 mitk::TrackingDeviceSourceConfigurator::TrackingDeviceSourceConfigurator(mitk::NavigationToolStorage::Pointer NavigationTools, mitk::TrackingDevice::Pointer TrackingDevice)
 {
 //make a copy of the navigation tool storage because we will modify the storage
 if (NavigationTools.IsNotNull())
   {
   m_NavigationTools = mitk::NavigationToolStorage::New();
   for (int i=0; i<NavigationTools->GetToolCount(); i++)
       {
       m_NavigationTools->AddTool(NavigationTools->GetTool(i));
       }
   }
 
 m_TrackingDevice = TrackingDevice;
 m_ToolCorrespondencesInToolStorage = std::vector<int>();
 m_ErrorMessage = "";
 }
 
 mitk::NavigationToolStorage::Pointer mitk::TrackingDeviceSourceConfigurator::GetUpdatedNavigationToolStorage()
 {
 return m_NavigationTools;
 }
 
 
 mitk::TrackingDeviceSourceConfigurator::~TrackingDeviceSourceConfigurator()
 {
 }
 
 bool mitk::TrackingDeviceSourceConfigurator::IsCreateTrackingDeviceSourcePossible()
 {
 if (m_NavigationTools.IsNull())
   {
   m_ErrorMessage = "NavigationToolStorage is NULL!";
   return false;
   }
 else if (m_TrackingDevice.IsNull())
   {
   m_ErrorMessage = "TrackingDevice is NULL!";
   return false;
   }
 else
   {
   for (int i=0; i<m_NavigationTools->GetToolCount(); i++)
     {
     if (m_NavigationTools->GetTool(i)->GetTrackingDeviceType() != m_TrackingDevice->GetType())
       {
       m_ErrorMessage = "At least one tool is not of the same type like the tracking device.";
       return false;
       }
     }
   //TODO in case of Aurora: check if the tools are automatically detected by comparing the serial number
   return true;
   }
 }
 
 mitk::TrackingDeviceSource::Pointer mitk::TrackingDeviceSourceConfigurator::CreateTrackingDeviceSource()
 {
 mitk::NavigationDataObjectVisualizationFilter::Pointer dummy; //this dummy is lost directly after creating the device
 return this->CreateTrackingDeviceSource(dummy);
 }
 
 mitk::TrackingDeviceSource::Pointer mitk::TrackingDeviceSourceConfigurator::CreateTrackingDeviceSource(mitk::NavigationDataObjectVisualizationFilter::Pointer &visualizationFilter)
 {
   if (!this->IsCreateTrackingDeviceSourcePossible()) {MITK_WARN << "Cannot create tracking decive: " << m_ErrorMessage; return NULL;}
 
   mitk::TrackingDeviceSource::Pointer returnValue;
 
   //create tracking device source
   if (m_TrackingDevice->GetType()==mitk::NDIAurora) {returnValue = CreateNDIAuroraTrackingDeviceSource(m_TrackingDevice,m_NavigationTools);}
   else if (m_TrackingDevice->GetType()==mitk::NDIPolaris) {returnValue = CreateNDIPolarisTrackingDeviceSource(m_TrackingDevice,m_NavigationTools);}
   else if (m_TrackingDevice->GetType()==mitk::ClaronMicron) {returnValue = CreateMicronTrackerTrackingDeviceSource(m_TrackingDevice,m_NavigationTools);}
   else if (m_TrackingDevice->GetType()==mitk::NPOptitrack) {returnValue = CreateNPOptitrackTrackingDeviceSource(m_TrackingDevice,m_NavigationTools);}
   else if (m_TrackingDevice->GetType()==mitk::VirtualTracker) {returnValue = CreateVirtualTrackingDeviceSource(m_TrackingDevice,m_NavigationTools);}
   else if (m_TrackingDevice->GetType()==mitk::OpenIGTLinkTrackingDeviceConnection) {returnValue = CreateOpenIGTLinkTrackingDeviceSource(m_TrackingDevice,m_NavigationTools);}
   //TODO: insert other tracking systems?
   if (returnValue.IsNull()) {MITK_WARN << "Cannot create tracking decive: " << m_ErrorMessage; return NULL;}
 
   //create visualization filter
   visualizationFilter = CreateNavigationDataObjectVisualizationFilter(returnValue,m_NavigationTools);
   if (visualizationFilter.IsNull()) {MITK_WARN << "Cannot create tracking decive: " << m_ErrorMessage; return NULL;}
 
   return returnValue;
 }
 
 std::string mitk::TrackingDeviceSourceConfigurator::GetErrorMessage()
 {
   return this->m_ErrorMessage;
 }
 
 //############################ internal help methods ########################################
 
 mitk::TrackingDeviceSource::Pointer mitk::TrackingDeviceSourceConfigurator::CreateNDIPolarisTrackingDeviceSource(mitk::TrackingDevice::Pointer trackingDevice, mitk::NavigationToolStorage::Pointer navigationTools)
   {
   mitk::TrackingDeviceSource::Pointer returnValue = mitk::TrackingDeviceSource::New();
   mitk::NDITrackingDevice::Pointer thisDevice = dynamic_cast<mitk::NDITrackingDevice*>(trackingDevice.GetPointer());
   m_ToolCorrespondencesInToolStorage = std::vector<int>();
   //add the tools to the tracking device
   for (int i=0; i<navigationTools->GetToolCount(); i++)
       {
         mitk::NavigationTool::Pointer thisNavigationTool = m_NavigationTools->GetTool(i);
         m_ToolCorrespondencesInToolStorage.push_back(i);
         bool toolAddSuccess = thisDevice->AddTool(thisNavigationTool->GetToolName().c_str(),thisNavigationTool->GetCalibrationFile().c_str());
         if (!toolAddSuccess)
           {
           //todo: error handling
           this->m_ErrorMessage = "Can't add tool, is the SROM-file valid?";
           return NULL;
           }
         thisDevice->GetTool(i)->SetToolTip(thisNavigationTool->GetToolTipPosition(),thisNavigationTool->GetToolTipOrientation());
       }
   returnValue->SetTrackingDevice(thisDevice);
   return returnValue;
   }
 
 mitk::TrackingDeviceSource::Pointer mitk::TrackingDeviceSourceConfigurator::CreateNDIAuroraTrackingDeviceSource(mitk::TrackingDevice::Pointer trackingDevice, mitk::NavigationToolStorage::Pointer navigationTools)
   {
   MITK_DEBUG << "Creating Aurora tracking device.";
   mitk::TrackingDeviceSource::Pointer returnValue = mitk::TrackingDeviceSource::New();
   mitk::NDITrackingDevice::Pointer thisDevice = dynamic_cast<mitk::NDITrackingDevice*>(trackingDevice.GetPointer());
 
   try
   {
     //connect to aurora to dectect tools automatically
     thisDevice->OpenConnection();
   }
   catch (mitk::IGTHardwareException& e)
   {
     m_ErrorMessage = std::string("Hardware error on opening the connection (") + e.GetDescription() + ")";
     return NULL;
   }
   catch (mitk::IGTException& e)
   {
     m_ErrorMessage = std::string("Error on opening the connection (") + e.GetDescription() + ")";
     return NULL;
   }
 
   //now search for automatically detected tools in the tool storage and save them
   mitk::NavigationToolStorage::Pointer newToolStorageInRightOrder = mitk::NavigationToolStorage::New();
   std::vector<int> alreadyFoundTools = std::vector<int>();
   m_ToolCorrespondencesInToolStorage = std::vector<int>();
   for (unsigned int i=0; i<thisDevice->GetToolCount(); i++)
       {
       bool toolFound = false;
       for (int j=0; j<navigationTools->GetToolCount(); j++)
         {
           //check if the serial number is the same to identify the tool
           if ((dynamic_cast<mitk::NDIPassiveTool*>(thisDevice->GetTool(i)))->GetSerialNumber() == navigationTools->GetTool(j)->GetSerialNumber())
             {
             //check if this tool was already added to make sure that every tool is only added once (in case of same serial numbers)
             bool toolAlreadyAdded = false;
             for(unsigned int k=0; k<alreadyFoundTools.size(); k++) if (alreadyFoundTools.at(k) == j) toolAlreadyAdded = true;
 
             if(!toolAlreadyAdded)
               {
               //add tool in right order
               newToolStorageInRightOrder->AddTool(navigationTools->GetTool(j));
               m_ToolCorrespondencesInToolStorage.push_back(j);
               //adapt name of tool
               dynamic_cast<mitk::NDIPassiveTool*>(thisDevice->GetTool(i))->SetToolName(navigationTools->GetTool(j)->GetToolName());
               //set tip of tool
               dynamic_cast<mitk::NDIPassiveTool*>(thisDevice->GetTool(i))->SetToolTip(navigationTools->GetTool(j)->GetToolTipPosition(),navigationTools->GetTool(j)->GetToolTipOrientation());
               //rember that this tool was already found
               alreadyFoundTools.push_back(j);
 
               toolFound = true;
               break;
               }
             }
         }
       if (!toolFound)
         {
         this->m_ErrorMessage = "Error: did not find every automatically detected tool in the loaded tool storage: aborting initialization.";
         return NULL;
         }
       }
 
   //delete all tools from the tool storage
   navigationTools->DeleteAllTools();
 
   //and add only the detected tools in the right order
   for (int i=0; i<newToolStorageInRightOrder->GetToolCount(); i++)
       {
       navigationTools->AddTool(newToolStorageInRightOrder->GetTool(i));
       }
   returnValue->SetTrackingDevice(thisDevice);
   MITK_DEBUG << "Number of tools of created tracking device: " << thisDevice->GetToolCount();
   MITK_DEBUG << "Number of outputs of created source: " << returnValue->GetNumberOfOutputs();
   return returnValue;
   }
 
 mitk::TrackingDeviceSource::Pointer mitk::TrackingDeviceSourceConfigurator::CreateOpenIGTLinkTrackingDeviceSource(mitk::TrackingDevice::Pointer trackingDevice, mitk::NavigationToolStorage::Pointer navigationTools)
 {
   mitk::TrackingDeviceSource::Pointer returnValue = mitk::TrackingDeviceSource::New();
   mitk::OpenIGTLinkTrackingDevice::Pointer thisDevice = dynamic_cast<mitk::OpenIGTLinkTrackingDevice*>(trackingDevice.GetPointer());
   thisDevice->DiscoverTools();
   if (thisDevice->GetToolCount() != navigationTools->GetToolCount())
     {
     this->m_ErrorMessage = "The number of tools in the connected device differs from the tool storage, cannot add tools.";
     return NULL;
     }
   returnValue->SetTrackingDevice(thisDevice);
   return returnValue;
 }
 
 mitk::TrackingDeviceSource::Pointer mitk::TrackingDeviceSourceConfigurator::CreateMicronTrackerTrackingDeviceSource(mitk::TrackingDevice::Pointer trackingDevice, mitk::NavigationToolStorage::Pointer navigationTools)
   {
   mitk::TrackingDeviceSource::Pointer returnValue = mitk::TrackingDeviceSource::New();
   mitk::ClaronTrackingDevice::Pointer thisDevice = dynamic_cast<mitk::ClaronTrackingDevice*>(trackingDevice.GetPointer());
   m_ToolCorrespondencesInToolStorage = std::vector<int>();
   //add the tools to the tracking device
   for (int i=0; i<navigationTools->GetToolCount(); i++)
       {
         mitk::NavigationTool::Pointer thisNavigationTool = m_NavigationTools->GetTool(i);
         m_ToolCorrespondencesInToolStorage.push_back(i);
         bool toolAddSuccess = thisDevice->AddTool(thisNavigationTool->GetToolName().c_str(),thisNavigationTool->GetCalibrationFile().c_str());
         if (!toolAddSuccess)
           {
           //todo error handling
           this->m_ErrorMessage = "Can't add tool, is the toolfile valid?";
           return NULL;
           }
         thisDevice->GetTool(i)->SetToolTip(thisNavigationTool->GetToolTipPosition(),thisNavigationTool->GetToolTipOrientation());
       }
   returnValue->SetTrackingDevice(thisDevice);
   return returnValue;
   }
 
 
 mitk::TrackingDeviceSource::Pointer mitk::TrackingDeviceSourceConfigurator::CreateNPOptitrackTrackingDeviceSource(mitk::TrackingDevice::Pointer trackingDevice, mitk::NavigationToolStorage::Pointer navigationTools)
   {
   mitk::TrackingDeviceSource::Pointer returnValue = mitk::TrackingDeviceSource::New();
   mitk::OptitrackTrackingDevice::Pointer thisDevice = dynamic_cast<mitk::OptitrackTrackingDevice*>(trackingDevice.GetPointer());
   m_ToolCorrespondencesInToolStorage = std::vector<int>();
 
   //OpenConnection with Optitrack
   thisDevice->OpenConnection();
 
 
   //add the tools to the tracking device
   for (int i=0; i<navigationTools->GetToolCount(); i++)
       {
         mitk::NavigationTool::Pointer thisNavigationTool = m_NavigationTools->GetTool(i);
         m_ToolCorrespondencesInToolStorage.push_back(i);
     bool toolAddSuccess = thisDevice->AddToolByDefinitionFile(thisNavigationTool->GetCalibrationFile());
     thisDevice->GetOptitrackTool(i)->SetToolName(thisNavigationTool->GetToolName().c_str());
         if (!toolAddSuccess)
           {
           //todo error handling
           this->m_ErrorMessage = "Can't add tool, is the toolfile valid?";
           return NULL;
           }
         //thisDevice->GetTool(i)->SetToolTip(thisNavigationTool->GetToolTipPosition(),thisNavigationTool->GetToolTipOrientation());
       }
   returnValue->SetTrackingDevice(thisDevice);
   return returnValue;
   }
 
 mitk::TrackingDeviceSource::Pointer mitk::TrackingDeviceSourceConfigurator::CreateVirtualTrackingDeviceSource(mitk::TrackingDevice::Pointer trackingDevice, mitk::NavigationToolStorage::Pointer navigationTools)
   {
   mitk::TrackingDeviceSource::Pointer returnValue = mitk::TrackingDeviceSource::New();
   mitk::VirtualTrackingDevice::Pointer thisDevice = dynamic_cast<mitk::VirtualTrackingDevice*>(trackingDevice.GetPointer());
   m_ToolCorrespondencesInToolStorage = std::vector<int>();
 
   //add the tools to the tracking device
   for (int i=0; i<navigationTools->GetToolCount(); i++)
       {
         mitk::NavigationTool::Pointer thisNavigationTool = m_NavigationTools->GetTool(i);
         m_ToolCorrespondencesInToolStorage.push_back(i);
         bool toolAddSuccess = thisDevice->AddTool(thisNavigationTool->GetToolName().c_str());
         if (!toolAddSuccess)
           {
           //todo error handling
           this->m_ErrorMessage = "Can't add tool, is the toolfile valid?";
           return NULL;
           }
       }
   returnValue->SetTrackingDevice(thisDevice);
   return returnValue;
   }
 
 mitk::NavigationDataObjectVisualizationFilter::Pointer mitk::TrackingDeviceSourceConfigurator::CreateNavigationDataObjectVisualizationFilter(mitk::TrackingDeviceSource::Pointer trackingDeviceSource, mitk::NavigationToolStorage::Pointer navigationTools)
   {
   mitk::NavigationDataObjectVisualizationFilter::Pointer returnValue = mitk::NavigationDataObjectVisualizationFilter::New();
   for (unsigned int i=0; i<trackingDeviceSource->GetNumberOfIndexedOutputs(); i++)
     {
     mitk::NavigationTool::Pointer currentTool = navigationTools->GetToolByName(trackingDeviceSource->GetOutput(i)->GetName());
     if (currentTool.IsNull())
       {
-      this->m_ErrorMessage = "Error: did not find correspondig tool in tracking device after initialization.";
+      this->m_ErrorMessage = "Error: did not find corresponding tool in tracking device after initialization.";
       return NULL;
       }
     returnValue->SetInput(i,trackingDeviceSource->GetOutput(i));
     returnValue->SetRepresentationObject(i,currentTool->GetDataNode()->GetData());
     }
   return returnValue;
   }
 
 int mitk::TrackingDeviceSourceConfigurator::GetToolNumberInToolStorage(unsigned int outputID)
   {
   if (outputID < m_ToolCorrespondencesInToolStorage.size()) return m_ToolCorrespondencesInToolStorage.at(outputID);
   else return -1;
   }
 
 std::string mitk::TrackingDeviceSourceConfigurator::GetToolIdentifierInToolStorage(unsigned int outputID)
   {
   if (outputID < m_ToolCorrespondencesInToolStorage.size()) return m_NavigationTools->GetTool(m_ToolCorrespondencesInToolStorage.at(outputID))->GetIdentifier();
   else return "";
   }
 
 std::vector<int> mitk::TrackingDeviceSourceConfigurator::GetToolNumbersInToolStorage()
   {
   return m_ToolCorrespondencesInToolStorage;
   }
 
 std::vector<std::string> mitk::TrackingDeviceSourceConfigurator::GetToolIdentifiersInToolStorage()
   {
   std::vector<std::string> returnValue = std::vector<std::string>();
   for (unsigned int i=0; i<m_ToolCorrespondencesInToolStorage.size(); i++)
     {returnValue.push_back(m_NavigationTools->GetTool(m_ToolCorrespondencesInToolStorage.at(i))->GetIdentifier());}
   return returnValue;
   }
diff --git a/Modules/IGT/TrackingDevices/mitkOpenIGTLinkTrackingDevice.cpp b/Modules/IGT/TrackingDevices/mitkOpenIGTLinkTrackingDevice.cpp
index c98152d446..aae220b1d2 100644
--- a/Modules/IGT/TrackingDevices/mitkOpenIGTLinkTrackingDevice.cpp
+++ b/Modules/IGT/TrackingDevices/mitkOpenIGTLinkTrackingDevice.cpp
@@ -1,334 +1,336 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkOpenIGTLinkTrackingDevice.h"
 #include "mitkOpenIGTLinkTrackingTool.h"
 #include "mitkIGTConfig.h"
 #include "mitkIGTTimeStamp.h"
 #include "mitkIGTHardwareException.h"
 #include "mitkTrackingTypes.h"
 #include <itksys/SystemTools.hxx>
 #include <iostream>
 #include <itkMutexLockHolder.h>
 #include <itkCommand.h>
 #include <igtlTrackingDataMessage.h>
 
 typedef itk::MutexLockHolder<itk::FastMutexLock> MutexLockHolder;
 
 
 mitk::OpenIGTLinkTrackingDevice::OpenIGTLinkTrackingDevice(): mitk::TrackingDevice()
 {
   //set the type of this tracking device
   this->m_Data = mitk::DeviceDataOpenIGTLinkTrackingDeviceConnection;
 
   m_OpenIGTLinkClient = mitk::IGTLClient::New();
   m_OpenIGTLinkClient->EnableInfiniteBufferingMode(m_OpenIGTLinkClient->GetReceiveQueue(),false);
   m_OpenIGTLinkClient->SetName("OpenIGTLink Tracking Device");
 
   m_IGTLDeviceSource =  mitk::IGTLDeviceSource::New();
   m_IGTLDeviceSource->SetIGTLDevice(m_OpenIGTLinkClient);
 }
 
 
 mitk::OpenIGTLinkTrackingDevice::~OpenIGTLinkTrackingDevice()
 {
 }
 
 int mitk::OpenIGTLinkTrackingDevice::GetPortNumber()
 {
   return m_OpenIGTLinkClient->GetPortNumber();
 }
 
 std::string mitk::OpenIGTLinkTrackingDevice::GetHostname()
 {
   return m_OpenIGTLinkClient->GetHostname();
 }
 
 
 void mitk::OpenIGTLinkTrackingDevice::SetPortNumber(int portNumber)
 {
   m_OpenIGTLinkClient->SetPortNumber(portNumber);
 }
 
 void mitk::OpenIGTLinkTrackingDevice::SetHostname(std::string hostname)
 {
   m_OpenIGTLinkClient->SetHostname(hostname);
 }
 
 bool mitk::OpenIGTLinkTrackingDevice::IsDeviceInstalled()
 {
   return true;
 }
 
 mitk::TrackingTool* mitk::OpenIGTLinkTrackingDevice::AddTool( const char* toolName, const char* fileName )
 {
   mitk::OpenIGTLinkTrackingTool::Pointer t;// = mitk::OpenIGTLinkTrackingTool::New();
   //TODO: Implement
   if (this->InternalAddTool(t) == false)
     return NULL;
   return t.GetPointer();
 }
 
 
 bool mitk::OpenIGTLinkTrackingDevice::InternalAddTool(OpenIGTLinkTrackingTool::Pointer tool)
 {
   m_AllTools.push_back(tool);
   return true;
 }
 
 
 bool mitk::OpenIGTLinkTrackingDevice::DiscoverTools(int WaitingTime)
 {
   if (m_OpenIGTLinkClient->GetPortNumber() == -1)
     {
     MITK_WARN << "Connection not initialized, aborting (invalid port number).";
     return false;
     }
 
   try
     {
     m_IGTLDeviceSource->Connect();
     m_IGTLDeviceSource->StartCommunication();
     }
   catch(std::runtime_error &e)
     {
     MITK_WARN << "Open IGT Link device retruned an error while trying to connect: " << e.what();
     return false;
     }
 
   //send a message to the server: start tracking stream
   mitk::IGTLMessageFactory::Pointer msgFactory = m_OpenIGTLinkClient->GetMessageFactory();
   std::string message = "STT_TDATA";
-  //m_OpenIGTLinkClient->SendMessage(msgFactory->CreateInstance(message));
+  igtl::MessageBase::Pointer sttMsg = msgFactory->CreateInstance(message);
+  ((igtl::StartTrackingDataMessage*)sttMsg.GetPointer())->SetResolution(1);
+  m_OpenIGTLinkClient->SendMessage(sttMsg);
 
   Sleep(WaitingTime); //wait for data to arrive
 
   m_IGTLDeviceSource->Update();
 
   //check the tracking stream for the number and type of tools
   //igtl::MessageBase::Pointer receivedMessage = m_OpenIGTLinkClient->GetNextMessage();
   mitk::IGTLMessage::Pointer receivedMessage = m_IGTLDeviceSource->GetOutput();
   if (receivedMessage.IsNull())
     {
     MITK_WARN << "No message was received. Is there really a server?";
     return false;
     }
   else if (!receivedMessage->IsDataValid())
     {
     MITK_WARN << "Received invalid message.";
     return false;
     }
 
   const char* msgType = receivedMessage->GetIGTLMessageType();
 
   if( !(strcmp(msgType,"TDATA") == 0) )
     {
     MITK_INFO << "Server does not send tracking data. Received data is not of the type TDATA. Received type: " << msgType;
     return true;
     }
 
 
   igtl::TrackingDataMessage* tdMsg = (igtl::TrackingDataMessage*)(receivedMessage->GetMessage().GetPointer());
 
   if(!tdMsg)
     {
      MITK_WARN << "Cannot cast message object as expected, aborting!";
      return false;
     }
 
   int numberOfTools = tdMsg->GetNumberOfTrackingDataElements();
   MITK_INFO << "Found " << numberOfTools << " tools";
   for(int i=0; i<numberOfTools; i++)
     {
     mitk::OpenIGTLinkTrackingTool::Pointer newTool = mitk::OpenIGTLinkTrackingTool::New();
     igtl::TrackingDataElement::Pointer currentTrackingData;
     tdMsg->GetTrackingDataElement(i,currentTrackingData);
     std::string name = currentTrackingData->GetName();
     if (name == "") //if no name was given create a default name
       {
       std::stringstream defaultName;
       defaultName << "OpenIGTLinkTool#" << i;
       name = defaultName.str();
       }
     MITK_INFO << "Added tool " << name << " to tracking device.";
     newTool->SetToolName(name);
     this->InternalAddTool(newTool);
     }
 
   m_IGTLDeviceSource->StopCommunication();
   this->SetState(Ready);
   return true;
 }
 
 void mitk::OpenIGTLinkTrackingDevice::UpdateTools()
 {
   if (this->GetState() != Tracking)
     {
     MITK_ERROR << "Method was called in the wrong state, something went wrong!";
     return;
     }
 
   m_IGTLMsgToNavDataFilter->Update();
   for (int i=0; i<this->GetToolCount(); i++)
   {
     mitk::NavigationData::Pointer currentNavData = m_IGTLMsgToNavDataFilter->GetOutput(i);
     m_AllTools.at(i)->SetDataValid(currentNavData->IsDataValid());
     m_AllTools.at(i)->SetPosition(currentNavData->GetPosition());
     m_AllTools.at(i)->SetOrientation(currentNavData->GetOrientation());
     m_AllTools.at(i)->SetIGTTimeStamp(currentNavData->GetIGTTimeStamp());
 
 
     mitk::Point3D pos;
     m_AllTools.at(i)->GetPosition(pos);
 
     //MITK_INFO << "Updated Tool " << i << " Pos: " << pos;
   }
 
 }
 
 
 bool mitk::OpenIGTLinkTrackingDevice::StartTracking()
 {
    //check tracking state
    if (this->GetState() != Ready)
     {
     MITK_WARN << "Cannot start tracking, device is not ready!";
     return false;
     }
 
    try
     {
     m_IGTLDeviceSource->StartCommunication();
 
     //send a message to the server: start tracking stream
     mitk::IGTLMessageFactory::Pointer msgFactory = m_OpenIGTLinkClient->GetMessageFactory();
     std::string message = "STT_TDATA";
     //m_OpenIGTLinkClient->SendMessage(msgFactory->CreateInstance(message));
     }
   catch(std::runtime_error &e)
     {
     MITK_WARN << "Open IGT Link device retruned an error while starting communication: " << e.what();
     return false;
     }
 
   //create internal igtl pipeline
   m_IGTLMsgToNavDataFilter =  mitk::IGTLMessageToNavigationDataFilter::New();
   m_IGTLMsgToNavDataFilter->SetNumberOfExpectedOutputs(this->GetToolCount());
   m_IGTLMsgToNavDataFilter->ConnectTo(m_IGTLDeviceSource);
 
 
   //connect itk events
   typedef itk::SimpleMemberCommand< mitk::OpenIGTLinkTrackingDevice > CurCommandType;
   CurCommandType::Pointer messageReceivedCommand = CurCommandType::New();
   messageReceivedCommand->SetCallbackFunction(this, &mitk::OpenIGTLinkTrackingDevice::UpdateTools);
   m_MessageReceivedObserverTag = m_OpenIGTLinkClient->AddObserver(mitk::MessageReceivedEvent(),messageReceivedCommand);
 
   this->SetState(Tracking);
   return true;
 }
 
 
 bool mitk::OpenIGTLinkTrackingDevice::StopTracking()
 {
   //check tracking state
   if (this->GetState() != Tracking)
     {
     MITK_WARN << "Cannot open connection, device is already connected!";
     return false;
     }
 
   m_OpenIGTLinkClient->RemoveObserver(m_MessageReceivedObserverTag); //disconnect itk events
 
   try
     {
     m_IGTLDeviceSource->StopCommunication();
     }
   catch(std::runtime_error &e)
     {
     MITK_WARN << "Open IGT Link device retruned an error while stopping communication: " << e.what();
     return false;
     }
   this->SetState(Ready);
   return true;
 }
 
 
 unsigned int mitk::OpenIGTLinkTrackingDevice::GetToolCount() const
 {
   return (unsigned int)this->m_AllTools.size();
 }
 
 
 mitk::TrackingTool* mitk::OpenIGTLinkTrackingDevice::GetTool(unsigned int toolNumber) const
 {
   if ( toolNumber >= this->GetToolCount())
     return NULL;
   else
     return this->m_AllTools[toolNumber];
 }
 
 
 bool mitk::OpenIGTLinkTrackingDevice::OpenConnection()
 {
   //check tracking state
   if (this->GetState() != Setup)
     {
     MITK_WARN << "Cannot open connection, device is already connected!";
     return false;
     }
 
   try
     {
     m_IGTLDeviceSource->Connect();
     }
   catch(std::runtime_error &e)
     {
     MITK_WARN << "Open IGT Link device retruned an error while trying to connect: " << e.what();
     return false;
     }
   this->SetState(Ready);
   return true;
 }
 
 
 bool mitk::OpenIGTLinkTrackingDevice::CloseConnection()
 {
   //check tracking state
   if (this->GetState() != Ready)
     {
     MITK_WARN << "Cannot close connection, device is in the wrong state!";
     return false;
     }
 
   try
     {
     m_IGTLDeviceSource->Disconnect();
     }
   catch(std::runtime_error &e)
     {
     MITK_WARN << "Open IGT Link device retruned an error while trying to disconnect: " << e.what();
     return false;
     }
 
   this->SetState(Setup);
 
   return true;
 }
 
 std::vector<mitk::OpenIGTLinkTrackingTool::Pointer> mitk::OpenIGTLinkTrackingDevice::GetAllTools()
 {
   return this->m_AllTools;
 }
diff --git a/Modules/IGT/TrackingDevices/mitkOpenIGTLinkTrackingDevice.h b/Modules/IGT/TrackingDevices/mitkOpenIGTLinkTrackingDevice.h
index 4cbdd445c8..b284b2f309 100644
--- a/Modules/IGT/TrackingDevices/mitkOpenIGTLinkTrackingDevice.h
+++ b/Modules/IGT/TrackingDevices/mitkOpenIGTLinkTrackingDevice.h
@@ -1,145 +1,145 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef MITKOPENIGTLINKTRACKINGDEVICE_H_HEADER_INCLUDED_
 #define MITKOPENIGTLINKTRACKINGDEVICE_H_HEADER_INCLUDED_
 
 
 #include <mitkIGTConfig.h>
 #include <mitkTrackingDevice.h>
 #include <mitkOpenIGTLinkTrackingTool.h>
 #include <mitkIGTLClient.h>
 #include <mitkIGTLDeviceSource.h>
 #include <mitkIGTLMessageToNavigationDataFilter.h>
 #include <itkMultiThreader.h>
 
 
 namespace mitk
 {
   /** Documentation:
   *   \brief An object of this class represents the MicronTracker device. You can add tools to this
   *          device, then open the connection and start tracking. The tracking device will then
   *          continuously update the tool coordinates.
   *   \ingroup IGT
   */
   class MitkIGT_EXPORT OpenIGTLinkTrackingDevice : public TrackingDevice
   {
   public:
     mitkClassMacro(OpenIGTLinkTrackingDevice, TrackingDevice);
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
     /** Sets the port number for the Open IGT Link connection. Default value is -1 (invalid). */
     void SetPortNumber(int portNumber);
 
     /** Sets the hostname for the Open IGT Link connection. Default value is 127.0.0.1 (localhost). */
     void mitk::OpenIGTLinkTrackingDevice::SetHostname(std::string hostname);
 
     int GetPortNumber();
 
     std::string GetHostname();
 
     /**
     * \brief Starts the tracking.
     * \return Returns true if the tracking is started. Throws an exception if an error occures.
     * @throw mitk::IGTHardwareException Throws an exception if there is an error during start tracking.
     */
     virtual bool StartTracking();
 
     /**
     * \brief Stops the tracking.
     * \return Returns true if the tracking is stopped.
     */
     virtual bool StopTracking();
 
     /**
     * \brief Opens the connection to the device. This have to be done before the tracking is started.
     * @throw mitk::IGTHardwareException Throws an exception if there is an error during open connection.
     */
     virtual bool OpenConnection();
 
     /**
     * \brief Closes the connection and clears all resources.
     */
     virtual bool CloseConnection();
 
     /**
     * \return Returns the number of tools which have been added to the device.
     */
     virtual unsigned int GetToolCount() const;
 
     /**
     * \param toolNumber The number of the tool which should be given back.
     * \return Returns the tool which the number "toolNumber". Returns NULL, if there is
     * no tool with this number.
     */
     TrackingTool* GetTool(unsigned int toolNumber)  const;
 
     /**
     * \brief Discover the tools available from the connected OpenIGTLink device and adds these tools to this tracking device. Therefore, a connection
     *        is opened, the tools are discovered and added.
-    * \param WaitingTime Defines how long the method waits for an answer from the server (in milliseconds). Default value is 2000 (2 seconds).
+    * \param WaitingTime Defines how long the method waits for an answer from the server (in milliseconds). Default value is 10000 (10 seconds).
     * \return Returns true if the connection was established and the tools were discovered successfully and - if at least one tool was found - were added to this device.
     *         Retruns false if no valid connection is available.
     */
-    bool DiscoverTools(int WaitingTime = 2000);
+    bool DiscoverTools(int WaitingTime = 10000);
 
 
     /**
     * \brief Create a new OpenIGTLink tool with toolName and fileName and add it to the list of tools
     *
     * Note that tools are usually provided by the OpenIGTLink connection. In most cases, the method DiscoverTools() should be used
     * instead which automatically finds the provided tools. If you use this method to manually add tools be sure that you add the
     * same number and type of tools that are provided by the connected device. Otherwise problems might occur when you try to start
     * tracking.
     */
     mitk::TrackingTool* AddTool(const char* toolName, const char* fileName);
 
     bool IsDeviceInstalled();
 
   protected:
     OpenIGTLinkTrackingDevice();
     ~OpenIGTLinkTrackingDevice();
 
     /**
     * \brief Adds a tool to the tracking device.
     *
     * \param tool  The tool which will be added.
     * \return Returns true if the tool has been added, false otherwise.
     */
     bool InternalAddTool(OpenIGTLinkTrackingTool::Pointer tool);
 
 
     /** Updates the tools from the open IGT link connection. Is called every time a message received event is invoked.*/
     void UpdateTools();
     unsigned long m_MessageReceivedObserverTag;
 
     /**
     * \return Returns all tools of the tracking device.
     */
     std::vector<OpenIGTLinkTrackingTool::Pointer> GetAllTools();
 
     //OpenIGTLink connection class
     mitk::IGTLClient::Pointer m_OpenIGTLinkClient;
 
     //OpenIGTLink pipeline
     mitk::IGTLDeviceSource::Pointer m_IGTLDeviceSource;
     mitk::IGTLMessageToNavigationDataFilter::Pointer m_IGTLMsgToNavDataFilter;
 
     std::vector<OpenIGTLinkTrackingTool::Pointer> m_AllTools; ///< vector holding all tools
   };
 }//mitk
 #endif /* MITKOpenIGTLinkTRACKINGDEVICE_H_HEADER_INCLUDED_ */
diff --git a/Plugins/org.mitk.gui.qt.igtlplugin/src/internal/OpenIGTLinkProviderExample.cpp b/Plugins/org.mitk.gui.qt.igtlplugin/src/internal/OpenIGTLinkProviderExample.cpp
index d830187c8f..8c4463a9e3 100644
--- a/Plugins/org.mitk.gui.qt.igtlplugin/src/internal/OpenIGTLinkProviderExample.cpp
+++ b/Plugins/org.mitk.gui.qt.igtlplugin/src/internal/OpenIGTLinkProviderExample.cpp
@@ -1,239 +1,242 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkRenderWindow.h"
 
 // Qt
 #include <QMessageBox>
 #include <QFileDialog>
 
 // mitk
 #include <mitkImage.h>
 #include <mitkSurface.h>
 #include <mitkIGTLMessageToNavigationDataFilter.h>
 #include <mitkNavigationDataReaderXML.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 
 // vtk
 #include <vtkSphereSource.h>
 
 //
 #include "OpenIGTLinkProviderExample.h"
 
 //igtl
 #include "igtlStringMessage.h"
 
 
 const std::string OpenIGTLinkProviderExample::VIEW_ID =
     "org.mitk.views.OpenIGTLinkProviderExample";
 
 OpenIGTLinkProviderExample::~OpenIGTLinkProviderExample()
 {
    this->DestroyPipeline();
 }
 
 void OpenIGTLinkProviderExample::SetFocus()
 {
 }
 
 void OpenIGTLinkProviderExample::CreateQtPartControl( QWidget *parent )
 {
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi( parent );
 
   // connect the widget items with the methods
   connect( m_Controls.butStart, SIGNAL(clicked()),
            this, SLOT(Start()) );
   connect( m_Controls.butOpenNavData, SIGNAL(clicked()),
            this, SLOT(OnOpenFile()) );
   connect( &m_VisualizerTimer, SIGNAL(timeout()),
            this, SLOT(UpdateVisualization()));
 }
 
 void OpenIGTLinkProviderExample::CreatePipeline()
 {
   //create a new OpenIGTLink Client
   m_IGTLServer = mitk::IGTLServer::New();
   m_IGTLServer->SetName("OIGTL Provider Example Device");
 
   //create a new OpenIGTLink Device source
   m_IGTLMessageProvider = mitk::IGTLMessageProvider::New();
 
   //set the OpenIGTLink server as the source for the device source
   m_IGTLMessageProvider->SetIGTLDevice(m_IGTLServer);
 
   //register the provider so that it can be configured with the IGTL manager
   //plugin. This could be hardcoded but now I already have the fancy plugin.
   m_IGTLMessageProvider->RegisterAsMicroservice();
 
   //create a filter that converts navigation data into IGTL messages
   m_NavDataToIGTLMsgFilter = mitk::NavigationDataToIGTLMessageFilter::New();
 
   //define the operation mode for this filter, we want to send tracking data
   //messages
   m_NavDataToIGTLMsgFilter->SetOperationMode(
         mitk::NavigationDataToIGTLMessageFilter::ModeSendTDataMsg);
 //       mitk::NavigationDataToIGTLMessageFilter::ModeSendTransMsg);
 
   //set the name of this filter to identify it easier
   m_NavDataToIGTLMsgFilter->SetName("Tracking Data Source From Example");
 
   //register this filter as micro service. The message provider looks for
   //provided IGTLMessageSources, once it found this microservice and someone
   //requested this data type then the provider will connect with this filter
   //automatically (this is not implemented so far, check m_StreamingConnector
   //for more information)
   m_NavDataToIGTLMsgFilter->RegisterAsMicroservice();
 
   //create a navigation data player object that will play nav data from a
   //recorded file
   m_NavDataPlayer = mitk::NavigationDataPlayer::New();
 
   //set the currently read navigation data set
   m_NavDataPlayer->SetNavigationDataSet(m_NavDataSet);
 
   //connect the filters with each other
   //the navigation data player reads a file with recorded navigation data,
   //passes this data to a filter that converts it into a IGTLMessage.
   //The provider is not connected because it will search for fitting services.
   //Once it found the filter it will automatically connect to it (this is not
   // implemented so far, check m_StreamingConnector for more information).
   m_NavDataToIGTLMsgFilter->ConnectTo(m_NavDataPlayer);
 
   //create an object that will be moved respectively to the navigation data
   m_DemoNodeT1 = mitk::DataNode::New();
   m_DemoNodeT1->SetName("DemoNode IGTLProviderExmpl T1");
   m_DemoNodeT2 = mitk::DataNode::New();
   m_DemoNodeT2->SetName("DemoNode IGTLProviderExmpl T2");
   m_DemoNodeT3 = mitk::DataNode::New();
   m_DemoNodeT3->SetName("DemoNode IGTLProviderExmpl T3");
 
   //create small sphere and use it as surface
   mitk::Surface::Pointer mySphere = mitk::Surface::New();
   vtkSphereSource *vtkData = vtkSphereSource::New();
   vtkData->SetRadius(2.0f);
   vtkData->SetCenter(0.0, 0.0, 0.0);
   vtkData->Update();
   mySphere->SetVtkPolyData(vtkData->GetOutput());
   vtkData->Delete();
   m_DemoNodeT1->SetData(mySphere);
 
   mitk::Surface::Pointer mySphere2 = mySphere->Clone();
   m_DemoNodeT2->SetData(mySphere2);
   mitk::Surface::Pointer mySphere3 = mySphere->Clone();
   m_DemoNodeT3->SetData(mySphere3);
 
   // add node to DataStorage
   this->GetDataStorage()->Add(m_DemoNodeT1);
   this->GetDataStorage()->Add(m_DemoNodeT2);
   this->GetDataStorage()->Add(m_DemoNodeT3);
 
   //initialize the streaming connector
   //the streaming connector is checking if the data from the filter has to be
   //streamed. The message provider is used for sending the messages.
 //  m_StreamingConnector.Initialize(m_NavDataToIGTLMsgFilter.GetPointer(),
 //                                  m_IGTLMessageProvider);
 
   //also create a visualize filter to visualize the data
   m_NavDataVisualizer = mitk::NavigationDataObjectVisualizationFilter::New();
   m_NavDataVisualizer->SetRepresentationObject(0, mySphere);
   m_NavDataVisualizer->SetRepresentationObject(1, mySphere2);
   m_NavDataVisualizer->SetRepresentationObject(2, mySphere3);
   m_NavDataVisualizer->ConnectTo(m_NavDataPlayer);
 
   //start the player
   this->Start();
 
   mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(this->GetDataStorage());
 }
 
 void OpenIGTLinkProviderExample::DestroyPipeline()
 {
-  m_NavDataPlayer->StopPlaying();
-  this->GetDataStorage()->Remove(m_DemoNodeT1);
-  this->GetDataStorage()->Remove(m_DemoNodeT2);
-  this->GetDataStorage()->Remove(m_DemoNodeT3);
+   if (m_NavDataPlayer.IsNotNull())
+   {
+      m_NavDataPlayer->StopPlaying();
+   }
+   this->GetDataStorage()->Remove(m_DemoNodeT1);
+   this->GetDataStorage()->Remove(m_DemoNodeT2);
+   this->GetDataStorage()->Remove(m_DemoNodeT3);
 }
 
 void OpenIGTLinkProviderExample::Start()
 {
   if ( this->m_Controls.butStart->text().contains("Start") )
   {
     m_NavDataPlayer->SetRepeat(true);
     m_NavDataPlayer->StartPlaying();
     this->m_Controls.butStart->setText("Stop Playing Recorded Navigation Data ");
 
     //start the visualization
     this->m_VisualizerTimer.start(10);
   }
   else
   {
     m_NavDataPlayer->StopPlaying();
     this->m_Controls.butStart->setText("Start Playing Recorded Navigation Data ");
 
     //stop the visualization
     this->m_VisualizerTimer.stop();
   }
 }
 
 void OpenIGTLinkProviderExample::OnOpenFile(){
   mitk::NavigationDataReaderXML::Pointer reader = mitk::NavigationDataReaderXML::New();
 
   // FIXME Filter for correct files and use correct Reader
   QString fileName =
       QFileDialog::getOpenFileName(NULL, "Open Navigation Data Set", "", "XML files (*.xml)");
   if ( fileName.isNull() ) { return; } // user pressed cancel
 
   try
   {
     m_NavDataSet = reader->Read(fileName.toStdString());
   }
   catch ( const mitk::Exception &e )
   {
     MITK_WARN("NavigationDataPlayerView") << "could not open file " << fileName.toStdString();
     QMessageBox::critical(0, "Error Reading File", "The file '" + fileName
                           +"' could not be read.\n" + e.GetDescription() );
     return;
   }
 
   this->m_Controls.butStart->setEnabled(true);
 
   //Setup the pipeline
   this->CreatePipeline();
 
   // Update Labels
 //  m_Controls->m_LblFilePath->setText(fileName);
 //  m_Controls->m_LblTools->setText(QString::number(m_NavDataSet->GetNumberOfTools()));
 }
 
 void OpenIGTLinkProviderExample::UpdateVisualization()
 {
   //update the filter
   this->m_NavDataVisualizer->Update();
 
   //update the bounds
   mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(this->GetDataStorage());
 
   //update rendering
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }