diff --git a/Core/Code/DataManagement/mitkTypes.h b/Core/Code/DataManagement/mitkTypes.h
index 21193e412f..7c0d891e70 100644
--- a/Core/Code/DataManagement/mitkTypes.h
+++ b/Core/Code/DataManagement/mitkTypes.h
@@ -1,371 +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
+ *
+ * @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
+ */
+template <typename DifferenceType>
+static inline bool DifferenceBiggerEps(DifferenceType diff, mitk::ScalarType epsilon = mitk::eps)
+{
+  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 =  fabs(matrix1(r,c)-matrix2(r,c));
-        if (difference>epsilon)
+        TCoordRep difference =  matrix1(r,c)-matrix2(r,c);
+        if (DifferenceBiggerEps(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 (diff[i]>eps || diff[i]<-eps)
+    if (DifferenceBiggerEps(diff[i], eps))
     {
       isEqual = false;
       break;
     }
   }
 
-  if(verbose && !isEqual)
-  {
-    MITK_INFO << "Vectors not equal. Lefthandside " << std::setprecision(12) << vector1 << " - Righthandside " << vector2 << " - epsilon " << eps;
-  }
+  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 (diff[i]>eps || diff[i]<-eps)
+    if (DifferenceBiggerEps(diff[i], eps))
     {
       isEqual = false;
       break;
     }
   }
 
-  if(verbose && !isEqual)
-  {
-    MITK_INFO << "Points not equal. Lefthandside " << std::setprecision(12) << point1 << " - Righthandside " << point2 << " - epsilon " << eps;
-  }
+  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 (diff[i]>eps || diff[i]<-eps)
+    if (DifferenceBiggerEps(diff[i], eps))
     {
       isEqual = false;
       break;
     }
   }
 
-  if(verbose && !isEqual)
-  {
-    MITK_INFO << "Vectors not equal. Lefthandside " << std::setprecision(12) << vector1 << " - Righthandside " << vector2 << " - epsilon " << eps;
-  }
+  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( fabs(scalar1-scalar2) < eps );
-  if(verbose && !isEqual)
-  {
-    MITK_INFO << "Scalars not equal. Lefthandside " << std::setprecision(12) << scalar1 << " - Righthandside " << scalar2 << " - epsilon " << eps;
-  }
+  bool isEqual( !DifferenceBiggerEps(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(diff[i]>eps || diff[i]<-eps)
+    if (DifferenceBiggerEps(diff[i], eps))
     {
       isEqual = false;
       break;
     }
   }
 
-  if(verbose && !isEqual)
-  {
-    MITK_INFO << "Vectors not equal. Lefthandside " << std::setprecision(12) << vector1 << " - Righthandside " << vector2 << " - epsilon " << eps;
-  }
+  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);
   }
 
