diff --git a/Core/Code/Testing/mitkClippedSurfaceBoundsCalculatorTest.cpp b/Core/Code/Testing/mitkClippedSurfaceBoundsCalculatorTest.cpp
index 971576446a..b363685972 100644
--- a/Core/Code/Testing/mitkClippedSurfaceBoundsCalculatorTest.cpp
+++ b/Core/Code/Testing/mitkClippedSurfaceBoundsCalculatorTest.cpp
@@ -1,388 +1,388 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2008-02-25 17:27:17 +0100 (Mo, 25 Feb 2008) $
 Version:   $Revision: 7837 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include "mitkTestingMacros.h"
 
 #include <iostream>
 
 #include "mitkClippedSurfaceBoundsCalculator.h"
 #include "mitkGeometry3D.h"
 #include "mitkGeometry2D.h"
 #include "mitkVector.h"
 
 static void CheckPlanesInsideBoundingBoxOnlyOnOneSlice(mitk::Geometry3D::Pointer geometry3D)
 {
   //Check planes which are inside the bounding box
 
   mitk::ClippedSurfaceBoundsCalculator* calculator = new mitk::ClippedSurfaceBoundsCalculator();
   mitk::Image::Pointer image = mitk::Image::New();
   image->SetGeometry(geometry3D);
 
   //Check planes which are only on one slice:
 
   //Slice 0
   mitk::Point3D origin;
   origin[0] = 511;
   origin[1] = 0;
   origin[2] = 0;
 
   mitk::Vector3D normal;
   mitk::FillVector3D(normal, 0, 0, 1);
 
   mitk::PlaneGeometry::Pointer planeOnSliceZero = mitk::PlaneGeometry::New();
   planeOnSliceZero->InitializePlane(origin, normal);
 
   calculator->SetInput( planeOnSliceZero , image);
   calculator->Update();
 
   mitk::ClippedSurfaceBoundsCalculator::OutputType minMax = calculator->GetMinMaxSpatialDirectionZ();
 
   MITK_TEST_CONDITION(minMax.first == minMax.second, "Check if plane is only on one slice");
   MITK_TEST_CONDITION(minMax.first == 0 && minMax.second == 0, "Check if plane is on slice 0");
 
 
   //Slice 3
   origin[2] = 3;
 
   mitk::PlaneGeometry::Pointer planeOnSliceThree = mitk::PlaneGeometry::New();
   planeOnSliceThree->InitializePlane(origin, normal);
   planeOnSliceThree->SetImageGeometry(false);
 
   calculator->SetInput( planeOnSliceThree , image);
   calculator->Update();
 
   minMax = calculator->GetMinMaxSpatialDirectionZ();
 
   MITK_TEST_CONDITION(minMax.first == minMax.second, "Check if plane is only on one slice");
   MITK_TEST_CONDITION(minMax.first == 3 && minMax.second == 3, "Check if plane is on slice 3");
 
   //Slice 17
   origin[2] = 17;
 
   mitk::PlaneGeometry::Pointer planeOnSliceSeventeen = mitk::PlaneGeometry::New();
   planeOnSliceSeventeen->InitializePlane(origin, normal);
 
   calculator->SetInput( planeOnSliceSeventeen , image);
   calculator->Update();
 
   minMax = calculator->GetMinMaxSpatialDirectionZ();
 
   MITK_TEST_CONDITION(minMax.first == minMax.second, "Check if plane is only on one slice");
   MITK_TEST_CONDITION(minMax.first == 17 && minMax.second == 17, "Check if plane is on slice 17");
 
 
   //Slice 20
   origin[2] = 19;
 
   mitk::PlaneGeometry::Pointer planeOnSliceTwenty = mitk::PlaneGeometry::New();
   planeOnSliceTwenty->InitializePlane(origin, normal);
 
   calculator->SetInput( planeOnSliceTwenty , image);
   calculator->Update();
 
   minMax = calculator->GetMinMaxSpatialDirectionZ();
 
   MITK_TEST_CONDITION(minMax.first == minMax.second, "Check if plane is only on one slice");
   MITK_TEST_CONDITION(minMax.first == 19 && minMax.second == 19, "Check if plane is on slice 19");
 
   delete calculator;
 }
 
 static void CheckPlanesInsideBoundingBox(mitk::Geometry3D::Pointer geometry3D)
 {
   //Check planes which are inside the bounding box
 
   mitk::ClippedSurfaceBoundsCalculator* calculator = new mitk::ClippedSurfaceBoundsCalculator();
   mitk::Image::Pointer image = mitk::Image::New();
   image->SetGeometry(geometry3D);
 
   //Check planes which are only on one slice:
   //Slice 0
   mitk::Point3D origin;
   origin[0] = 511; // Set to 511.9 so that the intersection point is inside the bounding box
   origin[1] = 0;
   origin[2] = 0;
 
   mitk::Vector3D normal;
   mitk::FillVector3D(normal, 1, 0, 0);
 
   mitk::PlaneGeometry::Pointer planeSagittalOne = mitk::PlaneGeometry::New();
   planeSagittalOne->InitializePlane(origin, normal);
 
   calculator->SetInput( planeSagittalOne , image);
   calculator->Update();
 
   mitk::ClippedSurfaceBoundsCalculator::OutputType minMax = calculator->GetMinMaxSpatialDirectionZ();
   MITK_TEST_CONDITION(minMax.first == 0 && minMax.second == 19, "Check if plane is from slice 0 to slice 19");
 
 
   //Slice 3
   origin[0] = 256;
 
   MITK_INFO << "Case1 origin: " << origin;
 
   mitk::PlaneGeometry::Pointer planeSagittalTwo = mitk::PlaneGeometry::New();
   planeSagittalTwo->InitializePlane(origin, normal);
 
   MITK_INFO << "PlaneNormal: " << planeSagittalTwo->GetNormal();
   MITK_INFO << "PlaneOrigin: " << planeSagittalTwo->GetOrigin();
 
   calculator->SetInput( planeSagittalTwo , image);
   calculator->Update();
 
   minMax = calculator->GetMinMaxSpatialDirectionZ();
   MITK_INFO << "min: " << minMax.first << " max: " << minMax.second;
 
   MITK_TEST_CONDITION(minMax.first == 0 && minMax.second == 19, "Check if plane is from slice 0 to slice 19");
 
   //Slice 17
   origin[0] = 0;  // Set to 0.1 so that the intersection point is inside the bounding box
 
   mitk::PlaneGeometry::Pointer planeOnSliceSeventeen = mitk::PlaneGeometry::New();
   planeOnSliceSeventeen->InitializePlane(origin, normal);
 
   calculator->SetInput( planeOnSliceSeventeen , image);
   calculator->Update();
 
   minMax = calculator->GetMinMaxSpatialDirectionZ();
   MITK_TEST_CONDITION(minMax.first == 0 && minMax.second == 19, "Check if plane is from slice 0 to slice 19");
 
   //Crooked planes:
   origin[0] = 0;
   origin[1] = 507;
   origin[2] = 0;
 
   normal[0] = 1;
   normal[1] = -1;
   normal[2] = 1;
 
   mitk::PlaneGeometry::Pointer planeCrookedOne = mitk::PlaneGeometry::New();
   planeCrookedOne->InitializePlane(origin, normal);
 
   calculator->SetInput( planeCrookedOne , image);
   calculator->Update();
 
   minMax = calculator->GetMinMaxSpatialDirectionZ();
   MITK_INFO << "min: " << minMax.first << " max: " << minMax.second;
 
   MITK_TEST_CONDITION(minMax.first == 0 && minMax.second == 4, "Check if plane is from slice 0 to slice 4 with inclined plane");
 
   origin[0] = 512;
   origin[1] = 0;
   origin[2] = 16;
 
   mitk::PlaneGeometry::Pointer planeCrookedTwo = mitk::PlaneGeometry::New();
   planeCrookedTwo->InitializePlane(origin, normal);
 
   calculator->SetInput( planeCrookedTwo , image);
   calculator->Update();
 
   minMax = calculator->GetMinMaxSpatialDirectionZ();
   MITK_INFO << "min: " << minMax.first << " max: " << minMax.second;
 
   MITK_TEST_CONDITION(minMax.first == 17 && minMax.second == 19, "Check if plane is from slice 17 to slice 19 with inclined plane");
 
 
   origin[0] = 511;
   origin[1] = 0;
   origin[2] = 0;
 
   normal[1] = 0;
   normal[2] = 0.04;
 
   mitk::PlaneGeometry::Pointer planeCrookedThree = mitk::PlaneGeometry::New();
   planeCrookedThree->InitializePlane(origin, normal);
 
   calculator->SetInput( planeCrookedThree , image);
   calculator->Update();
 
   minMax = calculator->GetMinMaxSpatialDirectionZ();
   MITK_INFO << "min: " << minMax.first << " max: " << minMax.second;
 
   MITK_TEST_CONDITION(minMax.first == 0 && minMax.second == 19, "Check if plane is from slice 0 to slice 19 with inclined plane");
 
 
   delete calculator;
 }
 
 static void CheckPlanesOutsideOfBoundingBox(mitk::Geometry3D::Pointer geometry3D)
 {
   //Check planes which are outside of the bounding box
 
   mitk::ClippedSurfaceBoundsCalculator* calculator = new mitk::ClippedSurfaceBoundsCalculator();
   mitk::Image::Pointer image = mitk::Image::New();
   image->SetGeometry(geometry3D);
 
   //In front of the bounding box
   mitk::Point3D origin;
   origin[0] = 511;
   origin[1] = 0;
   origin[2] = -5;
 
   mitk::Vector3D normal;
   mitk::FillVector3D(normal, 0, 0, 1);
 
   mitk::PlaneGeometry::Pointer planeInFront = mitk::PlaneGeometry::New();
   planeInFront->InitializePlane(origin, normal);
 
   calculator->SetInput( planeInFront , image);
   calculator->Update();
 
   mitk::ClippedSurfaceBoundsCalculator::OutputType minMax = calculator->GetMinMaxSpatialDirectionZ();
 
   MITK_TEST_CONDITION(minMax.first == std::numeric_limits<int>::max(), "Check if min value hasn't been set");
   MITK_TEST_CONDITION(minMax.second == std::numeric_limits<int>::min(), "Check if max value hasn't been set");
 
   //Behind the bounding box
   origin[2] = 515;
 
   mitk::PlaneGeometry::Pointer planeBehind = mitk::PlaneGeometry::New();
   planeBehind->InitializePlane(origin, normal);
 
   calculator->SetInput( planeBehind , image);
   calculator->Update();
 
   minMax = calculator->GetMinMaxSpatialDirectionZ();
 
   MITK_TEST_CONDITION(minMax.first == std::numeric_limits<int>::max(), "Check if min value hasn't been set");
   MITK_TEST_CONDITION(minMax.second == std::numeric_limits<int>::min(), "Check if max value hasn't been set");
 
   //Above
   origin[1] = 515;
 
   mitk::FillVector3D(normal, 0, 1, 0);
 
   mitk::PlaneGeometry::Pointer planeAbove = mitk::PlaneGeometry::New();
   planeAbove->InitializePlane(origin, normal);
 
   calculator->SetInput( planeAbove , image);
   calculator->Update();
 
   minMax = calculator->GetMinMaxSpatialDirectionZ();
 
   MITK_TEST_CONDITION(minMax.first == std::numeric_limits<int>::max(), "Check if min value hasn't been set");
   MITK_TEST_CONDITION(minMax.second == std::numeric_limits<int>::min(), "Check if max value hasn't been set");
 
   //Below
   origin[1] = -5;
 
   mitk::PlaneGeometry::Pointer planeBelow = mitk::PlaneGeometry::New();
   planeBelow->InitializePlane(origin, normal);
 
   calculator->SetInput( planeBelow , image);
   calculator->Update();
 
   minMax = calculator->GetMinMaxSpatialDirectionZ();
 
   MITK_TEST_CONDITION(minMax.first == std::numeric_limits<int>::max(), "Check if min value hasn't been set");
   MITK_TEST_CONDITION(minMax.second == std::numeric_limits<int>::min(), "Check if max value hasn't been set");
 
   //Left side
   origin[0] = -5;
 
 
   mitk::FillVector3D(normal, 1, 0, 0);
 
   mitk::PlaneGeometry::Pointer planeLeftSide = mitk::PlaneGeometry::New();
   planeLeftSide->InitializePlane(origin, normal);
 
   calculator->SetInput( planeLeftSide , image);
   calculator->Update();
 
   minMax = calculator->GetMinMaxSpatialDirectionZ();
 
   MITK_TEST_CONDITION(minMax.first == std::numeric_limits<int>::max(), "Check if min value hasn't been set");
   MITK_TEST_CONDITION(minMax.second == std::numeric_limits<int>::min(), "Check if max value hasn't been set");
 
   //Right side
   origin[1] = 515;
 
   mitk::PlaneGeometry::Pointer planeRightSide = mitk::PlaneGeometry::New();
   planeRightSide->InitializePlane(origin, normal);
 
   calculator->SetInput( planeRightSide , image);
   calculator->Update();
 
   minMax = calculator->GetMinMaxSpatialDirectionZ();
 
   MITK_TEST_CONDITION(minMax.first == std::numeric_limits<int>::max(), "Check if min value hasn't been set");
   MITK_TEST_CONDITION(minMax.second == std::numeric_limits<int>::min(), "Check if max value hasn't been set");
 
   delete calculator;
 }
 
 
