diff --git a/Core/Code/DataManagement/mitkLine.h b/Core/Code/DataManagement/mitkLine.h
index 1a55b657b9..991d58b3d7 100644
--- a/Core/Code/DataManagement/mitkLine.h
+++ b/Core/Code/DataManagement/mitkLine.h
@@ -1,428 +1,427 @@
 /*===================================================================
 
 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 MITKLINE_H_HEADER_INCLUDED_C19C01E2
 #define MITKLINE_H_HEADER_INCLUDED_C19C01E2
 
 #include "mitkVector.h"
 #include <vnl/vnl_vector.h>
 #include <vnl/vnl_cross.h>
 #include <itkTransform.h>
 #include <itkMatrix.h>
 
 namespace mitk {
 
 //##Documentation
 //## @brief Descibes a line
 //## @ingroup Geometry
 template <class TCoordRep, unsigned int NPointDimension=3>
 class Line
 {
 public:
   Line()
   {
     m_Point.Fill(0);
     m_Direction.Fill(0);
   };
 
   //##Documentation
   //## @brief Define line by point and direction
   //##
   //## Length of direction defines the the length of the line
   Line( const itk::Point<TCoordRep,NPointDimension>& point, const itk::Vector<TCoordRep,NPointDimension>& direction )
   {
     this->m_Point = point;
     this->m_Direction = direction;
   }
 
   //##Documentation
   //## @brief Get start point of the line
   const itk::Point<TCoordRep,NPointDimension>& GetPoint() const
   {
     return m_Point;
   }
 
   //##Documentation
   //## @brief Get start point of the line
   itk::Point<TCoordRep,NPointDimension>& GetPoint()
   {
     return m_Point;
   }
 
   //##Documentation
   //## @brief Get point on the line with parameter @a t
   //##
   //## @return m_Point+t*m_Direction
   const itk::Point<TCoordRep,NPointDimension> GetPoint(TCoordRep t) const
   {
     return m_Point+m_Direction*t;
   }
 
   //##Documentation
   //## @brief Set/change start point of the line
   void SetPoint( const itk::Point<TCoordRep,NPointDimension>& point1 )
   {
-    itk::Vector<TCoordRep,NPointDimension> point2;
+    itk::Point<TCoordRep,NPointDimension> point2;
     point2 = m_Point + m_Direction;
-
     m_Point = point1;
-    m_Direction = point2 - point1;
+    m_Direction = point2.GetVectorFromOrigin() - point1.GetVectorFromOrigin();
   }
 
   //##Documentation
   //## @brief Get the direction vector of the line
   const itk::Vector<TCoordRep,NPointDimension>& GetDirection() const
   {
     return m_Direction;
   }
 
   //##Documentation
   //## @brief Get the direction vector of the line
   itk::Vector<TCoordRep,NPointDimension>& GetDirection()
   {
     return m_Direction;
   }
 
   //##Documentation
   //## @brief Set the direction vector of the line
   void SetDirection( const itk::Vector<TCoordRep,NPointDimension>& direction )
   {
     m_Direction = direction;
   }
 
   //##Documentation
   //## @brief Define line by point and direction
   //##
   //## Length of direction defines the the length of the line
   void Set( const itk::Point<TCoordRep,NPointDimension>& point, const itk::Vector<TCoordRep,NPointDimension>& direction ) {
 
     this->m_Point = point;
     this->m_Direction = direction;
   }
 
   //##Documentation
   //## @brief Define line by two points
   void SetPoints( const itk::Point<TCoordRep,NPointDimension>& point1, const itk::Point<TCoordRep,NPointDimension>& point2 ) {
 
     this->m_Point = point1;
     //this->m_Direction.sub( point2, point1 );
     m_Direction = point2 - point1;
   }
 
   //##Documentation
   //## @brief Set/change start point of the line
   void SetPoint1( const itk::Point<TCoordRep,NPointDimension>& point1 ) {
 
     itk::Vector<TCoordRep,NPointDimension> point2;
     point2 = m_Point + m_Direction;
 
     m_Point = point1;
     m_Direction = point2 - point1;
   }
 
   //##Documentation
   //## @brief Get start point of the line
   const itk::Point<TCoordRep,NPointDimension>& GetPoint1() const
   {
     return m_Point;
   }
 
   //##Documentation
   //## @brief Set/change end point of the line
   void SetPoint2( const itk::Point<TCoordRep,NPointDimension>& point2 )
   {
     m_Direction = point2 - m_Point;
   }
 
   //##Documentation
   //## @brief Get end point of the line
   itk::Point<TCoordRep,NPointDimension> GetPoint2() const
   {
     itk::Point<TCoordRep,NPointDimension> point2;
     point2 = m_Point+m_Direction;
     return point2;
   }
 
   //##Documentation
   //## @brief Transform the line with a Transform
   void Transform(itk::Transform<TCoordRep, NPointDimension, NPointDimension>& transform)
   {
     m_Direction = transform.TransformVector(m_Direction);
     m_Point = transform.TransformPoint(m_Point);
   }
 
   //##Documentation
   //## @brief Transform the line with a matrix
   //##
   //## Only the direction will be changed, not the start point.
   void Transform( const itk::Matrix<TCoordRep, NPointDimension, NPointDimension>& matrix )
   {
     m_Direction = matrix*m_Direction;
   }
 
   //##Documentation
   //## @brief Distance between two lines
   double Distance( const Line<TCoordRep,NPointDimension>& line ) const;
 
   //##Documentation
   //## @brief Distance of a point from the line
   double Distance( const itk::Point<TCoordRep,NPointDimension>& point ) const
   {
     itk::Vector<TCoordRep,NPointDimension> diff;
     diff =  Project(point)-point;
     return diff.GetNorm();
   }
 
   //##Documentation
   //## @brief Project a point on the line
   itk::Point<TCoordRep,NPointDimension> Project( const itk::Point<TCoordRep,NPointDimension>& point ) const
   {
     if(m_Direction.GetNorm()==0)
       return this->m_Point;
 
     itk::Vector<TCoordRep,NPointDimension> diff;
     diff = point-this->m_Point;
 
     itk::Vector<TCoordRep,NPointDimension> normalizedDirection = m_Direction;
     normalizedDirection.Normalize();
 
     normalizedDirection *= dot_product(diff.GetVnlVector(), normalizedDirection.GetVnlVector());
 
     return this->m_Point + normalizedDirection;
   }
 
   //##Documentation
   //## @brief Test if a point is part of the line
   //##
   //## Length of the direction vector defines the length of the line
   bool IsPartOfStraightLine( const itk::Point<TCoordRep,NPointDimension>& point ) const
   {
     if( Distance( point ) > eps )
       return false;
 
     itk::Vector<TCoordRep,NPointDimension> diff;
     diff = point - this->m_Point;
 
     if( diff*m_Direction < 0 )
       return false;
 
     if( diff.GetSquaredNorm() <= m_Direction.GetSquaredNorm() )
       return true;
 
     return false;
   }
 
   //##Documentation
   //## @brief Test if a point is part of the line (line having infinite length)
   bool IsPartOfLine( const itk::Point<TCoordRep,NPointDimension>& point ) const {
 
     if ( Distance( point ) < eps )
       return true;
 
     return false;
   }
 
   //##Documentation
   //## @brief Test if a lines is parallel to this line
   bool IsParallel( const Line<TCoordRep,NPointDimension>& line) const
   {
     vnl_vector<TCoordRep> normal;
 
     normal = vnl_cross_3d( m_Direction.GetVnlVector(), line.GetDirection().GetVnlVector() );
 
     if ( normal.squared_magnitude() < eps )
       return true;
 
     return false;
   }
 
   //##Documentation
   //## @brief Test if a line is part of the line (line having infinite length)
   bool IsPartOfLine( const Line<TCoordRep,NPointDimension>& line ) const
   {
     return ( Distance( line.GetPoint() ) < 0 ) && ( IsParallel( line ) );
   }
 
   //##Documentation
   //## @brief Test if the two lines are identical
   //##
   //## Start point and direction and length of direction vector must be
   //## equal for identical lines.
   bool operator==( const Line<TCoordRep,NPointDimension>& line ) const
   {
     itk::Vector<TCoordRep,NPointDimension> diff;
     diff = GetPoint1()-line.GetPoint1();
     if(diff.GetSquaredNorm() > eps)
       return false;
     diff = GetPoint2()-line.GetPoint2();
     if(diff.GetSquaredNorm() > eps)
       return false;
     return true;
   }
 
   //##Documentation
   //## @brief Set the line by another line
   inline const Line<TCoordRep,NPointDimension>& operator=( const Line<TCoordRep,NPointDimension>& line )
   {
     m_Point = line.GetPoint();
     m_Direction = line.GetDirection();
     return *this;
   }
 
   //##Documentation
   //## @brief Test if two lines are not identical
   //##
   //## \sa operator==
   bool operator!=( const Line<TCoordRep,NPointDimension>& line ) const
   {
     return !((*this)==line);
   }
 
   //##Documentation
   //## @brief Calculates the intersection points of a straight line in 2D
   //## with a rectangle
   //##
   //## @param x1,y1,x2,y2   rectangle
   //## @param p,d           straight line: p point on it, d direction of line
   //## @param s1            first intersection point (valid only if s_num>0)
   //## @param s2            second intersection point (valid only if s_num==2)
   //## @return              number of intersection points (0<=s_num<=2)
   static int RectangleLineIntersection(
     TCoordRep x1, TCoordRep y1,
     TCoordRep x2, TCoordRep y2,
     itk::Point< TCoordRep, 2 > p, itk::Vector< TCoordRep, 2 > d,
     itk::Point< TCoordRep, 2 > &s1, itk::Point< TCoordRep, 2 > &s2 )
   {
     int s_num;
     TCoordRep t;
     s_num=0;
 
     /*test if intersecting with the horizontal axis*/
     if(fabs(d[0])>eps)
     {
       t=(x1-p[0])/d[0];
       itk::Point<TCoordRep,2> l=p+d*t;
       if((l[1]>=y1) && (l[1]<y2))
       { // yes, intersection point within the bounds of the border-line
         if(s_num) s2=l; else s1=l; ++s_num;
       }
     }
 
     if(fabs(d[0])>eps)
     {
       t=(x2-p[0])/d[0];
       itk::Point<TCoordRep,2> l=p+d*t;
 
       if((l[1]>=y1) && (l[1]<y2))
       { // yes, intersection point within the bounds of the border-line
         if(s_num) s2=l; else s1=l; ++s_num;
       }
     }
 
     /*test if intersecting with the vertical axis*/
     if(fabs(d[1])>eps)
     {
       t=(y1-p[1])/d[1];
       itk::Point<TCoordRep,2> l=p+d*t;
 
       if((l[0]>=x1) && (l[0]<x2))
       { // yes, intersection point within the bounds of the border-line
         if(s_num) s2=l; else s1=l; ++s_num;
       }
     }
 
     if(fabs(d[1])>eps)
     {
       t=(y2-p[1])/d[1];
       itk::Point<TCoordRep,2> l=p+d*t;
       if((l[0]>=x1) && (l[0]<x2))
       { // yes, intersection point within the bounds of the border-line
         if(s_num) s2=l; else s1=l; ++s_num;
       }
     }
     return s_num;
   }
 
 
   /**
    * \brief Calculates the intersection points of a straight line in 3D with
    * a box.
    *
    * \param x1,y1,z1  first corner of the box
    * \param x2,y2,z2  second corner of the box
    * \param p,d       straight line: p point on it, d direction of line
    * \param s1        first intersection point (valid only if s_num>0)
    * \param s2        second intersection point (valid only if s_num==2)
    * \return          number of intersection points (0<=s_num<=2)
    */
   static int BoxLineIntersection(
     TCoordRep x1, TCoordRep y1, TCoordRep z1,
     TCoordRep x2, TCoordRep y2, TCoordRep z2,
     itk::Point< TCoordRep, 3 > p, itk::Vector< TCoordRep, 3 > d,
     itk::Point< TCoordRep, 3 > &s1, itk::Point< TCoordRep, 3 > &s2 )
   {
     int num = 0;
 
     ScalarType box[6];
     box[0] = x1; box[1] = x2;
     box[2] = y1; box[3] = y2;
     box[4] = z1; box[5] = z2;
 
     itk::Point< TCoordRep, 3 > point;
 
     int i, j;
     for ( i = 0; i < 6; ++i )
     {
       j = i / 2;
       if ( fabs( d[j] ) > eps )
       {
         ScalarType lambda = (box[i] - p[j]) / d[j];
 
         point = p + d * lambda;
 
         int k = (j + 1) % 3;
         int l = (j + 2) % 3;
 
         if ( (point[k] >= box[k*2]) && (point[k] <= box[k*2+1])
           && (point[l] >= box[l*2]) && (point[l] <= box[l*2+1]) )
         {
           if ( num == 0 )
           {
             s1 = point;
           }
           else
           {
             s2 = point;
           }
           ++num;
         }
       }
     }
     return num;
   }
 
 
 protected:
   itk::Point<TCoordRep,NPointDimension>  m_Point;
   itk::Vector<TCoordRep,NPointDimension> m_Direction;
 };
 
 typedef Line<ScalarType, 3> Line3D;
 
 } // namespace mitk
 #endif /* MITKLINE_H_HEADER_INCLUDED_C19C01E2 */
 
