diff --git a/Core/Code/DataManagement/mitkOldTypeConversions.h b/Core/Code/DataManagement/mitkOldTypeConversions.h
index cd29efcc00..f286244a9f 100644
--- a/Core/Code/DataManagement/mitkOldTypeConversions.h
+++ b/Core/Code/DataManagement/mitkOldTypeConversions.h
@@ -1,242 +1,249 @@
 /*===================================================================
 
 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 MITKOLDTYPECONVERSIONS_H_
 #define MITKOLDTYPECONVERSIONS_H_
 
 #include <vnl/vnl_quaternion.h>
 
 #include "mitkTypeBasics.h"
 #include "mitkTypedefs.h"
 #include "mitkVector.h"
 
 
+
+
+
+#include "mitkVector.h"
+
+
 template <class T> class VectorTraits {
 public:
   typedef T ValueType;
 };
 
 template <> class VectorTraits<mitk::VnlVector> {
 public:
   typedef mitk::ScalarType ValueType;
 };
 
 template<> class VectorTraits<float[4]> {
 public:
   typedef float ValueType;
 };
 
 template<> class VectorTraits< itk::Index<5> > {
 public:
   typedef itk::Index<5>::IndexValueType ValueType;
 };
 
 template<> class VectorTraits< itk::Index<3> > {
 public:
   typedef itk::Index<3>::IndexValueType ValueType;
 };
 
 template<> class VectorTraits< long int [3]> {
 public:
   typedef long int ValueType;
 };
 template<> class VectorTraits< float [3]> {
 public:
   typedef float ValueType;
 };
 template<> class VectorTraits< double [3]> {
 public:
   typedef double ValueType;
 };
 
 template<> class VectorTraits< vnl_vector_fixed<mitk::ScalarType, 3> > {
 public:
   typedef mitk::ScalarType ValueType;
 };
 
 template<> class VectorTraits< long unsigned int[3]> {
 public:
   typedef long unsigned int ValueType;
 };
 
 template<> class VectorTraits< unsigned int *> {
 public:
   typedef unsigned int ValueType;
 };
 
 template<> class VectorTraits< double[4] > {
 public:
   typedef double ValueType;
 };
 
 template<> class VectorTraits< itk::Vector<float,3> > {
 public:
   typedef float ValueType;
 };
 
 template<> class VectorTraits< itk::Vector<double,3> > {
 public:
   typedef double ValueType;
 };
 
 template<> class VectorTraits< itk::Vector<int,3> > {
 public:
   typedef int ValueType;
 };
 
 template<> class VectorTraits< mitk::Vector<double,3> > {
 public:
   typedef double ValueType;
 };
 
 template<> class VectorTraits< mitk::Point<float,3> > {
 public:
   typedef float ValueType;
 };
 
 template<> class VectorTraits< mitk::Point<float,4> > {
 public:
   typedef float ValueType;
 };
 
 template<> class VectorTraits< itk::Point<float,3> > {
 public:
   typedef float ValueType;
 };
 
 template<> class VectorTraits< itk::Point<float,4> > {
 public:
   typedef float ValueType;
 };
 
 template<> class VectorTraits< mitk::Point<double,3> > {
 public:
   typedef double ValueType;
 };
 
 template<> class VectorTraits< mitk::Point<double,4> > {
 public:
   typedef double ValueType;
 };
 
 template<> class VectorTraits< itk::Point<double,3> > {
 public:
   typedef double ValueType;
 };
 
 template<> class VectorTraits< itk::Point<double,4> > {
 public:
   typedef double ValueType;
 };
 
 template<> class VectorTraits< mitk::Point<int,3> > {
 public:
   typedef int ValueType;
 };
 
 namespace mitk
 {
 
+
   template <class Tout>
   inline void FillVector3D(Tout& out, mitk::ScalarType x, mitk::ScalarType y, mitk::ScalarType z)
   {
     out[0] = (typename VectorTraits<Tout>::ValueType)x;
     out[1] = (typename VectorTraits<Tout>::ValueType)y;
     out[2] = (typename VectorTraits<Tout>::ValueType)z;
   }
   template <class Tout>
   inline void FillVector4D(Tout& out, mitk::ScalarType x, mitk::ScalarType y, mitk::ScalarType z, mitk::ScalarType t)
   {
     out[0] = (typename VectorTraits<Tout>::ValueType)x;
     out[1] = (typename VectorTraits<Tout>::ValueType)y;
     out[2] = (typename VectorTraits<Tout>::ValueType)z;
     out[3] = (typename VectorTraits<Tout>::ValueType)t;
   }
 
   template <class Tin, class Tout>
   inline void itk2vtk(const Tin& in, Tout& out)
   {
     out[0]=(typename VectorTraits<Tout>::ValueType)(in[0]);
     out[1]=(typename VectorTraits<Tout>::ValueType)(in[1]);
     out[2]=(typename VectorTraits<Tout>::ValueType)(in[2]);
   }
 
   template <class Tin, class Tout>
   inline void vtk2itk(const Tin& in, Tout& out)
   {
     out[0]=(typename VectorTraits<Tout>::ValueType)(in[0]);
     out[1]=(typename VectorTraits<Tout>::ValueType)(in[1]);
     out[2]=(typename VectorTraits<Tout>::ValueType)(in[2]);
   }
 
   template <class Tin, class Tout>
   inline void vnl2vtk(const vnl_vector<Tin>& in, Tout *out)
   {
     unsigned int i;
     for(i=0; i<in.size();++i)
       out[i]=(Tout) (in[i]);
   }
 
   template <class Tin, class Tout>
   inline void vtk2vnl(const Tin *in, vnl_vector<Tout>& out)
   {
     unsigned int i;
     for(i=0; i<out.size();++i)
       out[i]=(Tout) (in[i]);
   }
 
   template <class Tin, class Tout>
   inline void vtk2vnlref(const Tin *in, vnl_vector_ref<Tout>& out)
   {
     unsigned int i;
     for(i=0; i<out.size();++i)
       out[i]=(Tout) (in[i]);
   }
 
   template <class Tin, class Tout, unsigned int n>
   inline void vnl2vtk(const vnl_vector_fixed<Tin, n>& in, Tout *out)
   {
     unsigned int i;
     for(i=0; i<in.size();++i)
       out[i]=(Tout) (in[i]);
   }
 
   template <class Tin, class Tout, unsigned int n>
   inline void vtk2vnl(const Tin *in, vnl_vector_fixed<Tout, n>& out)
   {
     unsigned int i;
     for(i=0; i<out.size();++i)
       out[i]=(Tout) (in[i]);
   }
 
 
   template <typename U, typename V, unsigned int NRows, unsigned int NColumns>
   inline void TransferMatrix(const itk::Matrix<U, NRows, NColumns>& in, itk::Matrix<V, NRows, NColumns>& out)
   {
     for (unsigned int i = 0; i < in.RowDimensions; ++i)
       for (unsigned int j = 0; j < in.ColumnDimensions; ++j)
         out[i][j] = in[i][j];
   }
 
 
 } // namespace mitk
 
 
 
 
 
 #endif /* MITKOLDTYPECONVERSIONS_H_ */
