diff --git a/Modules/IGT/IO/mitkNavigationDataPlayer.h b/Modules/IGT/IO/mitkNavigationDataPlayer.h
index 3652ee5179..0b8ce97ec6 100644
--- a/Modules/IGT/IO/mitkNavigationDataPlayer.h
+++ b/Modules/IGT/IO/mitkNavigationDataPlayer.h
@@ -1,114 +1,109 @@
 /*===================================================================
 
 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 MITKNavigationDataPlayer_H_HEADER_INCLUDED_
 #define MITKNavigationDataPlayer_H_HEADER_INCLUDED_
 
 #include <mitkNavigationDataPlayerBase.h>
-#include <mitkNavigationDataSource.h>
-#include <mitkNavigationDataRecorder.h> //for the Recording Mode enum
-#include "mitkTrackingDevice.h"
 
 #include <itkMultiThreader.h>
 
-#include <istream>
-
 
 namespace mitk {
   /**Documentation
   * \brief This class is used to play recorded (see mitkNavigationDataRecorder class) files.
   *
   * If you want to play a file you have to set an input stream. This can be an own one (use StartPlaying(std::istream*))
   * or a preset (use StartPlaying()). The presets are NormalFile and ZipFile and can be set with the method
   * SetPlayerMode(PlayerMode). The presets need a FileName. Therefore the FileName must be set before the preset.
   * For pausing the player call Pause(). A call of Resume() will continue the playing.
   *
   *
   * \ingroup IGT
   */
   class MitkIGT_EXPORT NavigationDataPlayer : public NavigationDataPlayerBase
   {
   public:
     mitkClassMacro(NavigationDataPlayer, NavigationDataPlayerBase);
     itkNewMacro(Self);
 
     /**
     * \brief Used for pipeline update just to tell the pipeline that we always have to update
     */
     virtual void UpdateOutputInformation();
 
     /**
      * \brief This method starts the player.
      *
-     * Before the stream has to be set. Either with a PlayingMode (SetStream(PlayerMode)) and FileName. Or
-     * with an own inputstream (SetStream(istream*)).
+     * The method mitk::NavigationDataPlayer::SetNavigationDataSet() has to be called before.
      *
-     * @throw mitk::IGTIOException Throws an exception if the file cannot be opened.
-     * @throw mitk::IGTIOException Throws an exception if there is no valid filename.
-     * @throw mitk::IGTIOException Throws an exception if the file is damaged.
-     * @throw mitk::IGTException Throws an exception if there is no stream (i.e stream=NULL).
+     * @throw mitk::IGTException If m_NavigationDataSet is null.
      */
     void StartPlaying();
 
     /**
      * \brief Stops the player and closes the stream. After a call of StopPlaying()
      * StartPlaying() must be called to get new output data
      *
      * \warning the output is generated in this method because we know first about the number of output after
      * reading the first lines of the XML file. Therefore you should assign your output after the call of this method
      */
     void StopPlaying();
 
     /**
      * \brief This method pauses the player. If you want to play again call Resume()
      */
     void Pause();
 
     /**
      * \brief This method resumes the player when it was paused.
      */
     void Resume();
 
     /**
      * \brief This method checks if player arrived at end of file.
      *
      */
-    bool IsAtEnd();
+    virtual bool IsAtEnd();
 
   protected:
-    enum PlayerState { PlayerStopped, PlayerRunning, PlayerPaused };
-
-    PlayerState m_CurPlayerState;
-
     NavigationDataPlayer();
     virtual ~NavigationDataPlayer();
 
-    typedef mitk::NavigationData::TimeStampType TimeStampType;
-
     /**
-     * \brief filter execute method
+     * \brief Set outputs to the navigation data object corresponding to current time.
      */
     virtual void GenerateData();
 
-    TimeStampType m_StartPlayingTimeStamp; ///< the starttime of the playing set in the method StartPlaying()
-    TimeStampType m_PauseTimeStamp; ///< stores the beginning of a pause
+    enum PlayerState { PlayerStopped, PlayerRunning, PlayerPaused };
+    PlayerState m_CurPlayerState;
+
+    typedef mitk::NavigationData::TimeStampType TimeStampType;
 
-    std::vector<TimeStampType> m_StartTimeOfData; ///< stores the start time of the different tools
+    /**
+      * \brief The start time of the playing. Set in the method mitk::NavigationDataPlayer::StartPlaying().
+      */
+    TimeStampType m_StartPlayingTimeStamp;
+
+    /**
+      * \brief Stores the time when a pause began.
+      */
+    TimeStampType m_PauseTimeStamp;
   };
 } // namespace mitk
 
 #endif /* MITKNavigationDataPlayer_H_HEADER_INCLUDED_ */
