diff --git a/Modules/IGT/Testing/mitkOpenIGTLinkTrackingDeviceTest.cpp b/Modules/IGT/Testing/mitkOpenIGTLinkTrackingDeviceTest.cpp
index 9cf52ea47b..1c5f5a3247 100644
--- a/Modules/IGT/Testing/mitkOpenIGTLinkTrackingDeviceTest.cpp
+++ b/Modules/IGT/Testing/mitkOpenIGTLinkTrackingDeviceTest.cpp
@@ -1,84 +1,87 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 //testing headers
 #include <mitkTestingMacros.h>
 #include <mitkTestFixture.h>
 
 //headers of IGT classes releated to the tested class
 #include <mitkOpenIGTLinkTrackingDevice.h>
 
+//sleep headers
+#include <chrono>
+#include <thread>
 
 class mitkOpenIGTLinkTrackingDeviceTestSuite : public mitk::TestFixture
 {
   CPPUNIT_TEST_SUITE(mitkOpenIGTLinkTrackingDeviceTestSuite);
   MITK_TEST(TestInstantiation);
   MITK_TEST(TestSetConnectionParameters);
   MITK_TEST(TestDiscoverToolMethod);
   CPPUNIT_TEST_SUITE_END();
 
 private:
   /** Members used inside the different test methods. All members are initialized via setUp().*/
   mitk::OpenIGTLinkTrackingDevice::Pointer m_OpenIGTLinkTrackingDevice;
 
 public:
 
   /**@brief Setup Always call this method before each Test-case to ensure correct and new intialization of the used members for a new test case. (If the members are not used in a test, the method does not need to be called).*/
   void setUp()
   {
     m_OpenIGTLinkTrackingDevice = mitk::OpenIGTLinkTrackingDevice::New();
   }
 
   void tearDown()
   {
   }
 
   void TestInstantiation()
   {
   // let's create objects of our classes
   mitk::OpenIGTLinkTrackingDevice::Pointer testDevice = mitk::OpenIGTLinkTrackingDevice::New();
   CPPUNIT_ASSERT_MESSAGE("Testing instantiation of OpenIGTLinkTrackingDevice",testDevice.IsNotNull());
   }
 
   void TestSetConnectionParameters()
   {
     m_OpenIGTLinkTrackingDevice->SetHostname("localhost");
     m_OpenIGTLinkTrackingDevice->SetPortNumber(10);
     CPPUNIT_ASSERT_MESSAGE("Testing method SetHostname() ...", m_OpenIGTLinkTrackingDevice->GetHostname()=="localhost");
     CPPUNIT_ASSERT_MESSAGE("Testing method SetPort() ...", m_OpenIGTLinkTrackingDevice->GetPortNumber()==10);
   }
 
   void TestDiscoverToolMethod()
   {
   CPPUNIT_ASSERT_MESSAGE("Testing DiscoverTools() without initialization. (Warnings are expected)", m_OpenIGTLinkTrackingDevice->DiscoverTools()==false);
   m_OpenIGTLinkTrackingDevice->SetPortNumber(10);
   CPPUNIT_ASSERT_MESSAGE("Testing DiscoverTools() with initialization, but without existing server. (Warnings are expected)", m_OpenIGTLinkTrackingDevice->DiscoverTools()==false);
 
   m_OpenIGTLinkTrackingDevice->SetHostname("193.174.50.103");
   m_OpenIGTLinkTrackingDevice->SetPortNumber(18944);
   m_OpenIGTLinkTrackingDevice->DiscoverTools(20000);
   m_OpenIGTLinkTrackingDevice->OpenConnection();
   m_OpenIGTLinkTrackingDevice->StartTracking();
 
-  Sleep(20000);
+  std::this_thread::sleep_for(std::chrono::seconds(20));
 
   m_OpenIGTLinkTrackingDevice->StopTracking();
   m_OpenIGTLinkTrackingDevice->CloseConnection();
 
   }
 
 };
 MITK_TEST_SUITE_REGISTRATION(mitkOpenIGTLinkTrackingDevice)
