diff --git a/Core/Code/DataManagement/mitkTypeConversions.h b/Core/Code/DataManagement/mitkArray.h
similarity index 69%
rename from Core/Code/DataManagement/mitkTypeConversions.h
rename to Core/Code/DataManagement/mitkArray.h
index 911206f7a4..55cf9a92c0 100644
--- a/Core/Code/DataManagement/mitkTypeConversions.h
+++ b/Core/Code/DataManagement/mitkArray.h
@@ -1,98 +1,141 @@
 /*
- * mitkTypeConversions.h
+ * mitkArray.h
  *
  *  Created on: Nov 11, 2013
  *      Author: wirkert
  */
 
-#ifndef MITKTYPECONVERSIONS_H_
-#define MITKTYPECONVERSIONS_H_
+#ifndef MITKARRAY_H_
+#define MITKARRAY_H_
 
+#include <itkFixedArray.h>
 
 #include "mitkConstants.h"
+#include "mitkEqual.h"
 
 
 namespace mitk {
 
 
   /**
-   *  Now methods to copy from and into ArrayTypes.
+   *  Methods to copy from itk::FixedArray s (like mitk::Vector and mitk::Point) into ArrayTypes and vice versa.
    *  ArrayTypes here are all types who implement operator[].
    *  The two templated methods were made free floating so you may specialize them
    *  for your concrete type.
    */
 
 
   /**
    * @brief Copies elements of an array to this Vector
    * @param[in] array    the array whose values will be copied into the Vector. Must be of a type which overrides the [] operator
    * @param[out] toArray  the FixedArrray (e.g., mitk::Vector or mitk::Point) which should hold the elements of array.
    * @attention array must be of dimension NVectorDimension!
    * @attention this method implicitly converts between data types.
    */
   template <typename ArrayType, typename TCoordRep, unsigned int NVectorDimension>
   void FromArray(itk::FixedArray<TCoordRep, NVectorDimension>& toArray, const ArrayType& array)
   {
     itk::FixedArray<TCoordRep, NVectorDimension> vectorOrPoint;
 
     for (unsigned short int var = 0; var < NVectorDimension; ++var)
     {
       toArray[var] =  array[var];
     }
   }
 
   /**
    * @brief Copies elements of an array to this Vector
    * @param[in] array    the array whose values will be copied into the Vector. Must be of a type which overrides the [] operator
    * @param return       the FixedArrray (e.g., mitk::Vector or mitk::Point) which should hold the elements of array.
    * @attention array must be of dimension NVectorDimension!
    * @attention this method implicitly converts between data types.
    */
   template <typename ArrayType, typename TCoordRep, unsigned int NVectorDimension>
   itk::FixedArray<TCoordRep, NVectorDimension> FromArray(const ArrayType& array)
   {
     itk::FixedArray<TCoordRep, NVectorDimension> vectorOrPoint;
 
     mitk::FromArray(vectorOrPoint, array);
 
     return vectorOrPoint;
   }
 
   /**
    * @brief Copies the elements of this into an array
    * @param[in] vectorOrPoint   the itk::FixedArray which shall be copied into the array. Can e.g. be of type mitk::Vector or mitk::Point
    * @param[out] array    the array which will hold the elements. Must be of a type which overrides the [] operator.
    * @attention array must be of dimension NVectorDimension!
    * @attention this method implicitly converts between data types.
    */
   template <typename ArrayType, typename TCoordRep, unsigned int NVectorDimension>
   void ToArray(ArrayType& array, const itk::FixedArray<TCoordRep, NVectorDimension>& vectorOrPoint)
   {
     for (unsigned short int var = 0; var < NVectorDimension; ++var)
     {
       array[var] = vectorOrPoint[var];
     }
   }
 
 
   /**
    * @brief Copies the elements of this into an array
    * @param[in] vectorOrPoint   the itk::FixedArray which shall be copied into the array. Can e.g. be of type mitk::Vector or mitk::Point
    * @return    the array which will hold the elements. Must be of a type which overrides the [] operator.
    * @attention array must be of dimension NVectorDimension!
    * @attention this method implicitly converts between data types.
    */
   template <typename ArrayType, typename TCoordRep, unsigned int NVectorDimension>
   ArrayType ToArray(const itk::FixedArray<TCoordRep, NVectorDimension>& vectorOrPoint)
   {
     ArrayType result;
 
     mitk::ToArray(result, vectorOrPoint);
 
     return result;
   }
 
+
+  // The FillVector3D and FillVector4D methods are implemented for all common array types here
+
+  template <class Tout>
+  inline void FillVector3D(Tout& out, mitk::ScalarType x, mitk::ScalarType y, mitk::ScalarType z)
+  {
+    out[0] = x;
+    out[1] = y;
+    out[2] = z;
+  }
+
+  template <class Tout>
+  inline void FillVector4D(Tout& out, mitk::ScalarType x, mitk::ScalarType y, mitk::ScalarType z, mitk::ScalarType t)
+  {
+    out[0] = x;
+    out[1] = y;
+    out[2] = z;
+    out[3] = t;
+  }
+
+
+
+  /**
+   * 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 lead to unexpected results.
+   */
+  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;
+  }
+
 }
 
 
-#endif /* MITKTYPECONVERSIONS_H_ */
+#endif /* MITKARRAY_H_ */
diff --git a/Core/Code/DataManagement/mitkEqual.h b/Core/Code/DataManagement/mitkEqual.h
index 81adc166d4..750e4ee07e 100644
--- a/Core/Code/DataManagement/mitkEqual.h
+++ b/Core/Code/DataManagement/mitkEqual.h
@@ -1,71 +1,72 @@
 /*
  * mitkEqual.h
  *
  *  Created on: Apr 14, 2014
  *      Author: wirkert
  */
 
 #ifndef MITKEQUAL_H_
 #define MITKEQUAL_H_
 