diff --git a/Modules/IGT/IO/mitkNavigationDataPlayerBase.h b/Modules/IGT/IO/mitkNavigationDataPlayerBase.h
index df24137d67..edff7742b8 100644
--- a/Modules/IGT/IO/mitkNavigationDataPlayerBase.h
+++ b/Modules/IGT/IO/mitkNavigationDataPlayerBase.h
@@ -1,83 +1,89 @@
 /*===================================================================
 
 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 MITKNavigationDataPlayerBase_H_HEADER_INCLUDED_
 #define MITKNavigationDataPlayerBase_H_HEADER_INCLUDED_
 
 #include <mitkNavigationDataSource.h>
 #include "mitkNavigationDataReaderInterface.h"
 #include "tinyxml.h"
 
 
 namespace mitk{
 
   /**Documentation
   * \brief This class is a slightly changed reimplementation of the
   * NavigationDataPlayer which does not care about timestamps and just
   * outputs the navigationdatas in their sequential order
   *
   * \ingroup IGT
   */
   class MitkIGT_EXPORT NavigationDataPlayerBase
     : public NavigationDataSource
   {
   public:
     mitkClassMacro(NavigationDataPlayerBase, NavigationDataSource);
 
     /**
     * \brief Used for pipeline update just to tell the pipeline that we always have to update
     */
     virtual void UpdateOutputInformation();
 
     itkGetMacro(NavigationDataSet, NavigationDataSet::Pointer);
     void SetNavigationDataSet(NavigationDataSet::Pointer navigationDataSet);
 
     /**
      * @return Returns the number of navigation data snapshots available in the player
      */
     unsigned int GetNumberOfSnapshots();
 
+    /**
+     * \brief This method checks if player arrived at end of file.
+     *
+     */
+    virtual bool IsAtEnd() = 0;
+
   protected:
     NavigationDataPlayerBase();
     virtual ~NavigationDataPlayerBase();
 
     virtual void GenerateData() = 0;
 
     /**
      * \brief Initializes the outputs of this NavigationDataSource.
      */
     void InitPlayer();
 
     /**
       *
       */
     void GraftEmptyOutput();
 
     NavigationDataSet::Pointer m_NavigationDataSet;
     mitk::NavigationDataSet::NavigationDataSetIterator m_NavigationDataSetIterator;
 
     unsigned int m_NumberOfOutputs; ///< stores the number of outputs known from NavigationDataSet
 
     /**
     * \brief Creates NavigationData from XML element and returns it
     * @throw mitk::Exception Throws an exception if elem is NULL.
     */
     mitk::NavigationData::Pointer ReadNavigationData(TiXmlElement* elem);
   };
 } // namespace mitk
 
 #endif /* MITKNavigationDataSequentialPlayer_H_HEADER_INCLUDED_ */
diff --git a/Modules/IGT/IO/mitkNavigationDataReaderXML.cpp b/Modules/IGT/IO/mitkNavigationDataReaderXML.cpp
index 2008c0bd9a..5d2f8186fc 100644
--- a/Modules/IGT/IO/mitkNavigationDataReaderXML.cpp
+++ b/Modules/IGT/IO/mitkNavigationDataReaderXML.cpp
@@ -1,350 +1,331 @@
 /*===================================================================
 
 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 "mitkNavigationDataReaderXML.h"
 #include <itksys/SystemTools.hxx>
 #include <fstream>
 #include "tinyxml.h"
 
 //includes for exceptions
 #include "mitkIGTException.h"
 #include "mitkIGTIOException.h"
 
 mitk::NavigationDataReaderXML::NavigationDataReaderXML()
   : m_parentElement(0), m_currentNode(0)
 {
 }
 
 mitk::NavigationDataReaderXML::~NavigationDataReaderXML()
 {
 
 }
 
 mitk::NavigationDataSet::Pointer mitk::NavigationDataReaderXML::Read(std::string fileName)
 {
   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();
 
   return navigationDataSet;
 }
 
 mitk::NavigationDataSet::Pointer mitk::NavigationDataReaderXML::Read(std::istream* stream)
 {
   // 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 0;
   }
 
   m_NumberOfOutputs = this->GetNumberOfNavigationDatas(stream);
   if (m_NumberOfOutputs == 0) { return 0; }
 
   return this->ReadNavigationDataSet();
 }
 
 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, NULL);
       for (unsigned int n = 0; n < m_NumberOfOutputs; ++n)
       {
         curNavigationData = this->ReadVersion1();
 
         if (curNavigationData.IsNull())
         {
-          if (n == 0)
+          if (n != 0)
           {
-            MITK_ERROR("mitkNavigationDataReaderXML")
-                << "Different number of NaivigationData objects for different tools. Ignoring last ones.";
+            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==NULL)
     {
       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 == NULL) {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 NULL;  //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==NULL)
   {
     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;
 
   TiXmlDeclaration* 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 == NULL)
   {
     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::SetStream( std::istream* stream )
-{
-  if ( (stream == NULL) || (!stream->good()))
-  {
-    // throw an exception for stream=NULL or it is not good
-    mitkThrowException(mitk::IGTException) << "The stream is NULL or it is not good";
-    m_StreamEnd = true;
-    return;
-  }
-
-  if (m_StreamSetOutsideFromClass) { delete m_Stream; }
-
-  m_Stream = stream;
-  m_StreamSetOutsideFromClass = true;
-
-  this->Modified();
-}*/
-
 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/Modules/IGT/IO/mitkNavigationDataSequentialPlayer.cpp b/Modules/IGT/IO/mitkNavigationDataSequentialPlayer.cpp