-int mitkClippedSurfaceBoundsCalculatorTest(int, char**)
+int mitkClippedSurfaceBoundsCalculatorTest(int, char* [])
 {
   // always start with this!
   MITK_TEST_BEGIN("ClippedSurfaceBoundsCalculator");
 
   /** The class mitkClippedSurfaceBoundsCalculator calculates the intersection points of a PlaneGeometry and a Geometry3D.
   *   This unittest checks if the correct min and max values for the three spatial directions (x, y, z)
   *   are calculated. To test this we define artifical PlaneGeometries and Geometry3Ds and test different
   *   scenarios:
   *
   *   1. planes which are inside the bounding box of a 3D geometry but only on one slice
   *   2. planes which are outside of the bounding box
   *   3. planes which are inside the bounding box but over more than one slice
   *
   *   Note: Currently rotated geometries are not tested!
   */
 
   /********************* Define Geometry3D ***********************/
   //Define origin:
   mitk::Point3D origin;
   origin[0] = 511;
   origin[1] = 0;
   origin[2] = 0;
 
   //Define normal:
   mitk::Vector3D normal;
   mitk::FillVector3D(normal, 0, 0, 1);
 
   //Initialize PlaneGeometry:
   mitk::PlaneGeometry::Pointer planeGeometry = mitk::PlaneGeometry::New();
   planeGeometry->InitializePlane(origin, normal);
 
   //Set Bounds:
   mitk::BoundingBox::BoundsArrayType bounds = planeGeometry->GetBounds();
   bounds[0] = 0;
   bounds[1] = 512;
   bounds[2] = 0;
   bounds[3] = 512;
   bounds[4] = 0;
   bounds[5] = 1;
   planeGeometry->SetBounds(bounds);
 
   //Initialize SlicedGeometry3D:
   mitk::SlicedGeometry3D::Pointer slicedGeometry3D = mitk::SlicedGeometry3D::New();
   slicedGeometry3D->InitializeEvenlySpaced(dynamic_cast<mitk::Geometry2D*>(planeGeometry.GetPointer()), 20);
   mitk::Geometry3D::Pointer geometry3D = dynamic_cast< mitk::Geometry3D* > ( slicedGeometry3D.GetPointer() );
   geometry3D->SetImageGeometry(true);
 
   /***************************************************************/
 
   CheckPlanesInsideBoundingBoxOnlyOnOneSlice(geometry3D);
   CheckPlanesOutsideOfBoundingBox(geometry3D);
   CheckPlanesInsideBoundingBox(geometry3D);
 
   /** ToDo:
   *  test also rotated 3D geometry!
   */
 
   MITK_TEST_END();
 }
