diff --git a/Modules/IGT/IGTFilters/mitkNavigationDataEvaluationFilter.cpp b/Modules/IGT/IGTFilters/mitkNavigationDataEvaluationFilter.cpp
index e633e36ca5..9ab77d141c 100644
--- a/Modules/IGT/IGTFilters/mitkNavigationDataEvaluationFilter.cpp
+++ b/Modules/IGT/IGTFilters/mitkNavigationDataEvaluationFilter.cpp
@@ -1,240 +1,313 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date$
 Version:   $Revision: 16011 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include "mitkNavigationDataEvaluationFilter.h"
+#include <algorithm>
 
 
 mitk::NavigationDataEvaluationFilter::NavigationDataEvaluationFilter()
 : mitk::NavigationDataToNavigationDataFilter()
 {
 
 }
 
 
 mitk::NavigationDataEvaluationFilter::~NavigationDataEvaluationFilter()
 {
 
 }
 
 void mitk::NavigationDataEvaluationFilter::GenerateData()
 {
 
     this->CreateOutputsForAllInputs(); // make sure that we have the same number of outputs as inputs
     this->CreateMembersForAllInputs();
 
     /* update outputs with tracking data from tools */
     for (unsigned int i = 0; i < this->GetNumberOfOutputs() ; ++i)
     {
       //first copy outputs to inputs
       mitk::NavigationData* output = this->GetOutput(i);
       assert(output);
       const mitk::NavigationData* input = this->GetInput(i);
       assert(input);
       if (input->IsDataValid() == false) {output->SetDataValid(false);}
       else {output->Graft(input);}
 
       //then save statistics
       if(input->IsDataValid())
         {
         m_LoggedPositions[i].push_back(input->GetPosition());
         m_LoggedQuaternions[i].push_back(input->GetOrientation());
         }
       else 
         {
         m_InavildSamples[i]++;
         }
     }
   
 }
 void mitk::NavigationDataEvaluationFilter::CreateMembersForAllInputs()
 {
   while(this->m_LoggedPositions.size() < this->GetNumberOfInputs())
     {
     std::pair<int,std::vector<mitk::Point3D>> newElement(m_LoggedPositions.size(),std::vector<mitk::Point3D>());
     m_LoggedPositions.insert(newElement);
     }
   while(this->m_LoggedQuaternions.size() < this->GetNumberOfInputs())
     {
     std::pair<int,std::vector<mitk::Quaternion>> newElement(m_LoggedQuaternions.size(),std::vector<mitk::Quaternion>());
     m_LoggedQuaternions.insert(newElement);
     }
   while(this->m_InavildSamples.size() < this->GetNumberOfInputs())
     {
     std::pair<int,int> newElement(m_LoggedQuaternions.size(),0);
     m_InavildSamples.insert(newElement);
     }
 
   
 }
 
 void mitk::NavigationDataEvaluationFilter::ResetStatistic()
 {
 for (int i = 0; i < m_LoggedPositions.size(); i++) m_LoggedPositions[i] = std::vector<mitk::Point3D>();
 for (int i = 0; i < m_LoggedQuaternions.size(); i++) m_LoggedQuaternions[i] = std::vector<mitk::Quaternion>();
 for (int i = 0; i < m_InavildSamples.size(); i++) m_InavildSamples[i] = 0;
 }
 
 int mitk::NavigationDataEvaluationFilter::GetNumberOfAnalysedNavigationData(int input)
 {
 return this->m_LoggedPositions[input].size();
 }
 
 
 mitk::Point3D mitk::NavigationDataEvaluationFilter::GetPositionMean(int input)
 {
-mitk::Point3D returnValue;
-returnValue.Fill(0);
-
-for (int i=0; i<m_LoggedPositions[input].size(); i++)
-  {
-  returnValue[0] += m_LoggedPositions[input].at(i)[0];
-  returnValue[1] += m_LoggedPositions[input].at(i)[1];
-  returnValue[2] += m_LoggedPositions[input].at(i)[2];
-  }
-
-returnValue[0] /= m_LoggedPositions[input].size();
-returnValue[1] /= m_LoggedPositions[input].size();
-returnValue[2] /= m_LoggedPositions[input].size();
-
-return returnValue;
+return GetMean(m_LoggedPositions[input]);
 }
 
 mitk::Vector3D mitk::NavigationDataEvaluationFilter::GetPositionStandardDerivation(int input)
 {
 mitk::Vector3D returnValue;
-//TODO
+std::vector<double> listX = std::vector<double>();
+std::vector<double> listY = std::vector<double>();
+std::vector<double> listZ = std::vector<double>();
+for (int i=0; i<m_LoggedPositions[input].size(); i++)
+  {
+  listX.push_back(m_LoggedPositions[input].at(i)[0]);
+  listY.push_back(m_LoggedPositions[input].at(i)[1]);
+  listZ.push_back(m_LoggedPositions[input].at(i)[2]);
+  }
+returnValue[0] = GetStabw(listX);
+returnValue[1] = GetStabw(listY);
+returnValue[2] = GetStabw(listZ);
 return returnValue;
 }
 
 mitk::Quaternion mitk::NavigationDataEvaluationFilter::GetQuaternionMean(int input)
 {
-mitk::Quaternion returnValue;
-
-returnValue[0] = 0;
-returnValue[1] = 0;
-returnValue[2] = 0;
-returnValue[3] = 0;
-
-for (int i=0; i<m_LoggedQuaternions[input].size(); i++)
-  {
-  returnValue[0] += m_LoggedQuaternions[input].at(i)[0];
-  returnValue[1] += m_LoggedQuaternions[input].at(i)[1];
-  returnValue[2] += m_LoggedQuaternions[input].at(i)[2];
-  returnValue[3] += m_LoggedQuaternions[input].at(i)[3];
-  }
-
-returnValue[0] /= m_LoggedQuaternions[input].size();
-returnValue[1] /= m_LoggedQuaternions[input].size();
-returnValue[2] /= m_LoggedQuaternions[input].size();
-returnValue[3] /= m_LoggedQuaternions[input].size();
-
-return returnValue;
+return GetMean(m_LoggedQuaternions[input]);
 }
 
 mitk::Quaternion mitk::NavigationDataEvaluationFilter::GetQuaternionStandardDerivation(int input)
 {
 mitk::Quaternion returnValue;
-//TODO
+std::vector<double> list1 = std::vector<double>();
+std::vector<double> list2 = std::vector<double>();
+std::vector<double> list3 = std::vector<double>();
+std::vector<double> list4 = std::vector<double>();
+for (int i=0; i<m_LoggedQuaternions[input].size(); i++)
+  {
+  list1.push_back(m_LoggedQuaternions[input].at(i)[0]);
+  list2.push_back(m_LoggedQuaternions[input].at(i)[1]);
+  list3.push_back(m_LoggedQuaternions[input].at(i)[2]);
+  list4.push_back(m_LoggedQuaternions[input].at(i)[3]);
+  }
+returnValue[0] = GetStabw(list1);
+returnValue[1] = GetStabw(list2);
+returnValue[2] = GetStabw(list3);
+returnValue[3] = GetStabw(list4);
 return returnValue;
 }
 
 
 double mitk::NavigationDataEvaluationFilter::GetPositionErrorMean(int input)
 {
 double returnValue = 0.0;
-mitk::Point3D mean = this->GetPositionMean(input);
+mitk::Point3D mean = GetMean(m_LoggedPositions[input]);
 
 for(int i=0; i<m_LoggedPositions[input].size(); i++)
   {
   returnValue += mean.EuclideanDistanceTo(m_LoggedPositions[input].at(i));
   }
 returnValue /= m_LoggedPositions[input].size();
 
 return returnValue;
 }
 
 double mitk::NavigationDataEvaluationFilter::GetPositionErrorStandardDerication(int input)
 {
-double returnValue = 0.0;
-//TODO
-return returnValue;
+return GetStabw(GetErrorList(m_LoggedPositions[input]));
 }
 
 double mitk::NavigationDataEvaluationFilter::GetPositionErrorRMS(int input)
 {
 double returnValue = 0.0;
 
-mitk::Point3D mean = this->GetPositionMean(input);
+mitk::Point3D mean = GetMean(m_LoggedPositions[input]);
 
 for(int i=0; i<m_LoggedPositions[input].size(); i++)
   {
   returnValue += pow(mean.EuclideanDistanceTo(m_LoggedPositions[input].at(i)),2);
   }
 returnValue /= m_LoggedPositions[input].size();
 returnValue = sqrt(returnValue);
 
 return returnValue;
 }
 
 double mitk::NavigationDataEvaluationFilter::GetPositionErrorMedian(int input)
 {
-double returnValue = 0.0;
-//TODO
-return returnValue;
+return GetMedian(GetErrorList(m_LoggedPositions[input]));
 }
 