index cc63f5fe19..df72011dc1 100644
--- a/Modules/IGT/IO/mitkNavigationDataSequentialPlayer.cpp
+++ b/Modules/IGT/IO/mitkNavigationDataSequentialPlayer.cpp
@@ -1,88 +1,89 @@
 /*===================================================================
 
 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 "mitkNavigationDataSequentialPlayer.h"
 
 #include <itksys/SystemTools.hxx> //for the pause
 #include <fstream>
 #include <sstream>
 
 //Exceptions
 #include "mitkIGTException.h"
 #include "mitkIGTIOException.h"
 
 mitk::NavigationDataSequentialPlayer::NavigationDataSequentialPlayer()
-  : mitk::NavigationDataPlayerBase()
-  , m_DataElem(0)
-  , m_CurrentElem(0)
-  , m_Repeat(false)
-  , m_NumberOfSnapshots(0)
-  , m_LastGoTo(0)
+  : m_Repeat(false)
 {
 }
 
 mitk::NavigationDataSequentialPlayer::~NavigationDataSequentialPlayer()
 {
 }
 
 void mitk::NavigationDataSequentialPlayer::GoToSnapshot(unsigned int i)
 {
   if( !m_Repeat && (this->GetNumberOfSnapshots() <= i) )
   {
     MITK_ERROR << "Snaphot " << i << " does not exist and repat is off: can't go to that snapshot!";
-    mitkThrowException(mitk::IGTException) << "Snaphot " << i << " does not exist and repat is off: can't go to that snapshot!";
+    mitkThrowException(mitk::IGTException) << "Snapshot " << i << " does not exist and repat is off: can't go to that snapshot!";
   }
 
   // set iterator to given position (modulo for allowing repeat)
   m_NavigationDataSetIterator = m_NavigationDataSet->Begin() + ( i % this->GetNumberOfSnapshots() );
 
+  // set outputs to selected snapshot
   this->Update();
 }
 
 void mitk::NavigationDataSequentialPlayer::GenerateData()
 {
   if ( m_NavigationDataSetIterator == m_NavigationDataSet->End() )
   {
      if ( m_Repeat )
      {
        // set data back to start if repeat is enabled
        m_NavigationDataSetIterator = m_NavigationDataSet->Begin();
      }
      else
      {
        // no more data available
        this->GraftEmptyOutput();
        return;
      }
   }
 
 
   for (unsigned int index = 0; index < m_NumberOfOutputs; index++)
   {
     mitk::NavigationData* output = this->GetOutput(index);
     if( !output ) { mitkThrowException(mitk::IGTException) << "Output of index "<<index<<" is null."; }
 
     output->Graft(m_NavigationDataSetIterator->at(index));
   }
 
   ++m_NavigationDataSetIterator;
 }
 
 void mitk::NavigationDataSequentialPlayer::UpdateOutputInformation()
 {
   this->Modified();  // make sure that we need to be updated
   Superclass::UpdateOutputInformation();
 }
+
+bool mitk::NavigationDataSequentialPlayer::IsAtEnd()
+{
+  return m_NavigationDataSetIterator == m_NavigationDataSet->End();
+}
diff --git a/Modules/IGT/IO/mitkNavigationDataSequentialPlayer.h b/Modules/IGT/IO/mitkNavigationDataSequentialPlayer.h
index 0220fc5066..f9360e83ec 100644
--- a/Modules/IGT/IO/mitkNavigationDataSequentialPlayer.h
+++ b/Modules/IGT/IO/mitkNavigationDataSequentialPlayer.h
@@ -1,117 +1,88 @@
 /*===================================================================
 
 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 MITKNavigationDataSequentialPlayer_H_HEADER_INCLUDED_
 #define MITKNavigationDataSequentialPlayer_H_HEADER_INCLUDED_
 
 #include <mitkNavigationDataPlayerBase.h>
-#include "tinyxml.h"
-
 
 namespace mitk
 {
 
   /**Documentation
   * \brief This class is a slightly changed reimplementation of the
   * NavigationDataPlayer which does not care about timestamps and just
   * outputs the navigationdatas in their sequential order
   *
   * \ingroup IGT
   */
   class MitkIGT_EXPORT NavigationDataSequentialPlayer
     : public NavigationDataPlayerBase
   {
   public:
     mitkClassMacro(NavigationDataSequentialPlayer, NavigationDataPlayerBase);
     itkNewMacro(Self);
 
     /**
-     * \brief sets the file name and path (if XMLString is set, this is neglected)
-     * @throw mitk::IGTIOException Throws an exception if the given file cannot be loaded.
-     */
-    //void SetFileName(const std::string& _FileName);
-
-    /**
-    * \brief returns the file name and path
-    */
-    //itkGetStringMacro(FileName);
-
-    /**
-    * \brief sets a xml string (by this, the xml string is not read from file)
-    * @throw mitk::IGTExcepton Throws an mitk::IGTExcepton if the string to set is not an XMLString
-    */
-    //void SetXMLString(const std::string& _XMLString);
-
-    /**
-    * \brief returns the current xml string
-    */
-    itkGetStringMacro(XMLString);
-
-    /**
-     * @brief Set to true if the data player should repeat the outputs.
+     * \brief Set to true if the data player should repeat the outputs.
      */
     itkSetMacro(Repeat, bool);
 
     /**
-     * @return Returns if the data player should repeat the outputs.
+     * \return Returns if the data player should repeat the outputs.
      */
     itkGetMacro(Repeat, bool);
 
     /**
-    * advance the output to the i-th snapshot
-    * e.g. if you want to have the NavData of snapshot
-    * 17 then you can call GoToSnapshot(17). index begins at 1!
-    * you can then also go back to snapshot 1 with GoToSnapshot(1)
+    * \brief Advance the output to the i-th snapshot of mitk::NavigationData.
+    * E.g. if you want to have the NavData of snapshot
+    * 18 then you can call GoToSnapshot(17). Index begins at 0.
+    * You can only go back if m_Repeat is set true.
+    *
+    * Filter output is updated inside the function.
     *
     * @throw mitk::IGTException Throws an exception if cannot go back to particular snapshot.
     */
     void GoToSnapshot(unsigned int i);
 
     /**
     * \brief Used for pipeline update just to tell the pipeline
     * that we always have to update
     */
     virtual void UpdateOutputInformation();
 
-  protected:
-    NavigationDataSequentialPlayer();
-    virtual ~NavigationDataSequentialPlayer();
-
     /**
-     * @throw mitk::IGTException Throws an exception if data element is not found.
+     * \brief This method checks if player arrived at end of file.
+     *
      */
-    //void ReinitXML();
+    virtual bool IsAtEnd();
 
-    //mitk::NavigationData::Pointer ReadVersion1();
+  protected:
+    NavigationDataSequentialPlayer();
+    virtual ~NavigationDataSequentialPlayer();
 
     /**
-     * @throw mitk::IGTException Throws an exception if cannot parse input file
+     *
+     * @throw mitk::IGTException Throws an exception if an output is null.
      */
     virtual void GenerateData();
 
-    std::string m_FileName;
-    std::string m_XMLString;
-    TiXmlDocument* m_Doc;
-    TiXmlElement* m_DataElem;
-    TiXmlElement* m_CurrentElem;
     bool m_Repeat;
-    unsigned int m_NumberOfSnapshots;
-    int m_LastGoTo;
   };
 } // namespace mitk
 
 #endif /* MITKNavigationDataSequentialPlayer_H_HEADER_INCLUDED_ */