diff --git a/Modules/IGT/TrackingDevices/mitkOpenIGTLinkTrackingDevice.cpp b/Modules/IGT/TrackingDevices/mitkOpenIGTLinkTrackingDevice.cpp
index aae220b1d2..76449d504c 100644
--- a/Modules/IGT/TrackingDevices/mitkOpenIGTLinkTrackingDevice.cpp
+++ b/Modules/IGT/TrackingDevices/mitkOpenIGTLinkTrackingDevice.cpp
@@ -1,336 +1,341 @@
 /*===================================================================
 
 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>
 
+//sleep headers
+#include <chrono>
+#include <thread>
+
 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";
   igtl::MessageBase::Pointer sttMsg = msgFactory->CreateInstance(message);
   ((igtl::StartTrackingDataMessage*)sttMsg.GetPointer())->SetResolution(1);
   m_OpenIGTLinkClient->SendMessage(sttMsg);
 
-  Sleep(WaitingTime); //wait for data to arrive
+  std::this_thread::sleep_for(std::chrono::seconds(WaitingTime));
+  //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 28abef68e8..710f00baf1 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);
+    void 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 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 = 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/Modules/IGTBase/mitkStaticIGTHelperFunctions.cpp b/Modules/IGTBase/mitkStaticIGTHelperFunctions.cpp
index 71fe8db1e6..3332afd4e3 100644
--- a/Modules/IGTBase/mitkStaticIGTHelperFunctions.cpp
+++ b/Modules/IGTBase/mitkStaticIGTHelperFunctions.cpp
@@ -1,95 +1,95 @@
 /*===================================================================
 
 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 <mitkStaticIGTHelperFunctions.h>
 #include <itkVector.h>
 
 double mitk::StaticIGTHelperFunctions::GetAngleBetweenTwoQuaterions(mitk::Quaternion a, mitk::Quaternion b, itk::Vector<double,3> rotationVector)
   {
   double returnValue;
 
   itk::Vector<double,3> point; //caution 5D-Tools: correct verctor along the tool axis is needed
   point[0] = rotationVector[0];
   point[1] = rotationVector[1];
   point[2] = rotationVector[2];
 
   //Quaternions used for rotations should alway be normalized, so just to be safe:
   a.normalize();
   b.normalize();
 
   itk::Matrix<double,3,3> rotMatrixA;
   for(int i=0; i<3; i++) for(int j=0; j<3; j++) rotMatrixA[i][j] = a.rotation_matrix_transpose().transpose()[i][j];
 
   itk::Matrix<double,3,3> rotMatrixB;
   for(int i=0; i<3; i++) for(int j=0; j<3; j++) rotMatrixB[i][j] = b.rotation_matrix_transpose().transpose()[i][j];
 
   itk::Vector<double,3> pt1 = rotMatrixA * point;
   itk::Vector<double,3> pt2 = rotMatrixB * point;
 
   returnValue = (pt1[0]*pt2[0]+pt1[1]*pt2[1]+pt1[2]*pt2[2]) / ( sqrt(pow(pt1[0],2.0)+pow(pt1[1],2.0)+pow(pt1[2],2.0)) * sqrt(pow(pt2[0],2.0)+pow(pt2[1],2.0)+pow(pt2[2],2.0)));
-  returnValue = acos(returnValue) * 57,296; //57,296 = 180/Pi ; conversion to degrees
+  returnValue = acos(returnValue) * 57.296; //57,296 = 180/Pi ; conversion to degrees
 
   return returnValue;
   }
 
 double mitk::StaticIGTHelperFunctions::GetAngleBetweenTwoQuaterions(mitk::Quaternion a, mitk::Quaternion b)
 {
   itk::Vector<double,3> rotationVector = itk::Vector<double,3>();
   rotationVector[0] = 0;
   rotationVector[1] = 0;
   rotationVector[2] = 1000;
   return GetAngleBetweenTwoQuaterions(a,b,rotationVector);
 }
 
 itk::Matrix<double,3,3> mitk::StaticIGTHelperFunctions::ConvertEulerAnglesToRotationMatrix(double alpha, double beta, double gamma)
 {
     double PI = 3.141592653589793;
     alpha = alpha * PI / 180;
     beta = beta * PI / 180;
     gamma = gamma * PI / 180;
 
     //convert angles to matrix:
     itk::Matrix<double,3,3> matrix;
 
     /* x-Konvention (Z, X, Z)
     matrix[0][0] = cos(alpha) * cos(gamma) - sin(alpha) * cos(beta) * sin(gamma);
     matrix[0][1] = -cos(alpha) * sin(gamma)- sin(alpha) * cos(beta) * cos(gamma);
     matrix[0][2] = sin(alpha) * sin(beta);
 
     matrix[1][0] = sin(alpha) * cos(gamma) + cos(alpha) * cos(beta) * sin(gamma);
     matrix[1][1] = cos(alpha) * cos(beta) * cos(gamma) - sin(alpha) * sin(gamma);
     matrix[1][2] = -cos(alpha) * sin(beta);
 
     matrix[2][0] = sin(beta) * sin(gamma);
     matrix[2][1] = sin(beta) * cos(gamma);
     matrix[2][2] = cos(beta);
     */
 
     //Luftfahrtnorm (DIN 9300) (Yaw-Pitch-Roll, Z, Y, X)
     matrix[0][0] = cos(beta) * cos(alpha);
     matrix[0][1] = cos(beta) * sin(alpha);
     matrix[0][2] = -sin(beta);
 
     matrix[1][0] = sin(gamma) * sin(beta) * cos(alpha) - cos(gamma) * sin(alpha) ;
     matrix[1][1] = sin(gamma) * sin(beta) * sin(alpha) + cos(gamma) * cos(alpha);
     matrix[1][2] = sin(gamma) * cos(beta);
 
     matrix[2][0] = cos(gamma) * sin(beta) * cos(alpha) + sin(gamma) * sin(alpha);
     matrix[2][1] = cos(gamma) * sin(beta) * sin(alpha) - sin(gamma) * cos(alpha);
     matrix[2][2] = cos(gamma) * cos(beta);
 
     return matrix;
 }