diff --git a/Core/Code/Testing/files.cmake b/Core/Code/Testing/files.cmake
index 5fa971e04d..62de40dce5 100644
--- a/Core/Code/Testing/files.cmake
+++ b/Core/Code/Testing/files.cmake
@@ -1,199 +1,200 @@
 # tests with no extra command line parameter
 set(MODULE_TESTS
   # IMPORTANT: If you plan to deactivate / comment out a test please write a bug number to the commented out line of code.
   #
   #     Example: #mitkMyTest #this test is commented out because of bug 12345
   #
   # It is important that the bug is open and that the test will be activated again before the bug is closed. This assures that
   # no test is forgotten after it was commented out. If there is no bug for your current problem, please add a new one and
   # mark it as critical.
 
   ################## DISABLED TESTS #################################################
   #mitkAbstractTransformGeometryTest.cpp #seems as tested class mitkExternAbstractTransformGeometry doesnt exist any more
   #mitkStateMachineContainerTest.cpp #rewrite test, indirect since no longer exported Bug 14529
   #mitkRegistrationBaseTest.cpp #tested class  mitkRegistrationBase doesn't exist any more
   #mitkSegmentationInterpolationTest.cpp #file doesn't exist!
   #mitkPipelineSmartPointerCorrectnessTest.cpp #file doesn't exist!
   #mitkITKThreadingTest.cpp #test outdated because itk::Semaphore was removed from ITK
   #mitkAbstractTransformPlaneGeometryTest.cpp #mitkVtkAbstractTransformPlaneGeometry doesn't exist any more
   #mitkTestUtilSharedLibrary.cpp #Linker problem with this test...
   #mitkTextOverlay2DSymbolsRenderingTest.cpp #Implementation of the tested feature is not finished yet. Ask Christoph or see bug 15104 for details.
 
   ################# RUNNING TESTS ###################################################
   mitkAccessByItkTest.cpp
   mitkCoreObjectFactoryTest.cpp
   mitkMaterialTest.cpp
   mitkActionTest.cpp
   mitkDispatcherTest.cpp
   mitkEnumerationPropertyTest.cpp
   mitkEventTest.cpp
   mitkFocusManagerTest.cpp
   mitkGenericPropertyTest.cpp
   mitkGeometry2DTest.cpp
   mitkGeometry3DTest.cpp
   mitkGeometry3DEqualTest.cpp
   mitkGeometryDataToSurfaceFilterTest.cpp
   mitkGlobalInteractionTest.cpp
   mitkImageEqualTest.cpp
   mitkImageDataItemTest.cpp
   mitkImageGeneratorTest.cpp
   mitkIOUtilTest.cpp
   mitkBaseDataTest.cpp
   mitkImportItkImageTest.cpp
   mitkGrabItkImageMemoryTest.cpp
   mitkInstantiateAccessFunctionTest.cpp
   mitkInteractorTest.cpp
   mitkLevelWindowTest.cpp
   mitkMessageTest.cpp
   mitkPixelTypeTest.cpp
   mitkPlaneGeometryTest.cpp
   mitkPointSetEqualTest.cpp
   mitkPointSetFileIOTest.cpp
   mitkPointSetTest.cpp
   mitkPointSetWriterTest.cpp
   mitkPointSetReaderTest.cpp
   mitkPointSetInteractorTest.cpp
   mitkPropertyTest.cpp
   mitkPropertyListTest.cpp
   mitkSlicedGeometry3DTest.cpp
   mitkSliceNavigationControllerTest.cpp
   mitkStateMachineTest.cpp
   mitkStateTest.cpp
   mitkSurfaceTest.cpp
   mitkSurfaceEqualTest.cpp
   mitkSurfaceToSurfaceFilterTest.cpp
   mitkTimeGeometryTest.cpp
   mitkTransitionTest.cpp
   mitkUndoControllerTest.cpp
   mitkVtkWidgetRenderingTest.cpp
   mitkVerboseLimitedLinearUndoTest.cpp
   mitkWeakPointerTest.cpp
   mitkTransferFunctionTest.cpp
   mitkStepperTest.cpp
   mitkRenderingManagerTest.cpp
   vtkMitkThickSlicesFilterTest.cpp
   mitkNodePredicateSourceTest.cpp
   mitkVectorTest.cpp
   mitkClippedSurfaceBoundsCalculatorTest.cpp
   mitkExceptionTest.cpp
   mitkExtractSliceFilterTest.cpp
   mitkLogTest.cpp
   mitkImageDimensionConverterTest.cpp
   mitkLoggingAdapterTest.cpp
   mitkUIDGeneratorTest.cpp
   mitkShaderRepositoryTest.cpp
   mitkPlanePositionManagerTest.cpp
   mitkAffineTransformBaseTest.cpp
   mitkPropertyAliasesTest.cpp
   mitkPropertyDescriptionsTest.cpp
   mitkPropertyExtensionsTest.cpp
   mitkPropertyFiltersTest.cpp
   mitkTinyXMLTest.cpp
   mitkRawImageFileReaderTest.cpp
   mitkInteractionEventTest.cpp
   mitkLookupTableTest.cpp
   mitkSTLFileReaderTest.cpp
   mitkSurfaceToImageFilterTest.cpp
   mitkImageToSurfaceFilterTest.cpp
   mitkEqualTest.cpp
+  mitkLineTest.cpp
 )
 
 if(MITK_ENABLE_RENDERING_TESTING) #since mitkInteractionTestHelper is currently creating a vtkRenderWindow
 set(MODULE_TESTS
   ${MODULE_TESTS}
   mitkPointSetDataInteractorTest.cpp
 )
 endif()
 
 
 # test with image filename as an extra command line parameter
 set(MODULE_IMAGE_TESTS
   mitkImageTimeSelectorTest.cpp #only runs on images
   mitkImageAccessorTest.cpp #only runs on images
   mitkDataNodeFactoryTest.cpp #runs on all types of data
 )
 
 set(MODULE_SURFACE_TESTS
   mitkSurfaceVtkWriterTest.cpp #only runs on surfaces
   mitkDataNodeFactoryTest.cpp #runs on all types of data
 )
 
 # list of images for which the tests are run
 set(MODULE_TESTIMAGES
   US4DCyl.nrrd
   Pic3D.nrrd
   Pic2DplusT.nrrd
   BallBinary30x30x30.nrrd
   Png2D-bw.png
 )
 set(MODULE_TESTSURFACES
   binary.stl
   ball.stl
 )
 
 set(MODULE_CUSTOM_TESTS
     mitkDataStorageTest.cpp
     mitkDataNodeTest.cpp
     mitkDicomSeriesReaderTest.cpp
     mitkDICOMLocaleTest.cpp
     mitkEventMapperTest.cpp
     mitkEventConfigTest.cpp
     mitkNodeDependentPointSetInteractorTest.cpp
     mitkStateMachineFactoryTest.cpp
     mitkPointSetLocaleTest.cpp
     mitkImageTest.cpp
     mitkImageWriterTest.cpp
     mitkImageVtkMapper2DTest.cpp
     mitkImageVtkMapper2DLevelWindowTest.cpp
     mitkImageVtkMapper2DOpacityTest.cpp
     mitkImageVtkMapper2DResliceInterpolationPropertyTest.cpp
     mitkImageVtkMapper2DColorTest.cpp
     mitkImageVtkMapper2DSwivelTest.cpp
     mitkImageVtkMapper2DTransferFunctionTest.cpp
     mitkImageVtkMapper2DLookupTableTest.cpp
     mitkSurfaceVtkMapper3DTest
     mitkSurfaceVtkMapper3DTexturedSphereTest.cpp
     mitkSurfaceGLMapper2DColorTest.cpp
     mitkSurfaceGLMapper2DOpacityTest.cpp
     mitkVolumeCalculatorTest.cpp
     mitkLevelWindowManagerTest.cpp
     mitkPointSetVtkMapper2DTest.cpp
     mitkPointSetVtkMapper2DImageTest.cpp
     mitkPointSetVtkMapper2DGlyphTypeTest.cpp
     mitkPointSetVtkMapper2DTransformedPointsTest.cpp
     mitkLabelOverlay3DRendering2DTest.cpp
     mitkLabelOverlay3DRendering3DTest.cpp
     mitkTextOverlay2DRenderingTest.cpp
     mitkTextOverlay2DLayouterRenderingTest.cpp
     mitkTextOverlay3DRendering2DTest.cpp
     mitkTextOverlay3DRendering3DTest.cpp
     mitkTextOverlay3DColorRenderingTest.cpp
     mitkVTKRenderWindowSizeTest.cpp
     mitkMultiComponentImageDataComparisonFilterTest.cpp
     mitkImageToItkTest.cpp
     mitkImageSliceSelectorTest.cpp
     mitkSurfaceDepthPeelingTest.cpp
 )
 
 set(MODULE_RESOURCE_FILES
   Interactions/AddAndRemovePoints.xml
   Interactions/globalConfig.xml
   Interactions/StatemachineTest.xml
   Interactions/StatemachineConfigTest.xml
 )
 
 # Create an artificial module initializing class for
 # the usServiceListenerTest.cpp
 usFunctionGenerateExecutableInit(testdriver_init_file
                                  IDENTIFIER ${MODULE_NAME}TestDriver
                                 )
 
 # Embed the resources
 set(testdriver_resources )
 usFunctionEmbedResources(testdriver_resources
                          EXECUTABLE_NAME ${MODULE_NAME}TestDriver
                          ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Resources
                          FILES ${MODULE_RESOURCE_FILES}
                         )
 
 set(TEST_CPP_FILES ${testdriver_init_file} ${testdriver_resources})
