diff --git a/Core/Code/DataManagement/mitkOldTypeConversions.h b/Core/Code/DataManagement/mitkOldTypeConversions.h
index 753585fd96..6099975ffa 100644
--- a/Core/Code/DataManagement/mitkOldTypeConversions.h
+++ b/Core/Code/DataManagement/mitkOldTypeConversions.h
@@ -1,248 +1,226 @@
 /*===================================================================
 
 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 "mitkConstants.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/mitkPoint.h b/Core/Code/DataManagement/mitkPoint.h
index 55e040ea7d..26c65db0ed 100644
--- a/Core/Code/DataManagement/mitkPoint.h
+++ b/Core/Code/DataManagement/mitkPoint.h
@@ -1,110 +1,127 @@
 /*===================================================================
 
 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"
 
 
 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)
+  {
+    out[0] = x;
+    out[1] = y;
+    out[2] = z;
+    out[4] = t;
+  }
+  */
+
+
 
 } // namespace mitk
 
 
 #endif /* MITKPOINT_H */
diff --git a/Core/Code/DataManagement/mitkVector.h b/Core/Code/DataManagement/mitkVector.h
index 551715bef5..2376dd9f5a 100644
--- a/Core/Code/DataManagement/mitkVector.h
+++ b/Core/Code/DataManagement/mitkVector.h
@@ -1,161 +1,228 @@
 /*===================================================================
 
 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 "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)
+  {
+    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;
+  }
+
+/*
+  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;
+  }
+
+  inline void FillVector4D(Vector<mitk::ScalarType, 4>& out, mitk::ScalarType x, mitk::ScalarType y, mitk::ScalarType z, mitk::ScalarType t)
+  {
+    out[0] = x;
+    out[1] = y;
+    out[2] = z;
+    out[4] = t;
+  }
+
+  inline void FillVector3D(VnlVector& out, mitk::ScalarType x, mitk::ScalarType y, mitk::ScalarType z)
+  {
+    out[0] = x;
+    out[1] = y;
+    out[2] = z;
+  }
+
+  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;
+  }
+
+  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)
+  {
+    FillVector3D(out, x, y, z);
+    out[4] = t;
+  }
+  */
+
+
+
+
 } // end namespace mitk
 
 #endif /* MITKVECTOR_H_ */