diff --git a/Core/Code/DataManagement/itkVtkAbstractTransform.txx b/Core/Code/DataManagement/itkVtkAbstractTransform.txx
index fa7f1982fa..66aaba9d27 100644
--- a/Core/Code/DataManagement/itkVtkAbstractTransform.txx
+++ b/Core/Code/DataManagement/itkVtkAbstractTransform.txx
@@ -1,250 +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.
 
 ===================================================================*/
 
 #include "itkVtkAbstractTransform.h"
 #include <vtkAbstractTransform.h>
 #include <mitkVector.h>
 
 namespace itk {
 
 template <class TScalarType>
 itk::VtkAbstractTransform<TScalarType>::VtkAbstractTransform() :
   m_VtkAbstractTransform(NULL), m_InverseVtkAbstractTransform(NULL),
   m_LastVtkAbstractTransformTimeStamp(0)
 {
 
 }
 
 template <class TScalarType>
 itk::VtkAbstractTransform<TScalarType>::~VtkAbstractTransform()
 {
   if(m_VtkAbstractTransform!=NULL)
     m_VtkAbstractTransform->UnRegister(NULL);
 }
 
 template <class TScalarType>
 vtkAbstractTransform* itk::VtkAbstractTransform<TScalarType>::GetVtkAbstractTransform() const
 {
   return m_VtkAbstractTransform;
 }
 
 template <class TScalarType>
 vtkAbstractTransform* itk::VtkAbstractTransform<TScalarType>::GetInverseVtkAbstractTransform() const
 {
   return m_InverseVtkAbstractTransform;
 }
 
 template <class TScalarType>
 void itk::VtkAbstractTransform<TScalarType>::SetVtkAbstractTransform(vtkAbstractTransform* aVtkAbstractTransform)
 {
   if(m_VtkAbstractTransform==aVtkAbstractTransform)
     return;
 
   if(m_VtkAbstractTransform!=NULL)
     m_VtkAbstractTransform->UnRegister(NULL);
 
   m_VtkAbstractTransform=aVtkAbstractTransform;
   if(m_VtkAbstractTransform!=NULL)
   {
     m_VtkAbstractTransform->Register(NULL);
     m_InverseVtkAbstractTransform=m_VtkAbstractTransform->GetInverse(); // memory managed by m_VtkAbstractTransform
   }
 
   m_LastVtkAbstractTransformTimeStamp = m_VtkAbstractTransform->GetMTime();
 
   this->Modified();
 }
 
 // Transform a point
 template<class TScalarType>
 typename itk::VtkAbstractTransform<TScalarType>::OutputPointType
 itk::VtkAbstractTransform<TScalarType>::
 TransformPoint(const InputPointType &point) const
 {
   assert(m_VtkAbstractTransform!=NULL);
 
   OutputPointType outputpoint;
   vnl_vector<TScalarType> vnl_vec;
-  ScalarType vtkpt[3];
+  mitk::ScalarType vtkpt[3];
   mitk::itk2vtk(point, vtkpt);
   m_VtkAbstractTransform->TransformPoint(vtkpt, vtkpt);
   mitk::vtk2itk(vtkpt, outputpoint);
   return outputpoint;
 }
 
 
 // Transform a vector
 template<class TScalarType>
 typename itk::VtkAbstractTransform<TScalarType>::OutputVectorType
 itk::VtkAbstractTransform<TScalarType>::
 TransformVector(const InputVectorType &vect) const
 {
   assert(m_VtkAbstractTransform!=NULL);
 
   OutputVectorType outputvector;
   vnl_vector<TScalarType> vnl_vec;
-  ScalarType vtkpt[3]={0,0,0};
-  ScalarType vtkvec[3];
-  mitk::vnl2vtk<TScalarType, ScalarType>(vect.GetVnlVector(), vtkvec);
+  mitk::ScalarType vtkpt[3]={0,0,0};
+  mitk::ScalarType vtkvec[3];
+  mitk::vnl2vtk<TScalarType, mitk::ScalarType>(vect.GetVnlVector(), vtkvec);
   m_VtkAbstractTransform->TransformVectorAtPoint(vtkpt, vtkvec, vtkvec);
   mitk::vtk2itk(vtkvec, outputvector);
   return outputvector;
 }
 
 
 // Transform a vnl_vector_fixed
 template<class TScalarType>
 typename itk::VtkAbstractTransform<TScalarType>::OutputVnlVectorType
 itk::VtkAbstractTransform<TScalarType>::
 TransformVector(const InputVnlVectorType &vect) const
 {
   assert(m_VtkAbstractTransform!=NULL);
 
   OutputVnlVectorType outputvector;
-  ScalarType vtkpt[3]={0,0,0};
-  ScalarType vtkvec[3];
-  mitk::vnl2vtk<TScalarType, ScalarType>(vect, vtkvec);
+  mitk::ScalarType vtkpt[3]={0,0,0};
+  mitk::ScalarType vtkvec[3];
+  mitk::vnl2vtk<TScalarType, mitk::ScalarType>(vect, vtkvec);
   m_VtkAbstractTransform->TransformVectorAtPoint(vtkpt, vtkvec, vtkvec);
   mitk::vtk2itk(vtkvec, outputvector);
   return outputvector;
 }
 
 // Transform a CovariantVector
 template<class TScalarType>
 typename itk::VtkAbstractTransform<TScalarType>::OutputCovariantVectorType
 itk::VtkAbstractTransform<TScalarType>::
 TransformCovariantVector(const InputCovariantVectorType &/*vec*/) const
 {
   itkExceptionMacro( << "implement before using!" );
   OutputCovariantVectorType  result;    // Converted vector
 
 //  for (unsigned int i = 0; i < NDimensions; i++)
 //    {
-//    result[i] = NumericTraits<ScalarType>::Zero;
+//    result[i] = NumericTraits<mitk::ScalarType>::Zero;
 //    for (unsigned int j = 0; j < NDimensions; j++)
 //      {
 //      result[i] += m_Inverse[j][i]*vec[j]; // Inverse transposed
 //      }
 //    }
   return result;
 }
 
 // Back transform a point
 template<class TScalarType>
 typename VtkAbstractTransform<TScalarType>::InputPointType
 itk::VtkAbstractTransform<TScalarType>::
 BackTransform(const OutputPointType &point) const
 {
   assert(m_VtkAbstractTransform!=NULL);
 
   OutputPointType outputpoint;
-  ScalarType vtkpt[3];
+  mitk::ScalarType vtkpt[3];
   mitk::itk2vtk(point, vtkpt);
   m_InverseVtkAbstractTransform->TransformPoint(vtkpt, vtkpt);
   mitk::vtk2itk(vtkpt, outputpoint);
   return outputpoint;
 }
 
 // Back transform a vector
 template<class TScalarType>
 typename VtkAbstractTransform<TScalarType>::InputVectorType
 itk::VtkAbstractTransform<TScalarType>::
 BackTransform(const OutputVectorType &vect ) const
 {
   assert(m_VtkAbstractTransform!=NULL);
 
   OutputVectorType outputvector;
-  ScalarType vtkpt[3]={0,0,0};
-  ScalarType vtkvec[3];
+  mitk::ScalarType vtkpt[3]={0,0,0};
+  mitk::ScalarType vtkvec[3];
   mitk::itk2vtk(vect, vtkvec);
   m_InverseVtkAbstractTransform->TransformVectorAtPoint(vtkpt, vtkvec, vtkvec);
   mitk::vtk2itk(vtkvec, outputvector);
   return outputvector;
 }
 
 // Back transform a vnl_vector
 template<class TScalarType>
 typename VtkAbstractTransform<TScalarType>::InputVnlVectorType
 itk::VtkAbstractTransform<TScalarType>::
 BackTransform(const OutputVnlVectorType &vect ) const
 {
   assert(m_InverseVtkAbstractTransform!=NULL);
 
   OutputVnlVectorType outputvector;
-  ScalarType vtkpt[3]={0,0,0};
-  ScalarType vtkvec[3];
+  mitk::ScalarType vtkpt[3]={0,0,0};
+  mitk::ScalarType vtkvec[3];
   mitk::itk2vtk(vect, vtkvec);
   m_InverseVtkAbstractTransform->TransformVectorAtPoint(vtkpt, vtkvec, vtkvec);
   mitk::vtk2itk(vtkvec, outputvector);
   return outputvector;
 }
 
 // Back Transform a CovariantVector
 template<class TScalarType>
 typename VtkAbstractTransform<TScalarType>::InputCovariantVectorType
 itk::VtkAbstractTransform<TScalarType>::
 BackTransform(const OutputCovariantVectorType &vec) const
 {
   itkExceptionMacro( << "implement before using!" );
 //  for (unsigned int i = 0; i < NDimensions; i++)
 //    {
-//    result[i] = NumericTraits<ScalarType>::Zero;
+//    result[i] = NumericTraits<mitk::ScalarType>::Zero;
 //    for (unsigned int j = 0; j < NDimensions; j++)
 //      {
 //      result[i] += m_Matrix[j][i]*vec[j]; // Direct matrix transposed
 //      }
 //    }
   return vec;
 }
 
 template<class TScalarType>
 unsigned long
 itk::VtkAbstractTransform<TScalarType>::GetMTime() const
 {
   if((m_VtkAbstractTransform != NULL) && (m_LastVtkAbstractTransformTimeStamp < m_VtkAbstractTransform->GetMTime()))
   {
     m_LastVtkAbstractTransformTimeStamp=m_VtkAbstractTransform->GetMTime();
     this->Modified();
   }
 
   return Superclass::GetMTime();
 }
 
 template <class TScalarType>
 void itk::VtkAbstractTransform<TScalarType>::SetParameters(const ParametersType&)
 {
   // TODO
 }
 
 template <class TScalarType>
 void itk::VtkAbstractTransform<TScalarType>::SetFixedParameters(const ParametersType&)
 {
   // TODO
 }
 
 template <class TScalarType>
 void itk::VtkAbstractTransform<TScalarType>::ComputeJacobianWithRespectToParameters(const InputPointType&, JacobianType&) const
 {
   // TODO
 }
 
 template <class TScalarType>
 void itk::VtkAbstractTransform<TScalarType>::ComputeJacobianWithRespectToPosition(const InputPointType&, JacobianType&) const
 {
   // TODO
 }
 
 } // namespace itk