diff --git a/Core/Code/Testing/mitkPlanePositionManagerTest.cpp b/Core/Code/Testing/mitkPlanePositionManagerTest.cpp
index 434f6691d3..a55348867d 100644
--- a/Core/Code/Testing/mitkPlanePositionManagerTest.cpp
+++ b/Core/Code/Testing/mitkPlanePositionManagerTest.cpp
@@ -1,257 +1,257 @@
 #include "mitkRotationOperation.h"
 #include "mitkTestingMacros.h"
 #include "mitkPlanePositionManager.h"
 #include "mitkSliceNavigationController.h"
 #include "mitkGeometry3D.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkImage.h"
 #include "mitkSurface.h"
 #include "mitkStandaloneDataStorage.h"
 #include "mitkDataNode.h"
 #include "mitkStringProperty.h"
 #include "mitkBaseProperty.h"
 #include "mitkInteractionConst.h"
 #include "vnl/vnl_vector.h"
 #include <itkAffineGeometryFrame.h>
 #include "mitkGetModuleContext.h"
 
 std::vector<mitk::PlaneGeometry::Pointer> m_Geometries;
 std::vector<unsigned int> m_SliceIndices;
 
 mitk::PlanePositionManagerService* m_Service;
 
 
 int SetUpBeforeTest()
 {
     //Getting Service
     mitk::ServiceReference serviceRef = mitk::GetModuleContext()->GetServiceReference<mitk::PlanePositionManagerService>();
     m_Service = dynamic_cast<mitk::PlanePositionManagerService*>(mitk::GetModuleContext()->GetService(serviceRef));
 
     if (m_Service == 0)
         return EXIT_FAILURE;
 
     //Creating different Geometries
     m_Geometries.reserve(100);
     mitk::PlaneGeometry::PlaneOrientation views[] = {mitk::PlaneGeometry::Transversal, mitk::PlaneGeometry::Sagittal, mitk::PlaneGeometry::Frontal};
     for (unsigned int i = 0; i < 100; ++i)
     {
         mitk::PlaneGeometry::Pointer plane = mitk::PlaneGeometry::New();
 
         mitk::ScalarType width = 256+(0.01*i);
         mitk::ScalarType height = 256+(0.002*i);
 
         mitk::Vector3D right;
         mitk::Vector3D down;
         right[0] = 1;
         right[1] = i;
         right[2] = 0.5;
         down[0] = i*0.02;
         down[1] = 1;
         down[2] = i*0.03;
 
         mitk::Vector3D spacing;
         mitk::FillVector3D(spacing, 1.0*0.02*i, 1.0*0.15*i, 1.0);
 
         mitk::Vector3D rightVector;
         mitk::FillVector3D(rightVector, 0.02*(i+1), 0+(0.05*i), 1.0);
 
         mitk::Vector3D downVector;
         mitk::FillVector3D(downVector, 1, 3-0.01*i, 0.0345*i);
 
         vnl_vector<mitk::ScalarType> normal = vnl_cross_3d(rightVector.GetVnlVector(), downVector.GetVnlVector());
         normal.normalize();
         normal *= 1.5;
 
         mitk::Vector3D origin;
         origin.Fill(1);
         origin[0] = 12 + 0.03*i;
 
 
         mitk::AffineTransform3D::Pointer transform = mitk::AffineTransform3D::New();
         mitk::Matrix3D matrix;
         matrix.GetVnlMatrix().set_column(0, rightVector.GetVnlVector());
         matrix.GetVnlMatrix().set_column(1, downVector.GetVnlVector());
         matrix.GetVnlMatrix().set_column(2, normal);
         transform->SetMatrix(matrix);
         transform->SetOffset(origin);
 
 
         plane->InitializeStandardPlane(width, height, transform,
                                        views[i%3], i,
                                        true, false);
 
         m_Geometries.push_back(plane);
     }
 
     return EXIT_SUCCESS;
 }
 
 int testAddPlanePosition()
 {
     MITK_TEST_OUTPUT(<<"Starting Test: ######### A d d P l a n e P o s i t i o n #########");
 
     MITK_TEST_CONDITION(m_Service != NULL, "Testing getting of PlanePositionManagerService");
 
     unsigned int currentID(m_Service->AddNewPlanePosition(m_Geometries.at(0),0));
 
     bool error = ((m_Service->GetNumberOfPlanePositions() != 1)||(currentID != 0));
 
     if(error)
     {
         MITK_TEST_CONDITION(m_Service->GetNumberOfPlanePositions() == 1,"Checking for correct number of planepositions");
         MITK_TEST_CONDITION(currentID == 0, "Testing for correct ID");
         return EXIT_FAILURE;
     }
 
     //Adding new planes
     for(unsigned int i = 1; i < m_Geometries.size(); ++i)
     {
         unsigned int newID = m_Service->AddNewPlanePosition(m_Geometries.at(i),i);
         error = ((m_Service->GetNumberOfPlanePositions() != i+1)||(newID != (currentID+1)));
 
         if (error)
         {
             MITK_TEST_CONDITION(m_Service->GetNumberOfPlanePositions() == i+1,"Checking for correct number of planepositions");
             MITK_TEST_CONDITION(newID == (currentID+1), "Testing for correct ID");
             MITK_TEST_OUTPUT(<<"New: "<<newID<<" Last: "<<currentID);
             return EXIT_FAILURE;
         }
         currentID = newID;
     }
 
     unsigned int numberOfPlanePos = m_Service->GetNumberOfPlanePositions();
 
     //Adding existing planes -> nothing should change
     for(unsigned int i = 0; i < (m_Geometries.size()-1)*0.5; ++i)
     {
         unsigned int newID = m_Service->AddNewPlanePosition(m_Geometries.at(i*2),i*2);
         error = ((m_Service->GetNumberOfPlanePositions() != numberOfPlanePos)||(newID != i*2));
         if (error)
         {
             MITK_TEST_CONDITION( m_Service->GetNumberOfPlanePositions() == numberOfPlanePos, "Checking for correct number of planepositions");
             MITK_TEST_CONDITION(newID == i*2, "Testing for correct ID");
             return EXIT_FAILURE;
         }
     }
 
     return EXIT_SUCCESS;
 
 }
 
 int testGetPlanePosition()
 {
     mitk::PlaneGeometry* plane;
     mitk::RestorePlanePositionOperation* op;
     bool error(true);
 
     MITK_TEST_OUTPUT(<<"Starting Test: ######### G e t P l a n e P o s i t i o n #########");
 
     //Testing for existing planepositions
     for (unsigned int i = 0; i < m_Geometries.size(); ++i)
     {
         plane = m_Geometries.at(i);
         mitk::PlaneGeometry* test = m_Geometries.at(i); test;
         op = m_Service->GetPlanePosition(i);
         error = ( !mitk::Equal(op->GetHeight(),plane->GetExtent(1)) ||
                   !mitk::Equal(op->GetWidth(),plane->GetExtent(0)) ||
                   !mitk::Equal(op->GetSpacing(),plane->GetSpacing()) ||
                   !mitk::Equal(op->GetTransform()->GetOffset(),plane->GetIndexToWorldTransform()->GetOffset()) ||
                   !mitk::Equal(op->GetDirectionVector().Get_vnl_vector(),plane->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(2).normalize()) ||
                   !mitk::MatrixEqualElementWise(op->GetTransform()->GetMatrix(), plane->GetIndexToWorldTransform()->GetMatrix()) );
 
         if( error )
         {
             MITK_TEST_OUTPUT(<<"Iteration: "<<i)
             MITK_TEST_CONDITION( mitk::Equal(op->GetHeight(),plane->GetExtent(1)) && mitk::Equal(op->GetWidth(),plane->GetExtent(0)), "Checking for correct extent");
             MITK_TEST_CONDITION( mitk::Equal(op->GetSpacing(),plane->GetSpacing()), "Checking for correct spacing");
             MITK_TEST_CONDITION( mitk::Equal(op->GetTransform()->GetOffset(),plane->GetIndexToWorldTransform()->GetOffset()), "Checking for correct offset");
             MITK_INFO<<"Op: "<<op->GetDirectionVector()<<" plane: "<<plane->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(2)<<"\n";
             MITK_TEST_CONDITION( mitk::Equal(op->GetDirectionVector().Get_vnl_vector(),plane->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(2)), "Checking for correct direction");
             MITK_TEST_CONDITION( mitk::MatrixEqualElementWise(op->GetTransform()->GetMatrix(), plane->GetIndexToWorldTransform()->GetMatrix()), "Checking for correct matrix");
             return EXIT_FAILURE;
         }
     }
 
     //Testing for not existing planepositions
     error = ( m_Service->GetPlanePosition(100000000) != 0 ||
               m_Service->GetPlanePosition(-1) != 0 );
 
     if (error)
     {
         MITK_TEST_CONDITION(m_Service->GetPlanePosition(100000000) == 0, "Trying to get non existing pos");
         MITK_TEST_CONDITION(m_Service->GetPlanePosition(-1) == 0, "Trying to get non existing pos");
         return EXIT_FAILURE;
     }
 
     return EXIT_SUCCESS;
 }
 
 int testRemovePlanePosition()
 {
     MITK_TEST_OUTPUT(<<"Starting Test: ######### R e m o v e P l a n e P o s i t i o n #########");
     unsigned int size = m_Service->GetNumberOfPlanePositions();
 
     bool removed (true);
     //Testing for invalid IDs
     removed = m_Service->RemovePlanePosition( -1 );
     removed = m_Service->RemovePlanePosition( 1000000 );
     unsigned int size2 = m_Service->GetNumberOfPlanePositions();
 
     if (removed)
     {
         MITK_TEST_CONDITION(removed == false, "Testing remove not existing planepositions");
         MITK_TEST_CONDITION(size == size2, "Testing remove not existing planepositions");
         return EXIT_FAILURE;
     }
 
     //Testing for valid IDs
     for (unsigned int i = 0; i < m_Geometries.size()*0.5; i++)
     {
         removed = m_Service->RemovePlanePosition( i );
         unsigned int size2 = m_Service->GetNumberOfPlanePositions();
         removed = (size2 == (size-(i+1)));
         if (!removed)
         {
             MITK_TEST_CONDITION(removed == true, "Testing remove existing planepositions");
             MITK_TEST_CONDITION(size == (size-i+1), "Testing remove existing planepositions");
             return EXIT_FAILURE;
         }
     }
 
     return EXIT_SUCCESS;
 }
 
 int testRemoveAll()
 {
     MITK_TEST_OUTPUT(<<"Starting Test: ######### R e m o v e A l l #########");
 
     unsigned int numPos = m_Service->GetNumberOfPlanePositions();
     MITK_INFO<<numPos;
 
     m_Service->RemoveAllPlanePositions();
 
     bool error (true);
 
     error = (m_Service->GetNumberOfPlanePositions() != 0 ||
              m_Service->GetPlanePosition(60) != 0);
 
     if (error)
     {
         MITK_TEST_CONDITION(m_Service->GetNumberOfPlanePositions() == 0, "Testing remove all pos");
         MITK_TEST_CONDITION(m_Service->GetPlanePosition(60) == 0, "Testing remove all pos");
         return EXIT_FAILURE;
     }
     return EXIT_SUCCESS;
 }
 