diff --git a/Core/Code/DataManagement/mitkTypeConversions.h b/Core/Code/DataManagement/mitkTypeConversions.h
new file mode 100644
index 0000000000..3724f0bde9
--- /dev/null
+++ b/Core/Code/DataManagement/mitkTypeConversions.h
@@ -0,0 +1,74 @@
+/*
+ * mitkTypeConversions.h
+ *
+ *  Created on: Nov 11, 2013
+ *      Author: wirkert
+ */
+
+#ifndef MITKTYPECONVERSIONS_H_
+#define MITKTYPECONVERSIONS_H_
+
+
+#include "mitkTypeBasics.h"
+#include "mitkTypedefs.h"
+
+namespace mitk {
+
+
+  /**
+   *  Now methods to copy from and into ArrayTypes.
+   *  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.
+   */
+
+
+  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];
+    }
+  }
+
+
+}
+
+
+#endif /* MITKTYPECONVERSIONS_H_ */
diff --git a/Core/Code/DataManagement/mitkVector.h b/Core/Code/DataManagement/mitkVector.h
index d2f908ce9a..925ba58ff2 100644
--- a/Core/Code/DataManagement/mitkVector.h
+++ b/Core/Code/DataManagement/mitkVector.h
@@ -1,155 +1,125 @@
 /*===================================================================
 
 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 "mitkTypeBasics.h"
+#include "mitkTypeConversions.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.
      */
     Vector<TCoordRep, NVectorDimension>()
       : itk::Vector<TCoordRep, NVectorDimension>() {}
 
     /**
      * @brief Copy constructor.
      */