diff --git a/Core/Code/DataManagement/mitkPoint.h b/Core/Code/DataManagement/mitkPoint.h
index 731b2f6853..44766d5b25 100644
--- a/Core/Code/DataManagement/mitkPoint.h
+++ b/Core/Code/DataManagement/mitkPoint.h
@@ -1,78 +1,78 @@
 /*===================================================================
 
 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
 
 
 
 // this is needed for memcopy in ITK
 // can be removed when fixed in ITK
 #include <cstring>
 
 #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 <MitkExports.h>
 #include "mitkDataTypeBasics.h"
 
 
 namespace mitk {
 
 template<class TCoordRep, unsigned int NPointDimension = 3>
 class Point : public itk::Point<TCoordRep, NPointDimension>
 {
 
 public:
      /** Default constructor has nothing to do. */
-  mitk::Point<TCoordRep, NPointDimension>() {}
+  Point<TCoordRep, NPointDimension>() {}
 
   /** Pass-through constructors for the Array base class. */
-  mitk::Point<TCoordRep, NPointDimension>(const mitk::Point<TCoordRep, NPointDimension>& r) : itk::Point<TCoordRep, NPointDimension>(r) {}
-  mitk::Point<TCoordRep, NPointDimension>(const ValueType r[NPointDimension]):itk::Point<TCoordRep, NPointDimension>(r) {}
-  mitk::Point<TCoordRep, NPointDimension>(const ValueType & v):itk::Point<TCoordRep, NPointDimension>(v) {}
-  mitk::Point<TCoordRep, NPointDimension>(const itk::Point<TCoordRep, NPointDimension> r) : itk::Point<TCoordRep, NPointDimension>(r) {}
+  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> r) : itk::Point<TCoordRep, NPointDimension>(r) {}
 
   /**
   * Warning: Array must have same dimension as Point
   */
   void CopyToArray(ScalarType* const array_p) const
   {
     for (int i = 0; i < this->GetPointDimension(); i++)
     {
       array_p[i] = this->GetElement(i);
     }
   }
 };
 