-int mitkPlanePositionManagerTest(int, char**)
+int mitkPlanePositionManagerTest(int, char* [])
 {
     MITK_TEST_OUTPUT(<<"Starting Test PlanePositionManager");
     SetUpBeforeTest();
     int result;
     MITK_TEST_CONDITION_REQUIRED( (result = testAddPlanePosition()) == EXIT_SUCCESS, "");
     MITK_TEST_CONDITION_REQUIRED( (result = testGetPlanePosition()) == EXIT_SUCCESS, "");
     MITK_TEST_CONDITION_REQUIRED( (result = testRemovePlanePosition()) == EXIT_SUCCESS, "");
     MITK_TEST_CONDITION_REQUIRED( (result = testRemoveAll()) == EXIT_SUCCESS, "");
     return EXIT_SUCCESS;
 }
diff --git a/Modules/ImageStatistics/Testing/mitkImageStatisticsCalculatorTest.cpp b/Modules/ImageStatistics/Testing/mitkImageStatisticsCalculatorTest.cpp
index 831e17b185..0293be28f0 100644
--- a/Modules/ImageStatistics/Testing/mitkImageStatisticsCalculatorTest.cpp
+++ b/Modules/ImageStatistics/Testing/mitkImageStatisticsCalculatorTest.cpp
@@ -1,471 +1,471 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2008-02-25 17:27:17 +0100 (Mo, 25 Feb 2008) $
 Version:   $Revision: 7837 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include "mitkStandardFileLocations.h"
 #include "mitkDicomSeriesReader.h"
 #include "mitkTestingMacros.h"
 #include "mitkImageStatisticsCalculator.h"
 #include "mitkPlanarPolygon.h"
 
 #include "mitkDicomSeriesReader.h"
 #include <itkGDCMSeriesFileNames.h>
 
 #include "vtkStreamingDemandDrivenPipeline.h"
 
 
 //#include <QtCore>
 
 /**
  * \brief Test class for mitkImageStatisticsCalculator
  *
  * This test covers:
  * - instantiation of an ImageStatisticsCalculator class
  * - correctness of statistics when using PlanarFigures for masking
  */
 class mitkImageStatisticsCalculatorTestClass 
 { 
 
 public:
 
   struct testCase
   {
     int id;
     mitk::PlanarFigure::Pointer figure;
     double mean;
     double sd;
   };
 
 
 // calculate statistics for the given image and planarpolygon
 static const mitk::ImageStatisticsCalculator::Statistics TestStatistics( mitk::Image::Pointer image, mitk::PlanarFigure::Pointer polygon )
 {
   mitk::ImageStatisticsCalculator::Pointer statisticsCalculator = mitk::ImageStatisticsCalculator::New();
   statisticsCalculator->SetImage( image );
   statisticsCalculator->SetMaskingModeToPlanarFigure();
   statisticsCalculator->SetPlanarFigure( polygon );
 
   statisticsCalculator->ComputeStatistics();
 
   return statisticsCalculator->GetStatistics();
 }
 
 
 // returns a vector of defined test-cases
 static std::vector<testCase> InitializeTestCases( mitk::Geometry2D::Pointer geom )
 {
   std::vector<testCase> testCases;
 
   {
     /*****************************
     * one whole white pixel  
     * -> mean of 255 expected
     ******************************/
     mitk::PlanarPolygon::Pointer figure1 = mitk::PlanarPolygon::New();
     figure1->SetGeometry2D( geom );
     mitk::Point2D pnt1; pnt1[0] = 10.5 ; pnt1[1] = 3.5;
     figure1->PlaceFigure( pnt1 );
 
     mitk::Point2D pnt2; pnt2[0] = 9.5; pnt2[1] = 3.5;
     figure1->SetControlPoint( 1, pnt2, true );
     mitk::Point2D pnt3; pnt3[0] = 9.5; pnt3[1] = 4.5;
     figure1->SetControlPoint( 2, pnt3, true );
     mitk::Point2D pnt4; pnt4[0] = 10.5; pnt4[1] = 4.5;
     figure1->SetControlPoint( 3, pnt4, true );
     figure1->GetPolyLine(0);
 
     testCase test;
     test.id = testCases.size();
     test.figure = figure1;
     test.mean = 255.0;
     test.sd = 0.0;
 
     testCases.push_back( test );
   }
 
   {
     /*****************************
     * half pixel in x-direction (white) 
     * -> mean of 255 expected
     ******************************/
     mitk::PlanarPolygon::Pointer figure1 = mitk::PlanarPolygon::New();
     figure1->SetGeometry2D( geom );
     mitk::Point2D pnt1; pnt1[0] = 10.0 ; pnt1[1] = 3.5;
     figure1->PlaceFigure( pnt1 );
 
     mitk::Point2D pnt2; pnt2[0] = 9.5; pnt2[1] = 3.5;
     figure1->SetControlPoint( 1, pnt2, true );
     mitk::Point2D pnt3; pnt3[0] = 9.5; pnt3[1] = 4.5;
     figure1->SetControlPoint( 2, pnt3, true );
     mitk::Point2D pnt4; pnt4[0] = 10.0; pnt4[1] = 4.5;
     figure1->SetControlPoint( 3, pnt4, true );
     figure1->GetPolyLine(0);
 
     testCase test;
     test.id = testCases.size();
     test.figure = figure1;
     test.mean = 255.0;
     test.sd = 0.0;
 
     testCases.push_back( test );
   }
 
   {
     /*****************************
     * half pixel in diagonal-direction (white) 
     * -> mean of 255 expected
     ******************************/
     mitk::PlanarPolygon::Pointer figure1 = mitk::PlanarPolygon::New();
     figure1->SetGeometry2D( geom );
     mitk::Point2D pnt1; pnt1[0] = 10.5 ; pnt1[1] = 3.5;
     figure1->PlaceFigure( pnt1 );
 
     mitk::Point2D pnt2; pnt2[0] = 9.5; pnt2[1] = 3.5;
     figure1->SetControlPoint( 1, pnt2, true );
     mitk::Point2D pnt3; pnt3[0] = 9.5; pnt3[1] = 4.5;
     figure1->SetControlPoint( 2, pnt3, true );
     figure1->GetPolyLine(0);
 
     testCase test;
     test.id = testCases.size();
     test.figure = figure1;
     test.mean = 255.0;
     test.sd = 0.0;
 
     testCases.push_back( test );
   }
 
 
   {
     /*****************************
     * one pixel (white) + 2 half pixels (white) + 1 half pixel (black)
     * -> mean of 191.25 expected
     ******************************/
     mitk::PlanarPolygon::Pointer figure1 = mitk::PlanarPolygon::New();
     figure1->SetGeometry2D( geom );
     mitk::Point2D pnt1; pnt1[0] = 1.1; pnt1[1] = 1.1;
     figure1->PlaceFigure( pnt1 );
 
     mitk::Point2D pnt2; pnt2[0] = 2.0; pnt2[1] = 2.0;
     figure1->SetControlPoint( 1, pnt2, true );
     mitk::Point2D pnt3; pnt3[0] = 3.0; pnt3[1] = 1.0;
     figure1->SetControlPoint( 2, pnt3, true );
     mitk::Point2D pnt4; pnt4[0] = 2.0; pnt4[1] = 0.0;
     figure1->SetControlPoint( 3, pnt4, true );
     figure1->GetPolyLine(0);
 
     testCase test;
     test.id = testCases.size();
     test.figure = figure1;
     test.mean = 191.25;
     test.sd = 127.5;
 
     testCases.push_back( test );
   }
 
 
   {
     /*****************************
     * whole pixel (white) + half pixel (gray) in x-direction 
     * -> mean of 191.5 expected
     ******************************/
     mitk::PlanarPolygon::Pointer figure1 = mitk::PlanarPolygon::New();
     figure1->SetGeometry2D( geom );
     mitk::Point2D pnt1; pnt1[0] = 11.0; pnt1[1] = 3.5;
     figure1->PlaceFigure( pnt1 );
 
     mitk::Point2D pnt2; pnt2[0] = 9.5; pnt2[1] = 3.5;
     figure1->SetControlPoint( 1, pnt2, true );
     mitk::Point2D pnt3; pnt3[0] = 9.5; pnt3[1] = 4.5;
     figure1->SetControlPoint( 2, pnt3, true );
     mitk::Point2D pnt4; pnt4[0] = 11.0; pnt4[1] = 4.5;
     figure1->SetControlPoint( 3, pnt4, true );
     figure1->GetPolyLine(0);
 
     testCase test;
     test.id = testCases.size();
     test.figure = figure1;
     test.mean = 191.50;
     test.sd = 89.80;
 
     testCases.push_back( test );
   }
 
   {
     /*****************************
     * quarter pixel (black) + whole pixel (white) + half pixel (gray) in x-direction 
     * -> mean of 191.5 expected
     ******************************/
     mitk::PlanarPolygon::Pointer figure1 = mitk::PlanarPolygon::New();
     figure1->SetGeometry2D( geom );
     mitk::Point2D pnt1; pnt1[0] = 11.0; pnt1[1] = 3.5;
     figure1->PlaceFigure( pnt1 );
 
     mitk::Point2D pnt2; pnt2[0] = 9.25; pnt2[1] = 3.5;
     figure1->SetControlPoint( 1, pnt2, true );
     mitk::Point2D pnt3; pnt3[0] = 9.25; pnt3[1] = 4.5;
     figure1->SetControlPoint( 2, pnt3, true );
     mitk::Point2D pnt4; pnt4[0] = 11.0; pnt4[1] = 4.5;
     figure1->SetControlPoint( 3, pnt4, true );
     figure1->GetPolyLine(0);
 
     testCase test;
     test.id = testCases.size();
     test.figure = figure1;
     test.mean = 191.5;
     test.sd = 89.80;
 
     testCases.push_back( test );
   }
 
   {
     /*****************************
     * half pixel (black) + whole pixel (white) + half pixel (gray) in x-direction 
     * -> mean of 127.66 expected
     ******************************/
     mitk::PlanarPolygon::Pointer figure1 = mitk::PlanarPolygon::New();
     figure1->SetGeometry2D( geom );
     mitk::Point2D pnt1; pnt1[0] = 11.0; pnt1[1] = 3.5;
     figure1->PlaceFigure( pnt1 );
 
     mitk::Point2D pnt2; pnt2[0] = 9.0; pnt2[1] = 3.5;
     figure1->SetControlPoint( 1, pnt2, true );
     mitk::Point2D pnt3; pnt3[0] = 9.0; pnt3[1] = 4.0;
     figure1->SetControlPoint( 2, pnt3, true );
     mitk::Point2D pnt4; pnt4[0] = 11.0; pnt4[1] = 4.0;
     figure1->SetControlPoint( 3, pnt4, true );
     figure1->GetPolyLine(0);
 
     testCase test;
     test.id = testCases.size();
     test.figure = figure1;
     test.mean = 127.66;
     test.sd = 127.5;
 
     testCases.push_back( test );
   }
 
 
   {
     /*****************************
     * whole pixel (gray) 
     * -> mean of 128 expected
     ******************************/
     mitk::PlanarPolygon::Pointer figure2 = mitk::PlanarPolygon::New();
     figure2->SetGeometry2D( geom );
     mitk::Point2D pnt1; pnt1[0] = 11.5; pnt1[1] = 10.5;
     figure2->PlaceFigure( pnt1 );
 
     mitk::Point2D pnt2; pnt2[0] = 11.5; pnt2[1] = 11.5;
     figure2->SetControlPoint( 1, pnt2, true );
     mitk::Point2D pnt3; pnt3[0] = 12.5; pnt3[1] = 11.5;
     figure2->SetControlPoint( 2, pnt3, true );
     mitk::Point2D pnt4; pnt4[0] = 12.5; pnt4[1] = 10.5;
     figure2->SetControlPoint( 3, pnt4, true );
     figure2->GetPolyLine(0);
 
     testCase test;
     test.id = testCases.size();
     test.figure = figure2;
     test.mean = 128.0;
     test.sd = 0.0;
 
     testCases.push_back( test );
   }
 
   {
     /*****************************
     * whole pixel (gray) + half pixel (white) in y-direction
     * -> mean of 191.5 expected
     ******************************/
     mitk::PlanarPolygon::Pointer figure2 = mitk::PlanarPolygon::New();
     figure2->SetGeometry2D( geom );
     mitk::Point2D pnt1; pnt1[0] = 11.5; pnt1[1] = 10.5;
     figure2->PlaceFigure( pnt1 );
 
     mitk::Point2D pnt2; pnt2[0] = 11.5; pnt2[1] = 12.0;
     figure2->SetControlPoint( 1, pnt2, true );
     mitk::Point2D pnt3; pnt3[0] = 12.5; pnt3[1] = 12.0;
     figure2->SetControlPoint( 2, pnt3, true );
     mitk::Point2D pnt4; pnt4[0] = 12.5; pnt4[1] = 10.5;
     figure2->SetControlPoint( 3, pnt4, true );
     figure2->GetPolyLine(0);
 
     testCase test;
     test.id = testCases.size();
     test.figure = figure2;
     test.mean = 191.5;
     test.sd = 89.80;
 
     testCases.push_back( test );
   }
 
   {
     /*****************************
     * 2 whole pixel (white) + 2 whole pixel (black) in y-direction
     * -> mean of 127.66 expected
     ******************************/
     mitk::PlanarPolygon::Pointer figure2 = mitk::PlanarPolygon::New();
     figure2->SetGeometry2D( geom );
     mitk::Point2D pnt1; pnt1[0] = 11.5; pnt1[1] = 10.5;
     figure2->PlaceFigure( pnt1 );
 
     mitk::Point2D pnt2; pnt2[0] = 11.5; pnt2[1] = 13.5;
     figure2->SetControlPoint( 1, pnt2, true );
     mitk::Point2D pnt3; pnt3[0] = 12.5; pnt3[1] = 13.5;
     figure2->SetControlPoint( 2, pnt3, true );
     mitk::Point2D pnt4; pnt4[0] = 12.5; pnt4[1] = 10.5;
     figure2->SetControlPoint( 3, pnt4, true );
     figure2->GetPolyLine(0);
 
     testCase test;
     test.id = testCases.size();
     test.figure = figure2;
     test.mean = 127.66;
     test.sd = 127.5;
 
     testCases.push_back( test );
   }
 
 
   {
     /*****************************
     * 9 whole pixels (white) + 3 half pixels (white) 
     * + 3 whole pixel (black) [ + 3 slightly less than half pixels (black)]
     * -> mean of 204.0 expected
     ******************************/
     mitk::PlanarPolygon::Pointer figure2 = mitk::PlanarPolygon::New();
     figure2->SetGeometry2D( geom );
     mitk::Point2D pnt1; pnt1[0] = 0.5; pnt1[1] = 0.5;
     figure2->PlaceFigure( pnt1 );
 
     mitk::Point2D pnt2; pnt2[0] = 3.5; pnt2[1] = 3.5;
     figure2->SetControlPoint( 1, pnt2, true );
     mitk::Point2D pnt3; pnt3[0] = 8.4999; pnt3[1] = 3.5;
     figure2->SetControlPoint( 2, pnt3, true );
     mitk::Point2D pnt4; pnt4[0] = 5.4999; pnt4[1] = 0.5;
     figure2->SetControlPoint( 3, pnt4, true );
     figure2->GetPolyLine(0);
 
     testCase test;
     test.id = testCases.size();
     test.figure = figure2;
     test.mean = 204.0;
     test.sd = 105.58;
 
     testCases.push_back( test );
   }
 
   {
     /*****************************
     * half pixel (white) + whole pixel (white) + half pixel (black)
     * -> mean of 212.66 expected
     ******************************/
     mitk::PlanarPolygon::Pointer figure2 = mitk::PlanarPolygon::New();
     figure2->SetGeometry2D( geom );
     mitk::Point2D pnt1; pnt1[0] = 9.5; pnt1[1] = 0.5;
     figure2->PlaceFigure( pnt1 );
 
     mitk::Point2D pnt2; pnt2[0] = 9.5; pnt2[1] = 2.5;
     figure2->SetControlPoint( 1, pnt2, true );
     mitk::Point2D pnt3; pnt3[0] = 11.5; pnt3[1] = 2.5;
     figure2->SetControlPoint( 2, pnt3, true );
     figure2->GetPolyLine(0);
 
     testCase test;
     test.id = testCases.size();
     test.figure = figure2;
     test.mean = 212.66;
     test.sd = 73.32;
 
     testCases.push_back( test );
   }
 
 
   
   return testCases;
 }
 
 // loads the test image
 static mitk::Image::Pointer GetTestImage()
 {
   mitk::StandardFileLocations::Pointer locator = mitk::StandardFileLocations::GetInstance();
 
   const std::string filename = locator->FindFile("testimage.dcm", "Modules/MitkExt/Testing/Data");
   if (filename.empty())
   {
     MITK_ERROR << "Could not find test file";
     return NULL;
   }
   else
   {
     MITK_INFO << "Found testimage.dcm";
   }
 
 
   itk::FilenamesContainer file;
   file.push_back( filename );
 
   mitk::DicomSeriesReader* reader = new mitk::DicomSeriesReader;
      
   mitk::DataNode::Pointer node = reader->LoadDicomSeries( file, false, false );
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>( node->GetData() );
 
   return image;
 }
 
 };
 