-    Vector<TCoordRep, NVectorDimension>(const Vector<TCoordRep, NVectorDimension>& r)
+    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 (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)
+    Vector<TCoordRep, NVectorDimension>(const vnl_vector_fixed<TCoordRep, NVectorDimension>& vnlVectorFixed)
         : itk::Vector<TCoordRep, NVectorDimension>()
     {
-      for (int var = 0; var < 3; ++var) {
+      for (int var = 0; var < NVectorDimension; ++var) {
         this->SetElement(var,  vnlVectorFixed[var]);
       }
     };
 
+    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);
+    }
+
 
     /**
      * @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
     {
-      vnl_vector<TCoordRep> vnlVector(this->GetVnlVector());
-      return vnlVector;
+      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;
 
-  /**
-   *  Now methods to copy from and into ArrayTypes.
-   *  ArrayTypes here are all types who implement operator[].
-   *  The two methods were made free floating so you may template specifications for you 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] vectorOrPoint          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>& vectorOrPoint, const ArrayType& array)
-  {
-    for (unsigned short int var = 0; var < NVectorDimension; ++var)
-    {
-      vectorOrPoint[var] =  array[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
-   * @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];
-    }
-  }
+
 
 } // end namespace mitk
 
 #endif /* MITKVECTOR_H_ */