-double mitk::NavigationDataEvaluationFilter::GetQuaternionErrorMean(int input)
+double mitk::NavigationDataEvaluationFilter::GetPositionErrorMax(int input)
 {
-double returnValue = 0.0;
-//TODO
-return returnValue;
+return GetMax(GetErrorList(m_LoggedPositions[input]));
+}
+  
+double mitk::NavigationDataEvaluationFilter::GetPositionErrorMin(int input)
+{
+return GetMin(GetErrorList(m_LoggedPositions[input]));
 }
 
-double mitk::NavigationDataEvaluationFilter::GetQuaternionErrorStandardDerication(int input)
+int mitk::NavigationDataEvaluationFilter::GetNumberOfInvalidSamples(int input)
 {
-double returnValue = 0.0;
-//TODO
-return returnValue;
+return m_InavildSamples[input];
 }
 
-double mitk::NavigationDataEvaluationFilter::GetQuaternionErrorRMS(int input)
+double mitk::NavigationDataEvaluationFilter::GetPercentageOfInvalidSamples(int input)
 {
-double returnValue = 0.0;
-//TODO
-return returnValue;
+return (m_InavildSamples[input]/(m_InavildSamples[input]+((double)m_LoggedPositions.size())))*100.0;
 }
 
-double mitk::NavigationDataEvaluationFilter::GetQuaternionErrorMedian(int input)
+double mitk::NavigationDataEvaluationFilter::GetMedian(std::vector<double> list)
 {
-double returnValue = 0.0;
-//TODO
-return returnValue;
+std::sort(list.begin(), list.end());
+if (list.size() % 2 == 0.) //even
+  {
+  double element1 = list.at(list.size()/2);
+  double element2 = list.at(list.size()/2);
+  return ((element1+element2)/2.0);
+  }
+else //odd
+  {
+  return list.at((list.size()+1)/2);
+  }
 }
 