diff --git a/Modules/IGT/IO/mitkNavigationDataSetWriterXML.cpp b/Modules/IGT/IO/mitkNavigationDataSetWriterXML.cpp
index dd8baad821..9ce7eee434 100644
--- a/Modules/IGT/IO/mitkNavigationDataSetWriterXML.cpp
+++ b/Modules/IGT/IO/mitkNavigationDataSetWriterXML.cpp
@@ -1,130 +1,130 @@
 /*===================================================================
 
 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 "mitkNavigationDataSetWriterXML.h"
 
 // Third Party
 #include <tinyxml.h>
 #include <itksys/SystemTools.hxx>
 #include <fstream>
 #include <iostream>
 
 mitk::NavigationDataSetWriterXML::NavigationDataSetWriterXML()
 {
 }
 
 mitk::NavigationDataSetWriterXML::~NavigationDataSetWriterXML()
 {
 }
 
 void mitk::NavigationDataSetWriterXML::Write (std::string path, mitk::NavigationDataSet::Pointer data)
 {
   std::ofstream stream;
-  stream.open (path);
+  stream.open (path.c_str(), std::ios_base::trunc);
 
   // Pass to Stream Handler
   Write(&stream, data);
   stream.close();
 }
 
 void mitk::NavigationDataSetWriterXML::Write (std::ostream* stream, mitk::NavigationDataSet::Pointer data)
 {
   StreamHeader(stream, data);
   StreamData(stream, data);
   StreamFooter(stream);
 
   // Cleanup
 
   stream->flush();
 }
 
 void mitk::NavigationDataSetWriterXML::StreamHeader (std::ostream* stream, mitk::NavigationDataSet::Pointer data)
 {
   stream->precision(10);
 
   //TODO store date and GMT time
   //checking if the stream is good
   if (stream->good())
   {
     *stream << "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>" << std::endl;
     /**m_Stream << "<Version Ver=\"1\" />" << std::endl;*/
     // should be a generic version, meaning a member variable, which has the actual version
     *stream << "    " << "<Data ToolCount=\"" << data->GetNumberOfTools() << "\" version=\"1.0\">" << std::endl;
   }
 }
 
 void mitk::NavigationDataSetWriterXML::StreamData (std::ostream* stream, mitk::NavigationDataSet::Pointer data)
 {
   // For each time step in the Dataset
   for (mitk::NavigationDataSet::NavigationDataSetIterator it = data->Begin(); it != data->End(); it++)
   {
     for (int toolIndex = 0; toolIndex < it->size(); toolIndex++)
     {
       mitk::NavigationData::Pointer nd = it->at(toolIndex);
       TiXmlElement* elem = new TiXmlElement("ND");
 
       elem->SetDoubleAttribute("Time", nd->GetIGTTimeStamp());
       // elem->SetAttribute("SystemTime", sysTimeStr); // tag for system time
       elem->SetDoubleAttribute("Tool", toolIndex);
       elem->SetDoubleAttribute("X", nd->GetPosition()[0]);
       elem->SetDoubleAttribute("Y", nd->GetPosition()[1]);
       elem->SetDoubleAttribute("Z", nd->GetPosition()[2]);
 
       elem->SetDoubleAttribute("QX", nd->GetOrientation()[0]);
       elem->SetDoubleAttribute("QY", nd->GetOrientation()[1]);
       elem->SetDoubleAttribute("QZ", nd->GetOrientation()[2]);
       elem->SetDoubleAttribute("QR", nd->GetOrientation()[3]);
 
       elem->SetDoubleAttribute("C00", nd->GetCovErrorMatrix()[0][0]);
       elem->SetDoubleAttribute("C01", nd->GetCovErrorMatrix()[0][1]);
       elem->SetDoubleAttribute("C02", nd->GetCovErrorMatrix()[0][2]);
       elem->SetDoubleAttribute("C03", nd->GetCovErrorMatrix()[0][3]);
       elem->SetDoubleAttribute("C04", nd->GetCovErrorMatrix()[0][4]);
       elem->SetDoubleAttribute("C05", nd->GetCovErrorMatrix()[0][5]);
       elem->SetDoubleAttribute("C10", nd->GetCovErrorMatrix()[1][0]);
       elem->SetDoubleAttribute("C11", nd->GetCovErrorMatrix()[1][1]);
       elem->SetDoubleAttribute("C12", nd->GetCovErrorMatrix()[1][2]);
       elem->SetDoubleAttribute("C13", nd->GetCovErrorMatrix()[1][3]);
       elem->SetDoubleAttribute("C14", nd->GetCovErrorMatrix()[1][4]);
       elem->SetDoubleAttribute("C15", nd->GetCovErrorMatrix()[1][5]);
 
       if (nd->IsDataValid())
         elem->SetAttribute("Valid",1);
       else
         elem->SetAttribute("Valid",0);
 
       if (nd->GetHasOrientation())
         elem->SetAttribute("hO",1);
       else
         elem->SetAttribute("hO",0);
 
       if (nd->GetHasPosition())
         elem->SetAttribute("hP",1);
       else
         elem->SetAttribute("hP",0);
 
       *stream << "        " << *elem << std::endl;
 
       delete elem;
     }
   }
 }
 
 void mitk::NavigationDataSetWriterXML::StreamFooter (std::ostream* stream)
 {
   *stream << "</Data>" << std::endl;
 }