-typedef mitk::Point<ScalarType,2> Point2D;
-typedef mitk::Point<ScalarType,3> Point3D;
-typedef mitk::Point<ScalarType,4> Point4D;
+typedef Point<ScalarType,2> Point2D;
+typedef Point<ScalarType,3> Point3D;
+typedef Point<ScalarType,4> Point4D;
 
-typedef mitk::Point<int,2> Point2I;
-typedef mitk::Point<int,3> Point3I;
-typedef mitk::Point<int,4> Point4I;
+typedef Point<int,2> Point2I;
+typedef Point<int,3> Point3I;
+typedef Point<int,4> Point4I;
 
 } // namespace mitk
 
 
 #endif /* MITKPOINT_H */
diff --git a/Modules/Segmentation/DataManagement/mitkContour.h b/Modules/Segmentation/DataManagement/mitkContour.h
index b10433813b..8b76143f74 100644
--- a/Modules/Segmentation/DataManagement/mitkContour.h
+++ b/Modules/Segmentation/DataManagement/mitkContour.h
@@ -1,185 +1,185 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 #ifndef _MITK_CONTOUR_H_
 #define _MITK_CONTOUR_H_
 
 #include "mitkCommon.h"
 #include "SegmentationExports.h"
 #include "mitkBaseData.h"
 #include <vtkRenderWindow.h>
 
 #include <itkPolyLineParametricPath.h>
 
 namespace mitk
 {
 
 /**
   \brief Stores vertices for drawing a contour.
   \deprecated Use class mitk::ContourModel instead.
 
   \sa ContourModel
 */
 class Segmentation_EXPORT Contour : public BaseData
 {
 public:
   mitkClassMacro(Contour, BaseData);
 
   itkNewMacro(Self);
 
   mitkCloneMacro(Contour);
 
   typedef itk::PolyLineParametricPath<3>                        PathType;
   typedef PathType::Pointer                                     PathPointer;
   typedef PathType::ContinuousIndexType                         ContinuousIndexType;
   typedef PathType::InputType                                   InputType;
   typedef PathType::OutputType                                  OutputType;
   typedef PathType::OffsetType                                  OffsetType;
   typedef itk::BoundingBox<unsigned long, 3, ScalarType,
-    itk::VectorContainer< unsigned long, mitk::Point< ScalarType, 3 > >>        BoundingBoxType;
+    itk::VectorContainer< unsigned long, mitk::Point< ScalarType, 3 > > >        BoundingBoxType;
   typedef BoundingBoxType::PointsContainer                      PointsContainer;
   typedef BoundingBoxType::PointsContainer::Pointer             PointsContainerPointer;
   typedef BoundingBoxType::PointsContainerIterator              PointsContainerIterator;
 
   /**
   * sets whether the contour should be closed or open.
   * by default the contour is closed
   */
   itkSetMacro(Closed, bool);
 
   /**
   * returns if the contour is closed or opened
   */
   itkGetMacro(Closed, bool);
 
   itkSetMacro(Selected, bool);
 
   itkGetMacro(Selected, bool);
 
   itkSetMacro(Width, float);
 
   itkGetMacro(Width, float);
 
 
   /**
   * clean up the contour data
   */
   void Initialize();
 
   /**
   * add a new vertex to the contour
   */
   void AddVertex(mitk::Point3D newPoint);
 
   /**
   * return an itk parametric path of the contour
   */
   PathPointer GetContourPath() const;
 
   /**
   * set the current render window. This is helpful if one
   * wants to draw the contour in one special window only.
   */
   void SetCurrentWindow(vtkRenderWindow* rw);
 
   /**
   * returns the points to the current render window
   */
   vtkRenderWindow* GetCurrentWindow() const;
 
   /**
   * returns the number of points stored in the contour
   */
   unsigned int GetNumberOfPoints() const;
 
   /**
   * returns the container of the contour points
   */
   PointsContainerPointer GetPoints() const;
 
   /**
   * set the contour points container.
   */
   void SetPoints(PointsContainerPointer points);
 
   /**
   * intherited from parent
   */
   virtual void UpdateOutputInformation();
 
   /**
   * intherited from parent
   */
   virtual void SetRequestedRegionToLargestPossibleRegion();
 
   /**
   * intherited from parent
   */
   virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
 
   /**
   * intherited from parent
   */
   virtual bool VerifyRequestedRegion();
 
   /**
   * intherited from parent
   */
   virtual void SetRequestedRegion( const itk::DataObject *data);
 
 protected:
   Contour();
   Contour(const Contour & other);
   virtual ~Contour();
 
   virtual void PrintSelf(std::ostream& os, itk::Indent indent) const;
 
 private:
 
   /**
   * parametric path of a contour;
   */
   PathType::Pointer m_ContourPath;
 
   /**
   * the current render window
   */
   vtkRenderWindow* m_CurrentWindow;
 
   /**
   * the bounding box of the contour
   */
   BoundingBoxType::Pointer m_BoundingBox;
 
   /**
   * container for all contour points
   */
   BoundingBoxType::PointsContainer::Pointer m_Vertices;
 
   /**
   * decide whether th contour is open or closed
   */
   bool m_Closed;
 
   bool m_Selected;
 
   float m_Width;
 };
 
 } // namespace mitk
 
 #endif //_MITK_CONTOUR_H_