-int GetNumberOfInvalidSamples(int input)
+std::vector<double> mitk::NavigationDataEvaluationFilter::GetErrorList(std::vector<mitk::Point3D> list)
 {
-int returnValue = 0;
-//TODO
-return returnValue;
+std::vector<double> errorList = std::vector<double>();
+mitk::Point3D mean = GetMean(list);
+for(int i=0; i<list.size(); i++)
+  {
+  errorList.push_back(mean.EuclideanDistanceTo(list.at(i)));
+  }
+return errorList;
 }
 
-double GetPercentageOfInvalidSamples(int input)
+mitk::Point3D mitk::NavigationDataEvaluationFilter::GetMean(std::vector<mitk::Point3D> list)
 {
-double returnValue = 0.0;
-//TODO
+//calculate mean
+mitk::Point3D mean;
+mean.Fill(0);
+
+for (int i=0; i<list.size(); i++)
+  {
+  mean[0] += list.at(i)[0];
+  mean[1] += list.at(i)[1];
+  mean[2] += list.at(i)[2];
+  }
+
+mean[0] /= list.size();
+mean[1] /= list.size();
+mean[2] /= list.size();
+
+return mean;
+
+}
+
+double mitk::NavigationDataEvaluationFilter::GetMax(std::vector<double> list)
+{
+std::sort(list.begin(), list.end());
+return list.at(list.size()-1);
+}
+
+double mitk::NavigationDataEvaluationFilter::GetMin(std::vector<double> list)
+{
+std::sort(list.begin(), list.end());
+return list.at(0);
+}
+
+double mitk::NavigationDataEvaluationFilter::GetStabw(std::vector<double> list)
+{
+double returnValue = 0;
+double mean = GetMean(list);
+for(int i=0; i<list.size(); i++)
+  {
+  returnValue += pow((list.at(i)-mean),2);
+  }
+returnValue /= list.size();
 return returnValue;
+}
+
+double  mitk::NavigationDataEvaluationFilter::GetMean(std::vector<double> list)
+{
+double mean = 0;
+for(int i=0; i<list.size(); i++)
+  {
+  mean += list.at(i);
+  }
+mean /= list.size();
+return mean;
+}
+
+mitk::Quaternion mitk::NavigationDataEvaluationFilter::GetMean(std::vector<mitk::Quaternion> list)
+{
+//calculate mean
+mitk::Quaternion mean;
+mean[0] = 0;
+mean[1] = 0;
+mean[2] = 0;
+mean[3] = 0;
+
+for (int i=0; i<list.size(); i++)
+  {
+  mean[0] += list.at(i)[0];
+  mean[1] += list.at(i)[1];
+  mean[2] += list.at(i)[2];
+  mean[3] += list.at(i)[3];
+  }
+
+mean[0] /= list.size();
+mean[1] /= list.size();
+mean[2] /= list.size();
+mean[3] /= list.size();
+
+return mean;
 }