diff --git a/Modules/IGT/Testing/mitkNavigationDataToPointSetFilterTest.cpp b/Modules/IGT/Testing/mitkNavigationDataToPointSetFilterTest.cpp
index 15dd43ae67..a662280da2 100644
--- a/Modules/IGT/Testing/mitkNavigationDataToPointSetFilterTest.cpp
+++ b/Modules/IGT/Testing/mitkNavigationDataToPointSetFilterTest.cpp
@@ -1,252 +1,248 @@
 /*===================================================================
 
 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 "mitkNavigationDataToPointSetFilter.h"
 #include "mitkNavigationDataSequentialPlayer.h"
 #include "mitkNavigationDataReaderXML.h"
 #include <mitkStandardFileLocations.h>
 #include <mitkTestingMacros.h>
 
 #include <iostream>
 
 #include <itksys/SystemTools.hxx>
 
 /**
  *  Simple example for a test for the (non-existent) class "NavigationDataToPointSetFilter".
  *
  *  argc and argv are the command line parameters which were passed to
  *  the ADD_TEST command in the CMakeLists.txt file. For the automatic
  *  tests, argv is either empty for the simple tests or contains the filename
  *  of a test image for the image tests (see CMakeLists.txt).
  */
 class mitkNavigationDataToPointSetFilterTestClass {
 
 public:
 
 static void TestMode3D(mitk::NavigationDataToPointSetFilter::Pointer myNavigationDataToPointSetFilter)
 {
   myNavigationDataToPointSetFilter->SetOperationMode(mitk::NavigationDataToPointSetFilter::Mode3D);
 
   //Build up test data
   mitk::NavigationData::Pointer nd0 = mitk::NavigationData::New();
   mitk::NavigationData::Pointer nd1 = mitk::NavigationData::New();
   mitk::NavigationData::Pointer nd2 = mitk::NavigationData::New();
   mitk::NavigationData::Pointer nd3 = mitk::NavigationData::New();
 
   mitk::NavigationData::PositionType point0;
   point0[0] = 1.0;
   point0[1] = 2.0;
   point0[2] = 3.0;
   nd0->SetPosition(point0);
   nd0->SetDataValid(true);
 
   mitk::NavigationData::PositionType point1;
   point1[0] = 4.0;
   point1[1] = 5.0;
   point1[2] = 6.0;
   nd1->SetPosition(point1);
   nd1->SetDataValid(true);
 
   mitk::NavigationData::PositionType point2;
   point2[0] = 7.0;
   point2[1] = 8.0;
   point2[2] = 9.0;
   nd2->SetPosition(point2);
   nd2->SetDataValid(true);
 
   mitk::NavigationData::PositionType point3;
   point3[0] = 10.0;
   point3[1] = 11.0;
   point3[2] = 12.0;
   nd3->SetPosition(point3);
   nd3->SetDataValid(true);
 
   myNavigationDataToPointSetFilter->SetInput(0, nd0);
   myNavigationDataToPointSetFilter->SetInput(1, nd1);
   myNavigationDataToPointSetFilter->SetInput(2, nd2);
   myNavigationDataToPointSetFilter->SetInput(3, nd3);
 
   //Process
   mitk::PointSet::Pointer pointSet0 = myNavigationDataToPointSetFilter->GetOutput();
   mitk::PointSet::Pointer pointSet1 = myNavigationDataToPointSetFilter->GetOutput(1);
   mitk::PointSet::Pointer pointSet2 = myNavigationDataToPointSetFilter->GetOutput(2);
   mitk::PointSet::Pointer pointSet3 = myNavigationDataToPointSetFilter->GetOutput(3);
 
   pointSet0->Update();
 
   MITK_TEST_OUTPUT(<< "Testing the conversion of navigation data object to PointSets in Mode 3D:");
   MITK_TEST_CONDITION(mitk::Equal(pointSet0->GetPoint(0), point0), "Pointset 0 correct?");
   MITK_TEST_CONDITION(mitk::Equal(pointSet1->GetPoint(0), point1), "Pointset 1 correct?");
   MITK_TEST_CONDITION(mitk::Equal(pointSet2->GetPoint(0), point2), "Pointset 2 correct?");
   MITK_TEST_CONDITION(mitk::Equal(pointSet3->GetPoint(0), point3), "Pointset 3 correct?");
 
     //pointSet0->GetPoint(0)[0] == 1.0  && pointSet0->GetPoint(0)[1] == 2.0  && pointSet0->GetPoint(0)[2] == 3.0 &&
     //                  pointSet1->GetPoint(0)[0] == 4.0  && pointSet1->GetPoint(0)[1] == 5.0  && pointSet1->GetPoint(0)[2] == 6.0 &&
     //                  pointSet2->GetPoint(0)[0] == 7.0  && pointSet2->GetPoint(0)[1] == 8.0  && pointSet2->GetPoint(0)[2] == 9.0 &&
     //                  pointSet3->GetPoint(0)[0] == 10.0 && pointSet3->GetPoint(0)[1] == 11.0 && pointSet3->GetPoint(0)[2] == 12.0
     //, "Testing the conversion of navigation data object to PointSets in Mode 3D" );
 
 }
 
 
 static void TestMode4D(mitk::NavigationDataToPointSetFilter::Pointer myNavigationDataToPointSetFilter)
 {
   myNavigationDataToPointSetFilter->SetOperationMode(mitk::NavigationDataToPointSetFilter::Mode4D);
   myNavigationDataToPointSetFilter->SetRingBufferSize(2);
 
   //Build up test data
   mitk::NavigationData::Pointer nd = mitk::NavigationData::New();
   mitk::NavigationData::Pointer nd2 = mitk::NavigationData::New();
   mitk::NavigationData::Pointer nd3 = mitk::NavigationData::New();
   mitk::NavigationData::Pointer nd4 = mitk::NavigationData::New();
 
   mitk::NavigationData::PositionType point;
 
   point[0] = 1.0;
   point[1] = 2.0;
   point[2] = 3.0;
   nd->SetPosition(point);
 
   point[0] = 4.0;
   point[1] = 5.0;
   point[2] = 6.0;
   nd2->SetPosition(point);
 
   point[0] = 7.0;
   point[1] = 8.0;
   point[2] = 9.0;
   nd3->SetPosition(point);
 
   point[0] = 10.0;
   point[1] = 11.0;
   point[2] = 12.0;
   nd4->SetPosition(point);
 
   myNavigationDataToPointSetFilter->SetInput(0, nd);
   myNavigationDataToPointSetFilter->SetInput(1, nd2);
 
   mitk::PointSet::Pointer pointSet = myNavigationDataToPointSetFilter->GetOutput();
   pointSet->Update();
 
   MITK_TEST_CONDITION( pointSet->GetPoint(0,0)[0] == 1.0 && pointSet->GetPoint(0,0)[1] == 2.0 && pointSet->GetPoint(0,0)[2] == 3.0 &&
     pointSet->GetPoint(1,0)[0] == 4.0 && pointSet->GetPoint(1,0)[1] == 5.0 && pointSet->GetPoint(1,0)[2] == 6.0
     , "Testing the conversion of navigation data object to one point set in Mode 4D in first timestep" );
 
   myNavigationDataToPointSetFilter->SetInput(0, nd3);
   myNavigationDataToPointSetFilter->SetInput(1, nd4);
   myNavigationDataToPointSetFilter->Update();
   pointSet = myNavigationDataToPointSetFilter->GetOutput();
 
   MITK_TEST_CONDITION( pointSet->GetPoint(0,0)[0] == 1.0 && pointSet->GetPoint(0,0)[1] == 2.0 && pointSet->GetPoint(0,0)[2] == 3.0 &&
     pointSet->GetPoint(1,0)[0] == 4.0 && pointSet->GetPoint(1,0)[1] == 5.0 && pointSet->GetPoint(1,0)[2] == 6.0 &&
     pointSet->GetPoint(0,1)[0] == 7.0 && pointSet->GetPoint(0,1)[1] == 8.0 && pointSet->GetPoint(0,1)[2] == 9.0 &&
     pointSet->GetPoint(1,1)[0] == 10.0 && pointSet->GetPoint(1,1)[1] == 11.0 && pointSet->GetPoint(1,1)[2] == 12.0
     , "Testing the conversion of navigation data object to one point set in Mode 4D in second timestep" );
 
   myNavigationDataToPointSetFilter->SetInput(0, nd3);
   //nd3->Modified(); //necessary because the generate data is only called when input has changed...
   myNavigationDataToPointSetFilter->SetInput(1, nd4);
   //nd4->Modified();
   //myNavigationDataToPointSetFilter->Update();
   pointSet = myNavigationDataToPointSetFilter->GetOutput();
   pointSet->Update();
 
   MITK_TEST_CONDITION( pointSet->GetPoint(0,0)[0] == 7.0 && pointSet->GetPoint(0,0)[1] == 8.0 && pointSet->GetPoint(0,0)[2] == 9.0 &&
     pointSet->GetPoint(1,0)[0] == 10.0 && pointSet->GetPoint(1,0)[1] == 11.0 && pointSet->GetPoint(1,0)[2] == 12.0 &&
     pointSet->GetPoint(0,1)[0] == 7.0 && pointSet->GetPoint(0,1)[1] == 8.0 && pointSet->GetPoint(0,1)[2] == 9.0 &&
     pointSet->GetPoint(1,1)[0] == 10.0 && pointSet->GetPoint(1,1)[1] == 11.0 && pointSet->GetPoint(1,1)[2] == 12.0
     , "Testing the correct ring buffer behavior" );
 }
 
 static void TestMode3DMean(mitk::NavigationDataToPointSetFilter::Pointer myNavigationDataToPointSetFilter)
 {
   myNavigationDataToPointSetFilter->SetOperationMode(mitk::NavigationDataToPointSetFilter::Mode3DMean);
   int numberForMean = 5;
   myNavigationDataToPointSetFilter->SetNumberForMean(numberForMean);
 
   MITK_TEST_CONDITION(mitk::Equal(myNavigationDataToPointSetFilter->GetNumberForMean(), numberForMean), "Testing get/set for numberForMean");
 
   mitk::NavigationDataSequentialPlayer::Pointer player = mitk::NavigationDataSequentialPlayer::New();
 
   std::string file = mitk::StandardFileLocations::GetInstance()->FindFile("NavigationDataTestData_2Tools.xml", "Modules/IGT/Testing/Data");
 
   mitk::NavigationDataReaderXML::Pointer reader = mitk::NavigationDataReaderXML::New();
 
   player->SetNavigationDataSet( reader->Read(file) );
-  //player->StartPlaying();
 
   for (int i = 0; i< player->GetNumberOfOutputs(); i++)
   {
     myNavigationDataToPointSetFilter->SetInput(i, player->GetOutput(i));
   }
 
   mitk::PointSet::Pointer pointSet0 = myNavigationDataToPointSetFilter->GetOutput();
   mitk::PointSet::Pointer pointSet1 = myNavigationDataToPointSetFilter->GetOutput(1);
 
   myNavigationDataToPointSetFilter->Update();
 
-  //player->StopPlaying();
-
   MITK_TEST_CONDITION(pointSet0->GetPoint(0)[0]==3.0 && pointSet0->GetPoint(0)[1]==2.0 && pointSet0->GetPoint(0)[2]==5.0,
     "Testing the average of first input");
 
   MITK_TEST_CONDITION(pointSet1->GetPoint(0)[0]==30.0 && pointSet1->GetPoint(0)[1]==20.0 && pointSet1->GetPoint(0)[2]==50.0,
     "Testing the average of second input");
-
 }
 };
 
 
 int mitkNavigationDataToPointSetFilterTest(int /* argc */, char* /*argv*/[])
 {
   // always start with this!
   MITK_TEST_BEGIN("NavigationDataToPointSetFilter");
 
   // let's create an object of our class
   mitk::NavigationDataToPointSetFilter::Pointer myNavigationDataToPointSetFilter = mitk::NavigationDataToPointSetFilter::New();
 
   // first test: did this work?
   // using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since
   // it makes no sense to continue without an object.
   MITK_TEST_CONDITION_REQUIRED(myNavigationDataToPointSetFilter.IsNotNull(),"Testing instantiation");
 
   // write your own tests here and use the macros from mitkTestingMacros.h !!!
   // do not write to std::cout and do not return from this function yourself!
 
   mitk::NavigationData::Pointer nd_in = mitk::NavigationData::New();
   const mitk::NavigationData* nd_out = mitk::NavigationData::New();
   mitk::NavigationData::PositionType point;
 
   point[0] = 1.0;
   point[1] = 2.0;
   point[2] = 3.0;
   nd_in->SetPosition(point);
 
   myNavigationDataToPointSetFilter->SetInput(nd_in);
   nd_out = myNavigationDataToPointSetFilter->GetInput();
 
   MITK_TEST_CONDITION( nd_out->GetPosition() == nd_in->GetPosition(),
     "Testing get/set input" );
 
   myNavigationDataToPointSetFilter = mitk::NavigationDataToPointSetFilter::New();
   mitkNavigationDataToPointSetFilterTestClass::TestMode3D(myNavigationDataToPointSetFilter);
   myNavigationDataToPointSetFilter = mitk::NavigationDataToPointSetFilter::New();
   mitkNavigationDataToPointSetFilterTestClass::TestMode4D(myNavigationDataToPointSetFilter);
   myNavigationDataToPointSetFilter = mitk::NavigationDataToPointSetFilter::New();
   mitkNavigationDataToPointSetFilterTestClass::TestMode3DMean(myNavigationDataToPointSetFilter);
   // always end with this!
   MITK_TEST_END();
 }