-  if(verbose && !isEqual)
-  {
-    MITK_INFO << "Array not equal. Lefthandside " << std::setprecision(12) << arrayType1 << " - Righthandside " << arrayType2 << " - epsilon " << 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/mitkEqualTest.cpp b/Core/Code/Testing/mitkEqualTest.cpp
index 12b89c3cb0..894496a0fe 100644
--- a/Core/Code/Testing/mitkEqualTest.cpp
+++ b/Core/Code/Testing/mitkEqualTest.cpp
@@ -1,207 +1,207 @@
 /*===================================================================
 
  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 <mitkTestFixture.h>
 #include <mitkTypes.h>
 
 class mitkEqualTestSuite : public mitk::TestFixture
 {
 
   CPPUNIT_TEST_SUITE(mitkEqualTestSuite);
   MITK_TEST(Equal_SameMitkVector3D_ReturnTrue);
   MITK_TEST(Equal_SameMitkVector2D_ReturnTrue);
   MITK_TEST(Equal_DifferentMitkVector3D_ReturnFalse);
   MITK_TEST(Equal_DifferentMitkVector2D_ReturnFalse);
   MITK_TEST(Equal_SameMitkVnlVector_ReturnTrue);
   MITK_TEST(Equal_DifferentMitkVnlVector_ReturnFalse);
   MITK_TEST(Equal_SameVnlVector_ReturnTrue);
   MITK_TEST(Equal_DifferentVnlVector_ReturnFalse);
   MITK_TEST(Equal_SameItkVector_ReturnTrue);
   MITK_TEST(Equal_DifferentItkVector_ReturnFalse);
   MITK_TEST(Equal_SameScalar_ReturnTrue);
   MITK_TEST(Equal_DifferentScalar_ReturnFalse);
   MITK_TEST(Equal_SameItkPoint_ReturnTrue);
   MITK_TEST(Equal_DifferentItkPoint_ReturnFalse);
   CPPUNIT_TEST_SUITE_END();
 
 public:
 
   void Equal_SameMitkVector3D_ReturnTrue()
   {
     mitk::Vector3D v1;
     v1.Fill(1);
     mitk::Vector3D v2;
     v2.Fill(1);
     CPPUNIT_ASSERT(mitk::Equal(v1,v2));
   }
 
   void Equal_SameMitkVector2D_ReturnTrue()
   {
     mitk::Vector2D v1;
     v1.Fill(2);
     mitk::Vector2D v2;
     v2.Fill(2);
     CPPUNIT_ASSERT(mitk::Equal(v1,v2));
   }
 
   void Equal_DifferentMitkVector3D_ReturnFalse()
   {
     mitk::Vector3D v1;
     v1.SetElement(0, 1);
     v1.SetElement(1, 1);
     v1.SetElement(2, 1);
     mitk::Vector3D v2;
     v2.SetElement(0, 2);
     v2.SetElement(1, 1);
     v2.SetElement(2, 1);
     CPPUNIT_ASSERT_EQUAL_MESSAGE("Coparison of 2 different 3D MITK vectors (first element). Result should be false.", mitk::Equal(v1,v2), false);
     mitk::Vector3D v3;
     v3.SetElement(0, 1);
     v3.SetElement(1, 2);
     v3.SetElement(2, 1);
     CPPUNIT_ASSERT_EQUAL_MESSAGE("Coparison of 2 different 3D MITK vectors (second element). Result should be false.", mitk::Equal(v1,v3), false);
     mitk::Vector3D v4;
     v4.SetElement(0, 1);
     v4.SetElement(1, 1);
     v4.SetElement(2, 2);
     CPPUNIT_ASSERT_EQUAL_MESSAGE("Coparison of 2 different 3D MITK vectors (third element). Result should be false.", mitk::Equal(v1,v4), false);
   }
 
   void Equal_DifferentMitkVector2D_ReturnFalse()
   {
     mitk::Vector2D v1;
     v1.SetElement(0, 1);
     v1.SetElement(1, 1);
     mitk::Vector2D v2;
     v2.SetElement(0, 2);
     v2.SetElement(1, 1);
     CPPUNIT_ASSERT_EQUAL_MESSAGE("Coparison of 2 different 2D MITK vectors (first element). Result should be false.", mitk::Equal(v1,v2), false);
     mitk::Vector2D v3;
     v3.SetElement(0, 1);
     v3.SetElement(1, 2);
     CPPUNIT_ASSERT_EQUAL_MESSAGE("Coparison of 2 different 2D MITK vectors (second element). Result should be false.", mitk::Equal(v1,v3), false);
   }
 
   void Equal_SameMitkVnlVector_ReturnTrue()
   {
     mitk::VnlVector v1(2);
     v1.fill(8);
     mitk::VnlVector v2(2);
     v2.fill(8);
     CPPUNIT_ASSERT(mitk::Equal(v1,v2));
   }
 
   void Equal_DifferentMitkVnlVector_ReturnFalse()
   {
     mitk::VnlVector v1(3);
     v1.fill(9.2);
     mitk::VnlVector v2(3);
     v2.fill(9.2);
     v2[0] = 6;
     CPPUNIT_ASSERT_EQUAL_MESSAGE("Comparison of 2 different MITK VNL vectors. Result should be false.", mitk::Equal(v1,v2), false);
   }
 
   void Equal_SameVnlVector_ReturnTrue()
   {
     vnl_vector_fixed<mitk::ScalarType, 4u> v1;
     v1.fill(3.0);
     vnl_vector_fixed<mitk::ScalarType, 4u> v2;
     v2.fill(3.0);
     CPPUNIT_ASSERT(mitk::Equal(v1,v2));
   }
 
   void Equal_DifferentVnlVector_ReturnFalse()
   {
     vnl_vector_fixed<mitk::ScalarType, 2u> v1;
     v1.fill(8.231);
     vnl_vector_fixed<mitk::ScalarType, 2u> v2;
     v2[0] = 3.1;
     v2[1] = 8.231;
     CPPUNIT_ASSERT_EQUAL_MESSAGE("Comparison of 2 different VNL vectors (first element). Result should be false.", mitk::Equal(v1,v2), false);
     vnl_vector_fixed<mitk::ScalarType, 2u> v3;
     v3[0] = 8.231;
     v3[1] = 2.14;
     CPPUNIT_ASSERT_EQUAL_MESSAGE("Comparison of 2 different VNL vectors (first element). Result should be false.", mitk::Equal(v1,v3), false);
   }
 
   void Equal_SameItkVector_ReturnTrue()
   {
     itk::Vector<mitk::ScalarType, 3u> v1;
     v1.Fill(1.32);
     itk::Vector<mitk::ScalarType, 3u> v2;
     v2.Fill(1.32);
     mitk::Equal(v1, v2);
     CPPUNIT_ASSERT(mitk::Equal(v1,v2));
   }
 
   void Equal_DifferentItkVector_ReturnFalse()
   {
     itk::Vector<mitk::ScalarType, 3u> v1;
     v1.Fill(5.2);
     itk::Vector<mitk::ScalarType, 3u> v2;
     v2.Fill(5.2);
     v2.SetElement(0, 1.4);
     CPPUNIT_ASSERT_EQUAL_MESSAGE("Coparison of 2 different ITK vectors (first element). Result should be false.", mitk::Equal(v1,v2), false);
     itk::Vector<mitk::ScalarType, 3u> v3;
     v3.Fill(5.2);
     v3.SetElement(1, 1.4);
     CPPUNIT_ASSERT_EQUAL_MESSAGE("Coparison of 2 different ITK vectors (second element). Result should be false.", mitk::Equal(v1,v3), false);
     itk::Vector<mitk::ScalarType, 3u> v4;
     v4.Fill(5.2);
     v4.SetElement(2, 1.4);
     CPPUNIT_ASSERT_EQUAL_MESSAGE("Coparison of 2 different ITK vectors (third element). Result should be false.", mitk::Equal(v1,v4), false);
   }
 
   void Equal_SameScalar_ReturnTrue()
   {
     mitk::ScalarType a = 6.432;
     mitk::ScalarType b = 6.432;
     CPPUNIT_ASSERT(mitk::Equal(a,b));
   }
 
   void Equal_DifferentScalar_ReturnFalse()
   {
-    mitk::ScalarType a = 6;
-    mitk::ScalarType b = 6 + 1.01*mitk::eps;
+    mitk::ScalarType a = 0.6;
+    mitk::ScalarType b = 0.6 + 1.01*mitk::eps;
     CPPUNIT_ASSERT_EQUAL_MESSAGE("Comparison of 2 different scalars. Result should be false", mitk::Equal(a,b), false);
   }
 
   void Equal_SameItkPoint_ReturnTrue()
   {
     itk::Point<mitk::ScalarType, 2> p1;
     p1.Fill(3.21);
     itk::Point<mitk::ScalarType, 2> p2;
     p2.Fill(3.21);
     CPPUNIT_ASSERT(mitk::Equal(p1,p2));
   }
 
   void Equal_DifferentItkPoint_ReturnFalse()
   {
     itk::Point<mitk::ScalarType, 2> p1;
     p1.Fill(2.1);
     itk::Point<mitk::ScalarType, 2> p2;
     p2[0] = 1;
     p2[1] = 2.1;
     CPPUNIT_ASSERT_EQUAL_MESSAGE("Comparison of 2 different points (first element). Result should be false.", mitk::Equal(p1,p2), false);
     itk::Point<mitk::ScalarType, 2> p3;
     p3[0] = 2.1;
     p3[1] = 2.1 + 1.01*mitk::eps;
     CPPUNIT_ASSERT_EQUAL_MESSAGE("Comparison of 2 different points (second element). Result should be false.", mitk::Equal(p1,p3), false);
   }
 };
 
 MITK_TEST_SUITE_REGISTRATION(mitkEqual)
diff --git a/Core/Code/Testing/mitkVectorTest.cpp b/Core/Code/Testing/mitkVectorTest.cpp
index a73392d696..16b88cb5ac 100644
--- a/Core/Code/Testing/mitkVectorTest.cpp
+++ b/Core/Code/Testing/mitkVectorTest.cpp
@@ -1,139 +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;
-  mitk::ScalarType scalar3 = scalar1 + mitk::eps*0.95;
+  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 less 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_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();
 }