diff --git a/Modules/IGT/Tutorial/mitkIGTTutorialStep1.cpp b/Modules/IGT/Tutorial/mitkIGTTutorialStep1.cpp
index abd5ce62ba..09cbd8c4c4 100644
--- a/Modules/IGT/Tutorial/mitkIGTTutorialStep1.cpp
+++ b/Modules/IGT/Tutorial/mitkIGTTutorialStep1.cpp
@@ -1,192 +1,190 @@
 /*===================================================================
 
 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 <mitkVirtualTrackingDevice.h>
 #include <mitkInternalTrackingTool.h>
 #include <mitkIOUtil.h>
 
 #include <mitkNavigationData.h>
 #include <mitkTrackingDeviceSource.h>
 #include "mitkNavigationDataDisplacementFilter.h"
 #include <mitkNavigationDataRecorder.h>
 #include <mitkNavigationDataPlayer.h>
-#include <mitkNavigationDataReaderXML.h>
 
 #include <itksys/SystemTools.hxx>
 
 //##Documentation
 //## \brief A small console tutorial about MITK-IGT
 int main(int  /*argc*/, char*  /*argv*/[])
 {
   //*************************************************************************
   // What we will do...
   //*************************************************************************
   //In this tutorial we build up a small navigation pipeline with a virtual tracking device
   //which produce random positions and orientation so no additional hardware is required.
   //The source of the pipeline is a TrackingDeviceSource object. This we connect to a simple
   //filter which just displaces the positions with an offset. After that we use a recorder
   //to store this new positions and other information to disc in a XML file. After that we use
   //another source (NavigationDataPlayer) to replay the recorded data.
 
   //*************************************************************************
   // Part I: Basic initialization of the source and tracking device
   //*************************************************************************
   //First of all create a tracking device object and two tools for this "device".
 
   //Here we take the VirtualTrackingDevice. This is not a real tracking device it just delivers random
   //positions and orientations. You can use other/real tracking devices if you replace the following
   //code with different tracking devices, e.g. mitk::NDITrackingDevice. The tools represent the
   //sensors of the tracking device. The TrackingDevice fills the tools with data.
   std::cout << "Generating TrackingDevice ..." << std::endl;
 
   mitk::VirtualTrackingDevice::Pointer tracker = mitk::VirtualTrackingDevice::New();
   tracker->AddTool("tool1");
   tracker->AddTool("tool2");
 
   //The tracking device object is used for the physical connection to the device. To use the
   //data inside of our tracking pipeline we need a source. This source encapsulate the tracking device
   //and provides objects of the type mitk::NavigationData as output. The NavigationData objects stores
   //position, orientation, if the data is valid or not and special error informations in a covariance
   //matrix.
   //
   //Typically the start of our pipeline is a TrackingDeviceSource. To work correct we have to set a
   //TrackingDevice object. Attention you have to set the tools before you set the whole TrackingDevice
   //object to the TrackingDeviceSource because the source need to know how many outputs should be
   //generated.
 
   std::cout << "Generating Source ..." << std::endl;
 
   mitk::TrackingDeviceSource::Pointer source = mitk::TrackingDeviceSource::New();
   source->SetTrackingDevice(tracker); //here we set the device for the pipeline source
 
   source->Connect();        //here we connect to the tracking system
   //Note we do not call this on the TrackingDevice object
   source->StartTracking();  //start the tracking
   //Now the source generates outputs.
 
   //*************************************************************************
   // Part II: Create a NavigationDataToNavigationDataFilter
   //*************************************************************************
 
   //The next thing we do is using a NavigationDataToNavigationDataFilter. One of these filter is the
   //very simple NavigationDataDisplacementFilter. This filter just changes the positions of the input
   //NavigationData objects with an offset for each direction (X,Y,Z). The input of this filter is the
   //source and the output of this filter is the "displaced" input.
 
   std::cout << "Generating DisplacementFilter ..." << std::endl;
 
   mitk::NavigationDataDisplacementFilter::Pointer displacer = mitk::NavigationDataDisplacementFilter::New();
   mitk::Vector3D offset;
   mitk::FillVector3D(offset, 10.0, 100.0, 1.0); //initialize the offset
   displacer->SetOffset(offset); //now set the offset in the NavigationDataDisplacementFilter object
 
   //Connect the two filters. You can use the ConnectTo method to automatically connect all outputs from one filter
   // to inputs from another filter.
   displacer->ConnectTo(source.GetPointer());
 
   // Alternatively, you can manually connect inputs and outputs.
   // The code below shows what the ConnectTo Methods does internally:
   //
   //for (unsigned int i = 0; i < source->GetNumberOfOutputs(); i++)
   //{
   //  displacer->SetInput(i, source->GetOutput(i));  //here we connect to the displacement filter
   //}
 
   //*************************************************************************
   // Part III: Record the data with the NavigationDataRecorder
   //*************************************************************************
 
   //The next part of our pipeline is the recorder. The input of the recorder is the output of the displacement filter
   //and the output is a XML file with the name "Test Output-0.xml", which is written with a NavigationDataSetWriter.
 
   std::cout << "Start Recording ..." << std::endl;
 
   //we need the stringstream for building up our filename
   std::stringstream filename;
 
  //the .xml extension and an counter is NOT added automatically anymore -- that was the case in an earlier version
   filename << itksys::SystemTools::GetCurrentWorkingDirectory() << "/Test Output-0.xml";
 
   std::cout << "Record to file: " << filename.str() << " ..." << std::endl;
 
   mitk::NavigationDataRecorder::Pointer recorder = mitk::NavigationDataRecorder::New();
 
   //now the output of the displacer object is connected to the recorder object
   recorder->ConnectTo(displacer);
 
   recorder->StartRecording(); //after finishing the settings you can start the recording mechanism
   //now every update of the recorder stores one line into the file for
   //each added NavigationData
 
   for (unsigned int x = 0; x < 100; x++) //write 100 datasets
   {
     recorder->Update(); //the update causes one line in the XML file for every tool
     //in this case two lines
     itksys::SystemTools::Delay(100);         //sleep a little
   }
   recorder->StopRecording(); //to get proper XML files you should stop recording
   //if your application crashes during recording no data
   //will be lost it is all stored to disc
 
   //The IO-System needs a filename. Otherwise the output
   //is redirected to the console. See MITK-Concepts page for more details on IO in MITK
   mitk::IOUtil::SaveBaseData(recorder->GetNavigationDataSet(), filename.str());
   //*************************************************************************
   // Part IV: Play the data with the NavigationDataPlayer
   //*************************************************************************
 
   //The recording is finished now so now we can play the data. The NavigationDataPlayer is similar
   //to the TrackingDevice source. It also derives from NavigationDataSource. So you can use a player
   //instead of a TrackingDeviceSource. The input of this player is a NavigationDataSet, which we
   //read with a NavigationDataReader.
 
   std::cout << "Start playing from file: " << filename.str() << " ..." << std::endl;
 
   mitk::NavigationDataPlayer::Pointer player = mitk::NavigationDataPlayer::New();
 
-  mitk::NavigationDataReaderXML::Pointer reader = mitk::NavigationDataReaderXML::New();
-  mitk::NavigationDataSet::Pointer naviDataSet = reader->Read(filename.str());
+  mitk::NavigationDataSet::Pointer naviDataSet = dynamic_cast<mitk::NavigationDataSet*> (mitk::IOUtil::LoadBaseData(filename.str()).GetPointer());
   player->SetNavigationDataSet(naviDataSet);
 
   player->StartPlaying(); //this starts the player
   //From now on the player provides NavigationDatas in the order and
   //correct time as they were recorded
 
   //this connects the outputs of the player to the NavigationData objects
   mitk::NavigationData::Pointer nd = player->GetOutput();
   mitk::NavigationData::Pointer nd2 = player->GetOutput(1);
   for (unsigned int x=0; x<100; x++)
   {
     if (nd.IsNotNull()) //check if the output is not null
     {
       //With this update the NavigationData object propagates through the pipeline to get a new value.
       //In this case we only have a source (NavigationDataPlayer).
       nd->Update();
 
       std::cout << x << ": 1:" << nd->GetPosition() << std::endl;
       std::cout << x << ": 2:" << nd2->GetPosition() << std::endl;
       std::cout << x << ": 1:" << nd->GetOrientation() << std::endl;
       std::cout << x << ": 2:" << nd2->GetOrientation() << std::endl;
 
       itksys::SystemTools::Delay(100); //sleep a little like in the recorder part
     }
   }
   player->StopPlaying(); //This stops the player
   //With another call of StartPlaying the player will start again at the beginning of the file
 
   itksys::SystemTools::Delay(2000);
   std::cout << "finished" << std::endl;
 }