+#include <iomanip>
 
 #include "mitkConstants.h"
 #include "mitkLogMacros.h"
 
 namespace mitk {
 
   /**
    * Helper method to check if the difference is bigger or equal 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
    */
   template <typename DifferenceType>
   inline bool DifferenceBiggerOrEqualEps(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>
   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;
     }
   }
 
   /**
    * @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( !DifferenceBiggerOrEqualEps(scalar1-scalar2, eps));
 
     ConditionalOutputOfDifference(scalar1, scalar2, eps, verbose, isEqual);
 
     return isEqual;
   }
 
 }
 
 
 
 #endif /* MITKEQUAL_H_ */
diff --git a/Core/Code/DataManagement/mitkMatrix.h b/Core/Code/DataManagement/mitkMatrix.h
index 4b738ecdde..0c183e4942 100644
--- a/Core/Code/DataManagement/mitkMatrix.h
+++ b/Core/Code/DataManagement/mitkMatrix.h
@@ -1,86 +1,171 @@
 /*===================================================================
 
 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 MITKMATRIX_H_
 #define MITKMATRIX_H_
 
-#include "mitkConstants.h"
 #include <itkMatrix.h>
 
+#include "mitkConstants.h"
+#include "mitkArray.h"
+#include "mitkEqual.h"
+
 namespace mitk
 {
 
   template< class T, unsigned int NRows = 3, unsigned int NColumns = 3 >
   class Matrix : public itk::Matrix<T, NRows, NColumns>
   {
   public:
 
     /** Standard class typedefs. */
     typedef Matrix Self;
 
     typedef typename itk::Matrix<T, NRows, NColumns>::InternalMatrixType InternalMatrixType;
 
     /** Default constructor. */
     Matrix<T, NRows, NColumns>() :
         itk::Matrix<T, NRows, NColumns>() {}
 
     /** Copy constructor. */
     Matrix<T, NRows, NColumns>(const Matrix & matrix) :
             itk::Matrix<T, NRows, NColumns>(matrix) {}
 
     /** Copy constructor for itk compatibility */
     Matrix<T, NRows, NColumns>(const itk::Matrix<T, NRows, NColumns> & matrix) :
             itk::Matrix<T, NRows, NColumns>(matrix) {}
 
     /**For every operator=, there should be an equivalent copy constructor. */
     inline Matrix<T, NRows, NColumns>(const vnl_matrix< T > & matrix) :
         itk::Matrix<T, NRows, NColumns>(matrix) {}
 
     /**For every operator=, there should be an equivalent copy constructor. */
     inline explicit Matrix<T, NRows, NColumns>(InternalMatrixType & matrix) :
         itk::Matrix<T, NRows, NColumns>(matrix) {}
 
     /**
      * Necessary because otherwise operator= is default operator= from Matrix.
      */
     using itk::Matrix<T, NRows, NColumns>::operator=;
 
 
 
     /**
      * Warning: Array must have same dimension as Matrix
      */
     void CopyToArray(ScalarType const array_p[NRows][NColumns]) const
     {
       for (int i = 0; i < this->GetPointDimension(); i++)
       {
         array_p[i] = this->GetElement(i);
       }
     }
   };
 
   typedef Matrix<ScalarType,2,2> Matrix2D;
   typedef Matrix<ScalarType,3,3> Matrix3D;
   typedef Matrix<ScalarType,4,4> Matrix4D;
 
   // other matrix types used in mitk code
   typedef vnl_matrix_fixed<ScalarType, 3, 3> VnlMatrix3D;
 
 
+
+  /*!
+  \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 (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);
+  }
+
 }
 
 
 #endif /* MITKMATRIX_H_ */
diff --git a/Core/Code/DataManagement/mitkPoint.h b/Core/Code/DataManagement/mitkPoint.h
index 26c65db0ed..97ae2fdad6 100644
--- a/Core/Code/DataManagement/mitkPoint.h
+++ b/Core/Code/DataManagement/mitkPoint.h
@@ -1,127 +1,142 @@
 /*===================================================================
 
 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 MITKPOINT_H
 #define MITKPOINT_H
 
 
 #include <itkPoint.h>
-#include "mitkConstants.h"
 
+#include "mitkConstants.h"
+#include "mitkArray.h"
+#include "mitkEqual.h"
 
 namespace mitk {
 
   //##Documentation
   //##@brief enumeration of the type a point can be
   enum PointSpecificationType
   {
     PTUNDEFINED = 0,
     PTSTART,
     PTCORNER,
     PTEDGE,
     PTEND
   };
 
   template<class TCoordRep, unsigned int NPointDimension = 3>
   class Point : public itk::Point<TCoordRep, NPointDimension>
   {
 
   public:
     /** Default constructor has nothing to do. */
     Point<TCoordRep, NPointDimension>() : itk::Point<TCoordRep, NPointDimension>() {}
 
     /** Pass-through constructors for the Array base class. */
     template< typename TPointValueType >
     Point(const Point< TPointValueType, NPointDimension > & r):itk::Point<TCoordRep, NPointDimension>(r) {}
 
     template< typename TPointValueType >
     Point(const TPointValueType r[NPointDimension]):itk::Point<TCoordRep, NPointDimension>(r) {}
 
     template< typename TPointValueType >
     Point(const TPointValueType & v):itk::Point<TCoordRep, NPointDimension>(v) {}
 
 
     Point<TCoordRep, NPointDimension>(const mitk::Point<TCoordRep, NPointDimension>& r) : itk::Point<TCoordRep, NPointDimension>(r) {}
     Point<TCoordRep, NPointDimension>(const TCoordRep r[NPointDimension]):itk::Point<TCoordRep, NPointDimension>(r) {}
     Point<TCoordRep, NPointDimension>(const TCoordRep & v):itk::Point<TCoordRep, NPointDimension>(v) {}
     Point<TCoordRep, NPointDimension>(const itk::Point<TCoordRep, NPointDimension> & p) : itk::Point<TCoordRep, NPointDimension>(p) {}
 
     /** Pass-through assignment operator for the Array base class. */
     /**
      * Assignment Operator
      */
     Point< TCoordRep, NPointDimension > &
     operator=(const Point & r)
     {
       itk::Point<TCoordRep, NPointDimension>::operator=(r);
       return *this;
     }
 
 
     /**
      * Assignment from a plain array
      */
     Point< TCoordRep, NPointDimension > &
     operator=(const TCoordRep r[NPointDimension])
     {
       itk::Point<TCoordRep, NPointDimension>::operator=(r);
       return *this;
     }
 
 
     /**
      * Warning: Array must have same dimension as Point
      */
     void CopyToArray(ScalarType array_p[NPointDimension]) const
     {
       for (unsigned int i = 0; i < this->GetPointDimension(); i++)
         {
           array_p[i] = this->GetElement(i);
         }
     }
   };
 
   typedef Point<ScalarType,2> Point2D;
   typedef Point<ScalarType,3> Point3D;
   typedef Point<ScalarType,4> Point4D;
 
   typedef Point<int,2> Point2I;
   typedef Point<int,3> Point3I;
   typedef Point<int,4> Point4I;