\ No newline at end of file
diff --git a/Modules/IGT/IGTFilters/mitkNavigationDataEvaluationFilter.h b/Modules/IGT/IGTFilters/mitkNavigationDataEvaluationFilter.h
index 5565e6665b..48d56cae3b 100644
--- a/Modules/IGT/IGTFilters/mitkNavigationDataEvaluationFilter.h
+++ b/Modules/IGT/IGTFilters/mitkNavigationDataEvaluationFilter.h
@@ -1,95 +1,119 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date$
 Version:   $Revision: 16011 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 
 #ifndef MITKNavigationDataEvaluationFilter_H_HEADER_INCLUDED_
 #define MITKNavigationDataEvaluationFilter_H_HEADER_INCLUDED_
 
 #include <mitkNavigationDataToNavigationDataFilter.h>
 
 #include <itkQuaternionRigidTransform.h>
 #include <itkTransform.h>
 
 
 namespace mitk {
 
   /**Documentation
   * \brief NavigationDataEvaluationFilter calculates statistical data (mean value, mean error, etc.) on the input navigation data.
   * Input navigation data are set 1:1 on output navigation data.
   *
   * \ingroup IGT
   */
   class MitkIGT_EXPORT NavigationDataEvaluationFilter : public NavigationDataToNavigationDataFilter
   {
 
   public:
 
     mitkClassMacro(NavigationDataEvaluationFilter, NavigationDataToNavigationDataFilter);
     itkNewMacro(Self);
 
     /** @brief Resets all statistics and starts again. */
     void ResetStatistic();
 
-    /** @return returns the number of analysed navigation datas for the specified input. */
+    /** @return Returns the number of analysed navigation datas for the specified input (without invalid samples). */
     int GetNumberOfAnalysedNavigationData(int input);
+    /** @return Returns the number of invalid samples for the specified input. Invalid samples are ignored for the statistical calculation.*/
     int GetNumberOfInvalidSamples(int input);
+    /** @return Returns the percentage of invalid samples in relation to all samples for the specified input.*/
     double GetPercentageOfInvalidSamples(int input);
-
-
+    /** @return Returns the mean position of the specified input since the start of the statistic (last call of ResetStatistic()) */
     mitk::Point3D GetPositionMean(int input);
+    /** @return Returns the standard derivation of each component (x, y and z) of the specified input since the start of the statistic (last call of ResetStatistic()) */
     mitk::Vector3D GetPositionStandardDerivation(int input);
 
+    /** @return Returns the mean quaternion of the specified input since the start of the statistic (last call of ResetStatistic()) */
     mitk::Quaternion GetQuaternionMean(int input);
+    /** @return Returns the standard derivation of each component of the specified input since the start of the statistic (last call of ResetStatistic()) */
     mitk::Quaternion GetQuaternionStandardDerivation(int input);
     
 
-    /** @return Returns the mean distance to the mean postion. */
+    /** @return Returns the mean distance to the mean postion (=mean error) to the specified input. */
     double GetPositionErrorMean(int input);
+    /** @return Returns the standard derivation of the errors of all positions to the specified input. */
     double GetPositionErrorStandardDerication(int input);
+    /** @return Returns the RMS of the errors of all positions to the specified input. */
     double GetPositionErrorRMS(int input);
+    /** @return Returns the median of the errors of all positions to the specified input. */
     double GetPositionErrorMedian(int input);
-    
-    double GetQuaternionErrorMean(int input);
-    double GetQuaternionErrorStandardDerication(int input);
-    double GetQuaternionErrorRMS(int input);
-    double GetQuaternionErrorMedian(int input);
-    
-    
-  
+    /** @return Returns the maximum of the errors of all positions to the specified input. */
+    double GetPositionErrorMax(int input);
+    /** @return Returns the minimum of the errors of all positions to the specified input. */
+    double GetPositionErrorMin(int input);
+      
   protected:
 
     NavigationDataEvaluationFilter();
     virtual ~NavigationDataEvaluationFilter();
 
     /**Documentation
     * \brief filter execute method
     *
     * transforms navigation data
     */
     virtual void GenerateData();
 
     /** @brief Creates the member variables which store all the statistical data for every input. */
     void CreateMembersForAllInputs();
 
     
     std::map<int,std::vector<mitk::Point3D>> m_LoggedPositions; //a map here, to have one list for every navigation data
     std::map<int,std::vector<mitk::Quaternion>> m_LoggedQuaternions;
     std::map<int,int> m_InavildSamples;
+
+
+    /** @return returns a list with the distances to the mean of the list */
+    std::vector<double> GetErrorList(std::vector<mitk::Point3D> list);
+
+    mitk::Point3D GetMean(std::vector<mitk::Point3D> list);
+
+    mitk::Quaternion GetMean(std::vector<mitk::Quaternion> list);
+
+
+    double GetMean(std::vector<double> list);
+
+    double GetMedian(std::vector<double> list);
+
+    double GetMax(std::vector<double> list);
+
+    double GetMin(std::vector<double> list);
+
+    /** @return returns the standard derivation of the list */
+    double GetStabw(std::vector<double> list);
   };
 } // namespace mitk
 
 #endif /* MITKNavigationDataEvaluationFilter_H_HEADER_INCLUDED_ */
\ No newline at end of file