diff --git a/Core/Code/DataManagement/mitkTypes.h b/Core/Code/DataManagement/mitkTypes.h
index 7c0d891e70..62c97188e5 100644
--- a/Core/Code/DataManagement/mitkTypes.h
+++ b/Core/Code/DataManagement/mitkTypes.h
@@ -1,391 +1,391 @@
 /*===================================================================
 
 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 MITKVECTOR_H_HEADER_INCLUDED_C1EBD0AD
 #define MITKVECTOR_H_HEADER_INCLUDED_C1EBD0AD
 
 
 #include <mitkLogMacros.h>
 
 #include <itkPoint.h>
 #include <float.h>
 #include <itkIndex.h>
 #include <itkContinuousIndex.h>
 #include <itkVector.h>
 #include <itkMatrix.h>
 #include <itkTransform.h>
 #include <vnl/vnl_quaternion.h>
 #include <iomanip>
 
 #include "mitkTypeBasics.h"
 #include "mitkTypedefs.h"
 #include "mitkPoint.h" // TODO SW: should not be included here, maybe generate one "general datatype include" like mitkPrimitives.h
 #include "mitkVector.h"
 #include "mitkMatrix.h"
 
 #include "mitkOldTypeConversions.h"
 
 
 #ifndef DOXYGEN_SKIP
 
 namespace mitk {
 
 
 template <class T, unsigned int NVectorDimension>
   itk::Vector<T, NVectorDimension> operator+(const itk::Vector<T, NVectorDimension> &vector, const itk::Point<T, NVectorDimension> &point)
 {
   itk::Vector<T, NVectorDimension> sub;
   for( unsigned int i=0; i<NVectorDimension; i++)
   {
     sub[i] = vector[i]+point[i];
   }
   return sub;
 }
 
 template <class T, unsigned int NVectorDimension>
   inline itk::Vector<T, NVectorDimension>& operator+=(itk::Vector<T, NVectorDimension> &vector, const itk::Point<T, NVectorDimension> &point)
 {
   for( unsigned int i=0; i<NVectorDimension; i++)
   {
     vector[i] += point[i];
   }
   return vector;
 }
 
 template <class T, unsigned int NVectorDimension>
   itk::Vector<T, NVectorDimension> operator-(const itk::Vector<T, NVectorDimension> &vector, const itk::Point<T, NVectorDimension> &point)
 {
   itk::Vector<T, NVectorDimension> sub;
   for( unsigned int i=0; i<NVectorDimension; i++)
   {
     sub[i] = vector[i]-point[i];
   }
   return sub;
 }
 
 template <class T, unsigned int NVectorDimension>
   inline itk::Vector<T, NVectorDimension>& operator-=(itk::Vector<T, NVectorDimension> &vector, const itk::Point<T, NVectorDimension> &point)
 {
   for( unsigned int i=0; i<NVectorDimension; i++)
   {
     vector[i] -= point[i];
   }
   return vector;
 }
 
 /**
- * Helper method to check if the difference is bigger than a given epsilon
+ * Helper method to check if the difference is bigger or eqaual to a given epsilon
  *
  * @param diff the difference to be checked against the epsilon
  * @param the epsilon. The absolute difference needs to be smaller than this.
- * @return true if abs(diff) > eps
+ * @return true if abs(diff) >= eps
  */
 template <typename DifferenceType>