-int mitkImageStatisticsCalculatorTest(int, char**)
+int mitkImageStatisticsCalculatorTest(int, char* [])
 {
   // always start with this!
   MITK_TEST_BEGIN("mitkImageStatisticsCalculatorTest")
   
   //QCoreApplication app(argc, argv);
 
   mitk::Image::Pointer image = mitkImageStatisticsCalculatorTestClass::GetTestImage();
   MITK_TEST_CONDITION_REQUIRED( image.IsNotNull(), "Loading test image" );
 
   mitk::Geometry2D::Pointer geom = image->GetSlicedGeometry()->GetGeometry2D(0);
 
   std::vector<mitkImageStatisticsCalculatorTestClass::testCase> allTestCases = 
     mitkImageStatisticsCalculatorTestClass::InitializeTestCases( geom );
 
 
   for ( std::vector<mitkImageStatisticsCalculatorTestClass::testCase>::size_type i=0; i<allTestCases.size(); i++ )
   {
     mitkImageStatisticsCalculatorTestClass::testCase test = allTestCases[i];
 
     const mitk::ImageStatisticsCalculator::Statistics stats = 
       mitkImageStatisticsCalculatorTestClass::TestStatistics( image, test.figure );
 
     int tmpMean = stats.Mean * 100;
     double calculatedMean = tmpMean / 100.0;
     MITK_TEST_CONDITION( calculatedMean == test.mean,
       "Calculated mean grayvalue '"<< calculatedMean <<"'  is equal to the desired value '"
       << test.mean <<"' for testcase #" << test.id );
 
     int tmpSD = stats.Sigma * 100;
     double calculatedSD = tmpSD / 100.0;
     MITK_TEST_CONDITION( calculatedSD == test.sd,
       "Calculated grayvalue sd '"<< calculatedSD <<"'  is equal to the desired value '"
       << test.sd <<"' for testcase #" << test.id );
   }
  
 
   MITK_TEST_END()
 }
 