-/**
-  inline void FillVector3D(Point<mitk::ScalarType, 3>& out, mitk::ScalarType x, mitk::ScalarType y, mitk::ScalarType z)
-  {
-    out[0] = x;
-    out[1] = y;
-    out[2] = z;
-  }
 
-  inline void FillVector4D(Point<mitk::ScalarType, 4>& out, mitk::ScalarType x, mitk::ScalarType y, mitk::ScalarType z, mitk::ScalarType t)
+
+  /**
+   * @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)
   {
-    out[0] = x;
-    out[1] = y;
-    out[2] = z;
-    out[4] = t;
+    bool isEqual = true;
+    typename itk::Point<TCoordRep, NPointDimension>::VectorType diff = point1-point2;
+    for (unsigned int i=0; i<NPointDimension; i++)
+    {
+      if (DifferenceBiggerOrEqualEps(diff[i], eps))
+      {
+        isEqual = false;
+        break;
+      }
+    }
+
+    ConditionalOutputOfDifference(point1, point2, eps, verbose, isEqual);
+
+    return isEqual;
   }
-  */
 
 
 
 } // namespace mitk
 
 
 #endif /* MITKPOINT_H */
diff --git a/Core/Code/DataManagement/mitkTypes.h b/Core/Code/DataManagement/mitkTypes.h
index ee1f1dc614..65a09dbdcd 100644
--- a/Core/Code/DataManagement/mitkTypes.h
+++ b/Core/Code/DataManagement/mitkTypes.h
@@ -1,303 +1,76 @@
 /*===================================================================
 
 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 "mitkConstants.h"
 #include "mitkQuaternion.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 "mitkEqual.h"
 
 #include "mitkOldTypeConversions.h"
 
 
-#ifndef DOXYGEN_SKIP
-
-namespace mitk {
-
-
-
-/*!
-\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 (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 (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 (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 (DifferenceBiggerOrEqualEps(diff[i], eps))
-    {
-      isEqual = false;
-      break;
-    }
-  }
-
-  ConditionalOutputOfDifference(vector1, vector2, 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 (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/DataManagement/mitkVector.h b/Core/Code/DataManagement/mitkVector.h
index 2376dd9f5a..888c01406e 100644
--- a/Core/Code/DataManagement/mitkVector.h
+++ b/Core/Code/DataManagement/mitkVector.h
@@ -1,228 +1,250 @@
 /*===================================================================
 
 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_
 #define MITKVECTOR_H_
 
 
 #include <itkVector.h>
 #include <vnl/vnl_vector_fixed.h>
 #include <vnl/vnl_vector.h>
 
 #include "mitkConstants.h"
-#include "mitkTypeConversions.h"
+#include "mitkArray.h"
+#include "mitkEqual.h"
 #include "mitkExceptionMacro.h"
 
 namespace mitk
 {
 
   template<class TCoordRep, unsigned int NVectorDimension = 3>
   class Vector : public itk::Vector<TCoordRep, NVectorDimension>
   {
   public:
     /**
      * @brief Default constructor has nothing to do.
      */
     explicit Vector<TCoordRep, NVectorDimension>()
       : itk::Vector<TCoordRep, NVectorDimension>() {}
 
     /**
      * @brief Copy constructor.
      */
     explicit Vector<TCoordRep, NVectorDimension>(const mitk::Vector<TCoordRep, NVectorDimension>& r)
       : itk::Vector<TCoordRep, NVectorDimension>(r) {}
 
     /**
      * @brief Constructor to convert from itk::Vector to mitk::Vector.
      */
     Vector<TCoordRep, NVectorDimension>(const itk::Vector<TCoordRep, NVectorDimension>& r)
       : itk::Vector<TCoordRep, NVectorDimension>(r) {}
 
 
     /**
      * @brief Constructor to convert an array to mitk::Vector
      * @param r the array.
      * @attention must have NVectorDimension valid arguments!
      */
     Vector<TCoordRep, NVectorDimension>(const TCoordRep r[NVectorDimension])
       : itk::Vector<TCoordRep, NVectorDimension>(r) {}
 
     /**
      * Constructor to initialize entire vector to one value.
      */
     Vector<TCoordRep, NVectorDimension>(const TCoordRep & v)
         : itk::Vector<TCoordRep, NVectorDimension>(v) {}
 
     /**
      * @brief Constructor for vnl_vectors.
      * @throws mitk::Exception if vnl_vector.size() != NVectorDimension.
      */
     Vector<TCoordRep, NVectorDimension>(const vnl_vector<TCoordRep>& vnlVector)
             : itk::Vector<TCoordRep, NVectorDimension>()
     {
       if (vnlVector.size() != NVectorDimension)
         mitkThrow() << "when constructing mitk::Vector from vnl_vector: sizes didn't match: mitk::Vector " << NVectorDimension << "; vnl_vector " << vnlVector.size();
 
       for (unsigned int var = 0; (var < NVectorDimension) && (var < vnlVector.size()); ++var) {
         this->SetElement(var, vnlVector.get(var));
       }
     }
 
     /**
      * @brief Constructor for vnl_vector_fixed.
      */
     Vector<TCoordRep, NVectorDimension>(const vnl_vector_fixed<TCoordRep, NVectorDimension>& vnlVectorFixed)
         : itk::Vector<TCoordRep, NVectorDimension>()
     {
       for (unsigned int var = 0; var < NVectorDimension; ++var) {
         this->SetElement(var,  vnlVectorFixed[var]);
       }
     };
 
     /**
      * Copies the elements from array array to this.
      * Note that this method will assign doubles to floats without complaining!
      *
      * @param array the array whose values shall be copied. Must overload [] operator.
      */
     template <typename ArrayType >
     void FromArray(const ArrayType& array)
     {
       itk::FixedArray<TCoordRep, NVectorDimension>* thisP = dynamic_cast<itk::FixedArray<TCoordRep, NVectorDimension>* >(this);
       mitk::FromArray<ArrayType, TCoordRep, NVectorDimension>(*thisP, array);
     }
 
     /**
      * Copies the elements of this vector to an array of type ArrayType
      * Note that this method will assign doubles to floats without complaining!
      *
      * @return the array holding the elements of this. Only requierement is that it overloads the [] operator
      */
     template <typename ArrayType >
     ArrayType ToArray()
     {
       ArrayType result = mitk::ToArray<ArrayType, TCoordRep, NVectorDimension>(*this);
       return result;
     }
 
     /**
      * Copies the values stored in this vector into the array array.
      * This method has to be used over the version returning the array when
      * copying to pod arrays.
      * Furthermore, the syntax may be a little bit nicer because ArrayType can be
      * inferred from the parameter.
      *
      * @param array the array which should store the values of this.
      */
     template <typename ArrayType >
     void ToArray(ArrayType array)
     {
       mitk::ToArray<ArrayType, TCoordRep, NVectorDimension>(array, *this);
     }
 
 
     /**
      * @brief User defined conversion of mitk::Vector to vnl_vector.
      * Note: the conversion to mitk::Vector to vnl_vector_fixed has not been implemented since this
      * would collide with the conversion vnl_vector to vnl_vector_fixed provided by vnl.
      */
     operator vnl_vector<TCoordRep> () const
     {
       return this->GetVnlVector();
     }
 
 
   }; // end mitk::Vector
 
   // convenience typedefs for often used mitk::Vector representations.
 
   typedef Vector<ScalarType,2> Vector2D;
   typedef Vector<ScalarType,3> Vector3D;
   typedef Vector<ScalarType,4> Vector4D;
 
   // other vector types used in MITK
   typedef vnl_vector<ScalarType> VnlVector;
   typedef vnl_vector_ref<ScalarType> VnlVectorRef;
 