diff --git a/Modules/IGTBase/autoload/IO/mitkNavigationDataReaderXML.cpp b/Modules/IGTBase/autoload/IO/mitkNavigationDataReaderXML.cpp
index 4dfb7c37ee..e88cca719d 100644
--- a/Modules/IGTBase/autoload/IO/mitkNavigationDataReaderXML.cpp
+++ b/Modules/IGTBase/autoload/IO/mitkNavigationDataReaderXML.cpp
@@ -1,383 +1,383 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // MITK
 #include "mitkNavigationDataReaderXML.h"
 #include <mitkIGTMimeTypes.h>
 
 // Third Party
 #include <itksys/SystemTools.hxx>
 #include <fstream>
 #include <tinyxml.h>
 
 
 mitk::NavigationDataReaderXML::NavigationDataReaderXML() : AbstractFileReader(
   mitk::IGTMimeTypes::NAVIGATIONDATASETXML_MIMETYPE(),
   "MITK NavigationData Reader (XML)"), m_parentElement(nullptr), m_currentNode(nullptr)
 {
   RegisterService();
 }
 
 mitk::NavigationDataReaderXML::~NavigationDataReaderXML()
 {
 }
 
 mitk::NavigationDataReaderXML::NavigationDataReaderXML(const mitk::NavigationDataReaderXML& other) : AbstractFileReader(other), m_parentElement(nullptr), m_currentNode(nullptr)
 {
 }
 
 mitk::NavigationDataReaderXML* mitk::NavigationDataReaderXML::Clone() const
 {
   return new NavigationDataReaderXML(*this);
 }
 
 
 std::vector<itk::SmartPointer<mitk::BaseData>> mitk::NavigationDataReaderXML::Read()
 {
   mitk::NavigationDataSet::Pointer dataset;
   std::istream* in = GetInputStream();
   if (in == nullptr)
   {
     dataset = Read(GetInputLocation());
   } else {
     dataset = Read(in);
   }
   std::vector<mitk::BaseData::Pointer> result;
   mitk::BaseData::Pointer base = dataset.GetPointer();
   result.push_back(base);
   return result;
 }
 
 
 
 mitk::NavigationDataSet::Pointer mitk::NavigationDataReaderXML::Read(std::string fileName)
 {
   //save old locale
   char * oldLocale;
   oldLocale = setlocale(LC_ALL, 0);
 
   //define own locale
   std::locale C("C");
   setlocale(LC_ALL, "C");
 
   m_FileName = fileName;
 
   TiXmlDocument document;
   if (!document.LoadFile(fileName))
   {
     mitkThrowException(mitk::IGTIOException) << "File '" << fileName << "' could not be loaded.";
   }
 
   TiXmlElement* m_DataElem = document.FirstChildElement("Version");
   if (!m_DataElem)
   {
     // for backwards compatibility of version tag
     m_DataElem = document.FirstChildElement("Data");
     if (!m_DataElem)
     {
       mitkThrowException(mitk::IGTIOException) << "Data element not found.";
     }
 
   }
 
   if (m_DataElem->QueryIntAttribute("Ver", &m_FileVersion) != TIXML_SUCCESS)
   {
     if (m_DataElem->QueryIntAttribute("version", &m_FileVersion) != TIXML_SUCCESS)
     {
       mitkThrowException(mitk::IGTIOException) << "Version not specified in XML file.";
     }
   }
 
   if (m_FileVersion != 1)
   {
     mitkThrowException(mitk::IGTIOException) << "File format version " << m_FileVersion << " is not supported.";
   }
 
   m_parentElement = document.FirstChildElement("Data");
   if (!m_parentElement)
   {
     mitkThrowException(mitk::IGTIOException) << "Data element not found.";
   }
 
   m_parentElement->QueryIntAttribute("ToolCount", &m_NumberOfOutputs);
 
   mitk::NavigationDataSet::Pointer navigationDataSet = this->ReadNavigationDataSet();
 
   //switch back to old locale
   setlocale(LC_ALL, oldLocale);
 
   return navigationDataSet;
 }
 
 mitk::NavigationDataSet::Pointer mitk::NavigationDataReaderXML::Read(std::istream* stream)
 {
   //save old locale
   char * oldLocale;
   oldLocale = setlocale( LC_ALL, nullptr );
 
   //define own locale
   std::locale C("C");
   setlocale( LC_ALL, "C" );
 
   // first get the file version
   m_FileVersion = this->GetFileVersion(stream);
 
   // check if we have a valid version: m_FileVersion has to be always bigger than 1 for playing
   if (m_FileVersion < 1)
   {
     StreamInvalid("Playing not possible. Invalid file version!");
     return nullptr;
   }
 
   m_NumberOfOutputs = this->GetNumberOfNavigationDatas(stream);
   if (m_NumberOfOutputs == 0) { return nullptr; }
 
   mitk::NavigationDataSet::Pointer dataSet = this->ReadNavigationDataSet();
 
   //switch back to old locale
   setlocale( LC_ALL, oldLocale );
 
   return dataSet;
 }
 
 mitk::NavigationDataSet::Pointer mitk::NavigationDataReaderXML::ReadNavigationDataSet()
 {
   mitk::NavigationDataSet::Pointer navigationDataSet = mitk::NavigationDataSet::New(m_NumberOfOutputs);
   mitk::NavigationData::Pointer curNavigationData;
 
   do
     {
       std::vector<mitk::NavigationData::Pointer> navDatas(m_NumberOfOutputs);
-      for (unsigned int n = 0; n < m_NumberOfOutputs; ++n)
+      for (int n = 0; n < m_NumberOfOutputs; ++n)
       {
         curNavigationData = this->ReadVersion1();
 
         if (curNavigationData.IsNull())
         {
           if (n != 0)
           {
             MITK_WARN("mitkNavigationDataReaderXML")
                 << "Different number of NavigationData objects for different tools. Ignoring last ones.";
           }
           break;
         }
         navDatas.at(n) = curNavigationData;
       }
 
       if (curNavigationData.IsNotNull())
       {
         navigationDataSet->AddNavigationDatas(navDatas);
       }
     }
     while (curNavigationData.IsNotNull());
 
     return navigationDataSet;
 }
 
 mitk::NavigationData::Pointer mitk::NavigationDataReaderXML::ReadVersion1()
 {
   if ( !m_parentElement )
   {
     mitkThrowException(mitk::IGTIOException) << "Reading XML is not possible. Parent element is not set.";
   }
 
   TiXmlElement* elem;
   m_currentNode = m_parentElement->IterateChildren(m_currentNode);
 
   bool delElem;
 
   if(m_currentNode)
   {
     elem = m_currentNode->ToElement();
     if(elem==nullptr)
     {
       mitkThrowException(mitk::IGTException) << "Cannot find element: Is this file damaged?";
     }
     delElem = false;
   }
 
   else
   {
     elem = new TiXmlElement("");
     delElem = true;
   }
 
 
   mitk::NavigationData::Pointer nd = this->ReadNavigationData(elem);
 
   if(delElem) { delete elem; }
 
   return nd;
 }
 
 mitk::NavigationData::Pointer mitk::NavigationDataReaderXML::ReadNavigationData(TiXmlElement* elem)
 {
   if (elem == nullptr) {mitkThrow() << "Error: Element is NULL!";}
 
   mitk::NavigationData::Pointer nd = mitk::NavigationData::New();
 
   mitk::NavigationData::PositionType position;
   mitk::NavigationData::OrientationType orientation(0.0,0.0,0.0,0.0);
   mitk::NavigationData::TimeStampType timestamp = -1;
   mitk::NavigationData::CovarianceMatrixType matrix;
 
   bool hasPosition = true;
   bool hasOrientation = true;
   bool dataValid = false;
 
   position.Fill(0.0);
   matrix.SetIdentity();
 
   elem->QueryDoubleAttribute("Time",&timestamp);
   if (timestamp == -1)
   {
     return nullptr;  //the calling method should check the return value if it is valid/not NULL
   }
 
   elem->QueryDoubleAttribute("X", &position[0]);
   elem->QueryDoubleAttribute("Y", &position[1]);
   elem->QueryDoubleAttribute("Z", &position[2]);
 
   elem->QueryDoubleAttribute("QX", &orientation[0]);
   elem->QueryDoubleAttribute("QY", &orientation[1]);
   elem->QueryDoubleAttribute("QZ", &orientation[2]);
   elem->QueryDoubleAttribute("QR", &orientation[3]);
 
   elem->QueryDoubleAttribute("C00", &matrix[0][0]);
   elem->QueryDoubleAttribute("C01", &matrix[0][1]);
   elem->QueryDoubleAttribute("C02", &matrix[0][2]);
   elem->QueryDoubleAttribute("C03", &matrix[0][3]);
   elem->QueryDoubleAttribute("C04", &matrix[0][4]);
   elem->QueryDoubleAttribute("C05", &matrix[0][5]);
   elem->QueryDoubleAttribute("C10", &matrix[1][0]);
   elem->QueryDoubleAttribute("C11", &matrix[1][1]);
   elem->QueryDoubleAttribute("C12", &matrix[1][2]);
   elem->QueryDoubleAttribute("C13", &matrix[1][3]);
   elem->QueryDoubleAttribute("C14", &matrix[1][4]);
   elem->QueryDoubleAttribute("C15", &matrix[1][5]);
 
   int tmpval = 0;
   elem->QueryIntAttribute("Valid", &tmpval);
   if (tmpval == 0)
     dataValid = false;
   else
     dataValid = true;
 
   tmpval = 0;
   elem->QueryIntAttribute("hO", &tmpval);
   if (tmpval == 0)
     hasOrientation = false;
   else
     hasOrientation = true;
 
   tmpval = 0;
   elem->QueryIntAttribute("hP", &tmpval);
   if (tmpval == 0)
     hasPosition = false;
   else
     hasPosition = true;
 
   nd->SetIGTTimeStamp(timestamp);
   nd->SetPosition(position);
   nd->SetOrientation(orientation);
   nd->SetCovErrorMatrix(matrix);
   nd->SetDataValid(dataValid);
   nd->SetHasOrientation(hasOrientation);
   nd->SetHasPosition(hasPosition);
 
 
   return nd;
 }
 
 // -- deprecated | begin
 unsigned int mitk::NavigationDataReaderXML::GetFileVersion(std::istream* stream)
 {
   if (stream==nullptr)
   {
     MITK_ERROR << "No input stream set!";
     mitkThrowException(mitk::IGTIOException)<<"No input stream set!";
   }
   if (!stream->good())
   {
     MITK_ERROR << "Stream is not good!";
     mitkThrowException(mitk::IGTIOException)<<"Stream is not good!";
   }
   int version = 1;
 
   auto  dec = new TiXmlDeclaration();
   *stream >> *dec;
   if(strcmp(dec->Version(),"") == 0)
   {
     MITK_ERROR << "The input stream seems to have XML incompatible format";
     mitkThrowException(mitk::IGTIOException) << "The input stream seems to have XML incompatible format";
   }
 
   m_parentElement = new TiXmlElement("");
   *stream >> *m_parentElement; //2nd line this is the file version
 
   std::string tempValue = m_parentElement->Value();
   if(tempValue != "Version")
   {
       if(tempValue == "Data"){
           m_parentElement->QueryIntAttribute("version",&version);
       }
   }
   else
   {
     m_parentElement->QueryIntAttribute("Ver",&version);
   }
 
   if (version > 0) { return version; }
   else { return 0; }
 }
 
 unsigned int mitk::NavigationDataReaderXML::GetNumberOfNavigationDatas(std::istream* stream)
 {
   if (stream == nullptr)
   {
     MITK_ERROR << "No input stream set!";
     mitkThrowException(mitk::IGTException)<<"No input stream set!";
   }
   if (!stream->good())
   {
     MITK_ERROR << "Stream not good!";
     mitkThrowException(mitk::IGTException)<<"Stream not good!";
   }
 
   //If something has changed in a future version of the XML definition e.g. navigationcount or addional parameters
   //catch this here with a select case block (see GenerateData() method)
 
   int numberOfTools = 0;
 
   std::string tempValue = m_parentElement->Value();
   if(tempValue == "Version"){
     *stream >> *m_parentElement;
   }
   m_parentElement->QueryIntAttribute("ToolCount",&numberOfTools);
 
   if (numberOfTools > 0) { return numberOfTools; }
 
   return 0;
 }
 
 void mitk::NavigationDataReaderXML::StreamInvalid(std::string message)
 {
   m_StreamEnd = true;
   m_ErrorMessage = message;
   m_StreamValid = false;
   mitkThrowException(mitk::IGTIOException) << "Invalid stream!";
 }
 // -- deprecated | end
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 5ae281ddc1..e2f3a4e553 100644
--- a/Plugins/org.mitk.gui.qt.igtlplugin/src/internal/OpenIGTLinkProviderExample.cpp
+++ b/Plugins/org.mitk.gui.qt.igtlplugin/src/internal/OpenIGTLinkProviderExample.cpp
@@ -1,241 +1,240 @@
 /*===================================================================
 
 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>
+#include <mitkIOUtil.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 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);
 
   //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();
 
   //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);
 
   //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();
 
   //also create a visualize filter to visualize the data
   m_NavDataVisualizer = mitk::NavigationDataObjectVisualizationFilter::New();
 
   //create an object that will be moved respectively to the navigation data
   for (size_t i = 0; i < m_NavDataPlayer->GetNumberOfIndexedOutputs(); i++)
   {
      mitk::DataNode::Pointer newNode = mitk::DataNode::New();
      QString name("DemoNode IGTLProviderExmpl T");
      name.append(QString::number(i));
      newNode->SetName(name.toStdString());
 
      //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();
      newNode->SetData(mySphere);
 
      this->GetDataStorage()->Add(newNode);
 
      m_NavDataVisualizer->SetRepresentationObject(i, mySphere);
 
      m_DemoNodes.append(newNode);
   }
 
   //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);
 
 
   //connect the visualization with the navigation data player
   m_NavDataVisualizer->ConnectTo(m_NavDataPlayer);
 
   //start the player
   this->Start();
 
   mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(this->GetDataStorage());
 }
 
 void OpenIGTLinkProviderExample::DestroyPipeline()
 {
    if (m_NavDataPlayer.IsNotNull())
    {
       m_NavDataPlayer->StopPlaying();
    }
    foreach(mitk::DataNode::Pointer node, m_DemoNodes)
    {
       this->GetDataStorage()->Remove(node);
    }
    this->m_DemoNodes.clear();
 }
 
 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(100);
   }
   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());
+    m_NavDataSet = dynamic_cast<mitk::NavigationDataSet*> (mitk::IOUtil::LoadBaseData(fileName.toStdString()).GetPointer());
   }
   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();
 }