diff --git a/Modules/ImageStatistics/Testing/mitkPointSetDifferenceStatisticsCalculatorTest.cpp b/Modules/ImageStatistics/Testing/mitkPointSetDifferenceStatisticsCalculatorTest.cpp
index a2835fdd15..e50a85f071 100644
--- a/Modules/ImageStatistics/Testing/mitkPointSetDifferenceStatisticsCalculatorTest.cpp
+++ b/Modules/ImageStatistics/Testing/mitkPointSetDifferenceStatisticsCalculatorTest.cpp
@@ -1,114 +1,114 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2008-02-25 17:27:17 +0100 (Mo, 25 Feb 2008) $
 Version:   $Revision: 7837 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include "mitkStandardFileLocations.h"
 #include "mitkTestingMacros.h"
 #include "mitkPointSetDifferenceStatisticsCalculator.h"
 
 //#include <QtCore>
 
 /**
  * \brief Test class for mitkPointSetDifferenceStatisticsCalculator
  */
 class mitkPointSetDifferenceStatisticsCalculatorTestClass
 {
 
 public:
 
   static void TestInstantiation()
     {
     // let's create an object of our class
     mitk::PointSetDifferenceStatisticsCalculator::Pointer myPointSetDifferenceStatisticsCalculator = mitk::PointSetDifferenceStatisticsCalculator::New();
     MITK_TEST_CONDITION_REQUIRED(myPointSetDifferenceStatisticsCalculator.IsNotNull(),"Testing instantiation with constructor 1.");
 
     mitk::PointSet::Pointer myTestPointSet1 = mitk::PointSet::New();
     mitk::PointSet::Pointer myTestPointSet2 = mitk::PointSet::New();
     mitk::PointSetDifferenceStatisticsCalculator::Pointer myPointSetDifferenceStatisticsCalculator2 = mitk::PointSetDifferenceStatisticsCalculator::New(myTestPointSet1,myTestPointSet2);
     MITK_TEST_CONDITION_REQUIRED(myPointSetDifferenceStatisticsCalculator2.IsNotNull(),"Testing instantiation with constructor 2.");
     }
 
 static void TestSimpleCase()
     {
     
     MITK_TEST_OUTPUT(<< "Starting simple test case...");
 
     mitk::Point3D test;
     mitk::PointSet::Pointer testPointSet1 = mitk::PointSet::New();
 
     mitk::FillVector3D(test,0,0,0);
     testPointSet1->InsertPoint(0,test);
 
     mitk::FillVector3D(test,1,1,1);
     testPointSet1->InsertPoint(1,test);
 
     mitk::PointSet::Pointer testPointSet2 = mitk::PointSet::New();
 
     mitk::FillVector3D(test,0.5,0.5,0.5);
     testPointSet2->InsertPoint(0,test);
 
     mitk::FillVector3D(test,2,2,2);
     testPointSet2->InsertPoint(1,test);
     double squaredDistance1 = 0.75;
     double squaredDistance2 = 3;
     double mean = (sqrt(squaredDistance1)+sqrt(squaredDistance2))/2;
     double variance = ((sqrt(squaredDistance1)-mean)*(sqrt(squaredDistance1)-mean)+(sqrt(squaredDistance2)-mean)*(sqrt(squaredDistance2)-mean))/2;
     double sd = sqrt(variance);
     double ms = 3.75/2;
     double rms = sqrt(ms);
     double min = sqrt(squaredDistance1);
     double max = sqrt(squaredDistance2);
     double median = (min + max)/2;
 
     mitk::PointSetDifferenceStatisticsCalculator::Pointer myPointSetDifferenceStatisticsCalculator = mitk::PointSetDifferenceStatisticsCalculator::New(testPointSet1,testPointSet2);
 
     MITK_TEST_CONDITION_REQUIRED((myPointSetDifferenceStatisticsCalculator->GetNumberOfPoints()==testPointSet1->GetSize()),".. Testing GetNumberOfPoints");
     MITK_TEST_CONDITION_REQUIRED(mitk::Equal(myPointSetDifferenceStatisticsCalculator->GetMean(),mean),".. Testing GetMean");
     MITK_TEST_CONDITION_REQUIRED(mitk::Equal(myPointSetDifferenceStatisticsCalculator->GetSD(),sd),".. Testing GetSD");
     MITK_TEST_CONDITION_REQUIRED(mitk::Equal(myPointSetDifferenceStatisticsCalculator->GetVariance(),variance),".. Testing GetVariance");
     MITK_TEST_CONDITION_REQUIRED(mitk::Equal(myPointSetDifferenceStatisticsCalculator->GetRMS(),rms),".. Testing GetRMS");
     MITK_TEST_CONDITION_REQUIRED(mitk::Equal(myPointSetDifferenceStatisticsCalculator->GetMin(),min),".. Testing GetMin");
     MITK_TEST_CONDITION_REQUIRED(mitk::Equal(myPointSetDifferenceStatisticsCalculator->GetMax(),max),".. Testing GetMax");
     MITK_TEST_CONDITION_REQUIRED(mitk::Equal(myPointSetDifferenceStatisticsCalculator->GetMedian(),median),".. Testing GetMedian");
 
     testPointSet2->InsertPoint(2,test);
     myPointSetDifferenceStatisticsCalculator->SetPointSets(testPointSet1,testPointSet2);
     MITK_TEST_OUTPUT(<<"Test for exception when using differently sized point sets");
     MITK_TEST_FOR_EXCEPTION(itk::ExceptionObject,myPointSetDifferenceStatisticsCalculator->GetMean());
     mitk::PointSetDifferenceStatisticsCalculator::Pointer myPointSetDifferenceStatisticsCalculator2 = mitk::PointSetDifferenceStatisticsCalculator::New();
     MITK_TEST_OUTPUT(<<"Test for exception when using point sets with size 0");
     MITK_TEST_FOR_EXCEPTION(itk::ExceptionObject,myPointSetDifferenceStatisticsCalculator2->GetMean());
 }
 };
 