diff --git a/Core/Code/Testing/mitkTypeVectorConversionTest.cpp b/Core/Code/Testing/mitkTypeVectorConversionTest.cpp
index 5619702e0f..499788f986 100644
--- a/Core/Code/Testing/mitkTypeVectorConversionTest.cpp
+++ b/Core/Code/Testing/mitkTypeVectorConversionTest.cpp
@@ -1,272 +1,272 @@
 /*===================================================================
 
 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 <iostream>
 
 #include "itkVector.h"
 
 #include <vnl/vnl_vector_ref.h>
 #include <vnl/vnl_vector_fixed_ref.h>
 #include "vnl/vnl_math.h"
 
 #include "mitkTestingMacros.h"
 #include "mitkTypeBasics.h"
 #include "mitkVector.h"
 #include "mitkTypes.h" // for Equals
 
 // TODO SW: here we will need a guard in case opencv is not activated in a build.
 #include <cv.h>
 
 using namespace mitk;
 
 /**
  * these static variables are used in the test functions
  *
  * The variable which should be copied into is set to its original value.
  * The value which should be copied is set to valuesToCopy.
  *
  * Then the copying takes place. The test is successful, if the variable which
  * should be copied into holds the valuesToCopy afterwards and is equal to the
  * vector which should be copied.
  */
 static const ScalarType originalValues[] =  {1.123456789987, 2.789456321456, 3.123654789987456};
 static const ScalarType valuesToCopy[]   =  {4.654789123321, 5.987456789321, 6.321654987789546};
 
 /**
  * @brief Convenience method to test if one vector has been assigned successfully to the other.
  *
  * More specifically, tests if v1 = v2 was performed correctly. The method therefore assures that
  * 1. v1 equals v2 and
  * 2. both hold the values of v2.
  *
  * @param v1    The vector v1 of the assignment v1 = v2
  * @param v2    The vector v2 of the assignment v1 = v2
  * @param v1Name        The type name of v1 (e.g.: mitk::Vector3D). Necessary for the correct test output.
  * @param v2Name        The type name of v2 (e.g.: mitk::Vector3D). Necessary for the correct test output.
 *  @param eps   defines the allowed tolerance when testing for equality.
  */
 template <typename T1, typename T2>
 static void TestForEquality(T1 v1, T2 v2, std::string v1Name, std::string v2Name, ScalarType eps = mitk::eps)
 {
   MITK_TEST_CONDITION( EqualArray(v1, v2, 3, eps),  "\nAssigning " << v2Name << " to " << v1Name << ":\n1. both are equal")
   MITK_TEST_CONDITION( EqualArray(v1, v2, 3, eps), "2. both hold values of " << v2Name)
 }
 
 const float epsDouble2Float = vnl_math::float_eps * 10.0;
 
 
 
 static void Test_pod2mitk(void)
 {
   mitk::Vector3D vector3D = valuesToCopy;
 
   TestForEquality(vector3D, valuesToCopy, "mitk::Vector3D", "double POD");
 }
 
 
 static void Test_mitk2pod(void)
 {
   ScalarType podArray[3];
   mitk::Vector3D vector3D = valuesToCopy;
 
   ToArray(podArray, vector3D);
 
   TestForEquality(podArray, vector3D, "double POD", "mitk::Vector3D");
 }
 
 
 static void Test_oneElement2mitk(void)
 {
   double twos[] = {2.0, 2.0, 2.0};
   mitk::Vector<double, 3> vector3D(2.0);
 
   MITK_TEST_CONDITION(EqualArray(vector3D, twos, 3), "\none values initializes all elements to this value")
 }
 
 
 static void Test_itk2mitk(void)
 {
   Vector3D vector3D = originalValues;
   itk::Vector<ScalarType, 3> itkVector = valuesToCopy;
 
   vector3D = itkVector;
 
   TestForEquality(vector3D, itkVector, "mitk::Vector3D", "itk::Vector");
 }
 
 
 static void Test_mitk2itk(void)
 {
   Vector3D vector3D = valuesToCopy;
   itk::Vector<ScalarType, 3> itkVector = originalValues;
 
   itkVector = vector3D;
 
   TestForEquality(itkVector, vector3D, "itk::Vector", "mitk::Vector3D");
 }
 
 
 static void Test_vnlfixed2mitk(void)
 {
   mitk::Vector3D vector3D = originalValues;
   vnl_vector_fixed<ScalarType, 3> vnlVectorFixed(valuesToCopy);
 
   vector3D = vnlVectorFixed;
 
   TestForEquality(vector3D, vnlVectorFixed, "mitk::Vector3D", "vnl_vector_fixed<ScalarType>");
 }
 
 
 static void Test_mitk2vnlfixed(void)
 {
   vnl_vector_fixed<ScalarType, 3> vnlVectorFixed(originalValues);
   mitk::Vector3D vector3D = valuesToCopy;
 
   vnlVectorFixed = vector3D;
 
   TestForEquality(vnlVectorFixed, vector3D, "vnl_vector_fixed<ScalarType>", "mitk::Vector3D");
 }
 
 
 static void Test_vnl2mitk(void)
 {
   mitk::Vector3D vector3D = originalValues;
   vnl_vector<ScalarType> vnlVector(3);
   vnlVector.set(valuesToCopy);
 
   vector3D = vnlVector;
 
   TestForEquality(vector3D, vnlVector, "mitk::Vector3D", "vnl_vector<ScalarType>");
 }
 
 
 static void Test_mitk2vnl(void)
 {
   vnl_vector<ScalarType> vnlVector(3);
   vnlVector.set(originalValues);
   mitk::Vector3D vector3D = valuesToCopy;
 
   vnlVector = vector3D;
 
   TestForEquality(vnlVector, vector3D, "vnl_vector<ScalarType>", "mitk::Vector3D");
 }
 
 
 /**
  * @brief Tests if an exception is thrown when constructing an mitk::Vector form a vnl_vector of not suited size.
  */
 static void Test_vnl2mitk_WrongVnlVectorSize()
 {
   ScalarType largerValuesToCopy[] = {4.12345678910, 5.10987654321, 6.123456789132456, 7.123456987789456};
   mitk::Vector3D vector3D = originalValues;
   vnl_vector<ScalarType> vnlVector(4);
   vnlVector.set(largerValuesToCopy);
 
   MITK_TEST_FOR_EXCEPTION(mitk::Exception&, vector3D = vnlVector;)
 }
 
 
 static void Test_mitk2opencv()
 {
   cv::Vec3d opencvVector(originalValues[0], originalValues[1], originalValues[2]);
   mitk::Vector3D vector3D = valuesToCopy;
 
   ToArray(opencvVector, vector3D);
 
   TestForEquality(opencvVector, vector3D, "cv::Vec3d", "mitk::Vector3D");
 }
 
 
 static void Test_opencv2mitk()
 {
   mitk::Vector3D vector3D = originalValues;
   cv::Vec3d opencvVector(valuesToCopy[0], valuesToCopy[1], valuesToCopy[2]);
 
-  FromArray(vector3D, opencvVector);
+  vector3D.FromArray(opencvVector);
 
   TestForEquality(vector3D, opencvVector, "mitk::Vector3D", "cv::Vec3d");
 }
 
 
 static void Test_ToArray_DifferentType(void)
 {
   float podArray[3];
   for (int var = 0; var < 3; ++var) {
     podArray[var] = originalValues[var];
   }
   mitk::Vector3D vector3D = valuesToCopy;
 
   ToArray(podArray, vector3D);
 
   TestForEquality(podArray, vector3D, "float POD", "mitk::Vector3D", epsDouble2Float);
 }
 
 
 static void Test_FromArray_DifferentType(void)
 {
   mitk::Vector3D vector3D = originalValues;
   float podArray[3];
   for (int var = 0; var < 3; ++var) {
     podArray[var] = valuesToCopy[var];
   }
 
-  FromArray(vector3D, podArray);
+  vector3D.FromArray(podArray);
 
   TestForEquality(vector3D, podArray, "mitk::Vector3D", "float POD", epsDouble2Float);
 }
 
 
 
 /**
 * @brief Test the conversions from and to the mitk::Vector type.
 *
 * Tests for every conversion, if it can be done and in a second test, if the assignment of a
 * different type succeeds. E.g., assign a double vnl_vector to a float mitk::Vector
 * In cases where the size can not be determined during compile time it is checked if the assignment of
 * a differently sized vector yields an error.
 */
 int mitkTypeVectorConversionTest(int /*argc*/ , char* /*argv*/[])
 {
   // always start with this!
   MITK_TEST_BEGIN("VectorConversionTest")
 
   Test_pod2mitk();
   Test_mitk2pod();
 
   Test_oneElement2mitk();
 
   Test_itk2mitk();
   Test_mitk2itk();
 
   Test_vnlfixed2mitk();
   Test_mitk2vnlfixed();
 
   Test_vnl2mitk();
   Test_mitk2vnl();
   Test_vnl2mitk_WrongVnlVectorSize();
 
   Test_mitk2opencv();
   Test_opencv2mitk();
 
   /**
    * The ToArray and FromArray can assign non equal types by implicit primitive type conversion.
    * The next two tests show this behavior
    */
   Test_ToArray_DifferentType();
   Test_FromArray_DifferentType();
 
   MITK_TEST_END()
 }
