diff --git a/Modules/IGT/IGTFilters/mitkTrackingDeviceSource.cpp b/Modules/IGT/IGTFilters/mitkTrackingDeviceSource.cpp
index 90f9188079..f30a7e5d2d 100644
--- a/Modules/IGT/IGTFilters/mitkTrackingDeviceSource.cpp
+++ b/Modules/IGT/IGTFilters/mitkTrackingDeviceSource.cpp
@@ -1,208 +1,210 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date$
 Version:   $Revision$
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include "mitkTrackingDeviceSource.h"
 
 #include "mitkTrackingDevice.h"
 #include "mitkTrackingTool.h"
 
 #include "mitkTimeStamp.h"
 
 
 mitk::TrackingDeviceSource::TrackingDeviceSource() 
 : mitk::NavigationDataSource(), m_TrackingDevice(NULL)
 {
 }
 
 
 mitk::TrackingDeviceSource::~TrackingDeviceSource()
 {
   if (m_TrackingDevice.IsNotNull())
   {
     if (m_TrackingDevice->GetState() == mitk::TrackingDevice::Tracking)
     {
       this->StopTracking();
     }
     if (m_TrackingDevice->GetState() == mitk::TrackingDevice::Ready)
     {
       this->Disconnect();
     }
     m_TrackingDevice = NULL;
   }
 }
 
 
 void mitk::TrackingDeviceSource::GenerateData()
 {
   if (m_TrackingDevice.IsNull())
     return;
 
   if (m_TrackingDevice->GetToolCount() < 1)
     return;
 
   if (this->GetNumberOfOutputs() != m_TrackingDevice->GetToolCount()) // mismatch between tools and outputs. What should we do? Were tools added to the tracking device after SetTrackingDevice() was called?
   {
     //check this: TODO:
     ////this might happen if a tool is plugged into an aurora during tracking.
     //this->CreateOutputs();
 
     std::stringstream ss;
     ss << "mitk::TrackingDeviceSource: not enough outputs available for all tools. " 
       << this->GetNumberOfOutputs() << " outputs available, but "
       << m_TrackingDevice->GetToolCount() << " tools available in the tracking device.";
     throw std::out_of_range(ss.str());
   }
   /* update outputs with tracking data from tools */
   unsigned int toolCount = m_TrackingDevice->GetToolCount();
   for (unsigned int i = 0; i < toolCount; ++i)
   {
     mitk::NavigationData* nd = this->GetOutput(i);
     assert(nd);
     mitk::TrackingTool* t = m_TrackingDevice->GetTool(i);
     assert(t);
 
     if ((t->IsEnabled() == false) || (t->IsDataValid() == false))
     {
       nd->SetDataValid(false);
       continue;
     }
     nd->SetDataValid(true);
     mitk::NavigationData::PositionType p;
     t->GetPosition(p);
     nd->SetPosition(p);
 
     mitk::NavigationData::OrientationType o;
     t->GetOrientation(o);
     nd->SetOrientation(o);
     nd->SetOrientationAccuracy(t->GetTrackingError());
     nd->SetPositionAccuracy(t->GetTrackingError());
     nd->SetTimeStamp( mitk::TimeStamp::GetInstance()->GetElapsed() );
   }
 }
 
 
 void mitk::TrackingDeviceSource::SetTrackingDevice( mitk::TrackingDevice* td )
 {
   itkDebugMacro("setting TrackingDevice to " << td );
   if (this->m_TrackingDevice.GetPointer() != td)
   {
     this->m_TrackingDevice = td;
     this->CreateOutputs();
   }
 }
 
 void mitk::TrackingDeviceSource::CreateOutputs(){
   //if outputs are set then delete them
   if (this->GetNumberOfOutputs() > 0)
   {
     for (unsigned int numOP = this->GetNumberOfOutputs(); numOP>0; numOP--)
       this->RemoveOutput(this->GetOutput(numOP));
     this->Modified();
   }
   
   //fill the outputs if a valid tracking device is set
   if (m_TrackingDevice.IsNull())
     return;
 
   this->SetNumberOfOutputs(m_TrackingDevice->GetToolCount());  // create outputs for all tools
   unsigned int numberOfOutputs = this->GetNumberOfOutputs();
   for (unsigned int idx = 0; idx < numberOfOutputs; ++idx)
   {
     if (this->GetOutput(idx) == NULL)
     {
       DataObjectPointer newOutput = this->MakeOutput(idx);
       static_cast<mitk::NavigationData*>(newOutput.GetPointer())->SetName(m_TrackingDevice->GetTool(idx)->GetToolName()); // set NavigationData name to ToolName
       this->SetNthOutput(idx, newOutput);
       this->Modified();
     }    
   }
 }
 
 void mitk::TrackingDeviceSource::Connect()
 {
   if (m_TrackingDevice.IsNull())
     throw std::invalid_argument("mitk::TrackingDeviceSource: No tracking device set");
   if (this->IsConnected())
     return;
   if (m_TrackingDevice->OpenConnection() == false)
     throw std::runtime_error(std::string("mitk::TrackingDeviceSource: Could not open connection to tracking device. Error: ") + m_TrackingDevice->GetErrorMessage());
   
   /* NDI Aurora needs a connection to discover tools that are connected to it. 
      Therefore we need to create outputs for these tools now */
   //if (m_TrackingDevice->GetType() == mitk::NDIAurora)
     //this->CreateOutputs();
 }
 
 
 void mitk::TrackingDeviceSource::StartTracking()
 {
   if (m_TrackingDevice.IsNull())
     throw std::invalid_argument("mitk::TrackingDeviceSource: No tracking device set");
+  if (m_TrackingDevice->GetState() == mitk::TrackingDevice::Tracking)
+    return;
   if (m_TrackingDevice->StartTracking() == false)
     throw std::runtime_error("mitk::TrackingDeviceSource: Could not start tracking");
 }
 
 
 void mitk::TrackingDeviceSource::Disconnect()
 {
   if (m_TrackingDevice.IsNull())
     throw std::invalid_argument("mitk::TrackingDeviceSource: No tracking device set");
   if (m_TrackingDevice->CloseConnection() == false)
     throw std::runtime_error("mitk::TrackingDeviceSource: Could not close connection to tracking device");
 }
 
 
 void mitk::TrackingDeviceSource::StopTracking()
 {
   if (m_TrackingDevice.IsNull())
     throw std::invalid_argument("mitk::TrackingDeviceSource: No tracking device set");
   if (m_TrackingDevice->StopTracking() == false)
     throw std::runtime_error("mitk::TrackingDeviceSource: Could not stop tracking");
 }
 
 
 void mitk::TrackingDeviceSource::UpdateOutputInformation()
 {
   this->Modified();  // make sure that we need to be updated
   Superclass::UpdateOutputInformation();
 }
 
 
 //unsigned int mitk::TrackingDeviceSource::GetToolCount()
 //{
 //  if (m_TrackingDevice) 
 //    return m_TrackingDevice->GetToolCount(); 
 //  return 0;
 //}
 
 
 bool mitk::TrackingDeviceSource::IsConnected()
 {
   if (m_TrackingDevice.IsNull())
     return false;
   
   return (m_TrackingDevice->GetState() == mitk::TrackingDevice::Ready) || (m_TrackingDevice->GetState() == mitk::TrackingDevice::Tracking);
 }
 
 
 bool mitk::TrackingDeviceSource::IsTracking()
 {
   if (m_TrackingDevice.IsNull())
     return false;
 
   return m_TrackingDevice->GetState() == mitk::TrackingDevice::Tracking;
 }