-  // The FillVector3D and FillVector4D methods are implemented for all common vector types here
-  // (mitk::Vector, vnl_vector and vnl_vector_ref)
-
-  template <class Tout>
-  inline void FillVector3D(Tout& out, mitk::ScalarType x, mitk::ScalarType y, mitk::ScalarType z)
+  // The equal methods to compare vectors for equality are below:
+
+  /**
+   * @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)
   {
-    out[0] = x;
-    out[1] = y;
-    out[2] = z;
-  }
+    bool isEqual = true;
+    typename itk::Vector<TCoordRep, NPointDimension>::VectorType diff = vector1-vector2;
+    for (unsigned int i=0; i<NPointDimension; i++)
+    {
+      if (DifferenceBiggerOrEqualEps(diff[i], eps))
+      {
+        isEqual = false;
+        break;
+      }
+    }
 
-  template <class Tout>
-  inline void FillVector4D(Tout& out, mitk::ScalarType x, mitk::ScalarType y, mitk::ScalarType z, mitk::ScalarType t)
-  {
-    out[0] = x;
-    out[1] = y;
-    out[2] = z;
-    out[3] = t;
-  }
+    ConditionalOutputOfDifference(vector1, vector2, eps, verbose, isEqual);
 
-/*
-  inline void FillVector3D(Vector<mitk::ScalarType, 3>& out, mitk::ScalarType x, mitk::ScalarType y, mitk::ScalarType z)
-  {
-    out[0] = x;
-    out[1] = y;
-    out[2] = z;
+    return isEqual;
   }
 
-  inline void FillVector4D(Vector<mitk::ScalarType, 4>& out, mitk::ScalarType x, mitk::ScalarType y, mitk::ScalarType z, mitk::ScalarType t)
+  /**
+   * @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)
   {
-    out[0] = x;
-    out[1] = y;
-    out[2] = z;
-    out[4] = t;
-  }
+    bool isEqual = true;
+    mitk::VnlVector diff = vector1-vector2;
+    for (unsigned int i=0; i<diff.size(); i++)
+    {
+      if (DifferenceBiggerOrEqualEps(diff[i], eps))
+      {
+        isEqual = false;
+        break;
+      }
+    }
 
-  inline void FillVector3D(VnlVector& out, mitk::ScalarType x, mitk::ScalarType y, mitk::ScalarType z)
-  {
-    out[0] = x;
-    out[1] = y;
-    out[2] = z;
-  }
+    ConditionalOutputOfDifference(vector1, vector2, eps, verbose, isEqual);
 
-  inline void FillVector4D(VnlVector& out, mitk::ScalarType x, mitk::ScalarType y, mitk::ScalarType z, mitk::ScalarType t)
-  {
-    FillVector3D(out, x, y, z);
-    out[4] = t;
+    return isEqual;
   }
 
-  inline void FillVector3D(VnlVectorRef& out, mitk::ScalarType x, mitk::ScalarType y, mitk::ScalarType z)
-  {
-    out[0] = x;
-    out[1] = y;
-    out[2] = z;
-  }
 
-  inline void FillVector4D(VnlVectorRef& out, mitk::ScalarType x, mitk::ScalarType y, mitk::ScalarType z, mitk::ScalarType t)
+  /**
+   * @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)
   {
-    FillVector3D(out, x, y, z);
-    out[4] = t;
-  }
-  */
+    vnl_vector_fixed<TCoordRep, NPointDimension> diff = vector1-vector2;
+    bool isEqual = true;
+    for( unsigned int i=0; i<diff.size(); i++)
+    {
+      if (DifferenceBiggerOrEqualEps(diff[i], eps))
+      {
+        isEqual = false;
+        break;
+      }
+    }
 