-int mitkPointSetDifferenceStatisticsCalculatorTest(int, char**)
+int mitkPointSetDifferenceStatisticsCalculatorTest(int, char* [])
 {
   // always start with this!
   MITK_TEST_BEGIN("mitkPointSetDifferenceStatisticsCalculatorTest")
 
   // let's create an object of our class
   mitk::PointSetDifferenceStatisticsCalculator::Pointer myPointSetDifferenceStatisticsCalculator = mitk::PointSetDifferenceStatisticsCalculator::New();
   MITK_TEST_CONDITION_REQUIRED(myPointSetDifferenceStatisticsCalculator.IsNotNull(),"Testing instantiation with constructor 1.");
 
   mitk::PointSet::Pointer myTestPointSet1 = mitk::PointSet::New();
   mitk::PointSet::Pointer myTestPointSet2 = mitk::PointSet::New();
   mitk::PointSetDifferenceStatisticsCalculator::Pointer myPointSetDifferenceStatisticsCalculator2 = mitk::PointSetDifferenceStatisticsCalculator::New(myTestPointSet1,myTestPointSet2);
   MITK_TEST_CONDITION_REQUIRED(myPointSetDifferenceStatisticsCalculator2.IsNotNull(),"Testing instantiation with constructor 2.");
 
   mitkPointSetDifferenceStatisticsCalculatorTestClass::TestInstantiation();
   mitkPointSetDifferenceStatisticsCalculatorTestClass::TestSimpleCase();
   MITK_TEST_END()
 }