diff --git a/Modules/IGT/IGTFilters/mitkTrackingDeviceSourceConfigurator.cpp b/Modules/IGT/IGTFilters/mitkTrackingDeviceSourceConfigurator.cpp
index 6d6e96562c..22b78eb0b5 100644
--- a/Modules/IGT/IGTFilters/mitkTrackingDeviceSourceConfigurator.cpp
+++ b/Modules/IGT/IGTFilters/mitkTrackingDeviceSourceConfigurator.cpp
@@ -1,195 +1,195 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2011-01-18 13:22:38 +0100 (Di, 18 Jan 2011) $
 Version:   $Revision: 28959 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include "mitkTrackingDeviceSourceConfigurator.h"
 
 #include "mitkNDITrackingDevice.h"
 #include "mitkClaronTrackingDevice.h"
 
 
 mitk::TrackingDeviceSourceConfigurator::TrackingDeviceSourceConfigurator(mitk::NavigationToolStorage::Pointer NavigationTools, mitk::TrackingDevice::Pointer TrackingDevice)
 {
 m_NavigationTools = NavigationTools;
 m_TrackingDevice = TrackingDevice;
 m_ErrorMessage = "";
 }
 
 
 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;
 return this->CreateTrackingDeviceSource(dummy); 
 }
 
 mitk::TrackingDeviceSource::Pointer mitk::TrackingDeviceSourceConfigurator::CreateTrackingDeviceSource(mitk::NavigationDataObjectVisualizationFilter::Pointer &visualizationFilter)
 {
   if (!this->IsCreateTrackingDeviceSourcePossible()) 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);}
     //TODO: insert other tracking systems? 
   if (returnValue.IsNull()) return NULL;
 
   //create visualization filter
   visualizationFilter = CreateNavigationDataObjectVisualizationFilter(returnValue,m_NavigationTools);
   if (visualizationFilter.IsNull()) 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());
   //add the tools to the tracking device
   for (int i=0; i<navigationTools->GetToolCount(); i++)
       {
         mitk::NavigationTool::Pointer thisNavigationTool = m_NavigationTools->GetTool(i);
         bool toolAddSuccess = thisDevice->AddTool(thisNavigationTool->GetToolName().c_str(),thisNavigationTool->GetCalibrationFile().c_str());
         if (!toolAddSuccess)
           {
           this->m_ErrorMessage = "Can't add tool, is the SROM-file valid?";
           return NULL;
           }
       } 
   returnValue->SetTrackingDevice(thisDevice);
   return returnValue;
   }
 
 mitk::TrackingDeviceSource::Pointer mitk::TrackingDeviceSourceConfigurator::CreateNDIAuroraTrackingDeviceSource(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());
 
   //connect to aurora to dectect tools automatically
   thisDevice->OpenConnection();
   thisDevice->StartTracking();