diff --git a/Core/Code/files.cmake b/Core/Code/files.cmake
index 39ee2a1b75..4924625a1c 100644
--- a/Core/Code/files.cmake
+++ b/Core/Code/files.cmake
@@ -1,415 +1,416 @@
 set(H_FILES
   Algorithms/itkImportMitkImageContainer.h
   Algorithms/itkImportMitkImageContainer.txx
   Algorithms/itkLocalVariationImageFilter.h
   Algorithms/itkLocalVariationImageFilter.txx
   Algorithms/itkMITKScalarImageToHistogramGenerator.h
   Algorithms/itkMITKScalarImageToHistogramGenerator.txx
   Algorithms/itkTotalVariationDenoisingImageFilter.h
   Algorithms/itkTotalVariationDenoisingImageFilter.txx
   Algorithms/itkTotalVariationSingleIterationImageFilter.h
   Algorithms/itkTotalVariationSingleIterationImageFilter.txx
   Algorithms/mitkBilateralFilter.h
   Algorithms/mitkBilateralFilter.cpp
   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/mitkExceptionMacro.h
   Common/mitkServiceBaseObject.h
   Common/mitkTestingMacros.h
   Common/mitkTesting.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/mitkImageToItk.txx
   DataManagement/mitkTimeSlicedGeometry.h # Deprecated, empty for compatibilty reasons.
   DataManagement/mitkOldTypeConversions.h
+  DataManagement/mitkTypeConversions.h
   DataManagement/mitkTypedefs.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
 
   IO/mitkPixelTypeTraits.h
 )
 
 set(CPP_FILES
   Algorithms/mitkBaseDataSource.cpp
   Algorithms/mitkCompareImageFilter.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/mitkRestorePlanePositionOperation.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/mitkTypeBasics.cpp
   DataManagement/mitkVtkInterpolationProperty.cpp
   DataManagement/mitkVtkRepresentationProperty.cpp
   DataManagement/mitkVtkResliceInterpolationProperty.cpp
   DataManagement/mitkVtkScalarModeProperty.cpp
   DataManagement/mitkVtkVolumeRenderingProperty.cpp
   DataManagement/mitkWeakPointerProperty.cpp
   DataManagement/mitkRenderingModeProperty.cpp
   DataManagement/mitkShaderProperty.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
 
   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/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
 
   Interfaces/mitkInteractionEventObserver.cpp
   Interfaces/mitkIShaderRepository.cpp
   Interfaces/mitkIPropertyAliases.cpp
   Interfaces/mitkIPropertyDescriptions.cpp
   Interfaces/mitkIPropertyExtensions.cpp
   Interfaces/mitkIPropertyFilters.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/mitkShaderRepository.cpp
   Rendering/mitkImageVtkMapper2D.cpp
   Rendering/vtkMitkThickSlicesFilter.cpp
   Rendering/vtkMitkLevelWindowFilter.cpp
   Rendering/vtkNeverTranslucentTexture.cpp
   Rendering/mitkRenderingTestHelper.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
 
   Common/mitkException.cpp
   Common/mitkCommon.h
   Common/mitkCoreObjectFactoryBase.cpp
   Common/mitkCoreObjectFactory.cpp
   Common/mitkCoreServices.cpp
 )
 
 list(APPEND CPP_FILES ${CppMicroServices_SOURCES})
 
 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
 
 Shaders/mitkShaderLighting.xml
 
 mitkLevelWindowPresets.xml
 )