-static inline bool DifferenceBiggerEps(DifferenceType diff, mitk::ScalarType epsilon = mitk::eps)
+static inline bool DifferenceBiggerOrEqualEps(DifferenceType diff, mitk::ScalarType epsilon = mitk::eps)
 {
-  return fabs(diff) > epsilon;
+  return fabs(diff) >= epsilon;
 }
 
 /**
  * outputs elem1, elem2 and eps in case verbose and !isEqual.
  * Elem can e.g. be a mitk::Vector or an mitk::Point.
  *
  * @param elem1 first element to be output
  * @param elem2 second
  * @param eps the epsilon which their difference was bigger than
  * @param verbose tells the function if something shall be output
  * @param isEqual function will only output something if the two elements are not equal
  */
 template <typename ElementToOutput1, typename ElementToOutput2>
 static inline void ConditionalOutputOfDifference(ElementToOutput1 elem1, ElementToOutput2 elem2, mitk::ScalarType eps, bool verbose, bool isEqual)
 {
   if(verbose && !isEqual)
   {
     MITK_INFO << typeid(ElementToOutput1).name() << " and " << typeid(ElementToOutput2).name() << " not equal. Lefthandside " << std::setprecision(12) << elem1 << " - Righthandside " << elem2 << " - epsilon " << eps;
   }
 }
 
 /*!
 \brief Check for matrix equality with a user defined accuracy. As an equality metric the root mean squared error (RMS) of all elements is calculated.
 \param matrix1 first vnl matrix
 \param matrix2 second vnl matrix
 \param epsilon user defined accuracy bounds
 */
 template <typename TCoordRep, unsigned int NRows, unsigned int NCols>
 inline bool MatrixEqualRMS(const vnl_matrix_fixed<TCoordRep,NRows,NCols>& matrix1,const vnl_matrix_fixed<TCoordRep,NRows,NCols>& matrix2,mitk::ScalarType epsilon=mitk::eps)
 {
   if ( (matrix1.rows() == matrix2.rows()) && (matrix1.cols() == matrix2.cols()) )
   {
     vnl_matrix_fixed<TCoordRep,NRows,NCols> differenceMatrix = matrix1-matrix2;
     if (differenceMatrix.rms()<epsilon)
     {
       return true;
     }
     else
     {
       return false;
     }
   }
   else
   {
     return false;
   }
 }
 
 /*!
 \brief Check for matrix equality with a user defined accuracy. As an equality metric the root mean squared error (RMS) of all elements is calculated.
 \param matrix1 first itk matrix
 \param matrix2 second itk matrix
 \param epsilon user defined accuracy bounds
 */
 template <typename TCoordRep, unsigned int NRows, unsigned int NCols>
 inline bool MatrixEqualRMS(const itk::Matrix<TCoordRep, NRows, NCols>& matrix1,const itk::Matrix<TCoordRep, NRows, NCols>& matrix2,mitk::ScalarType epsilon=mitk::eps)
 {
   return mitk::MatrixEqualRMS(matrix1.GetVnlMatrix(),matrix2.GetVnlMatrix(),epsilon);
 }
 
 /*!
 \brief Check for element-wise matrix equality with a user defined accuracy.
 \param matrix1 first vnl matrix
 \param matrix2 second vnl matrix
 \param epsilon user defined accuracy bounds
 */
 template <typename TCoordRep, unsigned int NRows, unsigned int NCols>
 inline bool MatrixEqualElementWise(const vnl_matrix_fixed<TCoordRep,NRows,NCols>& matrix1,const vnl_matrix_fixed<TCoordRep,NRows,NCols>& matrix2,mitk::ScalarType epsilon=mitk::eps)
 {
   if ( (matrix1.rows() == matrix2.rows()) && (matrix1.cols() == matrix2.cols()) )
   {
     for( unsigned int r=0; r<NRows; r++)
     {
       for( unsigned int c=0; c<NCols; c++ )
       {
         TCoordRep difference =  matrix1(r,c)-matrix2(r,c);
-        if (DifferenceBiggerEps(difference, epsilon))
+        if (DifferenceBiggerOrEqualEps(difference, epsilon))
         {
           return false;
         }
       }
     }
     return true;
   }
   else
   {
     return false;
   }
 }
 
 /*!
 \brief Check for element-wise matrix equality with a user defined accuracy.
 \param matrix1 first itk matrix
 \param matrix2 second itk matrix
 \param epsilon user defined accuracy bounds
 */
 template <typename TCoordRep, unsigned int NRows, unsigned int NCols>
 inline bool MatrixEqualElementWise(const itk::Matrix<TCoordRep, NRows, NCols>& matrix1,const itk::Matrix<TCoordRep, NRows, NCols>& matrix2,mitk::ScalarType epsilon=mitk::eps)
 {
   return mitk::MatrixEqualElementWise(matrix1.GetVnlMatrix(),matrix2.GetVnlMatrix(),epsilon);
 }
 
 /**
  * @ingroup MITKTestingAPI
  *
  * @param vector1 Vector to compare.
  * @param vector2 Vector to compare.
  * @param eps Tolerance for floating point comparison.
  * @param verbose Flag indicating detailed console output.
  * @return True if vectors are equal.
  */
 template <typename TCoordRep, unsigned int NPointDimension>
 inline bool Equal(const itk::Vector<TCoordRep, NPointDimension>& vector1, const itk::Vector<TCoordRep, NPointDimension>& vector2, TCoordRep eps=mitk::eps, bool verbose=false)
 {
   bool isEqual = true;
   typename itk::Vector<TCoordRep, NPointDimension>::VectorType diff = vector1-vector2;
   for (unsigned int i=0; i<NPointDimension; i++)
   {
-    if (DifferenceBiggerEps(diff[i], eps))
+    if (DifferenceBiggerOrEqualEps(diff[i], eps))
     {
       isEqual = false;
       break;
     }
   }
 
   ConditionalOutputOfDifference(vector1, vector2, eps, verbose, isEqual);
 
   return isEqual;
 }
 
 /**
  * @ingroup MITKTestingAPI
  *
  * @param point1 Point to compare.
  * @param point2 Point to compare.
  * @param eps Tolerance for floating point comparison.
  * @param verbose Flag indicating detailed console output.
  * @return True if points are equal.
  */
 template <typename TCoordRep, unsigned int NPointDimension>
   inline bool Equal(const itk::Point<TCoordRep, NPointDimension>& point1, const itk::Point<TCoordRep, NPointDimension>& point2, TCoordRep eps=mitk::eps, bool verbose=false)
 {
   bool isEqual = true;
   typename itk::Point<TCoordRep, NPointDimension>::VectorType diff = point1-point2;
   for (unsigned int i=0; i<NPointDimension; i++)
   {
-    if (DifferenceBiggerEps(diff[i], eps))
+    if (DifferenceBiggerOrEqualEps(diff[i], eps))
     {
       isEqual = false;
       break;
     }
   }
 
   ConditionalOutputOfDifference(point1, point2, eps, verbose, isEqual);
 
   return isEqual;
 }
 
 /**
  * @ingroup MITKTestingAPI
  *
  * @param vector1 Vector to compare.
  * @param vector2 Vector to compare.
  * @param eps Tolerance for floating point comparison.
  * @param verbose Flag indicating detailed console output.
  * @return True if vectors are equal.
  */
 inline bool Equal(const mitk::VnlVector& vector1, const mitk::VnlVector& vector2, ScalarType eps=mitk::eps, bool verbose=false)
 {
   bool isEqual = true;
   mitk::VnlVector diff = vector1-vector2;
   for (unsigned int i=0; i<diff.size(); i++)
   {
-    if (DifferenceBiggerEps(diff[i], eps))
+    if (DifferenceBiggerOrEqualEps(diff[i], eps))
     {
       isEqual = false;
       break;
     }
   }
 
   ConditionalOutputOfDifference(vector1, vector2, eps, verbose, isEqual);
 
   return isEqual;
 }
 
 /**
  * @ingroup MITKTestingAPI
  *
  * @param scalar1 Scalar value to compare.
  * @param scalar2 Scalar value to compare.
  * @param eps Tolerance for floating point comparison.
  * @param verbose Flag indicating detailed console output.
  * @return True if scalars are equal.
  */
 inline bool Equal(ScalarType scalar1, ScalarType scalar2, ScalarType eps=mitk::eps, bool verbose=false)
 {
-  bool isEqual( !DifferenceBiggerEps(scalar1-scalar2, eps));
+  bool isEqual( !DifferenceBiggerOrEqualEps(scalar1-scalar2, eps));
 
   ConditionalOutputOfDifference(scalar1, scalar2, eps, verbose, isEqual);
 
   return isEqual;
 }
 
 /**
  * @ingroup MITKTestingAPI
  *
  * @param vector1 Vector to compare.
  * @param vector2 Vector to compare.
  * @param eps Tolerance for floating point comparison.
  * @param verbose Flag indicating detailed console output.
  * @return True if vectors are equal.
  */
 template <typename TCoordRep, unsigned int NPointDimension>
   inline bool Equal(const vnl_vector_fixed<TCoordRep, NPointDimension> & vector1, const vnl_vector_fixed<TCoordRep, NPointDimension>& vector2, TCoordRep eps=mitk::eps, bool verbose=false)
 {
   vnl_vector_fixed<TCoordRep, NPointDimension> diff = vector1-vector2;
   bool isEqual = true;
   for( unsigned int i=0; i<diff.size(); i++)
   {
-    if (DifferenceBiggerEps(diff[i], eps))
+    if (DifferenceBiggerOrEqualEps(diff[i], eps))
     {
       isEqual = false;
       break;
     }
   }
 
   ConditionalOutputOfDifference(vector1, vector2, eps, verbose, isEqual);
 
   return isEqual;
 }
 
 /**
  * Compares two ArrayTypes of size size.
  * ArrayTypes are all Objects/Types who have a [] operator. Pay attention not to set size higher
  * than the actual size of the ArrayType. For POD arrays like float array[4] this will memory corruption.
  */
 template <typename TArrayType1, typename TArrayType2>
   inline bool EqualArray(TArrayType1& arrayType1, TArrayType2& arrayType2, int size, ScalarType eps = mitk::eps, bool verbose = false)
 {
   bool isEqual = true;
   for (int var = 0; var < size; ++var)
   {
     isEqual = isEqual && Equal(arrayType1[var], arrayType2[var], eps);
   }
 
   ConditionalOutputOfDifference(arrayType1, arrayType2, eps, verbose, isEqual);
 
   return isEqual;
 }
 
 
 
 
 
 } // namespace mitk
 
 #endif //DOXYGEN_SKIP
 
 /*
  * This part of the code has been shifted here to avoid compiler clashes
  * caused by including <itkAffineGeometryFrame.h> before the declaration of
  * the Equal() methods above. This problem occurs when using MSVC and is
  * probably related to a compiler bug.
  */
 
 #include <itkAffineGeometryFrame.h>
 
 namespace mitk
 {
   typedef itk::AffineGeometryFrame<ScalarType, 3>::TransformType AffineTransform3D;
 }
 
 
 #define mitkSetConstReferenceMacro(name,type) \
   virtual void Set##name (const type & _arg) \
   { \
     itkDebugMacro("setting " << #name " to " << _arg ); \
     if (this->m_##name != _arg) \
       { \
       this->m_##name = _arg; \
       this->Modified(); \
       } \
   }
 
 #define mitkSetVectorMacro(name,type) \
   mitkSetConstReferenceMacro(name,type)
 
 #define mitkGetVectorMacro(name,type) \
   itkGetConstReferenceMacro(name,type)
 
 #endif /* MITKVECTOR_H_HEADER_INCLUDED_C1EBD0AD */
diff --git a/Core/Code/Testing/mitkVectorTest.cpp b/Core/Code/Testing/mitkVectorTest.cpp
index 16b88cb5ac..22cd80829c 100644
--- a/Core/Code/Testing/mitkVectorTest.cpp
+++ b/Core/Code/Testing/mitkVectorTest.cpp
@@ -1,141 +1,141 @@
 /*===================================================================
 
 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 <mitkTestingMacros.h>
 #include <mitkTypes.h>
 
 #include <vnl/vnl_vector_fixed.txx>
 
 int mitkVectorTest(int /*argc*/, char* /*argv*/[])
 {
   MITK_TEST_BEGIN("mitkVector");
   // test itk vector equality methods
   itk::Vector<mitk::ScalarType,3> itkVector_1;
   itkVector_1[0] = 4.6;
   itkVector_1[1] = 9.76543;
   itkVector_1[2] = 746.09;
 
   itk::Vector<mitk::ScalarType,3> itkVector_2;
   itk::Vector<mitk::ScalarType,3> itkVector_3;
   for (int i=0; i<3; i++)
   {
     itkVector_2[i] = itkVector_1[i] - mitk::eps*1.1;
     itkVector_3[i] = itkVector_1[i] - mitk::eps*0.9;
   }
 
   MITK_TEST_CONDITION(mitk::Equal(itkVector_1,itkVector_1), "Test vector equality using the same vector with mitk::eps");
   MITK_TEST_CONDITION(!mitk::Equal(itkVector_1,itkVector_2), "Test vector equality using different vectors with an element-wise difference greater than mitk::eps");
   MITK_TEST_CONDITION( mitk::Equal(itkVector_1, itkVector_2, mitk::eps*1.2), "Vectors are equal for higher epsilon tolerance ( 1.2 * mitk::eps )");
   MITK_TEST_CONDITION(mitk::Equal(itkVector_1,itkVector_3), "Test vector equality using different vectors with an element-wise difference less than mitk::eps");
   // test itk point equality methods
   itk::Point<mitk::ScalarType,3> itkPoint_1;
   itk::Point<mitk::ScalarType,3> itkPoint_2;
   itk::Point<mitk::ScalarType,3> itkPoint_3;
   for (int i=0; i<3; i++)
   {
     itkPoint_1[i] = itkVector_1[i];
     itkPoint_2[i] = itkVector_2[i];
     itkPoint_3[i] = itkVector_3[i];
   }
   MITK_TEST_CONDITION(mitk::Equal(itkPoint_1,itkPoint_1), "Test point equality using the same point with mitk::eps");
   MITK_TEST_CONDITION(!mitk::Equal(itkPoint_1,itkPoint_2), "Test point equality using different points with an element-wise difference greater than mitk::eps");
   MITK_TEST_CONDITION( mitk::Equal(itkPoint_1, itkPoint_2, mitk::eps * 1.2), "Points are equal for higher epsilon tolerance ( 1.2 * mitk::eps )");
   MITK_TEST_CONDITION(mitk::Equal(itkPoint_1,itkPoint_3), "Test point equality using different points with an element-wise difference less than mitk::eps");
   // test mitk vnl vector equality methods
   mitk::VnlVector mitk_vnl_vector_1(3);
   mitk::VnlVector mitk_vnl_vector_2(3);
   mitk::VnlVector mitk_vnl_vector_3(3);
   for (int i=0; i<3; i++)
   {
     mitk_vnl_vector_1.put(i,itkVector_1[i]);
     mitk_vnl_vector_2.put(i,itkVector_2[i]);
     mitk_vnl_vector_3.put(i,itkVector_1[i]);
   }
 
   MITK_TEST_CONDITION(mitk::Equal(mitk_vnl_vector_1,mitk_vnl_vector_1), "Test mitk vnl vector equality using the same mitk vnl vector with mitk::eps");
   MITK_TEST_CONDITION(!mitk::Equal(mitk_vnl_vector_1,mitk_vnl_vector_2), "Test mitk vnl vector equality using different mitk vnl vectors with an element-wise difference greater than mitk::eps");
   MITK_TEST_CONDITION( mitk::Equal(mitk_vnl_vector_1, mitk_vnl_vector_2, mitk::eps*1.2), "Vnl vectors are equal for higher epsilon tolerance ( 1.2 * mitk::eps )");
   MITK_TEST_CONDITION(mitk::Equal(mitk_vnl_vector_1,mitk_vnl_vector_3), "Test mitk vnl vector equality using different mitk vnl vectors with an element-wise difference less than mitk::eps");
 
   // test vnl_vector equality method
   typedef mitk::ScalarType VnlValueType;
   vnl_vector_fixed<VnlValueType,7> vnlVector_1;
   vnlVector_1[3] = 56.98;
   vnlVector_1[4] = 22.32;
   vnlVector_1[5] = 1.00;
   vnlVector_1[6] = 746.09;
   vnl_vector_fixed<VnlValueType,7> vnlVector_2;
   vnl_vector_fixed<VnlValueType,7> vnlVector_3;
   for (int i=0; i<7; i++)
   {
     if (i<3)
     {
       vnlVector_1.put(i,itkVector_1[i]);
     }
 
     vnlVector_2[i] = vnlVector_1[i] - mitk::eps * 1.1f;
     vnlVector_3[i] = vnlVector_1[i] - mitk::eps * 0.9f;
   }
 
   MITK_TEST_CONDITION( (mitk::Equal<VnlValueType, 7>(vnlVector_1,vnlVector_1)), "vnl_fixed : v_1 == v_1 ");
   // the v_2 is constructed so that the equality test fails for mitk::eps, the norm of the difference between the vectors is 7 * eps/6.9
   MITK_TEST_CONDITION(!(mitk::Equal<VnlValueType, 7>(vnlVector_1,vnlVector_2)), "vnl_fixed : v_1 != v_2 with mitk::eps ");
   // increase the epsilon value used for testing equality - should now pass  ( 1.2 * mitk::eps > 7 * mitk::eps/6.9 )
   MITK_TEST_CONDITION( (mitk::Equal<VnlValueType, 7>(vnlVector_1,vnlVector_2, mitk::eps*1.2f)) , "vnl_fixed : v_1 == v_2 with eps = 1.2 * mitk::eps ");
   MITK_TEST_CONDITION( (mitk::Equal<VnlValueType, 7>(vnlVector_1,vnlVector_3, mitk::eps)), "vnl_fixed : v_1 == v_3 with eps = 0.8 * mitk::eps ");
   MITK_TEST_CONDITION(!(mitk::Equal<VnlValueType, 7>(vnlVector_1,vnlVector_3, mitk::eps*0.8f)), "vnl_fixed : v_1 != v_3 with eps = 0.8 * mitk::eps ");
 
   // test scalar equality method
   mitk::ScalarType scalar1 = 0.5689;
   mitk::ScalarType scalar2 = scalar1 + mitk::eps*1.01;
   mitk::ScalarType scalar3 = scalar1;
   mitk::ScalarType scalar4 = scalar1 + mitk::eps*0.95;
   MITK_TEST_CONDITION(mitk::Equal(scalar1,scalar1), "Test scalar equality using the same scalar with mitk::eps");
   MITK_TEST_CONDITION(!mitk::Equal(scalar1,scalar2), "Test scalar equality using the different scalars with a difference greater than mitk::eps");
   MITK_TEST_CONDITION(mitk::Equal(scalar1,scalar3), "Test scalar equality using the different scalars with a difference equal to mitk::eps");
   MITK_TEST_CONDITION(mitk::Equal(scalar1,scalar4), "Test scalar equality using the different scalars with a difference less than mitk::eps");
 
   // test matrix equality methods
   vnl_matrix_fixed<mitk::ScalarType,3,3> vnlMatrix3x3_1;
   vnlMatrix3x3_1(0,0) = 1.1;
   vnlMatrix3x3_1(0,1) = 0.4;
   vnlMatrix3x3_1(0,2) = 5.3;
   vnlMatrix3x3_1(1,0) = 2.7;
   vnlMatrix3x3_1(1,1) = 3578.56418;
   vnlMatrix3x3_1(1,2) = 123.56;
   vnlMatrix3x3_1(2,0) = 546.89;
   vnlMatrix3x3_1(2,1) = 0.0001;
   vnlMatrix3x3_1(2,2) = 1.0;
   vnl_matrix_fixed<mitk::ScalarType,3,3> vnlMatrix3x3_2;
   vnlMatrix3x3_2(0,0) = 1.1000009;
   vnlMatrix3x3_2(0,1) = 0.4000009;
   vnlMatrix3x3_2(0,2) = 5.3000009;
   vnlMatrix3x3_2(1,0) = 2.7000009;
   vnlMatrix3x3_2(1,1) = 3578.5641809;
   vnlMatrix3x3_2(1,2) = 123.5600009;
   vnlMatrix3x3_2(2,0) = 546.8900009;
   vnlMatrix3x3_2(2,1) = 0.0001009;
   vnlMatrix3x3_2(2,2) = 1.0000009;
 
   mitk::ScalarType epsilon = 0.000001;
-  MITK_TEST_CONDITION(mitk::MatrixEqualElementWise(vnlMatrix3x3_1,vnlMatrix3x3_1,0.0),"Test for matrix equality with given epsilon=0.0 and exactly the same matrix elements");
+  MITK_TEST_CONDITION(mitk::MatrixEqualElementWise(vnlMatrix3x3_1,vnlMatrix3x3_1,mitk::eps),"Test for matrix equality with given epsilon=mitk::eps and exactly the same matrix elements");
   MITK_TEST_CONDITION(!mitk::MatrixEqualElementWise(vnlMatrix3x3_1,vnlMatrix3x3_2,0.0),"Test for matrix equality with given epsilon=0.0 and slightly different matrix elements");
   MITK_TEST_CONDITION(mitk::MatrixEqualElementWise(vnlMatrix3x3_1,vnlMatrix3x3_2,epsilon),"Test for matrix equality with given epsilon and slightly different matrix elements");
   MITK_TEST_CONDITION(!mitk::MatrixEqualRMS(vnlMatrix3x3_1,vnlMatrix3x3_2,0.0),"Test for matrix equality with given epsilon=0.0 and slightly different matrix elements");
   MITK_TEST_CONDITION(mitk::MatrixEqualRMS(vnlMatrix3x3_1,vnlMatrix3x3_2,epsilon),"Test for matrix equality with given epsilon and slightly different matrix elements");
 
   MITK_TEST_END();
 }
diff --git a/Modules/IGT/Testing/mitkInternalTrackingToolTest.cpp b/Modules/IGT/Testing/mitkInternalTrackingToolTest.cpp
index 4ef454d2c4..cb631afce4 100644
--- a/Modules/IGT/Testing/mitkInternalTrackingToolTest.cpp
+++ b/Modules/IGT/Testing/mitkInternalTrackingToolTest.cpp
@@ -1,204 +1,185 @@
 /*===================================================================
 
 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 "mitkInternalTrackingTool.h"
 
 #include "mitkTestingMacros.h"
 
 #include <iostream>
 #include <time.h>
 
 /**Documentation
 * NDIPassiveTool has a protected constructor and a protected itkFactorylessNewMacro
 * so that only it's friend class NDITrackingDevice is able to instantiate
 * tool objects. Therefore, we derive from NDIPassiveTool and add a
 * public itkFactorylessNewMacro, so that we can instantiate and test the class
 */
 class InternalTrackingToolTestClass : public mitk::InternalTrackingTool
 {
 public:
   mitkClassMacro(InternalTrackingToolTestClass, InternalTrackingTool);
   /** make a public constructor, so that the test is able
   *   to instantiate NDIPassiveTool
   */
   itkFactorylessNewMacro(Self)
   itkCloneMacro(Self)
 protected:
   InternalTrackingToolTestClass() : mitk::InternalTrackingTool()
   {
   }
 
 public: //these static methods are only to structure the test
         //please see them seperated from the upper part of the class
 
 static void TestBasicFunctionality()
   {
   // let's create an object of our class
   mitk::InternalTrackingTool::Pointer internalTrackingTool = InternalTrackingToolTestClass::New().GetPointer();
 
   // 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(internalTrackingTool.IsNotNull(),"Testing instantiation");
 
     // test for Enable()
   internalTrackingTool->Enable();
   MITK_TEST_CONDITION((internalTrackingTool->IsEnabled()==true),"Testing of Enable()");
 
   srand(time(NULL));
   // generate a random position to test Set/GetPosition()
   mitk::Point3D position;
   position[0] = rand()%1000;
   position[1] = rand()%1000;
   position[2] = rand()%1000;
   internalTrackingTool->SetPosition(position);
   mitk::Point3D returnedPosition;
   returnedPosition.Fill(0);
   internalTrackingTool->GetPosition(returnedPosition);
   MITK_TEST_CONDITION((position==returnedPosition),"Testing of Set/GetPosition()");
 
   // generate a random orientation to test Set/GetOrientation()
   mitk::Quaternion orientation;
   orientation[0] = (rand()%1000)/1000.0;
   orientation[1] = (rand()%1000)/1000.0;
   orientation[2] = (rand()%1000)/1000.0;
   orientation[3] = (rand()%1000)/1000.0;
   internalTrackingTool->SetOrientation(orientation);
   mitk::Quaternion returnedOrientation(0,0,0,0);
   internalTrackingTool->GetOrientation(returnedOrientation);
   MITK_TEST_CONDITION((orientation==returnedOrientation),"Testing of Set/GetQuaternion()");
 
   // test Set/GetTrackingError()
   float trackingError = rand()%2;
   internalTrackingTool->SetTrackingError(trackingError);
   MITK_TEST_CONDITION((internalTrackingTool->GetTrackingError()==trackingError),"Testing of Set/GetTrackingError()");
   // test Set/GetDataValid()
   internalTrackingTool->SetDataValid(true);
   MITK_TEST_CONDITION((internalTrackingTool->IsDataValid()==true),"Testing of SetDataValid and IsDataValid() for parameter 'true'");
   internalTrackingTool->SetDataValid(false);
   MITK_TEST_CONDITION((internalTrackingTool->IsDataValid()==false),"Testing of SetDataValid and IsDataValid() for parameter 'false'");
 
   internalTrackingTool->Disable();
   MITK_TEST_CONDITION((internalTrackingTool->IsEnabled()==false),"Testing of Disable()");
   }
 
 static void TestTooltipFunctionality()
   {
   mitk::InternalTrackingTool::Pointer internalTrackingTool = InternalTrackingToolTestClass::New().GetPointer();
   mitk::Point3D toolTipPos; mitk::FillVector3D(toolTipPos,1,1,1);
   mitk::Quaternion toolTipQuat = mitk::Quaternion(0,0,0,1);
   internalTrackingTool->SetToolTip(toolTipPos,toolTipQuat);
 
   mitk::Point3D positionInput; mitk::FillVector3D(positionInput,5,6,7);
 
   internalTrackingTool->SetPosition(positionInput);
 
   mitk::Point3D positionOutput;
 
   internalTrackingTool->GetPosition(positionOutput);
 
   MITK_TEST_CONDITION(((positionOutput[0] == 6)&&
                        (positionOutput[0] == 6)&&
                        (positionOutput[0] == 6)&&
                        (positionOutput[0] == 6)),
                        "Testing tooltip definition."
                      );
 
 
   }
 
 static void TestModiciationTimeCorrectness()
 {
   mitk::InternalTrackingTool::Pointer tool = InternalTrackingToolTestClass::New().GetPointer();
   unsigned long mTime1 = tool->GetMTime();
 
   mitk::Point3D position1;
   mitk::FillVector3D(position1, 1.1, 2.2, 3.3);
   tool->SetPosition(position1);
   MITK_TEST_CONDITION( mTime1 < tool->GetMTime(),
                        "Testing MTime updated after initial position set" );
 
   mitk::Quaternion quat1 = mitk::Quaternion(0,0,0.70710678118654757,0.70710678118654757);
   tool->SetOrientation(quat1);
   MITK_TEST_CONDITION( mTime1 < tool->GetMTime(),
                        "Testing MTime updated after initial orientation set" );
 
   unsigned long mTime2 = tool->GetMTime();
 
-  tool->SetPosition(position1);
-  MITK_TEST_CONDITION( mTime2 == tool->GetMTime(),
-                       "Testing MTime NOT updated after same initial position set" );
-
-  tool->SetOrientation(quat1);
-  MITK_TEST_CONDITION( mTime2 == tool->GetMTime(),
-                       "Testing MTime NOT updated after same initial orientation set" );
-
   mitk::Point3D position2;
   mitk::FillVector3D(position2, 1.10001, 2.2, 3.3);
   tool->SetPosition(position2);
   MITK_TEST_CONDITION( mTime2 < tool->GetMTime(),
                        "Testing MTime updated after new position set" );
 
   unsigned long mTime3 = tool->GetMTime();
 
   mitk::Quaternion quat2 = mitk::Quaternion(0.0,
                                             0.0,
                                             0.70710678118654757,
                                             0.70710678118654757 + 0.00001);
   tool->SetOrientation(quat2);
   MITK_TEST_CONDITION( mTime3 < tool->GetMTime(),
                        "Testing MTime updated after new orientation set" );
 
   unsigned long mTime4 = tool->GetMTime();
 
   mitk::Point3D position3;
   mitk::FillVector3D(position3, 1.10002, 2.2, 3.3);
-  tool->SetPosition(position3, 0.001);
-  MITK_TEST_CONDITION( mTime4 == tool->GetMTime(),
-                       "Testing MTime NOT updated after position set within epsilon tolerance" );
-
-  mitk::Quaternion quat3 = mitk::Quaternion(0.0,
-                                            0.0,
-                                            0.70710678118654757,
-                                            0.70710678118654757 + 0.00002);
-  tool->SetOrientation(quat3, 0.001);
-  MITK_TEST_CONDITION( mTime4 == tool->GetMTime(),
-                       "Testing MTime NOT updated after orientation set within epsilon tolerance" );
 }
 };
 
 /**
  *  Simple example for a test for the class "InternalTrackingTool".
  *
  *  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).
  */
 int mitkInternalTrackingToolTest(int /* argc */, char* /*argv*/[])
 {
   // always start with this!
   MITK_TEST_BEGIN("InternalTrackingTool")
 
   InternalTrackingToolTestClass::TestBasicFunctionality();
   InternalTrackingToolTestClass::TestTooltipFunctionality();
   InternalTrackingToolTestClass::TestModiciationTimeCorrectness();
 
 
   // always end with this!
   MITK_TEST_END();
 }
 
diff --git a/Modules/IGT/TrackingDevices/mitkInternalTrackingTool.cpp b/Modules/IGT/TrackingDevices/mitkInternalTrackingTool.cpp
index 754f40176f..6e13d9010c 100644
--- a/Modules/IGT/TrackingDevices/mitkInternalTrackingTool.cpp
+++ b/Modules/IGT/TrackingDevices/mitkInternalTrackingTool.cpp
@@ -1,273 +1,270 @@
 /*===================================================================
 
 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 "mitkInternalTrackingTool.h"
 
 #include <itkMutexLockHolder.h>
 
 typedef itk::MutexLockHolder<itk::FastMutexLock> MutexLockHolder;
 
 mitk::InternalTrackingTool::InternalTrackingTool()
 : TrackingTool(),
 m_TrackingError(0.0f),
 m_Enabled(true),
 m_DataValid(false),
 m_ToolTipSet(false)
 {
   m_Position[0] = 0.0f;
   m_Position[1] = 0.0f;
   m_Position[2] = 0.0f;
   m_Orientation[0] = 0.0f;
   m_Orientation[1] = 0.0f;
   m_Orientation[2] = 0.0f;
   m_Orientation[3] = 0.0f;
   // this should not be necessary as the tools bring their own tooltip transformation
   m_ToolTip[0] = 0.0f;
   m_ToolTip[1] = 0.0f;
   m_ToolTip[2] = 0.0f;
   m_ToolTipRotation[0] = 0.0f;
   m_ToolTipRotation[1] = 0.0f;
   m_ToolTipRotation[2] = 0.0f;
   m_ToolTipRotation[3] = 1.0f;
 }
 
 mitk::InternalTrackingTool::~InternalTrackingTool()
 {
 }
 
 void mitk::InternalTrackingTool::PrintSelf(std::ostream& os, itk::Indent indent) const
 {
   Superclass::PrintSelf(os, indent);
 
   os << indent << "Position: " << m_Position << std::endl;
   os << indent << "Orientation: " << m_Orientation << std::endl;
   os << indent << "TrackingError: " << m_TrackingError << std::endl;
   os << indent << "Enabled: " << m_Enabled << std::endl;
   os << indent << "DataValid: " << m_DataValid << std::endl;
   os << indent << "ToolTip: " << m_ToolTip << std::endl;
   os << indent << "ToolTipRotation: " << m_ToolTipRotation << std::endl;
   os << indent << "ToolTipSet: " << m_ToolTipSet << std::endl;
 }
 
 void mitk::InternalTrackingTool::SetToolName(const char* _arg)
 {
   itkDebugMacro("setting  m_ToolName to " << _arg);
   MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
   if ( _arg && (_arg == this->m_ToolName) )
   {
     return;
   }
   if (_arg)
   {
     this->m_ToolName= _arg;
   }
   else
   {
     this->m_ToolName= "";
   }
   this->Modified();
 }
 
 
 void mitk::InternalTrackingTool::SetToolName( const std::string _arg )
 {
   this->SetToolName(_arg.c_str());
 }
 
 
 void mitk::InternalTrackingTool::GetPosition(mitk::Point3D& position) const
 {
   MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
   if (m_ToolTipSet)
     {
     // Compute the position of tool tip in the coordinate frame of the
     // tracking device: Rotate the position of the tip into the tracking
     // device coordinate frame then add to the position of the tracking
     // sensor
     vnl_vector<mitk::ScalarType> pos_vnl = m_Position.GetVnlVector() + m_Orientation.rotate( m_ToolTip.GetVnlVector() ) ;
 
     position[0] = pos_vnl[0];
     position[1] = pos_vnl[1];
     position[2] = pos_vnl[2];
     }
   else
     {
     position[0] = m_Position[0];
     position[1] = m_Position[1];
     position[2] = m_Position[2];
     }
   this->Modified();
 }
 
 
-void mitk::InternalTrackingTool::SetPosition(mitk::Point3D position, mitk::ScalarType eps)
+void mitk::InternalTrackingTool::SetPosition(mitk::Point3D position)
 {
   itkDebugMacro("setting  m_Position to " << position);
-  if (!Equal(m_Position, position, eps))
-  {
-    MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
-    m_Position = position;
-    this->Modified();
-  }
+
+  MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
+  m_Position = position;
+  this->Modified();
 }
 
 
 void mitk::InternalTrackingTool::GetOrientation(mitk::Quaternion& orientation) const
 {
   MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
   if (m_ToolTipSet)
     {
     // Compute the orientation of the tool tip in the coordinate frame of
     // the tracking device.
     //
     //   * m_Orientation is the orientation of the sensor relative to the transmitter
     //   * m_ToolTipRotation is the orientation of the tool tip relative to the sensor
     orientation =  m_Orientation * m_ToolTipRotation;
     }
   else
     {
     orientation = m_Orientation;
     }
 }
 
 void mitk::InternalTrackingTool::SetToolTip(mitk::Point3D toolTipPosition,
                                             mitk::Quaternion orientation,
                                             mitk::ScalarType eps)
 {
   if ( !Equal(m_ToolTip, toolTipPosition, eps) ||
        !Equal(m_ToolTipRotation, orientation, eps) )
   {
     if( (toolTipPosition[0] == 0) &&
         (toolTipPosition[1] == 0) &&
         (toolTipPosition[2] == 0) &&
         (orientation.x() == 0) &&
         (orientation.y() == 0) &&
         (orientation.z() == 0) &&
         (orientation.r() == 1))
     {
       m_ToolTipSet = false;
     }
     else
     {
       m_ToolTipSet = true;
     }
     m_ToolTip = toolTipPosition;
     m_ToolTipRotation = orientation;
     this->Modified();
   }
 }
 
-void mitk::InternalTrackingTool::SetOrientation(mitk::Quaternion orientation, mitk::ScalarType eps)
+void mitk::InternalTrackingTool::SetOrientation(mitk::Quaternion orientation)
 {
   itkDebugMacro("setting  m_Orientation to " << orientation);
-  if (!Equal(m_Orientation, orientation, eps))
-  {
-    MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
-    m_Orientation = orientation;
-    this->Modified();
-  }
+
+  MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
+  m_Orientation = orientation;
+  this->Modified();
+
 }
 
 
 void mitk::InternalTrackingTool::SetTrackingError(float error)
 {
   itkDebugMacro("setting  m_TrackingError  to " << error);
   MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
   if (error == m_TrackingError)
   {
     return;
   }
   m_TrackingError = error;
   this->Modified();
 }
 
 
 float mitk::InternalTrackingTool::GetTrackingError() const
 {
   MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
   float r = m_TrackingError;
   return r;
 }
 
 
 bool mitk::InternalTrackingTool::Enable()
 {
   MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
   if (m_Enabled == false)
   {
     this->m_Enabled = true;
     this->Modified();
   }
   return true;
 }
 
 
 bool mitk::InternalTrackingTool::Disable()
 {
   MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
   if (m_Enabled == true)
   {
     this->m_Enabled = false;
     this->Modified();
   }
   return true;
 }
 
 
 bool mitk::InternalTrackingTool::IsEnabled() const
 {
   MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
   return m_Enabled;
 }
 
 bool mitk::InternalTrackingTool::IsTooltipSet() const
 {
   MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
   return m_ToolTipSet;
 }
 
 bool mitk::InternalTrackingTool::IsDataValid() const
 {
   MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
   return m_DataValid;
 }
 
 
 void mitk::InternalTrackingTool::SetDataValid(bool _arg)
 {
   itkDebugMacro("setting m_DataValid to " << _arg);
   if (this->m_DataValid != _arg)
   {
     MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
     this->m_DataValid = _arg;
     this->Modified();
   }
 }
 
 
 void mitk::InternalTrackingTool::SetErrorMessage(const char* _arg)
 {
   itkDebugMacro("setting  m_ErrorMessage  to " << _arg);
   MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
   if ((_arg == NULL) || (_arg == this->m_ErrorMessage))
     return;
 
   if (_arg != NULL)
     this->m_ErrorMessage = _arg;
   else
     this->m_ErrorMessage = "";
   this->Modified();
 }
diff --git a/Modules/IGT/TrackingDevices/mitkInternalTrackingTool.h b/Modules/IGT/TrackingDevices/mitkInternalTrackingTool.h
index d95329b977..b420ae0601 100644
--- a/Modules/IGT/TrackingDevices/mitkInternalTrackingTool.h
+++ b/Modules/IGT/TrackingDevices/mitkInternalTrackingTool.h
@@ -1,80 +1,80 @@
 /*===================================================================
 
 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 MITKINTERNALTRACKINGTOOL_H_HEADER_INCLUDED_
 #define MITKINTERNALTRACKINGTOOL_H_HEADER_INCLUDED_
 
 #include <mitkTrackingTool.h>
 #include <MitkIGTExports.h>
 #include <mitkTypes.h>
 #include <itkFastMutexLock.h>
 
 namespace mitk {
 
 
   /**Documentation
   * \brief implements TrackingTool interface
   *
   * This class is a complete TrackingTool implementation. It can either be used directly by
   * TrackingDevices, or be subclassed for more specific implementations.
   * mitk::MicroBirdTrackingDevice uses this class to manage its tools. Other tracking devices
   * uses specialized versions of this class (e.g. mitk::NDITrackingTool)
   *
   * \ingroup IGT
   */
   class MitkIGT_EXPORT InternalTrackingTool : public TrackingTool
   {
     friend class MicroBirdTrackingDevice; // Add all TrackingDevice subclasses that use InternalTrackingDevice directly
   public:
     mitkClassMacro(InternalTrackingTool, TrackingTool);
 
     virtual void PrintSelf(std::ostream& os, itk::Indent indent) const;
 
     virtual void GetPosition(Point3D& position) const;    ///< returns the current position of the tool as an array of three floats (in the tracking device coordinate system)
     virtual void GetOrientation(Quaternion& orientation) const;  ///< returns the current orientation of the tool as a quaternion (in the tracking device coordinate system)
     virtual bool Enable();                                      ///< enablea the tool, so that it will be tracked. Returns true if enabling was successfull
     virtual bool Disable();                                     ///< disables the tool, so that it will not be tracked anymore. Returns true if disabling was successfull
     virtual bool IsEnabled() const;                             ///< returns whether the tool is enabled or disabled
     virtual bool IsDataValid() const;                           ///< returns true if the current position data is valid (no error during tracking, tracking error below threshold, ...)
     virtual float GetTrackingError() const;                     ///< return one value that corresponds to the overall tracking error. The dimension of this value is specific to each tracking device
     virtual bool IsTooltipSet() const;                          ///< returns true if a tooltip is set, false if not
     virtual void SetToolName(const std::string _arg);           ///< Sets the name of the tool
     virtual void SetToolName(const char* _arg);                 ///< Sets the name of the tool
-    virtual void SetPosition(Point3D position, ScalarType eps=0.0);           ///< sets the position
-    virtual void SetOrientation(Quaternion orientation, ScalarType eps=0.0);  ///< sets the orientation as a quaternion
+    virtual void SetPosition(Point3D position);           ///< sets the position
+    virtual void SetOrientation(Quaternion orientation);  ///< sets the orientation as a quaternion
     virtual void SetTrackingError(float error);                 ///< sets the tracking error
     virtual void SetDataValid(bool _arg);                       ///< sets if the tracking data (position & Orientation) is valid
     virtual void SetErrorMessage(const char* _arg);             ///< sets the error message
     virtual void SetToolTip(Point3D toolTipPosition, Quaternion orientation = Quaternion(0,0,0,1), ScalarType eps=0.0); ///< defines a tool tip for this tool in tool coordinates. GetPosition() and GetOrientation() return the data of the tool tip if it is defined. By default no tooltip is defined.
 
   protected:
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
     InternalTrackingTool();
     virtual ~InternalTrackingTool();
 
     Point3D m_Position;      ///< holds the position of the tool
     Quaternion m_Orientation;   ///< holds the orientation of the tool
     float m_TrackingError;    ///< holds the tracking error of the tool
     bool m_Enabled;           ///< if true, tool is enabled and should receive tracking updates from the tracking device
     bool m_DataValid;         ///< if true, data in m_Position and m_Orientation is valid, e.g. true tracking data
     Point3D m_ToolTip;
     Quaternion m_ToolTipRotation;
     bool m_ToolTipSet;
   };
 } // namespace mitk
 #endif /* MITKINTERNALTRACKINGTOOL_H_HEADER_INCLUDED_ */