-  thisDevice->StopTracking();
-  thisDevice->CloseConnection();
+  //thisDevice->StopTracking();
+  //thisDevice->CloseConnection();
   
   //now search for automatically detected tools in the tool storage and save them
   mitk::NavigationToolStorage::Pointer newToolStorageInRightOrder = mitk::NavigationToolStorage::New();
   for (int i=0; i<thisDevice->GetToolCount(); i++)
       {
       bool toolFound = false;
       for (int j=0; j<navigationTools->GetToolCount(); j++)
         {
           if ((dynamic_cast<mitk::NDIPassiveTool*>(thisDevice->GetTool(i)))->GetSerialNumber() == navigationTools->GetTool(j)->GetSerialNumber())
             {
             //add tool in right order
             newToolStorageInRightOrder->AddTool(navigationTools->GetTool(j));
             //adapt name of tool
             dynamic_cast<mitk::NDIPassiveTool*>(thisDevice->GetTool(i))->SetToolName(navigationTools->GetTool(j)->GetToolName());
             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);
   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());
   //add the tools to the tracking device
   for (int i=0; i<navigationTools->GetToolCount(); i++)
       {
         mitk::NavigationTool::Pointer thisNavigationTool = m_NavigationTools->GetTool(i);
         bool toolAddSuccess = thisDevice->AddTool(thisNavigationTool->GetToolName().c_str(),thisNavigationTool->GetCalibrationFile().c_str());
         if (!toolAddSuccess)
           {
           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 (int i=0; i<trackingDeviceSource->GetNumberOfOutputs(); 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.";
       return NULL;
       }
     returnValue->SetInput(i,trackingDeviceSource->GetOutput(i));
     returnValue->SetRepresentationObject(i,currentTool->GetDataNode()->GetData());
     }
   return returnValue;
   }