diff --git a/Modules/ImageStatistics/Testing/mitkPointSetStatisticsCalculatorTest.cpp b/Modules/ImageStatistics/Testing/mitkPointSetStatisticsCalculatorTest.cpp
index d9b8ff8d3d..2d250f351e 100644
--- a/Modules/ImageStatistics/Testing/mitkPointSetStatisticsCalculatorTest.cpp
+++ b/Modules/ImageStatistics/Testing/mitkPointSetStatisticsCalculatorTest.cpp
@@ -1,165 +1,165 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2008-02-25 17:27:17 +0100 (Mo, 25 Feb 2008) $
 Version:   $Revision: 7837 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include "mitkStandardFileLocations.h"
 #include "mitkTestingMacros.h"
 #include "mitkPointSetStatisticsCalculator.h"
 
 //#include <QtCore>
 
 /**
  * \brief Test class for mitkPointSetStatisticsCalculator
  */
 class mitkPointSetStatisticsCalculatorTestClass
 {
     /**************************** a few private help funktions ***********************************/
      private:
      /** @brief Rounds a double.
       *  @param precision   number of tested decimal places */
      static double round(double number, int precision)
       {
         double t = std::pow(10.,precision);
         double returnValue = (int)(number*t+0.5)/t;
         return returnValue;
       }
      /** @brief Tests two double values for equality.
       *  @param precision   number of tested decimal places */
     static bool equals(double a, double b, int precision = 5)
       {
       if (round(a,precision)==round(b,precision)) return true;
       else 
         {
           std::cout << a << " is not " << b << std::endl;
           return false;
         }
       }
     /**********************************************************************************************/
 
 public:
 
   static void TestInstantiation()
     {
     // let's create an object of our class
     mitk::PointSetStatisticsCalculator::Pointer myPointSetStatisticsCalculator = mitk::PointSetStatisticsCalculator::New();
     MITK_TEST_CONDITION_REQUIRED(myPointSetStatisticsCalculator.IsNotNull(),"Testing instantiation with constructor 1.");
 
     mitk::PointSet::Pointer myTestPointSet = mitk::PointSet::New();
     mitk::PointSetStatisticsCalculator::Pointer myPointSetStatisticsCalculator2 = mitk::PointSetStatisticsCalculator::New(myTestPointSet);
     MITK_TEST_CONDITION_REQUIRED(myPointSetStatisticsCalculator2.IsNotNull(),"Testing instantiation with constructor 2.");
     }
 
 static void TestSimpleCase()
     {
     
     MITK_TEST_OUTPUT(<< "Starting simple test case...");
 
     mitk::Point3D test;
     mitk::PointSet::Pointer testPointSet = mitk::PointSet::New();
 
     mitk::FillVector3D(test,0,0,0);
     testPointSet->InsertPoint(0,test);
 
     mitk::FillVector3D(test,1,1,1);
     testPointSet->InsertPoint(1,test);
 
     mitk::PointSetStatisticsCalculator::Pointer myPointSetStatisticsCalculator = mitk::PointSetStatisticsCalculator::New(testPointSet);
   
     MITK_TEST_CONDITION_REQUIRED((myPointSetStatisticsCalculator->GetPositionMean()[0]==0.5),".. Testing GetPositionMean");
     MITK_TEST_CONDITION_REQUIRED((myPointSetStatisticsCalculator->GetPositionStandardDeviation()[0]==0.5),".. Testing GetPositionStandardDeviation");
     MITK_TEST_CONDITION_REQUIRED(equals(myPointSetStatisticsCalculator->GetPositionSampleStandardDeviation()[0],0.70710672),".. Testing GetPositionStandardDeviation");
     MITK_TEST_CONDITION_REQUIRED(equals(myPointSetStatisticsCalculator->GetPositionErrorMean(),0.8660254),".. Testing GetPositionErrorMean");
     MITK_TEST_CONDITION_REQUIRED(equals(myPointSetStatisticsCalculator->GetPositionErrorRMS(),0.8660254),".. Testing GetPositionErrorRMS");
     MITK_TEST_CONDITION_REQUIRED(equals(myPointSetStatisticsCalculator->GetPositionErrorMax(),0.8660254),".. Testing GetPositionErrorMax");
     MITK_TEST_CONDITION_REQUIRED(equals(myPointSetStatisticsCalculator->GetPositionErrorMedian(),0.8660254),".. Testing GetPositionErrorMedian");
     MITK_TEST_CONDITION_REQUIRED(equals(myPointSetStatisticsCalculator->GetPositionErrorMin(),0.8660254),".. Testing GetPositionErrorMin");
     MITK_TEST_CONDITION_REQUIRED(equals(myPointSetStatisticsCalculator->GetPositionErrorSampleStandardDeviation(),0),".. Testing GetPositionErrorSampleStandardDeviation");
     MITK_TEST_CONDITION_REQUIRED(equals(myPointSetStatisticsCalculator->GetPositionErrorStandardDeviation(),0),".. Testing GetPositionErrorStandardDeviation");
     }
 
 static void TestComplexCase()
     {
     
     MITK_TEST_OUTPUT(<< "Starting complex test case...");
     mitk::Point3D testPoint;
     mitk::PointSet::Pointer testPointSet = mitk::PointSet::New();
    
     //1st point
     mitk::FillVector3D(testPoint,0,1,0);
     testPointSet->InsertPoint(0,testPoint);
 
     //2nd point
     mitk::FillVector3D(testPoint,0,1,0.34);
     testPointSet->InsertPoint(1,testPoint);
 
     //3rd point
     mitk::FillVector3D(testPoint,1,0.5,1);
     testPointSet->InsertPoint(2,testPoint);
 
     //4th point
     mitk::FillVector3D(testPoint,15,3,2);
     testPointSet->InsertPoint(3,testPoint);
 
     //5th point
     mitk::FillVector3D(testPoint,2,22.5,1.2655);
     testPointSet->InsertPoint(4,testPoint);
 
     //6th point
     mitk::FillVector3D(testPoint,4,1.3,2);
     testPointSet->InsertPoint(5,testPoint);
 
     //7th point
     mitk::FillVector3D(testPoint,0.001,0,1);
     testPointSet->InsertPoint(6,testPoint);
 
     //8th point
     mitk::FillVector3D(testPoint,1.2525,2.22,3);
     testPointSet->InsertPoint(7,testPoint);
 
     //9th point
     mitk::FillVector3D(testPoint,3.1,3,1);
     testPointSet->InsertPoint(8,testPoint);
 
     mitk::PointSetStatisticsCalculator::Pointer myPointSetStatisticsCalculator = mitk::PointSetStatisticsCalculator::New();
     myPointSetStatisticsCalculator->SetPointSet(testPointSet);
     
     MITK_TEST_CONDITION_REQUIRED(equals(myPointSetStatisticsCalculator->GetPositionMean()[2],1.2895),".. Testing GetPositionMean");
     MITK_TEST_CONDITION_REQUIRED(equals(myPointSetStatisticsCalculator->GetPositionStandardDeviation()[2],0.86614074),".. Testing GetPositionStandardDeviation");
     MITK_TEST_CONDITION_REQUIRED(equals(myPointSetStatisticsCalculator->GetPositionSampleStandardDeviation()[2],0.91868098),".. Testing GetPositionStandardDeviation");
     MITK_TEST_CONDITION_REQUIRED(equals(myPointSetStatisticsCalculator->GetPositionErrorMean(),6.06656587),".. Testing GetPositionErrorMean");
     MITK_TEST_CONDITION_REQUIRED(equals(myPointSetStatisticsCalculator->GetPositionErrorRMS(),8.0793161),".. Testing GetPositionErrorRMS");
     MITK_TEST_CONDITION_REQUIRED(equals(myPointSetStatisticsCalculator->GetPositionErrorMax(),18.6875241),".. Testing GetPositionErrorMax");
     MITK_TEST_CONDITION_REQUIRED(equals(myPointSetStatisticsCalculator->GetPositionErrorMedian(),4.18522229),".. Testing GetPositionErrorMedian");
     MITK_TEST_CONDITION_REQUIRED(equals(myPointSetStatisticsCalculator->GetPositionErrorMin(),0.90082741),".. Testing GetPositionErrorMin");
     MITK_TEST_CONDITION_REQUIRED(equals(myPointSetStatisticsCalculator->GetPositionErrorSampleStandardDeviation(),5.65960626),".. Testing GetPositionErrorSampleStandardDeviation");
     MITK_TEST_CONDITION_REQUIRED(equals(myPointSetStatisticsCalculator->GetPositionErrorStandardDeviation(),5.33592795),".. Testing GetPositionErrorStandardDeviation");
  
     }
 
 
 };
 
-int mitkPointSetStatisticsCalculatorTest(int, char**)
+int mitkPointSetStatisticsCalculatorTest(int, char* [])
 {
   // always start with this!
   MITK_TEST_BEGIN("mitkPointSetStatisticsCalculatorTest")
 
   mitkPointSetStatisticsCalculatorTestClass::TestInstantiation();
   mitkPointSetStatisticsCalculatorTestClass::TestSimpleCase();
   mitkPointSetStatisticsCalculatorTestClass::TestComplexCase();
 
   MITK_TEST_END()
 }