+    ConditionalOutputOfDifference(vector1, vector2, eps, verbose, isEqual);
 
+    return isEqual;
+  }
 
 
 } // end namespace mitk
 
 #endif /* MITKVECTOR_H_ */
diff --git a/Core/Code/files.cmake b/Core/Code/files.cmake
index ee4addf07a..f44b5785f4 100644
--- a/Core/Code/files.cmake
+++ b/Core/Code/files.cmake
@@ -1,414 +1,414 @@
 set(H_FILES
   Algorithms/itkImportMitkImageContainer.h
   Algorithms/itkImportMitkImageContainer.txx
   Algorithms/itkMITKScalarImageToHistogramGenerator.h
   Algorithms/itkMITKScalarImageToHistogramGenerator.txx
   Algorithms/mitkInstantiateAccessFunctions.h
   Algorithms/mitkPixelTypeList.h
   Algorithms/mitkPPArithmeticDec.h
   Algorithms/mitkPPArgCount.h
   Algorithms/mitkPPCat.h
   Algorithms/mitkPPConfig.h
   Algorithms/mitkPPControlExprIIf.h
   Algorithms/mitkPPControlIf.h
   Algorithms/mitkPPControlIIf.h
   Algorithms/mitkPPDebugError.h
   Algorithms/mitkPPDetailAutoRec.h
   Algorithms/mitkPPDetailDMCAutoRec.h
   Algorithms/mitkPPExpand.h
   Algorithms/mitkPPFacilitiesEmpty.h
   Algorithms/mitkPPFacilitiesExpand.h
   Algorithms/mitkPPLogicalBool.h
   Algorithms/mitkPPRepetitionDetailDMCFor.h
   Algorithms/mitkPPRepetitionDetailEDGFor.h
   Algorithms/mitkPPRepetitionDetailFor.h
   Algorithms/mitkPPRepetitionDetailMSVCFor.h
   Algorithms/mitkPPRepetitionFor.h
   Algorithms/mitkPPSeqElem.h
   Algorithms/mitkPPSeqForEach.h
   Algorithms/mitkPPSeqForEachProduct.h
   Algorithms/mitkPPSeq.h
   Algorithms/mitkPPSeqEnum.h
   Algorithms/mitkPPSeqSize.h
   Algorithms/mitkPPSeqToTuple.h
   Algorithms/mitkPPStringize.h
   Algorithms/mitkPPTupleEat.h
   Algorithms/mitkPPTupleElem.h
   Algorithms/mitkPPTupleRem.h
   Algorithms/mitkClippedSurfaceBoundsCalculator.h
   Algorithms/mitkExtractSliceFilter.h
   Algorithms/mitkConvert2Dto3DImageFilter.h
   Algorithms/mitkPlaneClipping.h
 
   Common/mitkCommon.h
   Common/mitkExceptionMacro.h
 
   DataManagement/mitkProportionalTimeGeometry.h
   DataManagement/mitkTimeGeometry.h
   DataManagement/mitkImageAccessByItk.h
   DataManagement/mitkImageCast.h
   DataManagement/mitkImagePixelAccessor.h
   DataManagement/mitkImagePixelReadAccessor.h
   DataManagement/mitkImagePixelWriteAccessor.h
   DataManagement/mitkImageReadAccessor.h
   DataManagement/mitkImageWriteAccessor.h
   DataManagement/mitkITKImageImport.h
   DataManagement/mitkITKImageImport.txx
   DataManagement/mitkImageToItk.h
   DataManagement/mitkShaderProperty.h
   DataManagement/mitkImageToItk.txx
   DataManagement/mitkTimeSlicedGeometry.h # Deprecated, empty for compatibilty reasons.
   DataManagement/mitkPropertyListReplacedObserver.cpp
   DataManagement/mitkOldTypeConversions.h
-  DataManagement/mitkTypeConversions.h
+  DataManagement/mitkArray.h
   DataManagement/mitkQuaternion.h
   DataManagement/mitkTypes.h
   DataManagement/mitkVector.h
   DataManagement/mitkPoint.h
   DataManagement/mitkMatrix.h
   DataManagement/mitkTypeOperations.h
 
   Interactions/mitkEventMapperAddOn.h
 
   Interfaces/mitkIDataNodeReader.h
 
   Rendering/mitkLocalStorageHandler.h
   Rendering/Colortables/HotIron.h
   Rendering/Colortables/Jet.h
   Rendering/Colortables/PET20.h
   Rendering/Colortables/PETColor.h
 
 
   IO/mitkPixelTypeTraits.h
 )
 
 set(CPP_FILES
   Algorithms/mitkBaseDataSource.cpp
   Algorithms/mitkCompareImageDataFilter.cpp
   Algorithms/mitkMultiComponentImageDataComparisonFilter.cpp
   Algorithms/mitkDataNodeSource.cpp
   Algorithms/mitkGeometry2DDataToSurfaceFilter.cpp
   Algorithms/mitkHistogramGenerator.cpp
   Algorithms/mitkImageChannelSelector.cpp
   Algorithms/mitkImageSliceSelector.cpp
   Algorithms/mitkImageSource.cpp
   Algorithms/mitkImageTimeSelector.cpp
   Algorithms/mitkImageToImageFilter.cpp
   Algorithms/mitkImageToSurfaceFilter.cpp
   Algorithms/mitkPointSetSource.cpp
   Algorithms/mitkPointSetToPointSetFilter.cpp
   Algorithms/mitkRGBToRGBACastImageFilter.cpp
   Algorithms/mitkSubImageSelector.cpp
   Algorithms/mitkSurfaceSource.cpp
   Algorithms/mitkSurfaceToImageFilter.cpp
   Algorithms/mitkSurfaceToSurfaceFilter.cpp
   Algorithms/mitkUIDGenerator.cpp
   Algorithms/mitkVolumeCalculator.cpp
   Algorithms/mitkClippedSurfaceBoundsCalculator.cpp
   Algorithms/mitkExtractSliceFilter.cpp
   Algorithms/mitkConvert2Dto3DImageFilter.cpp
 
   Controllers/mitkBaseController.cpp
   Controllers/mitkCallbackFromGUIThread.cpp
   Controllers/mitkCameraController.cpp
   Controllers/mitkCameraRotationController.cpp
   Controllers/mitkCoreActivator.cpp
   Controllers/mitkFocusManager.cpp
   Controllers/mitkLimitedLinearUndo.cpp
   Controllers/mitkOperationEvent.cpp
   Controllers/mitkPlanePositionManager.cpp
   Controllers/mitkProgressBar.cpp
   Controllers/mitkRenderingManager.cpp
   Controllers/mitkSliceNavigationController.cpp
   Controllers/mitkSlicesCoordinator.cpp
   Controllers/mitkSlicesRotator.cpp
   Controllers/mitkSlicesSwiveller.cpp
   Controllers/mitkStatusBar.cpp
   Controllers/mitkStepper.cpp
   Controllers/mitkTestManager.cpp
   Controllers/mitkUndoController.cpp
   Controllers/mitkVerboseLimitedLinearUndo.cpp
   Controllers/mitkVtkInteractorCameraController.cpp
   Controllers/mitkVtkLayerController.cpp
   DataManagement/mitkProportionalTimeGeometry.cpp
   DataManagement/mitkTimeGeometry.cpp
   DataManagement/mitkAbstractTransformGeometry.cpp
   DataManagement/mitkAnnotationProperty.cpp
   DataManagement/mitkApplicationCursor.cpp
   DataManagement/mitkBaseData.cpp
   DataManagement/mitkBaseProperty.cpp
   DataManagement/mitkClippingProperty.cpp
   DataManagement/mitkChannelDescriptor.cpp
   DataManagement/mitkColorProperty.cpp
   DataManagement/mitkDataStorage.cpp
 # DataManagement/mitkDataTree.cpp
   DataManagement/mitkDataNode.cpp
   DataManagement/mitkDataNodeFactory.cpp
 # DataManagement/mitkDataTreeStorage.cpp
   DataManagement/mitkDisplayGeometry.cpp
   DataManagement/mitkEnumerationProperty.cpp
   DataManagement/mitkGeometry2D.cpp
   DataManagement/mitkGeometry2DData.cpp
   DataManagement/mitkGeometry3D.cpp
   DataManagement/mitkGeometryData.cpp
   DataManagement/mitkGroupTagProperty.cpp
   DataManagement/mitkImage.cpp
   DataManagement/mitkImageAccessorBase.cpp
   DataManagement/mitkImageCaster.cpp
   DataManagement/mitkImageCastPart1.cpp
   DataManagement/mitkImageCastPart2.cpp
   DataManagement/mitkImageCastPart3.cpp
   DataManagement/mitkImageCastPart4.cpp
   DataManagement/mitkImageDataItem.cpp
   DataManagement/mitkImageDescriptor.cpp
   DataManagement/mitkImageVtkAccessor.cpp
   DataManagement/mitkImageStatisticsHolder.cpp
   DataManagement/mitkLandmarkBasedCurvedGeometry.cpp
   DataManagement/mitkLandmarkProjectorBasedCurvedGeometry.cpp
   DataManagement/mitkLandmarkProjector.cpp
   DataManagement/mitkLevelWindow.cpp
   DataManagement/mitkLevelWindowManager.cpp
   DataManagement/mitkLevelWindowPreset.cpp
   DataManagement/mitkLevelWindowProperty.cpp
   DataManagement/mitkLookupTable.cpp
   DataManagement/mitkLookupTables.cpp # specializations of GenericLookupTable
   DataManagement/mitkMemoryUtilities.cpp
   DataManagement/mitkModalityProperty.cpp
   DataManagement/mitkModeOperation.cpp
   DataManagement/mitkNodePredicateAnd.cpp
   DataManagement/mitkNodePredicateBase.cpp
   DataManagement/mitkNodePredicateCompositeBase.cpp
   DataManagement/mitkNodePredicateData.cpp
   DataManagement/mitkNodePredicateDataType.cpp
   DataManagement/mitkNodePredicateDimension.cpp
   DataManagement/mitkNodePredicateFirstLevel.cpp
   DataManagement/mitkNodePredicateNot.cpp
   DataManagement/mitkNodePredicateOr.cpp
   DataManagement/mitkNodePredicateProperty.cpp
   DataManagement/mitkNodePredicateSource.cpp
   DataManagement/mitkPlaneOrientationProperty.cpp
   DataManagement/mitkPlaneGeometry.cpp
   DataManagement/mitkPlaneOperation.cpp
   DataManagement/mitkPointOperation.cpp
   DataManagement/mitkPointSet.cpp
   DataManagement/mitkProperties.cpp
   DataManagement/mitkPropertyList.cpp
   DataManagement/mitkPropertyObserver.cpp
   DataManagement/mitkRestorePlanePositionOperation.cpp
   DataManagement/mitkApplyTransformMatrixOperation.cpp
   DataManagement/mitkRotationOperation.cpp
   DataManagement/mitkSlicedData.cpp
   DataManagement/mitkSlicedGeometry3D.cpp
   DataManagement/mitkSmartPointerProperty.cpp
   DataManagement/mitkStandaloneDataStorage.cpp
   DataManagement/mitkStateTransitionOperation.cpp
   DataManagement/mitkStringProperty.cpp
   DataManagement/mitkSurface.cpp
   DataManagement/mitkSurfaceOperation.cpp
   DataManagement/mitkThinPlateSplineCurvedGeometry.cpp
   DataManagement/mitkTransferFunction.cpp
   DataManagement/mitkTransferFunctionProperty.cpp
   DataManagement/mitkTransferFunctionInitializer.cpp
   DataManagement/mitkVector.cpp
   DataManagement/mitkConstants.cpp
   DataManagement/mitkVtkInterpolationProperty.cpp
   DataManagement/mitkVtkRepresentationProperty.cpp
   DataManagement/mitkVtkResliceInterpolationProperty.cpp
   DataManagement/mitkVtkScalarModeProperty.cpp
   DataManagement/mitkVtkVolumeRenderingProperty.cpp
   DataManagement/mitkWeakPointerProperty.cpp
   DataManagement/mitkRenderingModeProperty.cpp
   DataManagement/mitkResliceMethodProperty.cpp
   DataManagement/mitkMaterial.cpp
   DataManagement/mitkPointSetShapeProperty.cpp
   DataManagement/mitkFloatPropertyExtension.cpp
   DataManagement/mitkIntPropertyExtension.cpp
   DataManagement/mitkPropertyExtension.cpp
   DataManagement/mitkPropertyFilter.cpp
   DataManagement/mitkPropertyAliases.cpp
   DataManagement/mitkPropertyDescriptions.cpp
   DataManagement/mitkPropertyExtensions.cpp
   DataManagement/mitkPropertyFilters.cpp
   DataManagement/mitkShaderProperty.cpp
 
   Interactions/mitkAction.cpp
   Interactions/mitkAffineInteractor.cpp
   Interactions/mitkBindDispatcherInteractor.cpp
   Interactions/mitkCoordinateSupplier.cpp
   Interactions/mitkDataInteractor.cpp
   Interactions/mitkDispatcher.cpp
   Interactions/mitkDisplayCoordinateOperation.cpp
   Interactions/mitkDisplayInteractor.cpp
   Interactions/mitkDisplayPositionEvent.cpp
 # Interactions/mitkDisplayVectorInteractorLevelWindow.cpp # legacy, prob even now unneeded
 # Interactions/mitkDisplayVectorInteractorScroll.cpp
   Interactions/mitkEvent.cpp
   Interactions/mitkEventConfig.cpp
   Interactions/mitkEventDescription.cpp
   Interactions/mitkEventFactory.cpp
   Interactions/mitkInteractionEventHandler.cpp
   Interactions/mitkEventMapper.cpp
   Interactions/mitkEventRecorder.cpp
   Interactions/mitkEventStateMachine.cpp
   Interactions/mitkGlobalInteraction.cpp
   Interactions/mitkInteractor.cpp
   Interactions/mitkInternalEvent.cpp
   Interactions/mitkInteractionEvent.cpp
   Interactions/mitkInteractionEventConst.cpp
   Interactions/mitkInteractionPositionEvent.cpp
   Interactions/mitkInteractionKeyEvent.cpp
   Interactions/mitkMousePressEvent.cpp
   Interactions/mitkMouseMoveEvent.cpp
   Interactions/mitkMouseReleaseEvent.cpp
   Interactions/mitkMouseWheelEvent.cpp
   Interactions/mitkMouseDoubleClickEvent.cpp
   Interactions/mitkMouseModeSwitcher.cpp
   Interactions/mitkMouseMovePointSetInteractor.cpp
   Interactions/mitkMoveBaseDataInteractor.cpp
   Interactions/mitkNodeDepententPointSetInteractor.cpp
   Interactions/mitkPointSetDataInteractor.cpp
   Interactions/mitkPointSetInteractor.cpp
   Interactions/mitkPositionEvent.cpp
   Interactions/mitkPositionTracker.cpp
   Interactions/mitkStateMachineAction.cpp
   Interactions/mitkStateMachineCondition.cpp
   Interactions/mitkStateMachineState.cpp
   Interactions/mitkStateMachineTransition.cpp
   Interactions/mitkState.cpp
   Interactions/mitkStateMachineContainer.cpp
   Interactions/mitkStateEvent.cpp
   Interactions/mitkStateMachine.cpp
   Interactions/mitkStateMachineFactory.cpp
   Interactions/mitkTransition.cpp
   Interactions/mitkWheelEvent.cpp
   Interactions/mitkKeyEvent.cpp
   Interactions/mitkVtkEventAdapter.cpp
   Interactions/mitkVtkInteractorStyle.cxx
   Interactions/mitkCrosshairPositionEvent.cpp
   Interactions/mitkXML2EventParser.cpp
 
   Interfaces/mitkInteractionEventObserver.cpp
   Interfaces/mitkIShaderRepository.cpp
   Interfaces/mitkIPropertyAliases.cpp
   Interfaces/mitkIPropertyDescriptions.cpp
   Interfaces/mitkIPropertyExtensions.cpp
   Interfaces/mitkIPropertyFilters.cpp
   Interfaces/mitkIPersistenceService.cpp
 
   IO/mitkBaseDataIOFactory.cpp
   IO/mitkCoreDataNodeReader.cpp
   IO/mitkDicomSeriesReader.cpp
   IO/mitkDicomSR_LoadDICOMScalar.cpp
   IO/mitkDicomSR_LoadDICOMScalar4D.cpp
   IO/mitkDicomSR_LoadDICOMRGBPixel.cpp
   IO/mitkDicomSR_LoadDICOMRGBPixel4D.cpp
   IO/mitkDicomSR_ImageBlockDescriptor.cpp
   IO/mitkDicomSR_GantryTiltInformation.cpp
   IO/mitkDicomSR_SliceGroupingResult.cpp
 
   IO/mitkFileReader.cpp
   IO/mitkFileSeriesReader.cpp
   IO/mitkFileWriter.cpp
 # IO/mitkIpPicGet.c
   IO/mitkImageGenerator.cpp
   IO/mitkImageWriter.cpp
   IO/mitkImageWriterFactory.cpp
   IO/mitkItkImageFileIOFactory.cpp
   IO/mitkItkImageFileReader.cpp
   IO/mitkItkLoggingAdapter.cpp
   IO/mitkItkPictureWrite.cpp
   IO/mitkIOUtil.cpp
   IO/mitkLookupTableProperty.cpp
   IO/mitkOperation.cpp
 # IO/mitkPicFileIOFactory.cpp
 # IO/mitkPicFileReader.cpp
 # IO/mitkPicFileWriter.cpp
 # IO/mitkPicHelper.cpp
 # IO/mitkPicVolumeTimeSeriesIOFactory.cpp
 # IO/mitkPicVolumeTimeSeriesReader.cpp
   IO/mitkPixelType.cpp
   IO/mitkPointSetIOFactory.cpp
   IO/mitkPointSetReader.cpp
   IO/mitkPointSetWriter.cpp
   IO/mitkPointSetWriterFactory.cpp
   IO/mitkRawImageFileReader.cpp
   IO/mitkStandardFileLocations.cpp
   IO/mitkSTLFileIOFactory.cpp
   IO/mitkSTLFileReader.cpp
   IO/mitkSurfaceVtkWriter.cpp
   IO/mitkSurfaceVtkWriterFactory.cpp
   IO/mitkVtkLoggingAdapter.cpp
   IO/mitkVtiFileIOFactory.cpp
   IO/mitkVtiFileReader.cpp
   IO/mitkVtkImageIOFactory.cpp
   IO/mitkVtkImageReader.cpp
   IO/mitkVtkSurfaceIOFactory.cpp
   IO/mitkVtkSurfaceReader.cpp
   IO/vtkPointSetXMLParser.cpp
   IO/mitkLog.cpp
 
   Rendering/mitkBaseRenderer.cpp
   Rendering/mitkVtkMapper.cpp
   Rendering/mitkRenderWindowFrame.cpp
   Rendering/mitkGeometry2DDataMapper2D.cpp
   Rendering/mitkGeometry2DDataVtkMapper3D.cpp
   Rendering/mitkGLMapper.cpp
   Rendering/mitkGradientBackground.cpp
   Rendering/mitkManufacturerLogo.cpp
   Rendering/mitkMapper.cpp
   Rendering/mitkPointSetGLMapper2D.cpp
   Rendering/mitkPointSetVtkMapper2D.cpp
   Rendering/mitkPointSetVtkMapper3D.cpp
   Rendering/mitkPolyDataGLMapper2D.cpp
   Rendering/mitkSurfaceGLMapper2D.cpp
   Rendering/mitkSurfaceVtkMapper3D.cpp
   Rendering/mitkVolumeDataVtkMapper3D.cpp
   Rendering/mitkVtkPropRenderer.cpp
   Rendering/mitkVtkWidgetRendering.cpp
   Rendering/vtkMitkRectangleProp.cpp
   Rendering/vtkMitkRenderProp.cpp
   Rendering/mitkVtkEventProvider.cpp
   Rendering/mitkRenderWindow.cpp
   Rendering/mitkRenderWindowBase.cpp
   Rendering/mitkImageVtkMapper2D.cpp
   Rendering/vtkMitkThickSlicesFilter.cpp
   Rendering/vtkMitkLevelWindowFilter.cpp
   Rendering/vtkNeverTranslucentTexture.cpp
 
   Rendering/mitkOverlay.cpp
   Rendering/mitkVtkOverlay.cpp
   Rendering/mitkVtkOverlay2D.cpp
   Rendering/mitkVtkOverlay3D.cpp
   Rendering/mitkOverlayManager.cpp
   Rendering/mitkAbstractOverlayLayouter.cpp
 
   Rendering/mitkTextOverlay2D.cpp
   Rendering/mitkTextOverlay3D.cpp
   Rendering/mitkLabelOverlay3D.cpp
   Rendering/mitkOverlay2DLayouter.cpp
   Rendering/mitkScaleLegendOverlay
 
   Common/mitkException.cpp
   Common/mitkCommon.h
   Common/mitkCoreObjectFactoryBase.cpp
   Common/mitkCoreObjectFactory.cpp
   Common/mitkCoreServices.cpp
 )
 
 set(RESOURCE_FILES
 Interactions/globalConfig.xml
 Interactions/DisplayInteraction.xml
 Interactions/DisplayConfig.xml
 Interactions/DisplayConfigPACS.xml
 Interactions/DisplayConfigPACSPan.xml
 Interactions/DisplayConfigPACSScroll.xml
 Interactions/DisplayConfigPACSZoom.xml
 Interactions/DisplayConfigPACSLevelWindow.xml
 Interactions/DisplayConfigMITK.xml
 Interactions/PointSet.xml
 Interactions/Legacy/StateMachine.xml
 Interactions/Legacy/DisplayConfigMITKTools.xml
 Interactions/PointSetConfig.xml
 
 mitkLevelWindowPresets.xml
 )