diff --git a/Core/Code/Testing/mitkLineTest.cpp b/Core/Code/Testing/mitkLineTest.cpp
new file mode 100644
index 0000000000..0ad03741a2
--- /dev/null
+++ b/Core/Code/Testing/mitkLineTest.cpp
@@ -0,0 +1,83 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "mitkTestingMacros.h"
+#include <mitkTestingConfig.h>
+#include <mitkTestFixture.h>
+#include <mitkLine.h>
+
+class mitkLineTestSuite : public mitk::TestFixture
+{
+
+  CPPUNIT_TEST_SUITE(mitkLineTestSuite);
+  MITK_TEST(Test2DLine);
+  MITK_TEST(Test3DLine);
+  CPPUNIT_TEST_SUITE_END();
+
+private:
+
+  mitk::Line<double,2> m_2DLine;
+  mitk::Line<double,3> m_3DLine;
+
+public:
+
+  void setUp()
+  {
+    //set up simple 2D Line
+    m_2DLine = mitk::Line<double,2>();
+    itk::Point<double,2> p;
+    p[0] = 1;
+    p[1] = 2;
+    m_2DLine.SetPoint(p);
+
+    itk::Vector<double,2> direction;
+    direction[0] = 0;
+    direction[1] = 1;
+    m_2DLine.SetDirection(direction);
+
+    //set up simple 3D Line
+    m_3DLine = mitk::Line<double,3>();
+    mitk::Point3D p3D;
+    mitk::FillVector3D(p3D,0,1,2);
+    m_3DLine.SetPoint(p3D);
+
+    mitk::Vector3D direction3D;
+    mitk::FillVector3D(direction3D,4,5,6);
+    m_3DLine.SetDirection(direction3D);
+  }
+
+  void Test2DLine()
+  {
+    CPPUNIT_ASSERT_MESSAGE("Testing 2D Line (point[0])",m_2DLine.GetPoint()[0]==1);
+    CPPUNIT_ASSERT_MESSAGE("Testing 2D Line (point[1])",m_2DLine.GetPoint()[1]==2);
+    CPPUNIT_ASSERT_MESSAGE("Testing 2D Line (direction[0])",m_2DLine.GetDirection()[0]==0);
+    CPPUNIT_ASSERT_MESSAGE("Testing 2D Line (direction[1])",m_2DLine.GetDirection()[1]==1);
+  }
+
+  void Test3DLine()
+  {
+    CPPUNIT_ASSERT_MESSAGE("Testing 3D Line (point[0])",m_3DLine.GetPoint()[0]==0);
+    CPPUNIT_ASSERT_MESSAGE("Testing 3D Line (point[1])",m_3DLine.GetPoint()[1]==1);
+    CPPUNIT_ASSERT_MESSAGE("Testing 3D Line (point[2])",m_3DLine.GetPoint()[2]==2);
+    CPPUNIT_ASSERT_MESSAGE("Testing 3D Line (direction[0])",m_3DLine.GetDirection()[0]==4);
+    CPPUNIT_ASSERT_MESSAGE("Testing 3D Line (direction[1])",m_3DLine.GetDirection()[1]==5);
+    CPPUNIT_ASSERT_MESSAGE("Testing 3D Line (direction[2])",m_3DLine.GetDirection()[2]==6);
+  }
+
+
+};
+
+MITK_TEST_SUITE_REGISTRATION(mitkLine)