diff --git a/Core/Code/Controllers/mitkSliceNavigationController.cpp b/Core/Code/Controllers/mitkSliceNavigationController.cpp
index def6a28050..dd63411f09 100644
--- a/Core/Code/Controllers/mitkSliceNavigationController.cpp
+++ b/Core/Code/Controllers/mitkSliceNavigationController.cpp
@@ -1,840 +1,840 @@
 /*===================================================================
 
 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 "mitkSliceNavigationController.h"
 #include "mitkBaseRenderer.h"
 #include "mitkSlicedGeometry3D.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkOperation.h"
 #include "mitkOperationActor.h"
 #include "mitkStateEvent.h"
 #include "mitkCrosshairPositionEvent.h"
 #include "mitkPositionEvent.h"
 #include "mitkProportionalTimeGeometry.h"
 #include "mitkInteractionConst.h"
 #include "mitkAction.h"
 #include "mitkGlobalInteraction.h"
 #include "mitkEventMapper.h"
 #include "mitkFocusManager.h"
 #include "mitkVtkPropRenderer.h"
 #include "mitkRenderingManager.h"
 
 #include "mitkInteractionConst.h"
 #include "mitkPointOperation.h"
 #include "mitkPlaneOperation.h"
 #include "mitkUndoController.h"
 #include "mitkOperationEvent.h"
 #include "mitkNodePredicateDataType.h"
 #include "mitkStatusBar.h"
 
 #include "mitkApplyTransformMatrixOperation.h"
 
 #include "mitkMemoryUtilities.h"
 
 
 #include <itkCommand.h>
 
 namespace mitk {
 
 SliceNavigationController::SliceNavigationController( const char *type )
 : BaseController( type ),
   m_InputWorldGeometry3D( NULL ),
   m_InputWorldTimeGeometry( NULL ),
   m_CreatedWorldGeometry( NULL ),
   m_ViewDirection( Axial ),
   m_DefaultViewDirection( Axial ),
   m_RenderingManager( NULL ),
   m_Renderer( NULL ),
   m_Top( false ),
   m_FrontSide( false ),
   m_Rotated( false ),
   m_BlockUpdate( false ),
   m_SliceLocked( false ),
   m_SliceRotationLocked( false ),
   m_OldPos(0)
 {
   typedef itk::SimpleMemberCommand< SliceNavigationController > SNCCommandType;
   SNCCommandType::Pointer sliceStepperChangedCommand, timeStepperChangedCommand;
 
   sliceStepperChangedCommand = SNCCommandType::New();
   timeStepperChangedCommand = SNCCommandType::New();
 
   sliceStepperChangedCommand->SetCallbackFunction(
     this, &SliceNavigationController::SendSlice );
 
   timeStepperChangedCommand->SetCallbackFunction(
     this, &SliceNavigationController::SendTime );
 
   m_Slice->AddObserver( itk::ModifiedEvent(), sliceStepperChangedCommand );
   m_Time->AddObserver( itk::ModifiedEvent(), timeStepperChangedCommand );
 
   m_Slice->SetUnitName( "mm" );
   m_Time->SetUnitName( "ms" );
 
   m_Top = false;
   m_FrontSide = false;
   m_Rotated = false;
 }
 
 
 SliceNavigationController::~SliceNavigationController()
 {
 }
 
 
 void
 SliceNavigationController::SetInputWorldGeometry3D( const Geometry3D *geometry )
 {
   if ( geometry != NULL )
   {
     if ( const_cast< BoundingBox * >( geometry->GetBoundingBox())
          ->GetDiagonalLength2() < eps )
     {
       itkWarningMacro( "setting an empty bounding-box" );
       geometry = NULL;
     }
   }
   if ( m_InputWorldGeometry3D != geometry )
   {
     m_InputWorldGeometry3D = geometry;
     m_InputWorldTimeGeometry = NULL;
     this->Modified();
   }
 }
 
 void
 SliceNavigationController::SetInputWorldTimeGeometry( const TimeGeometry *geometry )
 {
   if ( geometry != NULL )
   {
     if ( const_cast< BoundingBox * >( geometry->GetBoundingBoxInWorld())
          ->GetDiagonalLength2() < eps )
     {
       itkWarningMacro( "setting an empty bounding-box" );
       geometry = NULL;
     }
   }
   if ( m_InputWorldTimeGeometry != geometry )
   {
     m_InputWorldTimeGeometry = geometry;
     m_InputWorldGeometry3D = NULL;
     this->Modified();
   }
 }
 
 RenderingManager *
 SliceNavigationController::GetRenderingManager() const
 {
   mitk::RenderingManager* renderingManager = m_RenderingManager.GetPointer();
 
   if (renderingManager != NULL)
     return renderingManager;
 
   if ( m_Renderer != NULL )
   {
     renderingManager = m_Renderer->GetRenderingManager();
 
     if (renderingManager != NULL)
       return renderingManager;
   }
 
   return mitk::RenderingManager::GetInstance();
 }
 
 
 void SliceNavigationController::SetViewDirectionToDefault()
 {
   m_ViewDirection = m_DefaultViewDirection;
 }
 
 const char* SliceNavigationController::GetViewDirectionAsString()
 {
     const char* viewDirectionString;
     switch(m_ViewDirection)
     {
     case 0:
         viewDirectionString = "Axial";
         break;
 
     case 1:
         viewDirectionString = "Sagittal";
         break;
 
     case 2:
         viewDirectionString = "Frontal";
         break;
 
     case 3:
         viewDirectionString = "Original";
         break;
 
     default:
         viewDirectionString = "No View Direction Available";
         break;
     }
     return viewDirectionString;
 }
 
 void SliceNavigationController::Update()
 {
   if ( !m_BlockUpdate )
   {
     if ( m_ViewDirection == Axial )
     {
       this->Update( Axial, false, false, true );
     }
     else
     {
       this->Update( m_ViewDirection );
     }
   }
 }
 void
 SliceNavigationController::Update(
   SliceNavigationController::ViewDirection viewDirection,
   bool top, bool frontside, bool rotated )
 {
   TimeGeometry::ConstPointer worldTimeGeometry = m_InputWorldTimeGeometry;
 
   if( m_BlockUpdate ||
       ( m_InputWorldTimeGeometry.IsNull() && m_InputWorldGeometry3D.IsNull() ) ||
       ( (worldTimeGeometry.IsNotNull()) && (worldTimeGeometry->CountTimeSteps() == 0) )
     )
   {
     return;
   }
 
   m_BlockUpdate = true;
 
   if ( m_InputWorldTimeGeometry.IsNotNull() &&
     m_LastUpdateTime < m_InputWorldTimeGeometry->GetMTime() )
   {
     Modified();
   }
   if ( m_InputWorldGeometry3D.IsNotNull() &&
     m_LastUpdateTime < m_InputWorldGeometry3D->GetMTime() )
   {
     Modified();
   }
   this->SetViewDirection( viewDirection );
   this->SetTop( top );
   this->SetFrontSide( frontside );
   this->SetRotated( rotated );
 
   if ( m_LastUpdateTime < GetMTime() )
   {
     m_LastUpdateTime = GetMTime();
 
     // initialize the viewplane
     SlicedGeometry3D::Pointer slicedWorldGeometry = NULL;
     Geometry3D::ConstPointer currentGeometry = NULL;
     if (m_InputWorldTimeGeometry.IsNotNull())
       if (m_InputWorldTimeGeometry->IsValidTimeStep(GetTime()->GetPos()))
         currentGeometry = m_InputWorldTimeGeometry->GetGeometryForTimeStep(GetTime()->GetPos());
       else
         currentGeometry = m_InputWorldTimeGeometry->GetGeometryForTimeStep(0);
     else
       currentGeometry = m_InputWorldGeometry3D;
 
     m_CreatedWorldGeometry = NULL;
     switch ( viewDirection )
     {
     case Original:
       if ( worldTimeGeometry.IsNotNull())
       {
         m_CreatedWorldGeometry = worldTimeGeometry->Clone();
 
         worldTimeGeometry = m_CreatedWorldGeometry.GetPointer();
 
         slicedWorldGeometry = dynamic_cast< SlicedGeometry3D * >(
           m_CreatedWorldGeometry->GetGeometryForTimeStep( this->GetTime()->GetPos() ).GetPointer() );
 
         if ( slicedWorldGeometry.IsNotNull() )
         {
           break;
         }
       }
       else
       {
         const SlicedGeometry3D *worldSlicedGeometry =
           dynamic_cast< const SlicedGeometry3D * >(
             currentGeometry.GetPointer());
 
         if ( worldSlicedGeometry != NULL )
         {
           slicedWorldGeometry = static_cast< SlicedGeometry3D * >(
             currentGeometry->Clone().GetPointer());
           break;
         }
       }
       //else: use Axial: no "break" here!!
 
     case Axial:
       slicedWorldGeometry = SlicedGeometry3D::New();
       slicedWorldGeometry->InitializePlanes(
         currentGeometry, PlaneGeometry::Axial,
         top, frontside, rotated );
       slicedWorldGeometry->SetSliceNavigationController( this );
       break;
 
     case Frontal:
       slicedWorldGeometry = SlicedGeometry3D::New();
       slicedWorldGeometry->InitializePlanes( currentGeometry,
         PlaneGeometry::Frontal, top, frontside, rotated );
       slicedWorldGeometry->SetSliceNavigationController( this );
       break;
 
     case Sagittal:
       slicedWorldGeometry = SlicedGeometry3D::New();
       slicedWorldGeometry->InitializePlanes( currentGeometry,
         PlaneGeometry::Sagittal, top, frontside, rotated );
       slicedWorldGeometry->SetSliceNavigationController( this );
       break;
     default:
       itkExceptionMacro("unknown ViewDirection");
     }
 
     m_Slice->SetPos( 0 );
     m_Slice->SetSteps( (int)slicedWorldGeometry->GetSlices() );
 
     if ( m_CreatedWorldGeometry.IsNull() )
     {
       // initialize TimeGeometry
       m_CreatedWorldGeometry = ProportionalTimeGeometry::New();
     }
     if ( worldTimeGeometry.IsNull())
     {
       m_CreatedWorldGeometry = ProportionalTimeGeometry::New();
       dynamic_cast<ProportionalTimeGeometry *>(m_CreatedWorldGeometry.GetPointer())->Initialize(slicedWorldGeometry, 1);
       m_Time->SetSteps( 0 );
       m_Time->SetPos( 0 );
       m_Time->InvalidateRange();
     }
     else
     {
       m_BlockUpdate = true;
       m_Time->SetSteps( worldTimeGeometry->CountTimeSteps() );
       m_Time->SetPos( 0 );
 
       const TimeBounds &timeBounds = worldTimeGeometry->GetTimeBounds();
       m_Time->SetRange( timeBounds[0], timeBounds[1] );
 
       m_BlockUpdate = false;
 
       assert( worldTimeGeometry->GetGeometryForTimeStep( this->GetTime()->GetPos() ).IsNotNull() );
 
       slicedWorldGeometry->SetTimeBounds(
         worldTimeGeometry->GetGeometryForTimeStep( this->GetTime()->GetPos() )->GetTimeBounds() );
 
       //@todo implement for non-evenly-timed geometry!
       m_CreatedWorldGeometry = ProportionalTimeGeometry::New();
       dynamic_cast<ProportionalTimeGeometry *>(m_CreatedWorldGeometry.GetPointer())->Initialize(slicedWorldGeometry, worldTimeGeometry->CountTimeSteps());
     }
   }
 
   // unblock update; we may do this now, because if m_BlockUpdate was already
   // true before this method was entered, then we will never come here.
   m_BlockUpdate = false;
 
   // Send the geometry. Do this even if nothing was changed, because maybe
   // Update() was only called to re-send the old geometry and time/slice data.
   this->SendCreatedWorldGeometry();
   this->SendSlice();
   this->SendTime();
 
   // Adjust the stepper range of slice stepper according to geometry
   this->AdjustSliceStepperRange();
 }
 
 void
 SliceNavigationController::SendCreatedWorldGeometry()
 {
   // Send the geometry. Do this even if nothing was changed, because maybe
   // Update() was only called to re-send the old geometry.
   if ( !m_BlockUpdate )
   {
     this->InvokeEvent( GeometrySendEvent(m_CreatedWorldGeometry, 0) );
   }
 }
 
 void
 SliceNavigationController::SendCreatedWorldGeometryUpdate()
 {
   if ( !m_BlockUpdate )
   {
     this->InvokeEvent(
       GeometryUpdateEvent(m_CreatedWorldGeometry, m_Slice->GetPos()) );
   }
 }
 
 void
 SliceNavigationController::SendSlice()
 {
   if ( !m_BlockUpdate )
   {
     if ( m_CreatedWorldGeometry.IsNotNull() )
     {
       this->InvokeEvent(
         GeometrySliceEvent(m_CreatedWorldGeometry, m_Slice->GetPos()) );
 
       // send crosshair event
       crosshairPositionEvent.Send();
 
       // Request rendering update for all views
       this->GetRenderingManager()->RequestUpdateAll();
     }
   }
 }
 
 void
 SliceNavigationController::SendTime()
 {
   if ( !m_BlockUpdate )
   {
     if ( m_CreatedWorldGeometry.IsNotNull() )
     {
       this->InvokeEvent(
         GeometryTimeEvent(m_CreatedWorldGeometry, m_Time->GetPos()) );
 
       // Request rendering update for all views
       this->GetRenderingManager()->RequestUpdateAll();
     }
   }
 }
 
 void
 SliceNavigationController::SetGeometry( const itk::EventObject & )
 {
 }
 
 void
 SliceNavigationController
 ::SetGeometryTime( const itk::EventObject &geometryTimeEvent )
 {
   const SliceNavigationController::GeometryTimeEvent *timeEvent =
     dynamic_cast< const SliceNavigationController::GeometryTimeEvent * >(
       &geometryTimeEvent);
 
   assert( timeEvent != NULL );
 
   TimeGeometry *timeGeometry = timeEvent->GetTimeGeometry();
   assert( timeGeometry != NULL );
 
   if ( m_CreatedWorldGeometry.IsNotNull() )
   {
     int timeStep = (int) timeEvent->GetPos();
     ScalarType timeInMS;
     timeInMS = timeGeometry->TimeStepToTimePoint( timeStep );
     timeStep = m_CreatedWorldGeometry->TimePointToTimeStep( timeInMS );
     this->GetTime()->SetPos( timeStep );
   }
 }
 
 void
 SliceNavigationController
 ::SetGeometrySlice(const itk::EventObject & geometrySliceEvent)
 {
   const SliceNavigationController::GeometrySliceEvent* sliceEvent =
     dynamic_cast<const SliceNavigationController::GeometrySliceEvent *>(
       &geometrySliceEvent);
   assert(sliceEvent!=NULL);
 
   this->GetSlice()->SetPos(sliceEvent->GetPos());
 }
 
 void
 SliceNavigationController::SelectSliceByPoint( const Point3D &point )
 {
   //@todo add time to PositionEvent and use here!!
   SlicedGeometry3D* slicedWorldGeometry = dynamic_cast< SlicedGeometry3D * >(
     m_CreatedWorldGeometry->GetGeometryForTimeStep( this->GetTime()->GetPos() ).GetPointer() );
 
   if ( slicedWorldGeometry )
   {
     int bestSlice = -1;
     double bestDistance = itk::NumericTraits<double>::max();
 
     int s, slices;
     slices = slicedWorldGeometry->GetSlices();
     if ( slicedWorldGeometry->GetEvenlySpaced() )
     {
       mitk::Geometry2D *plane = slicedWorldGeometry->GetGeometry2D( 0 );
 
       const Vector3D &direction = slicedWorldGeometry->GetDirectionVector();
 
       Point3D projectedPoint;
       plane->Project( point, projectedPoint );
 
       // Check whether the point is somewhere within the slice stack volume;
       // otherwise, the defualt slice (0) will be selected
       if ( direction[0] * (point[0] - projectedPoint[0])
          + direction[1] * (point[1] - projectedPoint[1])
          + direction[2] * (point[2] - projectedPoint[2]) >= 0 )
       {
         bestSlice = (int)(plane->Distance( point )
           / slicedWorldGeometry->GetSpacing()[2] + 0.5);
       }
     }
     else
     {
       Point3D projectedPoint;
       for ( s = 0; s < slices; ++s )
       {
         slicedWorldGeometry->GetGeometry2D( s )->Project( point, projectedPoint );
         Vector3D distance = projectedPoint - point;
         ScalarType currentDistance = distance.GetSquaredNorm();
 
         if ( currentDistance < bestDistance )
         {
           bestDistance = currentDistance;
           bestSlice = s;
         }
       }
     }
     if ( bestSlice >= 0 )
     {
       this->GetSlice()->SetPos( bestSlice );
     }
     else
     {
       this->GetSlice()->SetPos( 0 );
     }
     this->SendCreatedWorldGeometryUpdate();
   }
 }
 
 
 void
 SliceNavigationController::ReorientSlices( const Point3D &point,
   const Vector3D &normal )
 {
   PlaneOperation op( OpORIENT, point, normal );
 
   m_CreatedWorldGeometry->ExecuteOperation( &op );
 
   this->SendCreatedWorldGeometryUpdate();
 }
 
 void SliceNavigationController::ReorientSlices(const mitk::Point3D &point,
    const mitk::Vector3D &axisVec0, const mitk::Vector3D &axisVec1 )
 {
    PlaneOperation op( OpORIENT, point, axisVec0, axisVec1 );
 
    m_CreatedWorldGeometry->ExecuteOperation( &op );
 
    this->SendCreatedWorldGeometryUpdate();
 }
 
 mitk::TimeGeometry *
 SliceNavigationController::GetCreatedWorldGeometry()
 {
   return m_CreatedWorldGeometry;
 }
 
 const mitk::Geometry3D *
 SliceNavigationController::GetCurrentGeometry3D()
 {
   if ( m_CreatedWorldGeometry.IsNotNull() )
   {
     return m_CreatedWorldGeometry->GetGeometryForTimeStep( this->GetTime()->GetPos() );
   }
   else
   {
     return NULL;
   }
 }
 
 
 const mitk::PlaneGeometry *
 SliceNavigationController::GetCurrentPlaneGeometry()
 {
   const mitk::SlicedGeometry3D *slicedGeometry =
     dynamic_cast< const mitk::SlicedGeometry3D * >
       ( this->GetCurrentGeometry3D() );
 
   if ( slicedGeometry )
   {
     const mitk::PlaneGeometry *planeGeometry =
       dynamic_cast< mitk::PlaneGeometry * >
         ( slicedGeometry->GetGeometry2D(this->GetSlice()->GetPos()) );
     return planeGeometry;
   }
   else
   {
     return NULL;
   }
 }
 
 
 void
 SliceNavigationController::SetRenderer( BaseRenderer *renderer )
 {
   m_Renderer = renderer;
 }
 
 BaseRenderer *
 SliceNavigationController::GetRenderer() const
 {
   return m_Renderer;
 }
 
 
 
 void
 SliceNavigationController::AdjustSliceStepperRange()
 {
   const mitk::SlicedGeometry3D *slicedGeometry =
     dynamic_cast< const mitk::SlicedGeometry3D * >
       ( this->GetCurrentGeometry3D() );
 
   const Vector3D &direction = slicedGeometry->GetDirectionVector();
 
   int c = 0;
   int i, k = 0;
   for ( i = 0; i < 3; ++i )
   {
     if ( fabs(direction[i]) < 0.000000001 ) { ++c; }
     else { k = i; }
   }
 
   if ( c == 2 )
   {
     ScalarType min = slicedGeometry->GetOrigin()[k];
     ScalarType max = min + slicedGeometry->GetExtentInMM( k );
 
     m_Slice->SetRange( min, max );
   }
   else
   {
     m_Slice->InvalidateRange();
   }
 
 }
 
 
 void
 SliceNavigationController::ExecuteOperation( Operation *operation )
 {
   // switch on type
   // - select best slice for a given point
   // - rotate created world geometry according to Operation->SomeInfo()
   if ( !operation )
   {
     return;
   }
 
   switch ( operation->GetOperationType() )
   {
     case OpMOVE: // should be a point operation
     {
       if ( !m_SliceLocked ) //do not move the cross position
       {
         // select a slice
         PointOperation *po = dynamic_cast< PointOperation * >( operation );
         if ( po && po->GetIndex() == -1 )
         {
           this->SelectSliceByPoint( po->GetPoint() );
         }
         else if ( po && po->GetIndex() != -1 ) // undo case because index != -1, index holds the old position of this slice
         {
           this->GetSlice()->SetPos( po->GetIndex() );
         }
       }
       break;
     }
     case OpRESTOREPLANEPOSITION:
       {
         m_CreatedWorldGeometry->ExecuteOperation( operation );
 
         this->SendCreatedWorldGeometryUpdate();
 
         break;
       }
     case OpAPPLYTRANSFORMMATRIX:
       {
         m_CreatedWorldGeometry->ExecuteOperation( operation );
 
         this->SendCreatedWorldGeometryUpdate();
 
         break;
       }
     default:
     {
       // do nothing
       break;
     }
   }
 }
 
 mitk::DataNode::Pointer SliceNavigationController::GetTopLayerNode(mitk::DataStorage::SetOfObjects::ConstPointer nodes,mitk::Point3D worldposition)
 {
   mitk::DataNode::Pointer node;
   int  maxlayer = -32768;
   bool isHelper (false);
   if(nodes.IsNotNull())
   {
     for (unsigned int x = 0; x < nodes->size(); x++)
     {
       nodes->at(x)->GetBoolProperty("helper object", isHelper);
       if(nodes->at(x)->GetData()->GetGeometry()->IsInside(worldposition) && isHelper == false)
       {
         int layer = 0;
         if(!(nodes->at(x)->GetIntProperty("layer", layer))) continue;
         if(layer > maxlayer)
         {
           if(static_cast<mitk::DataNode::Pointer>(nodes->at(x))->IsVisible(m_Renderer))
           {
             node = nodes->at(x);
             maxlayer = layer;
           }
         }
       }
     }
   }
   return node;
 }
 // Relict from the old times, when automous decisions were accepted
 // behavior. Remains in here, because some RenderWindows do exist outside
 // of StdMultiWidgets.
 bool
 SliceNavigationController
 ::ExecuteAction( Action* action, StateEvent const* stateEvent )
 {
   bool ok = false;
 
   const PositionEvent* posEvent = dynamic_cast< const PositionEvent * >(
     stateEvent->GetEvent() );
   if ( posEvent != NULL )
   {
     if ( m_CreatedWorldGeometry.IsNull() )
     {
       return true;
     }
     switch (action->GetActionId())
     {
     case AcMOVE:
       {
         BaseRenderer *baseRenderer = posEvent->GetSender();
         if ( !baseRenderer )
         {
           baseRenderer = const_cast<BaseRenderer *>(
             GlobalInteraction::GetInstance()->GetFocus() );
         }
         if ( baseRenderer )
           if ( baseRenderer->GetMapperID() == 1 )
           {
             PointOperation doOp(OpMOVE, posEvent->GetWorldPosition());
 
             this->ExecuteOperation( &doOp );
 
             // If click was performed in this render window than we have to update the status bar information about position and pixel value.
             if(baseRenderer == m_Renderer)
             {
               {
                 std::string statusText;
                 TNodePredicateDataType<mitk::Image>::Pointer isImageData = TNodePredicateDataType<mitk::Image>::New();
 
                 mitk::DataStorage::SetOfObjects::ConstPointer nodes = baseRenderer->GetDataStorage()->GetSubset(isImageData).GetPointer();
                 mitk::Point3D worldposition = posEvent->GetWorldPosition();
                 //int  maxlayer = -32768;
                 mitk::Image::Pointer image3D;
                 mitk::DataNode::Pointer node;
                 mitk::DataNode::Pointer topSourceNode;
 
                 bool isBinary (false);
 
                 node = this->GetTopLayerNode(nodes,worldposition);
                 if(node.IsNotNull())
                 {
                   node->GetBoolProperty("binary", isBinary);
                   if(isBinary)
                   {
                     mitk::DataStorage::SetOfObjects::ConstPointer sourcenodes = baseRenderer->GetDataStorage()->GetSources(node, NULL, true);
                     if(!sourcenodes->empty())
                     {
                       topSourceNode = this->GetTopLayerNode(sourcenodes,worldposition);
                     }
                     if(topSourceNode.IsNotNull())
                     {
                       image3D = dynamic_cast<mitk::Image*>(topSourceNode->GetData());
                     }
                     else
                     {
                       image3D = dynamic_cast<mitk::Image*>(node->GetData());
                     }
                   }
                   else
                   {
                     image3D = dynamic_cast<mitk::Image*>(node->GetData());
                   }
                 }
                 std::stringstream stream;
                 stream.imbue(std::locale::classic());
 
                 // get the position and gray value from the image and build up status bar text
                 if(image3D.IsNotNull())
                 {
-                  Index3D p;
+                  itk::Index<3> p;
                   image3D->GetGeometry()->WorldToIndex(worldposition, p);
                   stream.precision(2);
                   stream<<"Position: <" << std::fixed <<worldposition[0] << ", " << std::fixed << worldposition[1] << ", " << std::fixed << worldposition[2] << "> mm";
                   stream<<"; Index: <"<<p[0] << ", " << p[1] << ", " << p[2] << "> ";
                   mitk::ScalarType pixelValue = image3D->GetPixelValueByIndex(p, baseRenderer->GetTimeStep());
                   if (fabs(pixelValue)>1000000 || fabs(pixelValue) < 0.01)
                   {
                     stream<<"; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: " << std::scientific<< pixelValue <<"  ";
                   }
                   else
                   {
                     stream<<"; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: "<< pixelValue <<"  ";
                   }
                 }
                 else
                 {
                   stream << "No image information at this position!";
                 }
 
                 statusText = stream.str();
                 mitk::StatusBar::GetInstance()->DisplayGreyValueText(statusText.c_str());
 
               }
 
             }
             ok = true;
             break;
           }
       }
     default:
       ok = true;
       break;
     }
     return ok;
   }
 
   const DisplayPositionEvent *displPosEvent =
     dynamic_cast< const DisplayPositionEvent * >( stateEvent->GetEvent() );
 
   if ( displPosEvent != NULL )
   {
     return true;
   }
 
   return false;
 }
 
 } // namespace
 
diff --git a/Core/Code/DataManagement/mitkAbstractTransformGeometry.h b/Core/Code/DataManagement/mitkAbstractTransformGeometry.h
index 360f940175..99fbb2271f 100644
--- a/Core/Code/DataManagement/mitkAbstractTransformGeometry.h
+++ b/Core/Code/DataManagement/mitkAbstractTransformGeometry.h
@@ -1,193 +1,193 @@
 /*===================================================================
 
 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 MITKVTKABSTRACTTRANSFORMPLANEGEOMETRY_H_HEADER_INCLUDED_C1C68A2C
 #define MITKVTKABSTRACTTRANSFORMPLANEGEOMETRY_H_HEADER_INCLUDED_C1C68A2C
 
 #include <MitkCoreExports.h>
 #include "mitkGeometry2D.h"
 #include "mitkPlaneGeometry.h"
 #include "itkVtkAbstractTransform.h"
 
 class vtkAbstractTransform;
 
 namespace mitk {
 
 //##Documentation
 //## @brief Describes a geometry defined by an vtkAbstractTransform and a plane
 //##
 //## vtkAbstractTransform is the most general transform in vtk (superclass for
 //## all vtk geometric transformations). It defines an arbitrary 3D transformation,
 //## i.e., a transformation of 3D space into 3D space. In contrast,
 //## AbstractTransformGeometry (since it is a subclass of Geometry2D) describes a
 //## 2D manifold in 3D space. The 2D manifold is defined as the manifold that results
 //## from transforming a rectangle (given in m_Plane as a PlaneGeometry) by the
 //## vtkAbstractTransform (given in m_VtkAbstractTransform).
 //## The PlaneGeometry m_Plane is used to define the parameter space. 2D coordinates are
 //## first mapped by the PlaneGeometry and the resulting 3D coordinates are put into
 //## the vtkAbstractTransform.
 //## @note This class is the superclass of concrete geometries. Since there is no
 //## write access to the vtkAbstractTransform and m_Plane, this class is somehow
 //## abstract. For full write access from extern, use ExternAbstractTransformGeometry.
 //## @note The bounds of the PlaneGeometry are used as the parametric bounds.
 //## @sa ExternAbstractTransformGeometry
 //## @ingroup Geometry
 class MITK_CORE_EXPORT AbstractTransformGeometry : public Geometry2D
 {
 public:
   mitkClassMacro(AbstractTransformGeometry, Geometry2D);
 
   itkFactorylessNewMacro(Self)
   itkCloneMacro(Self)
 
   //##Documentation
   //## @brief Get the vtkAbstractTransform (stored in m_VtkAbstractTransform)
   virtual vtkAbstractTransform* GetVtkAbstractTransform() const;
 
   virtual unsigned long GetMTime() const;
 
   //##Documentation
   //## @brief Get the rectangular area that is used for transformation by
   //## m_VtkAbstractTransform and therewith defines the 2D manifold described by
   //## AbstractTransformGeometry
   itkGetConstObjectMacro(Plane, PlaneGeometry);
 
   /**
   * \brief projects the given point onto the curved plane
   */
   virtual bool Project(const mitk::Point3D &pt3d_mm, mitk::Point3D &projectedPt3d_mm) const;
 
   /**
   * \brief projects a given vector starting from given point onto the curved plane
   * \warning no satisfiyng implementation existing yet
   */
   virtual bool Project(const mitk::Point3D & atPt3d_mm, const mitk::Vector3D &vec3d_mm, mitk::Vector3D &projectedVec3d_mm) const;
 
   /**
   * \brief projects a given vector starting from standard point onto the curved plane
   * \warning no satisfying implementation existing yet
   */
   virtual bool Project(const mitk::Vector3D &vec3d_mm, mitk::Vector3D &projectedVec3d_mm) const;
 
   virtual bool Map(const mitk::Point3D &pt3d_mm, mitk::Point2D &pt2d_mm) const;
 
   virtual void Map(const mitk::Point2D &pt2d_mm, mitk::Point3D &pt3d_mm) const;
 
   virtual bool Map(const mitk::Point3D & atPt3d_mm, const mitk::Vector3D &vec3d_mm, mitk::Vector2D &vec2d_mm) const;
 
   virtual void Map(const mitk::Point2D & atPt2d_mm, const mitk::Vector2D &vec2d_mm, mitk::Vector3D &vec3d_mm) const;
 
   virtual void IndexToWorld(const mitk::Point2D &pt_units, mitk::Point2D &pt_mm) const;
 
   virtual void WorldToIndex(const mitk::Point2D &pt_mm, mitk::Point2D &pt_units) const;
 
   //##Documentation
   //## @brief Convert (continuous or discrete) index coordinates of a \em vector
   //## \a vec_units to world coordinates (in mm)
   //## @deprecated First parameter (Point2D) is not used. If possible, please use void IndexToWorld(const mitk::Vector2D& vec_units, mitk::Vector2D& vec_mm) const.
   //## For further information about coordinates types, please see the Geometry documentation
   virtual void IndexToWorld(const mitk::Point2D &atPt2d_units, const mitk::Vector2D &vec_units, mitk::Vector2D &vec_mm) const;
 
   //##Documentation
   //## @brief Convert (continuous or discrete) index coordinates of a \em vector
   //## \a vec_units to world coordinates (in mm)
   //## For further information about coordinates types, please see the Geometry documentation
   virtual void IndexToWorld(const mitk::Vector2D &vec_units, mitk::Vector2D &vec_mm) const;
 
   //##Documentation
   //## @brief Convert world coordinates (in mm) of a \em vector
   //## \a vec_mm to (continuous!) index coordinates.
   //## @deprecated First parameter (Point2D) is not used. If possible, please use void WorldToIndex(const mitk::Vector2D& vec_mm, mitk::Vector2D& vec_units) const.
   //## For further information about coordinates types, please see the Geometry documentation
   virtual void WorldToIndex(const mitk::Point2D &atPt2d_mm, const mitk::Vector2D &vec_mm, mitk::Vector2D &vec_units) const;
 
   //##Documentation
   //## @brief Convert world coordinates (in mm) of a \em vector
   //## \a vec_mm to (continuous!) index coordinates.
   //## For further information about coordinates types, please see the Geometry documentation
   virtual void WorldToIndex(const mitk::Vector2D &vec_mm, mitk::Vector2D &vec_units) const;
 
   virtual bool IsAbove(const Point3D& pt3d_mm) const;
 
   virtual mitk::ScalarType GetParametricExtentInMM(int direction) const;
 
-  virtual const itk::Transform<ScalarType, 3, 3>* GetParametricTransform() const;
+  virtual const itk::Transform<mitk::ScalarType, 3, 3>* GetParametricTransform() const;
 
   //##Documentation
   //## @brief Change the parametric bounds to @a oversampling times
   //## the bounds of m_Plane.
   //##
   //## The change is done once (immediately). Later changes of the bounds
   //## of m_Plane will not influence the parametric bounds. (Consequently,
   //## there is no method to get the oversampling.)
   virtual void SetOversampling(mitk::ScalarType oversampling);
 
   virtual void Initialize();
 
   //##Documentation
   //## @brief Calculates the standard part of a Geometry3D
   //## (IndexToWorldTransform and bounding box) around the
   //## curved geometry. Has to be implemented in subclasses.
   //##
   //## \sa SetFrameGeometry
   virtual void CalculateFrameGeometry();
 
   //##Documentation
   //## @brief Set the frame geometry which is used as the standard
   //## part of an Geometry3D (IndexToWorldTransform and bounding box)
   //##
   //## Maybe used as a hint within which the interpolation shall occur
   //## by concrete sub-classes.
   //## \sa CalculateFrameGeometry
   virtual void SetFrameGeometry(const mitk::Geometry3D* frameGeometry);
 
   virtual itk::LightObject::Pointer InternalClone() const;
 protected:
   AbstractTransformGeometry();
   AbstractTransformGeometry(const AbstractTransformGeometry& other);
 
   virtual ~AbstractTransformGeometry();
 
   //##Documentation
   //## @brief Set the vtkAbstractTransform (stored in m_VtkAbstractTransform)
   //##
   //## Protected in this class, made public in ExternAbstractTransformGeometry.
   virtual void SetVtkAbstractTransform(vtkAbstractTransform* aVtkAbstractTransform);
 
   //##Documentation
   //## @brief Set the rectangular area that is used for transformation by
   //## m_VtkAbstractTransform and therewith defines the 2D manifold described by
   //## ExternAbstractTransformGeometry
   //##
   //## Protected in this class, made public in ExternAbstractTransformGeometry.
   //## @note The bounds of the PlaneGeometry are used as the parametric bounds.
   //## @note The PlaneGeometry is cloned, @em not linked/referenced.
   virtual void SetPlane(const mitk::PlaneGeometry* aPlane);
 
   //##Documentation
   //## @brief The rectangular area that is used for transformation by
   //## m_VtkAbstractTransform and therewith defines the 2D manifold described by
   //## AbstractTransformGeometry.
   mitk::PlaneGeometry::Pointer m_Plane;
 
   itk::VtkAbstractTransform<ScalarType>::Pointer m_ItkVtkAbstractTransform;
 
   mitk::Geometry3D::Pointer m_FrameGeometry;
 };
 
 } // namespace mitk
 #endif /* MITKVTKABSTRACTTRANSFORMPLANEGEOMETRY_H_HEADER_INCLUDED_C1C68A2C */
diff --git a/Core/Code/DataManagement/mitkGeometry3D.h b/Core/Code/DataManagement/mitkGeometry3D.h
index c27a4d961c..5ae7410272 100644
--- a/Core/Code/DataManagement/mitkGeometry3D.h
+++ b/Core/Code/DataManagement/mitkGeometry3D.h
@@ -1,826 +1,826 @@
 /*===================================================================
 
 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 GEOMETRY3D_H_HEADER_INCLUDED_C1EBD0AD
 #define GEOMETRY3D_H_HEADER_INCLUDED_C1EBD0AD
 
 #include <MitkCoreExports.h>
 #include <mitkCommon.h>
 #include "mitkTypes.h"
 #include "mitkOperationActor.h"
 
 #include <itkIndex.h>
 #include <itkBoundingBox.h>
 #include <itkQuaternionRigidTransform.h>
 #include <itkAffineGeometryFrame.h>
 #include "itkScalableAffineTransform.h"
 #include "itkBoundingBox.h"
 
 class vtkLinearTransform;
 class vtkMatrixToLinearTransform;
 class vtkMatrix4x4;
 
 namespace mitk {
    //##Documentation
    //## @brief Standard 3D-BoundingBox typedef
    //##
    //## Standard 3D-BoundingBox typedef to get rid of template arguments (3D, type).
    typedef itk::BoundingBox<unsigned long, 3, ScalarType>   BoundingBox;
 
    //##Documentation
    //## @brief Standard typedef for time-bounds
    typedef itk::FixedArray<ScalarType,2>  TimeBounds;
    typedef itk::FixedArray<ScalarType, 3> FixedArrayType;
 
    typedef itk::AffineGeometryFrame<ScalarType, 3>        AffineGeometryFrame3D;
 
    //##Documentation
    //## @brief Describes the geometry of a data object
    //##
    //## At least, it can return the bounding box of the data object.
    //##
    //## The class holds
    //## \li a bounding box which is axes-parallel in intrinsic coordinates
    //## (often integer indices of pixels), to be accessed by
    //## GetBoundingBox()
    //## \li a transform to convert intrinsic coordinates into a
    //## world-coordinate system with coordinates in millimeters
    //## and milliseconds (all are floating point values), to
    //## be accessed by GetIndexToWorldTransform()
    //## \li a life span, i.e. a bounding box in time in ms (with
    //## start and end time), to be accessed by GetTimeBounds().
    //## The default is minus infinity to plus infinity.
    //##
    //## Geometry3D and its sub-classes allow converting between
    //## intrinsic coordinates (called index or unit coordinates)
    //## and world-coordinates (called world or mm coordinates),
    //## e.g. WorldToIndex.
    //## In case you need integer index coordinates, provide an
-   //## mitk::Index3D (or itk::Index) as target variable to
+   //## itk::Index<3> (or itk::Index) as target variable to
    //## WorldToIndex, otherwise you will get a continuous index
    //## (floating point values).
    //##
    //## An important sub-class is SlicedGeometry3D, which descibes
    //## data objects consisting of slices, e.g., objects of type Image.
    //## Conversions between world coordinates (in mm) and unit coordinates
    //## (e.g., pixels in the case of an Image) can be performed.
    //##
    //## For more information on related classes, see \ref Geometry.
    //##
    //## Geometry3D instances referring to an Image need a slightly
    //## different definition of corners, see SetImageGeometry. This
    //## is usualy automatically called by Image.
    //##
    //## Geometry3D have to be initialized in the method GenerateOutputInformation()
    //## of BaseProcess (or CopyInformation/ UpdateOutputInformation of BaseData,
    //## if possible, e.g., by analyzing pic tags in Image) subclasses. See also
    //## itk::ProcessObject::GenerateOutputInformation(),
    //## itk::DataObject::CopyInformation() and
    //## itk::DataObject::UpdateOutputInformation().
    //##
    //## Rule: everything is in mm (ms) if not stated otherwise.
    //## @ingroup Geometry
    class MITK_CORE_EXPORT Geometry3D : public itk::Object, public OperationActor
    {
    public:
       mitkClassMacro(Geometry3D, itk::Object);
 
       typedef itk::QuaternionRigidTransform< ScalarType > QuaternionTransformType;
       typedef QuaternionTransformType::VnlQuaternionType VnlQuaternionType;
 
       /** Method for creation through the object factory. */
       itkFactorylessNewMacro(Self)
       itkCloneMacro(Self)
 
       typedef itk::ScalableAffineTransform<ScalarType, 3>    TransformType;
       typedef itk::BoundingBox<unsigned long, 3, ScalarType> BoundingBoxType;
       typedef BoundingBoxType::BoundsArrayType               BoundsArrayType;
       typedef BoundingBoxType::Pointer                       BoundingBoxPointer;
 
       // a bit of a misuse, but we want only doxygen to see the following:
 #ifdef DOXYGEN_SKIP
       //##Documentation
       //## @brief Get the transformation used to convert from index
       //## to world coordinates
       itkGetObjectMacro(IndexToWorldTransform, AffineTransform3D);
 #endif
       //## @brief Set the transformation used to convert from index
       //## to world coordinates
       virtual void SetIndexToWorldTransform(mitk::AffineTransform3D* transform);
       //##Documentation
       //## @brief Convenience method for setting the ITK transform
       //## (m_IndexToWorldTransform) via an vtkMatrix4x4
       //## \sa SetIndexToWorldTransform
       virtual void SetIndexToWorldTransformByVtkMatrix(vtkMatrix4x4* vtkmatrix);
 
 #ifdef DOXYGEN_SKIP
       //##Documentation
       //## @brief Get bounding box (in index/unit coordinates)
       itkGetConstObjectMacro(BoundingBox, BoundingBoxType);
       //##Documentation
       //## @brief Get bounding box (in index/unit coordinates) as a BoundsArrayType
       const BoundsArrayType GetBounds() const
       {
          assert(m_BoundingBox.IsNotNull());
          return m_BoundingBox->GetBounds();
       }
 #endif
       //##Documentation
       //## \brief Set the bounding box (in index/unit coordinates)
       //##
       //## Only possible via the BoundsArray to make clear that a
       //## copy of the bounding-box is stored, not a reference to it.
       virtual void SetBounds(const BoundsArrayType& bounds);
       //##Documentation
       //## @brief Set the bounding box (in index/unit coordinates) via a float array
       virtual void SetFloatBounds(const float bounds[6]);
       //##Documentation
       //## @brief Set the bounding box (in index/unit coordinates) via a double array
       virtual void SetFloatBounds(const double bounds[6]);
 
       //##Documentation
       //## @brief When switching from an Image Geometry to a normal Geometry (and the other way around), you have to change the origin as well (See Geometry Documentation)! This function will change the "isImageGeometry" bool flag and changes the origin respectively.
       virtual void ChangeImageGeometryConsideringOriginOffset( const bool isAnImageGeometry );
 
       //##Documentation
       //## @brief Checks, if the given geometry can be converted to 2D without information loss
       //## e.g. when a 2D image is saved, the matrix is usually cropped to 2x2, and when you load it back to MITK
       //## it will be filled with standard values. This function checks, if information would be lost during this
       //## procedure
       virtual bool Is2DConvertable();
 
       //##Documentation
       //## @brief Get the time bounds (in ms)
       itkGetConstReferenceMacro(TimeBounds, TimeBounds);
       //##Documentation
       //## @brief Set the time bounds (in ms)
       virtual void SetTimeBounds(const TimeBounds& timebounds);
 
       //##Documentation
       //## @brief Get the position of the corner number \a id (in world coordinates)
       //##
       //## See SetImageGeometry for how a corner is defined on images.
       Point3D GetCornerPoint(int id) const;
 
       //##Documentation
       //## @brief Get the position of a corner (in world coordinates)
       //##
       //## See SetImageGeometry for how a corner is defined on images.
       Point3D GetCornerPoint(bool xFront=true, bool yFront=true, bool zFront=true) const;
 
       //##Documentation
       //## @brief Get vector along bounding-box in the specified @a direction in mm
       //##
       //## The length of the vector is the size of the bounding-box in the
       //## specified @a direction in mm
       //## \sa GetMatrixColumn
       Vector3D GetAxisVector(unsigned int direction) const
       {
          Vector3D frontToBack;
          frontToBack.SetVnlVector(m_IndexToWorldTransform->GetMatrix().GetVnlMatrix().get_column(direction));
          frontToBack *= GetExtent(direction);
          return frontToBack;
       }
 
       //##Documentation
       //## @brief Get the center of the bounding-box in mm
       //##
       Point3D GetCenter() const
       {
          assert(m_BoundingBox.IsNotNull());
          return m_IndexToWorldTransform->TransformPoint(m_BoundingBox->GetCenter());
       }
 
       //##Documentation
       //## @brief Get the squared length of the diagonal of the bounding-box in mm
       //##
       double GetDiagonalLength2() const
       {
          Vector3D diagonalvector = GetCornerPoint()-GetCornerPoint(false, false, false);
          return diagonalvector.GetSquaredNorm();
       }
 
       //##Documentation
       //## @brief Get the length of the diagonal of the bounding-box in mm
       //##
       double GetDiagonalLength() const
       {
          return sqrt(GetDiagonalLength2());
       }
 
       //##Documentation
       //## @brief Get a VnlVector along bounding-box in the specified
       //## @a direction, length is spacing
       //##
       //## \sa GetAxisVector
       VnlVector GetMatrixColumn(unsigned int direction) const
       {
          return m_IndexToWorldTransform->GetMatrix().GetVnlMatrix().get_column(direction);
       }
 
 #ifdef DOXYGEN_SKIP
       //##Documentation
       //## @brief Get the extent of the bounding box (in index/unit coordinates)
       //##
       //## To access the extent in mm use GetExtentInMM
       ScalarType GetExtent(unsigned int direction) const;
 #endif
 
       //##Documentation
       //## @brief Get the extent of the bounding-box in the specified @a direction in mm
       //##
       //## Equals length of GetAxisVector(direction).
       ScalarType GetExtentInMM(int direction) const
       {
          return m_IndexToWorldTransform->GetMatrix().GetVnlMatrix().get_column(direction).magnitude()*GetExtent(direction);
       }
 
       //##Documentation
       //## @brief Set the extent of the bounding-box in the specified @a direction in mm
       //##
       //## @note This changes the matrix in the transform, @a not the bounds, which are given in units!
       virtual void SetExtentInMM(int direction, ScalarType extentInMM);
 
       //##Documentation
       //## @brief Get the m_IndexToWorldTransform as a vtkLinearTransform
       vtkLinearTransform* GetVtkTransform() const
       {
          return (vtkLinearTransform*)m_VtkIndexToWorldTransform;
       }
 
       //##Documentation
       //## @brief Set the origin, i.e. the upper-left corner of the plane
       //##
       virtual void SetOrigin(const Point3D& origin);
 
       //##Documentation
       //## @brief Translate the origin by a vector
       //##
       virtual void Translate(const Vector3D&  vector);
 
       //##Documentation
       //## @brief Set the transform to identity
       //##
       virtual void SetIdentity();
 
       //##Documentation
       //## @brief Compose new IndexToWorldTransform with a given transform.
       //##
       //## This method composes m_IndexToWorldTransform with another transform,
       //## modifying self to be the composition of self and other.
       //## If the argument pre is true, then other is precomposed with self;
       //## that is, the resulting transformation consists of first applying
       //## other to the source, followed by self. If pre is false or omitted,
       //## then other is post-composed with self; that is the resulting
       //## transformation consists of first applying self to the source,
       //## followed by other.
       virtual void Compose( const Geometry3D::TransformType * other, bool pre = 0 );
 
       //##Documentation
       //## @brief Compose new IndexToWorldTransform with a given vtkMatrix4x4.
       //##
       //## Converts the vtkMatrix4x4 into a itk-transform and calls the previous method.
       virtual void Compose( const vtkMatrix4x4 * vtkmatrix, bool pre = 0 );
 
       //##Documentation
       //## @brief Get the origin, e.g. the upper-left corner of the plane
       const Point3D& GetOrigin() const
       {
          return m_Origin;
       }
 
       //##Documentation
       //## @brief Get the origin as VnlVector
       //##
       //## \sa GetOrigin
       VnlVector GetOriginVnl() const
       {
          return const_cast<Self*>(this)->m_Origin.GetVnlVector();
       }
 
       //##Documentation
       //## @brief Convert world coordinates (in mm) of a \em point to (continuous!) index coordinates
       //## \warning If you need (discrete) integer index coordinates (e.g., for iterating easily over an image),
       //## use WorldToIndex(const mitk::Point3D& pt_mm, itk::Index<VIndexDimension> &index).
       //## For further information about coordinates types, please see the Geometry documentation
       void WorldToIndex(const mitk::Point3D& pt_mm, mitk::Point3D& pt_units) const;
 
       //##Documentation
       //## @brief Convert (continuous or discrete) index coordinates of a \em point to world coordinates (in mm)
       //## For further information about coordinates types, please see the Geometry documentation
       void IndexToWorld(const mitk::Point3D& pt_units, mitk::Point3D& pt_mm) const;
 
       //##Documentation
       //## @brief Convert (discrete) index coordinates of a \em point to world coordinates (in mm)
       //## For further information about coordinates types, please see the Geometry documentation
       template <unsigned int VIndexDimension>
       void IndexToWorld(const itk::Index<VIndexDimension> &index, mitk::Point3D& pt_mm ) const
       {
          mitk::Point3D pt_units;
          pt_units.Fill(0);
          int i, dim=index.GetIndexDimension();
          if(dim>3)
          {
             dim=3;
          }
          for(i=0;i<dim;++i)
          {
             pt_units[i] = index[i];
          }
 
          IndexToWorld(pt_units,pt_mm);
       }
 
       //##Documentation
       //## @brief Convert world coordinates (in mm) of a \em vector
       //## \a vec_mm to (continuous!) index coordinates.
       //## @deprecated First parameter (Point3D) is not used. If possible, please use void WorldToIndex(const mitk::Vector3D& vec_mm, mitk::Vector3D& vec_units) const.
       //## For further information about coordinates types, please see the Geometry documentation
       void WorldToIndex(const mitk::Point3D& atPt3d_mm, const mitk::Vector3D& vec_mm, mitk::Vector3D& vec_units) const;
 
       //##Documentation
       //## @brief Convert world coordinates (in mm) of a \em vector
       //## \a vec_mm to (continuous!) index coordinates.
       //## For further information about coordinates types, please see the Geometry documentation
       void WorldToIndex(const mitk::Vector3D& vec_mm, mitk::Vector3D& vec_units) const;
 
       //##Documentation
       //## @brief Convert (continuous or discrete) index coordinates of a \em vector
       //## \a vec_units to world coordinates (in mm)
       //## @deprecated First parameter (Point3D) is not used. If possible, please use void IndexToWorld(const mitk::Vector3D& vec_units, mitk::Vector3D& vec_mm) const.
       //## For further information about coordinates types, please see the Geometry documentation
       void IndexToWorld(const mitk::Point3D& atPt3d_units, const mitk::Vector3D& vec_units, mitk::Vector3D& vec_mm) const;
 
       //##Documentation
       //## @brief Convert (continuous or discrete) index coordinates of a \em vector
       //## \a vec_units to world coordinates (in mm)
       //## For further information about coordinates types, please see the Geometry documentation
       void IndexToWorld(const mitk::Vector3D& vec_units, mitk::Vector3D& vec_mm) const;
 
       //##Documentation
       //## @brief Convert world coordinates (in mm) of a \em point to (discrete!) index coordinates.
       //## This method rounds to integer indices!
       //## For further information about coordinates types, please see the Geometry documentation
       template <unsigned int VIndexDimension>
       void WorldToIndex(const mitk::Point3D& pt_mm, itk::Index<VIndexDimension> &index) const
       {
          typedef itk::Index<VIndexDimension> IndexType;
          mitk::Point3D pt_units;
          this->WorldToIndex(pt_mm, pt_units);
          int i, dim=index.GetIndexDimension();
          if(dim>3)
          {
             index.Fill(0);
             dim=3;
          }
          for(i=0;i<dim;++i){
             index[i]=itk::Math::RoundHalfIntegerUp<typename IndexType::IndexValueType>( pt_units[i] );
          }
       }
 
       //##Documentation
       //## @brief Deprecated for use with ITK version 3.10 or newer.
       //## Convert world coordinates (in mm) of a \em point to
       //## ITK physical coordinates (in mm, but without a possible rotation)
       //##
       //## This method is useful if you have want to access an mitk::Image
       //## via an itk::Image. ITK v3.8 and older did not support rotated (tilted)
       //## images, i.e., ITK images are always parallel to the coordinate axes.
       //## When accessing a (possibly rotated) mitk::Image via an itk::Image
       //## the rotational part of the transformation in the Geometry3D is
       //## simply discarded; in other word: only the origin and spacing is
       //## used by ITK, not the complete matrix available in MITK.
       //## With WorldToItkPhysicalPoint you can convert an MITK world
       //## coordinate (including the rotation) into a coordinate that
       //## can be used with the ITK image as a ITK physical coordinate
       //## (excluding the rotation).
       template<class TCoordRep>
       void WorldToItkPhysicalPoint(const mitk::Point3D& pt_mm,
          itk::Point<TCoordRep, 3>& itkPhysicalPoint) const
       {
          mitk::vtk2itk(pt_mm, itkPhysicalPoint);
       }
 
       //##Documentation
       //## @brief Deprecated for use with ITK version 3.10 or newer.
       //## Convert ITK physical coordinates of a \em point (in mm,
       //## but without a rotation) into MITK world coordinates (in mm)
       //##
       //## For more information, see WorldToItkPhysicalPoint.
       template<class TCoordRep>
       void ItkPhysicalPointToWorld(const itk::Point<TCoordRep, 3>& itkPhysicalPoint,
          mitk::Point3D& pt_mm) const
       {
          mitk::vtk2itk(itkPhysicalPoint, pt_mm);
       }
 
       //##Documentation
       //## @brief Initialize the Geometry3D
       virtual void Initialize();
 
       //##Documentation
       //## @brief Is this an ImageGeometry?
       //##
       //## For more information, see SetImageGeometry
       itkGetConstMacro(ImageGeometry, bool);
       //##Documentation
       //## @brief Define that this Geometry3D is refering to an Image
       //##
       //## A geometry referring to an Image needs a slightly different
       //## definition of the position of the corners (see GetCornerPoint).
       //## The position of a voxel is defined by the position of its center.
       //## If we would use the origin (position of the (center of) the first
       //## voxel) as a corner and display this point, it would seem to be
       //## \em not at the corner but a bit within the image. Even worse for
       //## the opposite corner of the image: here the corner would appear
       //## outside the image (by half of the voxel diameter). Thus, we have
       //## to correct for this and to be able to do that, we need to know
       //## that the Geometry3D is referring to an Image.
       itkSetMacro(ImageGeometry, bool);
       itkBooleanMacro(ImageGeometry);
 
       //##Documentation
       //## @brief Is this Geometry3D in a state that is valid?
       virtual bool IsValid() const
       {
          return m_Valid;
       }
 
       //##Documentation
       //## @brief Test whether the point \a p (world coordinates in mm) is
       //## inside the bounding box
       bool IsInside(const mitk::Point3D& p) const
       {
          mitk::Point3D index;
          WorldToIndex(p, index);
          return IsIndexInside(index);
       }
 
       //##Documentation
       //## @brief Test whether the point \a p ((continous!)index coordinates in units) is
       //## inside the bounding box
       bool IsIndexInside(const mitk::Point3D& index) const
       {
          bool inside = false;
          //if it is an image geometry, we need to convert the index to discrete values
          //this is done by applying the rounding function also used in WorldToIndex (see line 323)
          if (m_ImageGeometry)
          {
             mitk::Point3D discretIndex;
             discretIndex[0]=itk::Math::RoundHalfIntegerUp<mitk::ScalarType>( index[0] );
             discretIndex[1]=itk::Math::RoundHalfIntegerUp<mitk::ScalarType>( index[1] );
             discretIndex[2]=itk::Math::RoundHalfIntegerUp<mitk::ScalarType>( index[2] );
 
             inside = m_BoundingBox->IsInside(discretIndex);
             //we have to check if the index is at the upper border of each dimension,
             // because the boundingbox is not centerbased
             if (inside)
             {
                const BoundingBox::BoundsArrayType& bounds = m_BoundingBox->GetBounds();
                if((discretIndex[0] == bounds[1]) ||
                   (discretIndex[1] == bounds[3]) ||
                   (discretIndex[2] == bounds[5]))
                   inside = false;
             }
          }
          else
             inside = m_BoundingBox->IsInside(index);
 
          return inside;
       }
 
       //##Documentation
       //## @brief Convenience method for working with ITK indices
       template <unsigned int VIndexDimension>
       bool IsIndexInside(const itk::Index<VIndexDimension> &index) const
       {
          int i, dim=index.GetIndexDimension();
          Point3D pt_index;
          pt_index.Fill(0);
          for ( i = 0; i < dim; ++i )
          {
             pt_index[i] = index[i];
          }
          return IsIndexInside(pt_index);
       }
 
       //##Documentation
       //## @brief Get the spacing (size of a pixel).
       //##
       itkGetConstReferenceMacro(Spacing, mitk::Vector3D);
 
       //##Documentation
       //## @brief Get the spacing as a float[3] array.
       const float* GetFloatSpacing() const;
 
       //##Documentation
       //## @brief Set the spacing (m_Spacing)
       virtual void SetSpacing(const mitk::Vector3D& aSpacing);
 
       //##Documentation
       //## @brief Get the DICOM FrameOfReferenceID referring to the
       //## used world coordinate system
       itkGetConstMacro(FrameOfReferenceID, unsigned int);
       //##Documentation
       //## @brief Set the DICOM FrameOfReferenceID referring to the
       //## used world coordinate system
       itkSetMacro(FrameOfReferenceID, unsigned int);
 
       //##Documentation
       //## @brief Copy the ITK transform
       //## (m_IndexToWorldTransform) to the VTK transform
       //## \sa SetIndexToWorldTransform
       void TransferItkToVtkTransform();
 
       //##Documentation
       //## @brief Copy the VTK transform
       //## to the ITK transform (m_IndexToWorldTransform)
       //## \sa SetIndexToWorldTransform
       void TransferVtkToItkTransform();
 
       //##Documentation
       //## @brief Get the parametric bounding-box
       //##
       //## See AbstractTransformGeometry for an example usage of this.
       itkGetConstObjectMacro(ParametricBoundingBox, BoundingBox);
       //##Documentation
       //## @brief Get the parametric bounds
       //##
       //## See AbstractTransformGeometry for an example usage of this.
       const BoundingBox::BoundsArrayType& GetParametricBounds() const
       {
          assert(m_ParametricBoundingBox.IsNotNull());
          return m_ParametricBoundingBox->GetBounds();
       }
 
       //##Documentation
       //## @brief Get the parametric extent
       //##
       //## See AbstractTransformGeometry for an example usage of this.
       mitk::ScalarType GetParametricExtent(int direction) const
       {
          if (direction < 0 || direction>=3)
             mitkThrow() << "Invalid direction. Must be between either 0, 1 or 2. ";
          assert(m_ParametricBoundingBox.IsNotNull());
 
          BoundingBoxType::BoundsArrayType bounds = m_ParametricBoundingBox->GetBounds();
          return bounds[direction*2+1]-bounds[direction*2];
       }
 
       //##Documentation
       //## @brief Get the parametric extent in mm
       //##
       //## See AbstractTransformGeometry for an example usage of this.
       virtual mitk::ScalarType GetParametricExtentInMM(int direction) const
       {
          return GetExtentInMM(direction);
       }
 
       //##Documentation
       //## @brief Get the parametric transform
       //##
       //## See AbstractTransformGeometry for an example usage of this.
-      virtual const itk::Transform<ScalarType, 3, 3>* GetParametricTransform() const
+      virtual const itk::Transform<mitk::ScalarType, 3, 3>* GetParametricTransform() const
       {
          return m_IndexToWorldTransform;
       }
 
       //##Documentation
       //## @brief Calculates a bounding-box around the geometry relative
       //## to a coordinate system defined by a transform
       //##
       mitk::BoundingBox::Pointer CalculateBoundingBoxRelativeToTransform(const mitk::AffineTransform3D* transform) const;
 
       //##Documentation
       //## @brief clones the geometry
       //##
       //## Overwrite in all sub-classes.
       //## Normally looks like:
       //## \code
       //##  Self::Pointer newGeometry = new Self(*this);
       //##  newGeometry->UnRegister();
       //##  return newGeometry.GetPointer();
       //## \endcode
       virtual itk::LightObject::Pointer InternalClone() const;
 
       //##Documentation
       //##@brief executes affine operations (translate, rotate, scale)
       virtual void ExecuteOperation(Operation* operation);
 
       /** Set/Get the IndexToWorldTransform */
       itkGetConstObjectMacro(IndexToWorldTransform, AffineTransform3D);
       itkGetObjectMacro(IndexToWorldTransform, AffineTransform3D);
       /** Get the bounding box */
       itkGetConstObjectMacro(BoundingBox, BoundingBoxType);
 
       const BoundsArrayType GetBounds() const
       {
          assert(m_BoundingBox.IsNotNull());
          return m_BoundingBox->GetBounds();
       }
 
       /** Get the extent of the bounding box */
       ScalarType GetExtent(unsigned int direction) const
       {
          assert(m_BoundingBox.IsNotNull());
          if (direction>=NDimensions)
             mitkThrow() << "Direction is too big. This geometry is for 3D Data";
          BoundsArrayType bounds = m_BoundingBox->GetBounds();
          return bounds[direction*2+1]-bounds[direction*2];
       }
    protected:
       Geometry3D();
       Geometry3D(const Geometry3D& other);
 
       virtual void InitializeGeometry(Self * newGeometry) const;
 
       static const std::string GetTransformAsString( TransformType* transformType );
       static const unsigned int NDimensions = 3;
 
       virtual ~Geometry3D();
 
       virtual void PrintSelf(std::ostream& os, itk::Indent indent) const;
 
       virtual void BackTransform(const mitk::Point3D& in, mitk::Point3D& out) const;
       //##Documentation
       //## @brief Deprecated
       virtual void BackTransform(const mitk::Point3D& at, const mitk::Vector3D& in, mitk::Vector3D& out) const;
 
       //Without redundant parameter Point3D
       virtual void BackTransform(const mitk::Vector3D& in, mitk::Vector3D& out) const;
 
       //##Documentation
       //## @brief Set the parametric bounds
       //##
       //## Protected in this class, made public in some sub-classes, e.g.,
       //## ExternAbstractTransformGeometry.
       virtual void SetParametricBounds(const BoundingBox::BoundsArrayType& bounds);
 
       /** Resets sub-transforms that compose m_IndexToWorldTransform, by using
       * the current value of m_IndexToWorldTransform and setting the rotation
       * component to zero. */
       virtual void ResetSubTransforms();
 
       mutable mitk::BoundingBox::Pointer m_ParametricBoundingBox;
 
       mutable mitk::TimeBounds m_TimeBounds;
 
       vtkMatrix4x4* m_VtkMatrix;
 
       bool m_ImageGeometry;
 
       AffineTransform3D::Pointer m_IndexToWorldTransform;
       mutable BoundingBoxPointer m_BoundingBox;
 
       //##Documentation
       //## @brief Spacing of the data. Only significant if the geometry describes
       //## an Image (m_ImageGeometry==true).
       mitk::Vector3D m_Spacing;
 
       bool m_Valid;
 
       unsigned int m_FrameOfReferenceID;
 
       static const std::string INDEX_TO_OBJECT_TRANSFORM;
       static const std::string OBJECT_TO_NODE_TRANSFORM;
       static const std::string INDEX_TO_NODE_TRANSFORM;
       static const std::string INDEX_TO_WORLD_TRANSFORM;
 
    private:
       mutable TransformType::Pointer m_InvertedTransform;
       mutable unsigned long m_IndexToWorldTransformLastModified;
 
       VnlQuaternionType m_RotationQuaternion;
 
       float m_FloatSpacing[3];
       vtkMatrixToLinearTransform* m_VtkIndexToWorldTransform;
 
       //##Documentation
       //## @brief Origin, i.e. upper-left corner of the plane
       //##
       Point3D m_Origin;
    };
 
    //
    // Static compare functions mainly for testing
    //
    /**
    * @brief Equal A function comparing two geometries for beeing identical.
    * @warning This method is deprecated and will not be available in the future. Use the \a bool mitk::Equal(const mitk::mitk::Geometry3D& g1, const mitk::Geometry3D& g2) instead.
    *
    * @ingroup MITKTestingAPI
    *
    * The function compares the spacing, origin, axisvectors, extents, the matrix of the
    * IndexToWorldTransform (elementwise), the bounding (elementwise) and the ImageGeometry flag.
    *
    * The parameter eps is a tolarence value for all methods which are internally used for comparion.
    * If you want to use different tolarance values for different parts of the geometry, feel free to use
    * the other comparison methods and write your own implementation of Equal.
    * @param rightHandSide Compare this against leftHandSide.
    * @param leftHandSide Compare this against rightHandSide.
    * @param eps Tolarence for comparison. You can use mitk::eps in most cases.
    * @param verbose Flag indicating if the user wants detailed console output or not.
    * @return True, if all comparison are true. False in any other case.
    */
    DEPRECATED( MITK_CORE_EXPORT bool Equal(const mitk::Geometry3D* leftHandSide, const mitk::Geometry3D* rightHandSide, ScalarType eps, bool verbose));
 
    /**
    * @brief Equal A function comparing two geometries for beeing identical.
    *
    * @ingroup MITKTestingAPI
    *
    * The function compares the spacing, origin, axisvectors, extents, the matrix of the
    * IndexToWorldTransform (elementwise), the bounding (elementwise) and the ImageGeometry flag.
    *
    * The parameter eps is a tolarence value for all methods which are internally used for comparion.
    * If you want to use different tolarance values for different parts of the geometry, feel free to use
    * the other comparison methods and write your own implementation of Equal.
    * @param rightHandSide Compare this against leftHandSide.
    * @param leftHandSide Compare this against rightHandSide.
    * @param eps Tolarence for comparison. You can use mitk::eps in most cases.
    * @param verbose Flag indicating if the user wants detailed console output or not.
    * @return True, if all comparison are true. False in any other case.
    */
    MITK_CORE_EXPORT bool Equal(const mitk::Geometry3D& leftHandSide, const mitk::Geometry3D& rightHandSide, ScalarType eps, bool verbose);
 
    /**
    * @brief Equal A function comparing two transforms (TransformType) for beeing identical.
    * @warning This method is deprecated and will not be available in the future. Use the \a bool mitk::Equal(const mitk::mitk::Geometry3D::TransformType& t1, const mitk::Geometry3D::TransformType& t2) instead.
    *
    * @ingroup MITKTestingAPI
    *
    * The function compares the IndexToWorldTransform (elementwise).
    *
    * The parameter eps is a tolarence value for all methods which are internally used for comparion.
    * @param rightHandSide Compare this against leftHandSide.
    * @param leftHandSide Compare this against rightHandSide.
    * @param eps Tolarence for comparison. You can use mitk::eps in most cases.
    * @param verbose Flag indicating if the user wants detailed console output or not.
    * @return True, if all comparison are true. False in any other case.
    */
    DEPRECATED( MITK_CORE_EXPORT bool Equal(const mitk::Geometry3D::TransformType *leftHandSide, const mitk::Geometry3D::TransformType *rightHandSide, ScalarType eps, bool verbose));
 
    /**
    * @brief Equal A function comparing two transforms (TransformType) for beeing identical.
    *
    * @ingroup MITKTestingAPI
    *
    * The function compares the IndexToWorldTransform (elementwise).
    *
    * The parameter eps is a tolarence value for all methods which are internally used for comparion.
    * @param rightHandSide Compare this against leftHandSide.
    * @param leftHandSide Compare this against rightHandSide.
    * @param eps Tolarence for comparison. You can use mitk::eps in most cases.
    * @param verbose Flag indicating if the user wants detailed console output or not.
    * @return True, if all comparison are true. False in any other case.
    */
    MITK_CORE_EXPORT bool Equal(const mitk::Geometry3D::TransformType& leftHandSide, const mitk::Geometry3D::TransformType& rightHandSide, ScalarType eps, bool verbose);
 
    /**
    * @brief Equal A function comparing two bounding boxes (BoundingBoxType) for beeing identical.
    * @warning This method is deprecated and will not be available in the future. Use the \a bool mitk::Equal(const mitk::mitk::Geometry3D::BoundingBoxType& b1, const mitk::Geometry3D::BoundingBoxType& b2) instead.
    *
    * @ingroup MITKTestingAPI
    *
    * The function compares the bounds (elementwise).
    *
    * The parameter eps is a tolarence value for all methods which are internally used for comparion.
    * @param rightHandSide Compare this against leftHandSide.
    * @param leftHandSide Compare this against rightHandSide.
    * @param eps Tolarence for comparison. You can use mitk::eps in most cases.
    * @param verbose Flag indicating if the user wants detailed console output or not.
    * @return True, if all comparison are true. False in any other case.
    */
    DEPRECATED( MITK_CORE_EXPORT bool Equal( const mitk::Geometry3D::BoundingBoxType *leftHandSide, const mitk::Geometry3D::BoundingBoxType *rightHandSide, ScalarType eps, bool verbose));
 
    /**
    * @brief Equal A function comparing two bounding boxes (BoundingBoxType) for beeing identical.
    *
    * @ingroup MITKTestingAPI
    *
    * The function compares the bounds (elementwise).
    *
    * The parameter eps is a tolarence value for all methods which are internally used for comparion.
    * @param rightHandSide Compare this against leftHandSide.
    * @param leftHandSide Compare this against rightHandSide.
    * @param eps Tolarence for comparison. You can use mitk::eps in most cases.
    * @param verbose Flag indicating if the user wants detailed console output or not.
    * @return True, if all comparison are true. False in any other case.
    */
    MITK_CORE_EXPORT bool Equal( const  mitk::Geometry3D::BoundingBoxType& leftHandSide, const mitk::Geometry3D::BoundingBoxType& rightHandSide, ScalarType eps, bool verbose);
 } // namespace mitk
 
 #endif /* GEOMETRY3D_H_HEADER_INCLUDED_C1EBD0AD */
diff --git a/Core/Code/DataManagement/mitkImage.cpp b/Core/Code/DataManagement/mitkImage.cpp
index bf86a0dad7..ba9db44458 100644
--- a/Core/Code/DataManagement/mitkImage.cpp
+++ b/Core/Code/DataManagement/mitkImage.cpp
@@ -1,1383 +1,1383 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 //MITK
 #include "mitkImage.h"
 #include "mitkImageStatisticsHolder.h"
 #include "mitkPixelTypeMultiplex.h"
 #include <mitkProportionalTimeGeometry.h>
 #include "mitkCompareImageDataFilter.h"
 
 //VTK
 #include <vtkImageData.h>
 
 //Other
 #include <cmath>
 
 #define FILL_C_ARRAY( _arr, _size, _value) for(unsigned int i=0u; i<_size; i++) \
 { _arr[i] = _value; }
 
 
 mitk::Image::Image() :
   m_Dimension(0), m_Dimensions(NULL), m_ImageDescriptor(NULL), m_OffsetTable(NULL), m_CompleteData(NULL),
   m_ImageStatistics(NULL)
 {
   m_Dimensions = new unsigned int[MAX_IMAGE_DIMENSIONS];
   FILL_C_ARRAY( m_Dimensions, MAX_IMAGE_DIMENSIONS, 0u);
 
   m_Initialized = false;
 }
 
 mitk::Image::Image(const Image &other) : SlicedData(other), m_Dimension(0), m_Dimensions(NULL),
   m_ImageDescriptor(NULL), m_OffsetTable(NULL), m_CompleteData(NULL), m_ImageStatistics(NULL)
 {
   m_Dimensions = new unsigned int[MAX_IMAGE_DIMENSIONS];
   FILL_C_ARRAY( m_Dimensions, MAX_IMAGE_DIMENSIONS, 0u);
 
   this->Initialize( other.GetPixelType(), other.GetDimension(), other.GetDimensions());
 
   //Since the above called "Initialize" method doesn't take the geometry into account we need to set it
   //here manually
   TimeGeometry::Pointer cloned = other.GetTimeGeometry()->Clone();
   this->SetTimeGeometry(cloned.GetPointer());
 
   if (this->GetDimension() > 3)
   {
     const unsigned int time_steps = this->GetDimension(3);
 
     for (unsigned int i = 0u; i < time_steps; ++i)
     {
       ImageDataItemPointer volume = const_cast<Image&>(other).GetVolumeData(i);
 
       this->SetVolume(volume->GetData(), i);
     }
   }
   else
   {
     ImageDataItemPointer volume = const_cast<Image&>(other).GetVolumeData(0);
 
     this->SetVolume(volume->GetData(), 0);
   }
 }
 
 mitk::Image::~Image()
 {
   Clear();
   m_ReferenceCountLock.Lock();
   m_ReferenceCount = 3;
   m_ReferenceCountLock.Unlock();
   m_ReferenceCountLock.Lock();
   m_ReferenceCount = 0;
   m_ReferenceCountLock.Unlock();
   if(m_OffsetTable != NULL)
     delete [] m_OffsetTable;
 
   if(m_ImageStatistics != NULL)
     delete m_ImageStatistics;
 }
 
 const mitk::PixelType mitk::Image::GetPixelType(int n) const
 {
   return this->m_ImageDescriptor->GetChannelTypeById(n);
 }
 
 unsigned int mitk::Image::GetDimension() const
 {
   return m_Dimension;
 }
 
 unsigned int mitk::Image::GetDimension(int i) const
 {
   if((i>=0) && (i<(int)m_Dimension))
     return m_Dimensions[i];
   return 1;
 }
 
 void* mitk::Image::GetData()
 {
   if(m_Initialized==false)
   {
     if(GetSource().IsNull())
       return NULL;
     if(GetSource()->Updating()==false)
       GetSource()->UpdateOutputInformation();
   }
   m_CompleteData=GetChannelData();
 
   // update channel's data
   // if data was not available at creation point, the m_Data of channel descriptor is NULL
   // if data present, it won't be overwritten
   m_ImageDescriptor->GetChannelDescriptor(0).SetData(m_CompleteData->GetData());
 
   return m_CompleteData->GetData();
 }
 
 
 template <class T>
 void AccessPixel( const mitk::PixelType ptype, void* data, const unsigned int offset, double& value )
 {
   value = 0.0;
   if( data == NULL ) return;
 
   if(ptype.GetBpe() != 24)
   {
     value = (double) (((T*) data)[ offset ]);
   }
   else
   {
     const unsigned int rgboffset = 3 * offset;
 
     double returnvalue = (((T*) data)[rgboffset ]);
     returnvalue += (((T*) data)[rgboffset + 1]);
     returnvalue += (((T*) data)[rgboffset + 2]);
     value = returnvalue;
   }
 
 }
 
-double mitk::Image::GetPixelValueByIndex(const mitk::Index3D &position, unsigned int timestep)
+double mitk::Image::GetPixelValueByIndex(const itk::Index<3> &position, unsigned int timestep)
 {
   double value = 0;
   if (this->GetTimeSteps() < timestep)
   {
     timestep = this->GetTimeSteps();
   }
 
   value = 0.0;
 
   const unsigned int* imageDims = this->m_ImageDescriptor->GetDimensions();
   const mitk::PixelType ptype = this->m_ImageDescriptor->GetChannelTypeById(0);
 
   // Comparison ?>=0 not needed since all position[i] and timestep are unsigned int
   // (position[0]>=0 && position[1] >=0 && position[2]>=0 && timestep>=0)
   // bug-11978 : we still need to catch index with negative values
   if ( position[0] < 0 ||
        position[1] < 0 ||
        position[2] < 0 )
   {
     MITK_WARN << "Given position ("<< position << ") is out of image range, returning 0." ;
   }
   // check if the given position is inside the index range of the image, the 3rd dimension needs to be compared only if the dimension is not 0
   else if ( (unsigned int)position[0] >= imageDims[0] ||
             (unsigned int)position[1] >= imageDims[1] ||
             ( imageDims[2] && (unsigned int)position[2] >= imageDims[2] ))
   {
     MITK_WARN << "Given position ("<< position << ") is out of image range, returning 0." ;
   }
   else
   {
     const unsigned int offset = position[0] + position[1]*imageDims[0] + position[2]*imageDims[0]*imageDims[1] + timestep*imageDims[0]*imageDims[1]*imageDims[2];
 
     mitkPixelTypeMultiplex3( AccessPixel, ptype, this->GetData(), offset, value );
   }
 
   return value;
 }
 
 double mitk::Image::GetPixelValueByWorldCoordinate(const mitk::Point3D& position, unsigned int timestep)
 {
   double value = 0.0;
   if (this->GetTimeSteps() < timestep)
   {
     timestep = this->GetTimeSteps();
   }
 
-  Index3D itkIndex;
+  itk::Index<3> itkIndex;
   this->GetGeometry()->WorldToIndex(position, itkIndex);
 
   value = this->GetPixelValueByIndex( itkIndex, timestep);
 
   return value;
 }
 
 mitk::ImageVtkAccessor* mitk::Image::GetVtkImageData(int t, int n)
 {
   if(m_Initialized==false)
   {
     if(GetSource().IsNull())
       return NULL;
     if(GetSource()->Updating()==false)
       GetSource()->UpdateOutputInformation();
   }
   ImageDataItemPointer volume=GetVolumeData(t, n);
   if(volume.GetPointer()==NULL || volume->GetVtkImageData(this) == NULL)
     return NULL;
 
   SlicedGeometry3D* geom3d = GetSlicedGeometry(t);
   float *fspacing = const_cast<float *>(geom3d->GetFloatSpacing());
   double dspacing[3] = {fspacing[0],fspacing[1],fspacing[2]};
   volume->GetVtkImageData(this)->SetSpacing( dspacing );
 
   return volume->GetVtkImageData(this);
 }
 
 mitk::Image::ImageDataItemPointer mitk::Image::GetSliceData(int s, int t, int n, void *data, ImportMemoryManagementType importMemoryManagement)
 {
   if(IsValidSlice(s,t,n)==false) return NULL;
 
   const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
 
   // slice directly available?
   int pos=GetSliceIndex(s,t,n);
   if(m_Slices[pos].GetPointer()!=NULL)
     return m_Slices[pos];
 
   // is slice available as part of a volume that is available?
   ImageDataItemPointer sl, ch, vol;
   vol=m_Volumes[GetVolumeIndex(t,n)];
   if((vol.GetPointer()!=NULL) && (vol->IsComplete()))
   {
     sl=new ImageDataItem(*vol, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, ((size_t) s)*m_OffsetTable[2]*(ptypeSize));
     sl->SetComplete(true);
     return m_Slices[pos]=sl;
   }
 
   // is slice available as part of a channel that is available?
   ch=m_Channels[n];
   if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
   {
     sl=new ImageDataItem(*ch, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, (((size_t) s)*m_OffsetTable[2]+((size_t) t)*m_OffsetTable[3])*(ptypeSize));
     sl->SetComplete(true);
     return m_Slices[pos]=sl;
   }
 
   // slice is unavailable. Can we calculate it?
   if((GetSource().IsNotNull()) && (GetSource()->Updating()==false))
   {
     // ... wir mussen rechnen!!! ....
     m_RequestedRegion.SetIndex(0, 0);
     m_RequestedRegion.SetIndex(1, 0);
     m_RequestedRegion.SetIndex(2, s);
     m_RequestedRegion.SetIndex(3, t);
     m_RequestedRegion.SetIndex(4, n);
     m_RequestedRegion.SetSize(0, m_Dimensions[0]);
     m_RequestedRegion.SetSize(1, m_Dimensions[1]);
     m_RequestedRegion.SetSize(2, 1);
     m_RequestedRegion.SetSize(3, 1);
     m_RequestedRegion.SetSize(4, 1);
     m_RequestedRegionInitialized=true;
     GetSource()->Update();
     if(IsSliceSet(s,t,n))
       //yes: now we can call ourselves without the risk of a endless loop (see "if" above)
       return GetSliceData(s,t,n,data,importMemoryManagement);
     else
       return NULL;
   }
   else
   {
     ImageDataItemPointer item = AllocateSliceData(s,t,n,data,importMemoryManagement);
     item->SetComplete(true);
     return item;
   }
 }
 
 mitk::Image::ImageDataItemPointer mitk::Image::GetVolumeData(int t, int n, void *data, ImportMemoryManagementType importMemoryManagement)
 {
   if(IsValidVolume(t,n)==false) return NULL;
 
   ImageDataItemPointer ch, vol;
 
   // volume directly available?
   int pos=GetVolumeIndex(t,n);
   vol=m_Volumes[pos];
   if((vol.GetPointer()!=NULL) && (vol->IsComplete()))
     return vol;
 
   const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
 
   // is volume available as part of a channel that is available?
   ch=m_Channels[n];
   if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
   {
     vol=new ImageDataItem(*ch, m_ImageDescriptor, 3, data, importMemoryManagement == ManageMemory, (((size_t) t)*m_OffsetTable[3])*(ptypeSize));
     vol->SetComplete(true);
     return m_Volumes[pos]=vol;
   }
 
   // let's see if all slices of the volume are set, so that we can (could) combine them to a volume
   bool complete=true;
   unsigned int s;
   for(s=0;s<m_Dimensions[2];++s)
   {
     if(m_Slices[GetSliceIndex(s,t,n)].GetPointer()==NULL)
     {
       complete=false;
       break;
     }
   }
   if(complete)
   {
     // if there is only single slice we do not need to combine anything
     if(m_Dimensions[2]<=1)
     {
       ImageDataItemPointer sl;
       sl=GetSliceData(0,t,n,data,importMemoryManagement);
       vol=new ImageDataItem(*sl, m_ImageDescriptor, 3, data, importMemoryManagement == ManageMemory);
       vol->SetComplete(true);
     }
     else
     {
       mitk::PixelType chPixelType = this->m_ImageDescriptor->GetChannelTypeById(n);
 
       vol=m_Volumes[pos];
       // ok, let's combine the slices!
       if(vol.GetPointer()==NULL)
         vol=new ImageDataItem( chPixelType, 3, m_Dimensions, NULL, true);
       vol->SetComplete(true);
       size_t size=m_OffsetTable[2]*(ptypeSize);
       for(s=0;s<m_Dimensions[2];++s)
       {
         int posSl;
         ImageDataItemPointer sl;
         posSl=GetSliceIndex(s,t,n);
 
         sl=m_Slices[posSl];
         if(sl->GetParent()!=vol)
         {
           // copy data of slices in volume
           size_t offset = ((size_t) s)*size;
           std::memcpy(static_cast<char*>(vol->GetData())+offset, sl->GetData(), size);
 
           // FIXME mitkIpPicDescriptor * pic = sl->GetPicDescriptor();
 
           // replace old slice with reference to volume
           sl=new ImageDataItem(*vol, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, ((size_t) s)*size);
           sl->SetComplete(true);
           //mitkIpFuncCopyTags(sl->GetPicDescriptor(), pic);
           m_Slices[posSl]=sl;
         }
       }
       //if(vol->GetPicDescriptor()->info->tags_head==NULL)
       //  mitkIpFuncCopyTags(vol->GetPicDescriptor(), m_Slices[GetSliceIndex(0,t,n)]->GetPicDescriptor());
     }
     return m_Volumes[pos]=vol;
   }
 
   // volume is unavailable. Can we calculate it?
   if((GetSource().IsNotNull()) && (GetSource()->Updating()==false))
   {
     // ... wir muessen rechnen!!! ....
     m_RequestedRegion.SetIndex(0, 0);
     m_RequestedRegion.SetIndex(1, 0);
     m_RequestedRegion.SetIndex(2, 0);
     m_RequestedRegion.SetIndex(3, t);
     m_RequestedRegion.SetIndex(4, n);
     m_RequestedRegion.SetSize(0, m_Dimensions[0]);
     m_RequestedRegion.SetSize(1, m_Dimensions[1]);
     m_RequestedRegion.SetSize(2, m_Dimensions[2]);
     m_RequestedRegion.SetSize(3, 1);
     m_RequestedRegion.SetSize(4, 1);
     m_RequestedRegionInitialized=true;
     GetSource()->Update();
     if(IsVolumeSet(t,n))
       //yes: now we can call ourselves without the risk of a endless loop (see "if" above)
       return GetVolumeData(t,n,data,importMemoryManagement);
     else
       return NULL;
   }
   else
   {
     ImageDataItemPointer item = AllocateVolumeData(t,n,data,importMemoryManagement);
     item->SetComplete(true);
     return item;
   }
 
 }
 
 mitk::Image::ImageDataItemPointer mitk::Image::GetChannelData(int n, void *data, ImportMemoryManagementType importMemoryManagement)
 {
   if(IsValidChannel(n)==false) return NULL;
   ImageDataItemPointer ch, vol;
   ch=m_Channels[n];
   if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
     return ch;
 
   // let's see if all volumes are set, so that we can (could) combine them to a channel
   if(IsChannelSet(n))
   {
     // if there is only one time frame we do not need to combine anything
     if(m_Dimensions[3]<=1)
     {
       vol=GetVolumeData(0,n,data,importMemoryManagement);
       ch=new ImageDataItem(*vol, m_ImageDescriptor, m_ImageDescriptor->GetNumberOfDimensions(), data, importMemoryManagement == ManageMemory);
       ch->SetComplete(true);
     }
     else
     {
       const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
 
       ch=m_Channels[n];
       // ok, let's combine the volumes!
       if(ch.GetPointer()==NULL)
         ch=new ImageDataItem(this->m_ImageDescriptor, NULL, true);
       ch->SetComplete(true);
       size_t size=m_OffsetTable[m_Dimension-1]*(ptypeSize);
       unsigned int t;
       ImageDataItemPointerArray::iterator slicesIt = m_Slices.begin()+n*m_Dimensions[2]*m_Dimensions[3];
       for(t=0;t<m_Dimensions[3];++t)
       {
         int posVol;
         ImageDataItemPointer vol;
 
         posVol=GetVolumeIndex(t,n);
         vol=GetVolumeData(t,n,data,importMemoryManagement);
 
         if(vol->GetParent()!=ch)
         {
           // copy data of volume in channel
           size_t offset = ((size_t) t)*m_OffsetTable[3]*(ptypeSize);
           std::memcpy(static_cast<char*>(ch->GetData())+offset, vol->GetData(), size);
 
           // REVEIW FIX mitkIpPicDescriptor * pic = vol->GetPicDescriptor();
 
           // replace old volume with reference to channel
           vol=new ImageDataItem(*ch, m_ImageDescriptor, 3, data, importMemoryManagement == ManageMemory, offset);
           vol->SetComplete(true);
           //mitkIpFuncCopyTags(vol->GetPicDescriptor(), pic);
 
           m_Volumes[posVol]=vol;
 
           // get rid of slices - they may point to old volume
           ImageDataItemPointer dnull=NULL;
           for(unsigned int i = 0; i < m_Dimensions[2]; ++i, ++slicesIt)
           {
             assert(slicesIt != m_Slices.end());
             *slicesIt = dnull;
           }
         }
       }
       // REVIEW FIX
       //   if(ch->GetPicDescriptor()->info->tags_head==NULL)
       //     mitkIpFuncCopyTags(ch->GetPicDescriptor(), m_Volumes[GetVolumeIndex(0,n)]->GetPicDescriptor());
     }
     return m_Channels[n]=ch;
   }
 
   // channel is unavailable. Can we calculate it?
   if((GetSource().IsNotNull()) && (GetSource()->Updating()==false))
   {
     // ... wir muessen rechnen!!! ....
     m_RequestedRegion.SetIndex(0, 0);
     m_RequestedRegion.SetIndex(1, 0);
     m_RequestedRegion.SetIndex(2, 0);
     m_RequestedRegion.SetIndex(3, 0);
     m_RequestedRegion.SetIndex(4, n);
     m_RequestedRegion.SetSize(0, m_Dimensions[0]);
     m_RequestedRegion.SetSize(1, m_Dimensions[1]);
     m_RequestedRegion.SetSize(2, m_Dimensions[2]);
     m_RequestedRegion.SetSize(3, m_Dimensions[3]);
     m_RequestedRegion.SetSize(4, 1);
     m_RequestedRegionInitialized=true;
     GetSource()->Update();
     // did it work?
     if(IsChannelSet(n))
       //yes: now we can call ourselves without the risk of a endless loop (see "if" above)
       return GetChannelData(n,data,importMemoryManagement);
     else
       return NULL;
   }
   else
   {
     ImageDataItemPointer item = AllocateChannelData(n,data,importMemoryManagement);
     item->SetComplete(true);
     return item;
   }
 }
 
 bool mitk::Image::IsSliceSet(int s, int t, int n) const
 {
   if(IsValidSlice(s,t,n)==false) return false;
 
   if(m_Slices[GetSliceIndex(s,t,n)].GetPointer()!=NULL)
     return true;
 
   ImageDataItemPointer ch, vol;
   vol=m_Volumes[GetVolumeIndex(t,n)];
   if((vol.GetPointer()!=NULL) && (vol->IsComplete()))
     return true;
   ch=m_Channels[n];
   if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
     return true;
   return false;
 }
 
 bool mitk::Image::IsVolumeSet(int t, int n) const
 {
   if(IsValidVolume(t,n)==false) return false;
   ImageDataItemPointer ch, vol;
 
   // volume directly available?
   vol=m_Volumes[GetVolumeIndex(t,n)];
   if((vol.GetPointer()!=NULL) && (vol->IsComplete()))
     return true;
 
   // is volume available as part of a channel that is available?
   ch=m_Channels[n];
   if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
     return true;
 
   // let's see if all slices of the volume are set, so that we can (could) combine them to a volume
   unsigned int s;
   for(s=0;s<m_Dimensions[2];++s)
     if(m_Slices[GetSliceIndex(s,t,n)].GetPointer()==NULL)
       return false;
   return true;
 }
 
 bool mitk::Image::IsChannelSet(int n) const
 {
   if(IsValidChannel(n)==false) return false;
   ImageDataItemPointer ch, vol;
   ch=m_Channels[n];
   if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
 
     return true;
   // let's see if all volumes are set, so that we can (could) combine them to a channel
   unsigned int t;
   for(t=0;t<m_Dimensions[3];++t)
     if(IsVolumeSet(t,n)==false)
       return false;
   return true;
 }
 
 bool mitk::Image::SetSlice(const void *data, int s, int t, int n)
 {
   // const_cast is no risk for ImportMemoryManagementType == CopyMemory
   return SetImportSlice(const_cast<void*>(data), s, t, n, CopyMemory);
 }
 
 bool mitk::Image::SetVolume(const void *data, int t, int n)
 {
   // const_cast is no risk for ImportMemoryManagementType == CopyMemory
   return SetImportVolume(const_cast<void*>(data), t, n, CopyMemory);
 }
 
 bool mitk::Image::SetChannel(const void *data, int n)
 {
   // const_cast is no risk for ImportMemoryManagementType == CopyMemory
   return SetImportChannel(const_cast<void*>(data), n, CopyMemory);
 }
 
 bool mitk::Image::SetImportSlice(void *data, int s, int t, int n, ImportMemoryManagementType importMemoryManagement)
 {
   if(IsValidSlice(s,t,n)==false) return false;
   ImageDataItemPointer sl;
   const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
 
   if(IsSliceSet(s,t,n))
   {
     sl=GetSliceData(s,t,n,data,importMemoryManagement);
     if(sl->GetManageMemory()==false)
     {
       sl=AllocateSliceData(s,t,n,data,importMemoryManagement);
       if(sl.GetPointer()==NULL) return false;
     }
     if ( sl->GetData() != data )
       std::memcpy(sl->GetData(), data, m_OffsetTable[2]*(ptypeSize));
     sl->Modified();
     //we have changed the data: call Modified()!
     Modified();
   }
   else
   {
     sl=AllocateSliceData(s,t,n,data,importMemoryManagement);
     if(sl.GetPointer()==NULL) return false;
     if ( sl->GetData() != data )
       std::memcpy(sl->GetData(), data, m_OffsetTable[2]*(ptypeSize));
     //we just added a missing slice, which is not regarded as modification.
     //Therefore, we do not call Modified()!
   }
   return true;
 }
 
 bool mitk::Image::SetImportVolume(void *data, int t, int n, ImportMemoryManagementType importMemoryManagement)
 {
   if(IsValidVolume(t,n)==false) return false;
 
   const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
   ImageDataItemPointer vol;
   if(IsVolumeSet(t,n))
   {
     vol=GetVolumeData(t,n,data,importMemoryManagement);
     if(vol->GetManageMemory()==false)
     {
       vol=AllocateVolumeData(t,n,data,importMemoryManagement);
       if(vol.GetPointer()==NULL) return false;
     }
     if ( vol->GetData() != data )
       std::memcpy(vol->GetData(), data, m_OffsetTable[3]*(ptypeSize));
     vol->Modified();
     vol->SetComplete(true);
     //we have changed the data: call Modified()!
     Modified();
   }
   else
   {
     vol=AllocateVolumeData(t,n,data,importMemoryManagement);
     if(vol.GetPointer()==NULL) return false;
     if ( vol->GetData() != data )
     {
       std::memcpy(vol->GetData(), data, m_OffsetTable[3]*(ptypeSize));
     }
     vol->SetComplete(true);
     this->m_ImageDescriptor->GetChannelDescriptor(n).SetData( vol->GetData() );
     //we just added a missing Volume, which is not regarded as modification.
     //Therefore, we do not call Modified()!
   }
   return true;
 }
 
 bool mitk::Image::SetImportChannel(void *data, int n, ImportMemoryManagementType importMemoryManagement)
 {
   if(IsValidChannel(n)==false) return false;
 
   // channel descriptor
 
   const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
 
   ImageDataItemPointer ch;
   if(IsChannelSet(n))
   {
     ch=GetChannelData(n,data,importMemoryManagement);
     if(ch->GetManageMemory()==false)
     {
       ch=AllocateChannelData(n,data,importMemoryManagement);
       if(ch.GetPointer()==NULL) return false;
     }
     if ( ch->GetData() != data )
       std::memcpy(ch->GetData(), data, m_OffsetTable[4]*(ptypeSize));
     ch->Modified();
     ch->SetComplete(true);
     //we have changed the data: call Modified()!
     Modified();
   }
   else
   {
     ch=AllocateChannelData(n,data,importMemoryManagement);
     if(ch.GetPointer()==NULL) return false;
     if ( ch->GetData() != data )
       std::memcpy(ch->GetData(), data, m_OffsetTable[4]*(ptypeSize));
     ch->SetComplete(true);
 
     this->m_ImageDescriptor->GetChannelDescriptor(n).SetData( ch->GetData() );
     //we just added a missing Channel, which is not regarded as modification.
     //Therefore, we do not call Modified()!
   }
   return true;
 }
 
 void mitk::Image::Initialize()
 {
   ImageDataItemPointerArray::iterator it, end;
   for( it=m_Slices.begin(), end=m_Slices.end(); it!=end; ++it )
   {
     (*it)=NULL;
   }
   for( it=m_Volumes.begin(), end=m_Volumes.end(); it!=end; ++it )
   {
     (*it)=NULL;
   }
   for( it=m_Channels.begin(), end=m_Channels.end(); it!=end; ++it )
   {
     (*it)=NULL;
   }
   m_CompleteData = NULL;
 
   if( m_ImageStatistics == NULL)
   {
     m_ImageStatistics = new mitk::ImageStatisticsHolder( this );
   }
 
   SetRequestedRegionToLargestPossibleRegion();
 }
 
 void mitk::Image::Initialize(const mitk::ImageDescriptor::Pointer inDesc)
 {
   // store the descriptor
   this->m_ImageDescriptor = inDesc;
 
   // initialize image
   this->Initialize( inDesc->GetChannelDescriptor(0).GetPixelType(), inDesc->GetNumberOfDimensions(), inDesc->GetDimensions(), 1 );
 }
 
 void mitk::Image::Initialize(const mitk::PixelType& type, unsigned int dimension, const unsigned int *dimensions, unsigned int channels)
 {
   Clear();
 
   m_Dimension=dimension;
 
   if(!dimensions)
     itkExceptionMacro(<< "invalid zero dimension image");
 
   unsigned int i;
   for(i=0;i<dimension;++i)
   {
     if(dimensions[i]<1)
       itkExceptionMacro(<< "invalid dimension[" << i << "]: " << dimensions[i]);
   }
 
   // create new array since the old was deleted
   m_Dimensions = new unsigned int[MAX_IMAGE_DIMENSIONS];
 
   // initialize the first four dimensions to 1, the remaining 4 to 0
   FILL_C_ARRAY(m_Dimensions, 4, 1u);
   FILL_C_ARRAY((m_Dimensions+4), 4, 0u);
 
   // copy in the passed dimension information
   std::memcpy(m_Dimensions, dimensions, sizeof(unsigned int)*m_Dimension);
 
   this->m_ImageDescriptor = mitk::ImageDescriptor::New();
   this->m_ImageDescriptor->Initialize( this->m_Dimensions, this->m_Dimension );
 
   for(i=0;i<4;++i)
   {
     m_LargestPossibleRegion.SetIndex(i, 0);
     m_LargestPossibleRegion.SetSize (i, m_Dimensions[i]);
   }
   m_LargestPossibleRegion.SetIndex(i, 0);
   m_LargestPossibleRegion.SetSize(i, channels);
 
   if(m_LargestPossibleRegion.GetNumberOfPixels()==0)
   {
     delete [] m_Dimensions;
     m_Dimensions = NULL;
     return;
   }
 
   for( unsigned int i=0u; i<channels; i++)
   {
     this->m_ImageDescriptor->AddNewChannel( type );
   }
 
   PlaneGeometry::Pointer planegeometry = PlaneGeometry::New();
   planegeometry->InitializeStandardPlane(m_Dimensions[0], m_Dimensions[1]);
 
   SlicedGeometry3D::Pointer slicedGeometry = SlicedGeometry3D::New();
   slicedGeometry->InitializeEvenlySpaced(planegeometry, m_Dimensions[2]);
 
   if(dimension>=4)
   {
     TimeBounds timebounds;
     timebounds[0] = 0.0;
     timebounds[1] = 1.0;
     slicedGeometry->SetTimeBounds(timebounds);
   }
 
   ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
   timeGeometry->Initialize(slicedGeometry, m_Dimensions[3]);
   for (TimeStepType step = 0; step < timeGeometry->CountTimeSteps(); ++step)
   {
     timeGeometry->GetGeometryForTimeStep(step)->ImageGeometryOn();
   }
   SetTimeGeometry(timeGeometry);
 
   ImageDataItemPointer dnull=NULL;
 
   m_Channels.assign(GetNumberOfChannels(), dnull);
 
   m_Volumes.assign(GetNumberOfChannels()*m_Dimensions[3], dnull);
 
   m_Slices.assign(GetNumberOfChannels()*m_Dimensions[3]*m_Dimensions[2], dnull);
 
   ComputeOffsetTable();
 
   Initialize();
 
   m_Initialized = true;
 }
 
 void mitk::Image::Initialize(const mitk::PixelType& type, const mitk::Geometry3D& geometry, unsigned int channels, int tDim )
 {
   mitk::ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
   Geometry3D::Pointer geometry3D = geometry.Clone();
   timeGeometry->Initialize(geometry3D.GetPointer(), tDim);
   this->Initialize(type, *timeGeometry, channels, tDim);
 }
 
 void mitk::Image::Initialize(const mitk::PixelType& type, const mitk::TimeGeometry& geometry, unsigned int channels, int tDim )
 {
   unsigned int dimensions[5];
   dimensions[0] = (unsigned int)(geometry.GetGeometryForTimeStep(0)->GetExtent(0)+0.5);
   dimensions[1] = (unsigned int)(geometry.GetGeometryForTimeStep(0)->GetExtent(1)+0.5);
   dimensions[2] = (unsigned int)(geometry.GetGeometryForTimeStep(0)->GetExtent(2)+0.5);
   dimensions[3] = (tDim > 0) ? tDim : geometry.CountTimeSteps();
   dimensions[4] = 0;
 
   unsigned int dimension = 2;
   if ( dimensions[2] > 1 )
     dimension = 3;
   if ( dimensions[3] > 1 )
     dimension = 4;
 
   Initialize( type, dimension, dimensions, channels );
   if (geometry.CountTimeSteps() > 1)
   {
     TimeGeometry::Pointer cloned = geometry.Clone();
     SetTimeGeometry(cloned.GetPointer());
   }
   else
     Superclass::SetGeometry(geometry.GetGeometryForTimeStep(0));
 /* //Old //TODO_GOETZ Really necessary?
   mitk::BoundingBox::BoundsArrayType bounds = geometry.GetBoundingBoxInWorld()->GetBounds();
   if( (bounds[0] != 0.0) || (bounds[2] != 0.0) || (bounds[4] != 0.0) )
   {
     SlicedGeometry3D* slicedGeometry = GetSlicedGeometry(0);
 
     mitk::Point3D origin; origin.Fill(0.0);
     slicedGeometry->IndexToWorld(origin, origin);
 
     bounds[1]-=bounds[0]; bounds[3]-=bounds[2]; bounds[5]-=bounds[4];
     bounds[0] = 0.0;      bounds[2] = 0.0;      bounds[4] = 0.0;
     this->m_ImageDescriptor->Initialize( this->m_Dimensions, this->m_Dimension );
     slicedGeometry->SetBounds(bounds);
     slicedGeometry->GetIndexToWorldTransform()->SetOffset(origin.GetVnlVector().data_block());
 
     ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
     timeGeometry->Initialize(slicedGeometry, m_Dimensions[3]);
     SetTimeGeometry(timeGeometry);
   }*/
 }
 
 void mitk::Image::Initialize(const mitk::PixelType& type, int sDim, const mitk::Geometry2D& geometry2d, bool flipped, unsigned int channels, int tDim )
 {
   SlicedGeometry3D::Pointer slicedGeometry = SlicedGeometry3D::New();
   slicedGeometry->InitializeEvenlySpaced(static_cast<Geometry2D*>(geometry2d.Clone().GetPointer()), sDim, flipped);
   Initialize(type, *slicedGeometry, channels, tDim);
 }
 
 void mitk::Image::Initialize(const mitk::Image* image)
 {
   Initialize(image->GetPixelType(), *image->GetTimeGeometry());
 }
 
 void mitk::Image::Initialize(vtkImageData* vtkimagedata, int channels, int tDim, int sDim, int pDim)
 {
   if(vtkimagedata==NULL) return;
 
   m_Dimension=vtkimagedata->GetDataDimension();
   unsigned int i, *tmpDimensions=new unsigned int[m_Dimension>4?m_Dimension:4];
   for(i=0;i<m_Dimension;++i) tmpDimensions[i]=vtkimagedata->GetDimensions()[i];
   if(m_Dimension<4)
   {
     unsigned int *p;
     for(i=0,p=tmpDimensions+m_Dimension;i<4-m_Dimension;++i, ++p)
       *p=1;
   }
 
   if(pDim>=0)
   {
     tmpDimensions[1]=pDim;
     if(m_Dimension < 2)
       m_Dimension = 2;
   }
   if(sDim>=0)
   {
     tmpDimensions[2]=sDim;
     if(m_Dimension < 3)
       m_Dimension = 3;
   }
   if(tDim>=0)
   {
     tmpDimensions[3]=tDim;
     if(m_Dimension < 4)
       m_Dimension = 4;
   }
 
 
   switch ( vtkimagedata->GetScalarType() )
   {
   case VTK_BIT:
   case VTK_CHAR:
     //pixelType.Initialize(typeid(char), vtkimagedata->GetNumberOfScalarComponents());
     Initialize(mitk::MakeScalarPixelType<char>(), m_Dimension, tmpDimensions, channels);
     break;
   case VTK_UNSIGNED_CHAR:
     //pixelType.Initialize(typeid(unsigned char), vtkimagedata->GetNumberOfScalarComponents());
     Initialize(mitk::MakeScalarPixelType<unsigned char>(), m_Dimension, tmpDimensions, channels);
     break;
   case VTK_SHORT:
     //pixelType.Initialize(typeid(short), vtkimagedata->GetNumberOfScalarComponents());
     Initialize(mitk::MakeScalarPixelType<short>(), m_Dimension, tmpDimensions, channels);
     break;
   case VTK_UNSIGNED_SHORT:
     //pixelType.Initialize(typeid(unsigned short), vtkimagedata->GetNumberOfScalarComponents());
     Initialize(mitk::MakeScalarPixelType<unsigned short>(), m_Dimension, tmpDimensions, channels);
     break;
   case VTK_INT:
     //pixelType.Initialize(typeid(int), vtkimagedata->GetNumberOfScalarComponents());
     Initialize(mitk::MakeScalarPixelType<int>(), m_Dimension, tmpDimensions, channels);
     break;
   case VTK_UNSIGNED_INT:
     //pixelType.Initialize(typeid(unsigned int), vtkimagedata->GetNumberOfScalarComponents());
     Initialize(mitk::MakeScalarPixelType<unsigned int>(), m_Dimension, tmpDimensions, channels);
     break;
   case VTK_LONG:
     //pixelType.Initialize(typeid(long), vtkimagedata->GetNumberOfScalarComponents());
     Initialize(mitk::MakeScalarPixelType<long>(), m_Dimension, tmpDimensions, channels);
     break;
   case VTK_UNSIGNED_LONG:
     //pixelType.Initialize(typeid(unsigned long), vtkimagedata->GetNumberOfScalarComponents());
     Initialize(mitk::MakeScalarPixelType<unsigned long>(), m_Dimension, tmpDimensions, channels);
     break;
   case VTK_FLOAT:
     //pixelType.Initialize(typeid(float), vtkimagedata->GetNumberOfScalarComponents());
     Initialize(mitk::MakeScalarPixelType<float>(), m_Dimension, tmpDimensions, channels);
     break;
   case VTK_DOUBLE:
     //pixelType.Initialize(typeid(double), vtkimagedata->GetNumberOfScalarComponents());
     Initialize(mitk::MakeScalarPixelType<double>(), m_Dimension, tmpDimensions, channels);
     break;
   default:
     break;
   }
   /*
   Initialize(pixelType,
     m_Dimension,
     tmpDimensions,
     channels);
 */
 
   const double *spacinglist = vtkimagedata->GetSpacing();
   Vector3D spacing;
   FillVector3D(spacing, spacinglist[0], 1.0, 1.0);
   if(m_Dimension>=2)
     spacing[1]=spacinglist[1];
   if(m_Dimension>=3)
     spacing[2]=spacinglist[2];
 
   // access origin of vtkImage
   Point3D origin;
   double vtkorigin[3];
   vtkimagedata->GetOrigin(vtkorigin);
   FillVector3D(origin, vtkorigin[0], 0.0, 0.0);
   if(m_Dimension>=2)
     origin[1]=vtkorigin[1];
   if(m_Dimension>=3)
     origin[2]=vtkorigin[2];
 
   SlicedGeometry3D* slicedGeometry = GetSlicedGeometry(0);
 
   // re-initialize PlaneGeometry with origin and direction
   PlaneGeometry* planeGeometry = static_cast<PlaneGeometry*>(slicedGeometry->GetGeometry2D(0));
   planeGeometry->SetOrigin(origin);
 
   // re-initialize SlicedGeometry3D
   slicedGeometry->SetOrigin(origin);
   slicedGeometry->SetSpacing(spacing);
 
   ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
   timeGeometry->Initialize(slicedGeometry, m_Dimensions[3]);
   SetTimeGeometry(timeGeometry);
 
   delete [] tmpDimensions;
 }
 
 bool mitk::Image::IsValidSlice(int s, int t, int n) const
 {
   if(m_Initialized)
     return ((s>=0) && (s<(int)m_Dimensions[2]) && (t>=0) && (t< (int) m_Dimensions[3]) && (n>=0) && (n< (int)GetNumberOfChannels()));
   else
     return false;
 }
 
 bool mitk::Image::IsValidVolume(int t, int n) const
 {
   if(m_Initialized)
     return IsValidSlice(0, t, n);
   else
     return false;
 }
 
 bool mitk::Image::IsValidChannel(int n) const
 {
   if(m_Initialized)
     return IsValidSlice(0, 0, n);
   else
     return false;
 }
 
 void mitk::Image::ComputeOffsetTable()
 {
   if(m_OffsetTable!=NULL)
     delete [] m_OffsetTable;
 
   m_OffsetTable=new size_t[m_Dimension>4 ? m_Dimension+1 : 4+1];
 
   unsigned int i;
   size_t num=1;
   m_OffsetTable[0] = 1;
   for (i=0; i < m_Dimension; ++i)
   {
     num *= m_Dimensions[i];
     m_OffsetTable[i+1] = num;
   }
   for (;i < 4; ++i)
     m_OffsetTable[i+1] = num;
 }
 
 bool mitk::Image::IsValidTimeStep(int t) const
 {
   return ( ( m_Dimension >= 4 && t <= (int)m_Dimensions[3] && t > 0 ) || (t == 0) );
 }
 
 void mitk::Image::Expand(unsigned int timeSteps)
 {
   if(timeSteps < 1) itkExceptionMacro(<< "Invalid timestep in Image!");
   Superclass::Expand(timeSteps);
 }
 
 int mitk::Image::GetSliceIndex(int s, int t, int n) const
 {
   if(IsValidSlice(s,t,n)==false) return false;
   return ((size_t)s)+((size_t) t)*m_Dimensions[2]+((size_t) n)*m_Dimensions[3]*m_Dimensions[2]; //??
 }
 
 int mitk::Image::GetVolumeIndex(int t, int n) const
 {
   if(IsValidVolume(t,n)==false) return false;
   return ((size_t)t)+((size_t) n)*m_Dimensions[3]; //??
 }
 
 mitk::Image::ImageDataItemPointer mitk::Image::AllocateSliceData(int s, int t, int n, void *data, ImportMemoryManagementType importMemoryManagement)
 {
   int pos;
   pos=GetSliceIndex(s,t,n);
 
   const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
 
   // is slice available as part of a volume that is available?
   ImageDataItemPointer sl, ch, vol;
   vol=m_Volumes[GetVolumeIndex(t,n)];
   if(vol.GetPointer()!=NULL)
   {
     sl=new ImageDataItem(*vol, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, ((size_t) s)*m_OffsetTable[2]*(ptypeSize));
     sl->SetComplete(true);
     return m_Slices[pos]=sl;
   }
 
   // is slice available as part of a channel that is available?
   ch=m_Channels[n];
   if(ch.GetPointer()!=NULL)
   {
     sl=new ImageDataItem(*ch, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, (((size_t) s)*m_OffsetTable[2]+((size_t) t)*m_OffsetTable[3])*(ptypeSize));
     sl->SetComplete(true);
     return m_Slices[pos]=sl;
   }
 
   // allocate new volume (instead of a single slice to keep data together!)
   m_Volumes[GetVolumeIndex(t,n)]=vol=AllocateVolumeData(t,n,NULL,importMemoryManagement);
   sl=new ImageDataItem(*vol, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, ((size_t) s)*m_OffsetTable[2]*(ptypeSize));
   sl->SetComplete(true);
   return m_Slices[pos]=sl;
 
   ////ALTERNATIVE:
   //// allocate new slice
   //sl=new ImageDataItem(*m_PixelType, 2, m_Dimensions);
   //m_Slices[pos]=sl;
   //return vol;
 }
 
 mitk::Image::ImageDataItemPointer mitk::Image::AllocateVolumeData(int t, int n, void *data, ImportMemoryManagementType importMemoryManagement)
 {
   int pos;
   pos=GetVolumeIndex(t,n);
 
   const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
 
   // is volume available as part of a channel that is available?
   ImageDataItemPointer ch, vol;
   ch=m_Channels[n];
   if(ch.GetPointer()!=NULL)
   {
     vol=new ImageDataItem(*ch, m_ImageDescriptor, 3, data,importMemoryManagement == ManageMemory, (((size_t) t)*m_OffsetTable[3])*(ptypeSize));
     return m_Volumes[pos]=vol;
   }
 
   mitk::PixelType chPixelType = this->m_ImageDescriptor->GetChannelTypeById(n);
 
   // allocate new volume
   if(importMemoryManagement == CopyMemory)
   {
     vol=new ImageDataItem( chPixelType, 3, m_Dimensions, NULL, true);
     if(data != NULL)
       std::memcpy(vol->GetData(), data, m_OffsetTable[3]*(ptypeSize));
   }
   else
   {
     vol=new ImageDataItem( chPixelType, 3, m_Dimensions, data, importMemoryManagement == ManageMemory);
   }
   m_Volumes[pos]=vol;
   return vol;
 }
 
 mitk::Image::ImageDataItemPointer mitk::Image::AllocateChannelData(int n, void *data, ImportMemoryManagementType importMemoryManagement)
 {
   ImageDataItemPointer ch;
   // allocate new channel
   if(importMemoryManagement == CopyMemory)
   {
     const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
 
     ch=new ImageDataItem(this->m_ImageDescriptor, NULL, true);
     if(data != NULL)
       std::memcpy(ch->GetData(), data, m_OffsetTable[4]*(ptypeSize));
   }
   else
   {
     ch=new ImageDataItem(this->m_ImageDescriptor, data, importMemoryManagement == ManageMemory);
   }
   m_Channels[n]=ch;
   return ch;
 }
 
 unsigned int* mitk::Image::GetDimensions() const
 {
   return m_Dimensions;
 }
 
 void mitk::Image::Clear()
 {
   Superclass::Clear();
   delete [] m_Dimensions;
   m_Dimensions = NULL;
 }
 
 void mitk::Image::SetGeometry(Geometry3D* aGeometry3D)
 {
   // Please be aware of the 0.5 offset/pixel-center issue! See Geometry documentation for further information
 
   if(aGeometry3D->GetImageGeometry()==false)
   {
     MITK_INFO << "WARNING: Applied a non-image geometry onto an image. Please be SURE that this geometry is pixel-center-based! If it is not, you need to call Geometry3D->ChangeImageGeometryConsideringOriginOffset(true) before calling image->setGeometry(..)\n";
   }
   Superclass::SetGeometry(aGeometry3D);
   for (TimeStepType step = 0; step < GetTimeGeometry()->CountTimeSteps(); ++step)
     GetTimeGeometry()->GetGeometryForTimeStep(step)->ImageGeometryOn();
 }
 
 void mitk::Image::PrintSelf(std::ostream& os, itk::Indent indent) const
 {
   unsigned char i;
   if(m_Initialized)
   {
     os << indent << " Dimension: " << m_Dimension << std::endl;
     os << indent << " Dimensions: ";
     for(i=0; i < m_Dimension; ++i)
       os << GetDimension(i) << " ";
     os << std::endl;
 
     for(unsigned int ch=0; ch < this->m_ImageDescriptor->GetNumberOfChannels(); ch++)
     {
       mitk::PixelType chPixelType = this->m_ImageDescriptor->GetChannelTypeById(ch);
 
       os << indent << " Channel: " << this->m_ImageDescriptor->GetChannelName(ch) << std::endl;
       os << indent << " PixelType: " << chPixelType.GetPixelTypeAsString() << std::endl;
       os << indent << " BytesPerElement: " << chPixelType.GetSize() << std::endl;
       os << indent << " ComponentType: " << chPixelType.GetComponentTypeAsString() << std::endl;
       os << indent << " NumberOfComponents: " << chPixelType.GetNumberOfComponents() << std::endl;
       os << indent << " BitsPerComponent: " << chPixelType.GetBitsPerComponent() << std::endl;
     }
 
   }
   else
   {
     os << indent << " Image not initialized: m_Initialized: false" << std::endl;
   }
 
   Superclass::PrintSelf(os,indent);
 }
 
 bool mitk::Image::IsRotated() const
 {
   const mitk::Geometry3D* geo = this->GetGeometry();
   bool ret = false;
 
   if(geo)
   {
     const vnl_matrix_fixed<ScalarType, 3, 3> & mx = geo->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix();
     mitk::ScalarType ref = 0;
     for(short k = 0; k < 3; ++k)
       ref += mx[k][k];
     ref/=1000;  // Arbitrary value; if a non-diagonal (nd) element is bigger then this, matrix is considered nd.
 
     for(short i = 0; i < 3; ++i)
     {
       for(short j = 0; j < 3; ++j)
       {
         if(i != j)
         {
           if(std::abs(mx[i][j]) > ref) // matrix is nd
             ret = true;
         }
       }
     }
   }
   return ret;
 }
 
 mitk::ScalarType mitk::Image::GetScalarValueMin(int t) const
 {
   return m_ImageStatistics->GetScalarValueMin(t);
 }
 
 //## \brief Get the maximum for scalar images
 mitk::ScalarType mitk::Image::GetScalarValueMax(int t) const
 {
   return m_ImageStatistics->GetScalarValueMax(t);
 }
 
 //## \brief Get the second smallest value for scalar images
 mitk::ScalarType mitk::Image::GetScalarValue2ndMin(int t) const
 {
   return m_ImageStatistics->GetScalarValue2ndMin(t);
 }
 
 mitk::ScalarType mitk::Image::GetScalarValueMinNoRecompute( unsigned int t ) const
 {
   return m_ImageStatistics->GetScalarValueMinNoRecompute(t);
 }
 
 mitk::ScalarType mitk::Image::GetScalarValue2ndMinNoRecompute( unsigned int t ) const
 {
   return m_ImageStatistics->GetScalarValue2ndMinNoRecompute(t);
 }
 
 mitk::ScalarType mitk::Image::GetScalarValue2ndMax(int t) const
 {
   return m_ImageStatistics->GetScalarValue2ndMax(t);
 }
 
 mitk::ScalarType mitk::Image::GetScalarValueMaxNoRecompute( unsigned int t) const
 {
   return m_ImageStatistics->GetScalarValueMaxNoRecompute(t);
 }
 
 mitk::ScalarType mitk::Image::GetScalarValue2ndMaxNoRecompute( unsigned int t ) const
 {
   return m_ImageStatistics->GetScalarValue2ndMaxNoRecompute(t);
 }
 
 mitk::ScalarType mitk::Image::GetCountOfMinValuedVoxels(int t ) const
 {
   return m_ImageStatistics->GetCountOfMinValuedVoxels(t);
 }
 
 mitk::ScalarType mitk::Image::GetCountOfMaxValuedVoxels(int t) const
 {
   return m_ImageStatistics->GetCountOfMaxValuedVoxels(t);
 }
 
 unsigned int mitk::Image::GetCountOfMaxValuedVoxelsNoRecompute( unsigned int t  ) const
 {
   return m_ImageStatistics->GetCountOfMaxValuedVoxelsNoRecompute(t);
 }
 
 unsigned int mitk::Image::GetCountOfMinValuedVoxelsNoRecompute( unsigned int t ) const
 {
   return m_ImageStatistics->GetCountOfMinValuedVoxelsNoRecompute(t);
 }
 
 bool mitk::Equal(const mitk::Image* leftHandSide, const mitk::Image* rightHandSide, ScalarType eps, bool verbose)
 {
   if((leftHandSide == NULL)  || (rightHandSide == NULL))
   {
     MITK_ERROR << "mitk::Equal(const mitk::Image* leftHandSide, const mitk::Image* rightHandSide, ScalarType eps, bool verbose) does not work with NULL pointer input.";
     return false;
   }
   return mitk::Equal( *leftHandSide, *rightHandSide, eps, verbose);
 }
 
 bool mitk::Equal(const mitk::Image& leftHandSide, const mitk::Image& rightHandSide, ScalarType eps, bool verbose)
 {
   bool returnValue = true;
 
   // Dimensionality
   if( rightHandSide.GetDimension() != leftHandSide.GetDimension() )
   {
     if(verbose)
     {
       MITK_INFO << "[( Image )] Dimensionality differs.";
       MITK_INFO << "leftHandSide is " << leftHandSide.GetDimension()
        << "rightHandSide is " << rightHandSide.GetDimension();
     }
     returnValue = false;
   }
 
   // Pair-wise dimension (size) comparison
   unsigned int minDimensionality = std::min(rightHandSide.GetDimension(),leftHandSide.GetDimension());
   for( unsigned int i=0; i< minDimensionality; ++i)
   {
     if( rightHandSide.GetDimension(i) != leftHandSide.GetDimension(i) )
     {
       returnValue = false;
       if(verbose)
       {
         MITK_INFO << "[( Image )] dimension differs.";
         MITK_INFO << "leftHandSide->GetDimension("<<i<<") is " << leftHandSide.GetDimension(i)
          << "rightHandSide->GetDimension("<<i<<") is " << rightHandSide.GetDimension(i);
       }
     }
   }
 
   // Pixeltype
   mitk::PixelType pixelTypeRightHandSide = rightHandSide.GetPixelType();
   mitk::PixelType pixelTypeLeftHandSide = leftHandSide.GetPixelType();
   if( !( pixelTypeRightHandSide == pixelTypeLeftHandSide ) )
   {
     if(verbose)
     {
       MITK_INFO << "[( Image )] PixelType differs.";
       MITK_INFO << "leftHandSide is " << pixelTypeLeftHandSide.GetTypeAsString()
        << "rightHandSide is " << pixelTypeRightHandSide.GetTypeAsString();
     }
     returnValue = false;
   }
 
   // Geometries
   if( !mitk::Equal(  leftHandSide.GetGeometry(),
                      rightHandSide.GetGeometry(), eps, verbose) )
   {
     if(verbose)
     {
       MITK_INFO << "[( Image )] Geometries differ.";
     }
     returnValue = false;
   }
 
   // Pixel values - default mode [ 0 threshold in difference ]
   // compare only if all previous checks were successfull, otherwise the ITK filter will throw an exception
   if( returnValue )
   {
     mitk::CompareImageDataFilter::Pointer compareFilter = mitk::CompareImageDataFilter::New();
 
     compareFilter->SetInput(0, &rightHandSide);
     compareFilter->SetInput(1, &leftHandSide);
     compareFilter->SetTolerance(eps);
     compareFilter->Update();
 
     if(( !compareFilter->GetResult() ) )
     {
       returnValue = false;
       if(verbose)
       {
         MITK_INFO << "[(Image)] Pixel values differ: ";
         compareFilter->GetCompareResults().PrintSelf();
       }
     }
   }
 
   return returnValue;
 }
diff --git a/Core/Code/DataManagement/mitkImage.h b/Core/Code/DataManagement/mitkImage.h
index 06e8bbbe4a..96bf9d6af5 100644
--- a/Core/Code/DataManagement/mitkImage.h
+++ b/Core/Code/DataManagement/mitkImage.h
@@ -1,735 +1,735 @@
 /*===================================================================
 
 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 MITKIMAGE_H_HEADER_INCLUDED_C1C2FCD2
 #define MITKIMAGE_H_HEADER_INCLUDED_C1C2FCD2
 
 #include <MitkCoreExports.h>
 #include "mitkSlicedData.h"
 #include "mitkBaseData.h"
 #include "mitkLevelWindow.h"
 #include "mitkPlaneGeometry.h"
 #include <mitkProportionalTimeGeometry.h>
 #include "mitkImageDataItem.h"
 #include "mitkImageDescriptor.h"
 #include "mitkImageAccessorBase.h"
 #include "mitkImageVtkAccessor.h"
 
 //DEPRECATED
 #include <mitkTimeSlicedGeometry.h>
 
 #ifndef __itkHistogram_h
 #include <itkHistogram.h>
 #endif
 
 
 class vtkImageData;
 
 namespace mitk {
 
 class SubImageSelector;
 class ImageTimeSelector;
 
 class ImageStatisticsHolder;
 
 //##Documentation
 //## @brief Image class for storing images
 //##
 //## Can be asked for header information, the data vector,
 //## the mitkIpPicDescriptor struct or vtkImageData objects. If not the complete
 //## data is required, the appropriate SubImageSelector class should be used
 //## for access.
 //## Image organizes sets of slices (s x 2D), volumes (t x 3D) and channels (n
 //## x ND). Channels are for different kind of data, e.g., morphology in
 //## channel 0, velocities in channel 1. All channels must have the same Geometry! In
 //## particular, the dimensions of all channels are the same, only the pixel-type
 //## may differ between channels.
 //##
 //## For importing ITK images use of mitk::ITKImageImport is recommended, see
 //## \ref Adaptor.
 //##
 //## For ITK v3.8 and older: Converting coordinates from the ITK physical
 //## coordinate system (which does not support rotated images) to the MITK world
 //## coordinate system should be performed via the Geometry3D of the Image, see
 //## Geometry3D::WorldToItkPhysicalPoint.
 //## @ingroup Data
 class MITK_CORE_EXPORT Image : public SlicedData
 {
   friend class SubImageSelector;
 
   friend class ImageAccessorBase;
   friend class ImageVtkAccessor;
   friend class ImageReadAccessor;
   friend class ImageWriteAccessor;
 
 public:
   mitkClassMacro(Image, SlicedData);
 
   itkFactorylessNewMacro(Self)
   itkCloneMacro(Self)
 
   /** Smart Pointer type to a ImageDataItem. */
   typedef itk::SmartPointer<ImageDataItem> ImageDataItemPointer;
   typedef itk::Statistics::Histogram<double> HistogramType;
   typedef mitk::ImageStatisticsHolder* StatisticsHolderPointer;
 
   //## @param ImportMemoryManagementType This parameter is evaluated when setting new data to an image.
   //## The different options are:
   //## CopyMemory: Data to be set is copied and assigned to a new memory block. Data memory block will be freed on deletion of mitk::Image.
   //## MamageMemory: Data to be set will be referenced, and Data memory block will be freed on deletion of mitk::Image.
   //## Reference Memory: Data to be set will be referenced, but Data memory block will not be freed on deletion of mitk::Image.
   //## DontManageMemory = ReferenceMemory.
   enum ImportMemoryManagementType { CopyMemory, ManageMemory, ReferenceMemory, DontManageMemory = ReferenceMemory };
 
   //##Documentation
   //## @brief Vector container of SmartPointers to ImageDataItems;
   //## Class is only for internal usage to allow convenient access to all slices over iterators;
   //## See documentation of ImageDataItem for details.
   typedef std::vector<ImageDataItemPointer> ImageDataItemPointerArray;
 
 public:
   //##Documentation
   //## @brief Returns the PixelType of channel @a n.
   const mitk::PixelType GetPixelType(int n = 0) const;
 
   //##Documentation
   //## @brief Get dimension of the image
   //##
   unsigned int GetDimension() const;
 
   //##Documentation
   //## @brief Get the size of dimension @a i (e.g., i=0 results in the number of pixels in x-direction).
   //##
   //## @sa GetDimensions()
   unsigned int GetDimension(int i) const;
 
   /** @brief Get the data vector of the complete image, i.e., of all channels linked together.
 
   If you only want to access a slice, volume at a specific time or single channel
   use one of the SubImageSelector classes.
    \deprecatedSince{2012_09} Please use image accessors instead: See Doxygen/Related-Pages/Concepts/Image. This method can be replaced by ImageWriteAccessor::GetData() or ImageReadAccessor::GetData() */
   DEPRECATED(virtual void* GetData());
 
 public:
   /** @brief Get the pixel value at one specific index position.
 
   The pixel type is always being converted to double.
    \deprecatedSince{2012_09} Please use image accessors instead: See Doxygen/Related-Pages/Concepts/Image. This method can be replaced by a method from ImagePixelWriteAccessor or ImagePixelReadAccessor */
-  DEPRECATED(double GetPixelValueByIndex(const mitk::Index3D& position, unsigned int timestep = 0));
+  DEPRECATED(double GetPixelValueByIndex(const itk::Index<3>& position, unsigned int timestep = 0));
 
   /** @brief Get the pixel value at one specific world position.
 
   The pixel type is always being converted to double.
    \deprecatedSince{2012_09} Please use image accessors instead: See Doxygen/Related-Pages/Concepts/Image. This method can be replaced by a method from ImagePixelWriteAccessor or ImagePixelReadAccessor */
   DEPRECATED(double GetPixelValueByWorldCoordinate(const mitk::Point3D& position, unsigned int timestep = 0));
 
   //##Documentation
   //## @brief Get a volume at a specific time @a t of channel @a n as a vtkImageData.
   virtual ImageVtkAccessor* GetVtkImageData(int t = 0, int n = 0);
 
   //##Documentation
   //## @brief Get the complete image, i.e., all channels linked together, as a @a mitkIpPicDescriptor.
   //##
   //## If you only want to access a slice, volume at a specific time or single channel
   //## use one of the SubImageSelector classes.
   //virtual mitkIpPicDescriptor* GetPic();
 
   //##Documentation
   //## @brief Check whether slice @a s at time @a t in channel @a n is set
   virtual bool IsSliceSet(int s = 0, int t = 0, int n = 0) const;
 
   //##Documentation
   //## @brief Check whether volume at time @a t in channel @a n is set
   virtual bool IsVolumeSet(int t = 0, int n = 0) const;
 
   //##Documentation
   //## @brief Check whether the channel @a n is set
   virtual bool IsChannelSet(int n = 0) const;
 
   //##Documentation
   //## @brief Set @a data as slice @a s at time @a t in channel @a n. It is in
   //## the responsibility of the caller to ensure that the data vector @a data
   //## is really a slice (at least is not smaller than a slice), since there is
   //## no chance to check this.
   //##
   //## The data is copied to an array managed by the image. If the image shall
   //## reference the data, use SetImportSlice with ImportMemoryManagementType
   //## set to ReferenceMemory. For importing ITK images use of mitk::
   //## ITKImageImport is recommended.
   //## @sa SetPicSlice, SetImportSlice, SetImportVolume
   virtual bool SetSlice(const void *data, int s = 0, int t = 0, int n = 0);
 
   //##Documentation
   //## @brief Set @a data as volume at time @a t in channel @a n. It is in
   //## the responsibility of the caller to ensure that the data vector @a data
   //## is really a volume (at least is not smaller than a volume), since there is
   //## no chance to check this.
   //##
   //## The data is copied to an array managed by the image. If the image shall
   //## reference the data, use SetImportVolume with ImportMemoryManagementType
   //## set to ReferenceMemory. For importing ITK images use of mitk::
   //## ITKImageImport is recommended.
   //## @sa SetPicVolume, SetImportVolume
   virtual bool SetVolume(const void *data, int t = 0, int n = 0);
 
   //##Documentation
   //## @brief Set @a data in channel @a n. It is in
   //## the responsibility of the caller to ensure that the data vector @a data
   //## is really a channel (at least is not smaller than a channel), since there is
   //## no chance to check this.
   //##
   //## The data is copied to an array managed by the image. If the image shall
   //## reference the data, use SetImportChannel with ImportMemoryManagementType
   //## set to ReferenceMemory. For importing ITK images use of mitk::
   //## ITKImageImport is recommended.
   //## @sa SetPicChannel, SetImportChannel
   virtual bool SetChannel(const void *data, int n = 0);
 
   //##Documentation
   //## @brief Set @a data as slice @a s at time @a t in channel @a n. It is in
   //## the responsibility of the caller to ensure that the data vector @a data
   //## is really a slice (at least is not smaller than a slice), since there is
   //## no chance to check this.
   //##
   //## The data is managed according to the parameter \a importMemoryManagement.
   //## @sa SetPicSlice
   virtual bool SetImportSlice(void *data, int s = 0, int t = 0, int n = 0, ImportMemoryManagementType importMemoryManagement = CopyMemory );
 
   //##Documentation
   //## @brief Set @a data as volume at time @a t in channel @a n. It is in
   //## the responsibility of the caller to ensure that the data vector @a data
   //## is really a volume (at least is not smaller than a volume), since there is
   //## no chance to check this.
   //##
   //## The data is managed according to the parameter \a importMemoryManagement.
   //## @sa SetPicVolume
   virtual bool SetImportVolume(void *data, int t = 0, int n = 0, ImportMemoryManagementType importMemoryManagement = CopyMemory );
 
   //##Documentation
   //## @brief Set @a data in channel @a n. It is in
   //## the responsibility of the caller to ensure that the data vector @a data
   //## is really a channel (at least is not smaller than a channel), since there is
   //## no chance to check this.
   //##
   //## The data is managed according to the parameter \a importMemoryManagement.
   //## @sa SetPicChannel
   virtual bool SetImportChannel(void *data, int n = 0, ImportMemoryManagementType importMemoryManagement = CopyMemory );
 
   //##Documentation
   //## initialize new (or re-initialize) image information
   //## @warning Initialize() by pic assumes a plane, evenly spaced geometry starting at (0,0,0).
   virtual void Initialize(const mitk::PixelType& type, unsigned int dimension, const unsigned int *dimensions, unsigned int channels = 1);
 
   //##Documentation
   //## initialize new (or re-initialize) image information by a Geometry3D
   //##
   //## @param tDim defines the number of time steps for which the Image should be initialized
   virtual void Initialize(const mitk::PixelType& type, const mitk::Geometry3D& geometry, unsigned int channels = 1, int tDim=1);
 
   /**
   * initialize new (or re-initialize) image information by a Geometry3D
   *
   * @param tDim defines the number of time steps for which the Image should be initialized
   * \deprecatedSince{2013_09} Please use TimeGeometry instead of TimeSlicedGeometry. For more information see http://www.mitk.org/Development/Refactoring%20of%20the%20Geometry%20Classes%20-%20Part%201
   */
   DEPRECATED(virtual void Initialize(const mitk::PixelType& /*type*/, const mitk::TimeSlicedGeometry* /*geometry*/, unsigned int /*channels = 1*/, int /*tDim=1*/)){}
 
   /**
   * \brief Initialize new (or re-initialize) image information by a TimeGeometry
   *
   * \param tDim override time dimension if the value is bigger than 0 (Default -1)
   */
   virtual void Initialize(const mitk::PixelType& type, const mitk::TimeGeometry& geometry, unsigned int channels = 1, int tDim=-1 );
 
   //##Documentation
   //## initialize new (or re-initialize) image information by a Geometry2D and number of slices
   //##
   //## Initializes the bounding box according to the width/height of the
   //## Geometry2D and @a sDim via SlicedGeometry3D::InitializeEvenlySpaced.
   //## The spacing is calculated from the Geometry2D.
   //## \sa SlicedGeometry3D::InitializeEvenlySpaced
   virtual void Initialize(const mitk::PixelType& type, int sDim, const mitk::Geometry2D& geometry2d, bool flipped = false, unsigned int channels = 1, int tDim=1);
 
   //##Documentation
   //## initialize new (or re-initialize) image information by another
   //## mitk-image.
   //## Only the header is used, not the data vector!
   //##
   virtual void Initialize(const mitk::Image* image);
 
   virtual void Initialize(const mitk::ImageDescriptor::Pointer inDesc);
 
   //##Documentation
   //## initialize new (or re-initialize) image information by @a pic.
   //## Dimensions and @a Geometry3D /@a Geometry2D are set according
   //## to the tags in @a pic.
   //## Only the header is used, not the data vector! Use SetPicVolume(pic)
   //## to set the data vector.
   //##
   //## @param tDim override time dimension (@a n[3]) in @a pic (if >0)
   //## @param sDim override z-space dimension (@a n[2]) in @a pic (if >0)
   //## @warning Initialize() by pic assumes a plane, evenly spaced geometry starting at (0,0,0).
   //virtual void Initialize(const mitkIpPicDescriptor* pic, int channels = 1, int tDim = -1, int sDim = -1);
 
   //##Documentation
   //## initialize new (or re-initialize) image information by @a vtkimagedata,
   //## a vtk-image.
   //## Only the header is used, not the data vector! Use
   //## SetVolume(vtkimage->GetScalarPointer()) to set the data vector.
   //##
   //## @param tDim override time dimension in @a vtkimagedata (if >0 and <)
   //## @param sDim override z-space dimension in @a vtkimagedata (if >0 and <)
   //## @param pDim override y-space dimension in @a vtkimagedata (if >0 and <)
   virtual void Initialize(vtkImageData* vtkimagedata, int channels = 1, int tDim = -1, int sDim = -1, int pDim = -1);
 
   //##Documentation
   //## initialize new (or re-initialize) image information by @a itkimage,
   //## a templated itk-image.
   //## Only the header is used, not the data vector! Use
   //## SetVolume(itkimage->GetBufferPointer()) to set the data vector.
   //##
   //## @param tDim override time dimension in @a itkimage (if >0 and <)
   //## @param sDim override z-space dimension in @a itkimage (if >0 and <)
   template <typename itkImageType> void InitializeByItk(const itkImageType* itkimage, int channels = 1, int tDim = -1, int sDim=-1)
   {
     if(itkimage==NULL) return;
 
     MITK_DEBUG << "Initializing MITK image from ITK image.";
     // build array with dimensions in each direction with at least 4 entries
     m_Dimension=itkimage->GetImageDimension();
     unsigned int i, *tmpDimensions=new unsigned int[m_Dimension>4?m_Dimension:4];
     for(i=0;i<m_Dimension;++i)
       tmpDimensions[i]=itkimage->GetLargestPossibleRegion().GetSize().GetSize()[i];
     if(m_Dimension<4)
     {
       unsigned int *p;
       for(i=0,p=tmpDimensions+m_Dimension;i<4-m_Dimension;++i, ++p)
         *p=1;
     }
 
     // overwrite number of slices if sDim is set
     if((m_Dimension>2) && (sDim>=0))
       tmpDimensions[2]=sDim;
     // overwrite number of time points if tDim is set
     if((m_Dimension>3) && (tDim>=0))
       tmpDimensions[3]=tDim;
 
     // rough initialization of Image
    // mitk::PixelType importType = ImportItkPixelType( itkimage::PixelType );
 
 
     Initialize(MakePixelType<itkImageType>(),
       m_Dimension,
       tmpDimensions,
       channels);
     const typename itkImageType::SpacingType & itkspacing = itkimage->GetSpacing();
 
     MITK_DEBUG << "ITK spacing " << itkspacing;
     // access spacing of itk::Image
     Vector3D spacing;
     FillVector3D(spacing, itkspacing[0], 1.0, 1.0);
     if(m_Dimension >= 2)
       spacing[1]=itkspacing[1];
     if(m_Dimension >= 3)
       spacing[2]=itkspacing[2];
 
     // access origin of itk::Image
     Point3D origin;
     const typename itkImageType::PointType & itkorigin = itkimage->GetOrigin();
     MITK_DEBUG << "ITK origin " << itkorigin;
     FillVector3D(origin, itkorigin[0], 0.0, 0.0);
     if(m_Dimension>=2)
       origin[1]=itkorigin[1];
     if(m_Dimension>=3)
       origin[2]=itkorigin[2];
 
     // access direction of itk::Imagm_PixelType = new mitk::PixelType(type);e and include spacing
     const typename itkImageType::DirectionType & itkdirection = itkimage->GetDirection();
     MITK_DEBUG << "ITK direction " << itkdirection;
     mitk::Matrix3D matrix;
     matrix.SetIdentity();
     unsigned int j, itkDimMax3 = (m_Dimension >= 3? 3 : m_Dimension);
     // check if spacing has no zero entry and itkdirection has no zero columns
     bool itkdirectionOk = true;
     mitk::ScalarType columnSum;
     for( j=0; j < itkDimMax3; ++j )
     {
       columnSum = 0.0;
       for ( i=0; i < itkDimMax3; ++i)
       {
         columnSum += fabs(itkdirection[i][j]);
       }
       if(columnSum < mitk::eps)
       {
         itkdirectionOk = false;
       }
       if (    (spacing[j] < - mitk::eps) // (normally sized) negative value
           &&  (j==2) && (m_Dimensions[2] == 1) )
       {
         // Negative spacings can occur when reading single DICOM slices with ITK via GDCMIO
         // In these cases spacing is not determind by ITK correctly (because it distinguishes correctly
         // between slice thickness and inter slice distance -- slice distance is meaningless for
         // single slices).
         // I experienced that ITK produced something meaningful nonetheless because is is
         // evaluating the tag "(0018,0088) Spacing between slices" as a fallback. This tag is not
         // reliable (http://www.itk.org/pipermail/insight-users/2005-September/014711.html)
         // but gives at least a hint.
         // In real world cases I experienced that this tag contained the correct inter slice distance
         // with a negative sign, so we just invert such negative spacings.
         MITK_WARN << "Illegal value of itk::Image::GetSpacing()[" << j <<"]=" << spacing[j] << ". Using inverted value " << -spacing[j];
         spacing[j] = -spacing[j];
       }
       else if (spacing[j] < mitk::eps) // value near zero
       {
         MITK_ERROR << "Illegal value of itk::Image::GetSpacing()[" << j <<"]=" << spacing[j] << ". Using 1.0 instead.";
         spacing[j] = 1.0;
       }
     }
     if(itkdirectionOk == false)
     {
       MITK_ERROR << "Illegal matrix returned by itk::Image::GetDirection():" << itkdirection << " Using identity instead.";
       for ( i=0; i < itkDimMax3; ++i)
         for( j=0; j < itkDimMax3; ++j )
           if ( i == j )
             matrix[i][j] = spacing[j];
           else
             matrix[i][j] = 0.0;
     }
     else
     {
       for ( i=0; i < itkDimMax3; ++i)
         for( j=0; j < itkDimMax3; ++j )
           matrix[i][j] = itkdirection[i][j]*spacing[j];
     }
 
     // re-initialize PlaneGeometry with origin and direction
     PlaneGeometry* planeGeometry = static_cast<PlaneGeometry*>(GetSlicedGeometry(0)->GetGeometry2D(0));
     planeGeometry->SetOrigin(origin);
     planeGeometry->GetIndexToWorldTransform()->SetMatrix(matrix);
 
     // re-initialize SlicedGeometry3D
     SlicedGeometry3D* slicedGeometry = GetSlicedGeometry(0);
     slicedGeometry->InitializeEvenlySpaced(planeGeometry, m_Dimensions[2]);
     slicedGeometry->SetSpacing(spacing);
 
     // re-initialize TimeGeometry
     ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
     timeGeometry->Initialize(slicedGeometry, m_Dimensions[3]);
     SetTimeGeometry(timeGeometry);
 
     // clean-up
     delete [] tmpDimensions;
 
     this->Initialize();
   };
 
   //##Documentation
   //## @brief Check whether slice @a s at time @a t in channel @a n is valid, i.e.,
   //## is (or can be) inside of the image
   virtual bool IsValidSlice(int s = 0, int t = 0, int n = 0) const;
 
   //##Documentation
   //## @brief Check whether volume at time @a t in channel @a n is valid, i.e.,
   //## is (or can be) inside of the image
   virtual bool IsValidVolume(int t = 0, int n = 0) const;
 
   //##Documentation
   //## @brief Check whether the channel @a n is valid, i.e.,
   //## is (or can be) inside of the image
   virtual bool IsValidChannel(int n = 0) const;
 
   //##Documentation
   //## @brief Returns true if an image is rotated, i.e. its geometry's
   //## transformation matrix has nonzero elements besides the diagonal.
   //## Non-diagonal elements are checked if larger then 1/1000 of the matrix' trace.
   bool IsRotated() const;
 
   //##Documentation
   //## @brief Get the sizes of all dimensions as an integer-array.
   //##
   //## @sa GetDimension(int i);
   unsigned int* GetDimensions() const;
 
   ImageDescriptor::Pointer GetImageDescriptor() const
   { return m_ImageDescriptor; }
 
   ChannelDescriptor GetChannelDescriptor( int id = 0 ) const
   { return m_ImageDescriptor->GetChannelDescriptor(id); }
 
   /** \brief Sets a geometry to an image.
     */
   virtual void SetGeometry(Geometry3D* aGeometry3D);
 
   /**
   * @warning for internal use only
   */
   virtual ImageDataItemPointer GetSliceData(int s = 0, int t = 0, int n = 0, void *data = NULL, ImportMemoryManagementType importMemoryManagement = CopyMemory);
 
   /**
   * @warning for internal use only
   */
   virtual ImageDataItemPointer GetVolumeData(int t = 0, int n = 0, void *data = NULL, ImportMemoryManagementType importMemoryManagement = CopyMemory);
 
   /**
   * @warning for internal use only
   */
   virtual ImageDataItemPointer GetChannelData(int n = 0, void *data = NULL, ImportMemoryManagementType importMemoryManagement = CopyMemory);
 
   /**
   \brief (DEPRECATED) Get the minimum for scalar images
   */
   DEPRECATED (ScalarType GetScalarValueMin(int t=0) const);
 
 
   /**
   \brief (DEPRECATED) Get the maximum for scalar images
 
   \warning This method is deprecated and will not be available in the future. Use the \a GetStatistics instead
   */
   DEPRECATED (ScalarType GetScalarValueMax(int t=0) const);
 
   /**
   \brief (DEPRECATED) Get the second smallest value for scalar images
 
   \warning This method is deprecated and will not be available in the future. Use the \a GetStatistics instead
   */
   DEPRECATED (ScalarType GetScalarValue2ndMin(int t=0) const);
 
 
   /**
   \brief (DEPRECATED) Get the smallest value for scalar images, but do not recompute it first
 
   \warning This method is deprecated and will not be available in the future. Use the \a GetStatistics instead
   */
   DEPRECATED (ScalarType GetScalarValueMinNoRecompute( unsigned int t = 0 ) const);
 
   /**
   \brief (DEPRECATED) Get the second smallest value for scalar images, but do not recompute it first
 
   \warning This method is deprecated and will not be available in the future. Use the \a GetStatistics instead
   */
   DEPRECATED (ScalarType GetScalarValue2ndMinNoRecompute( unsigned int t = 0 ) const);
 
   /**
   \brief (DEPRECATED) Get the second largest value for scalar images
 
   \warning This method is deprecated and will not be available in the future. Use the \a GetStatistics instead
   */
   DEPRECATED (ScalarType GetScalarValue2ndMax(int t=0) const);
 
   /**
   \brief (DEPRECATED) Get the largest value for scalar images, but do not recompute it first
 
   \warning This method is deprecated and will not be available in the future. Use the \a GetStatistics instead
   */
   DEPRECATED (ScalarType GetScalarValueMaxNoRecompute( unsigned int t = 0 ) const );
 
   /**
   \brief (DEPRECATED) Get the second largest value for scalar images, but do not recompute it first
 
   \warning This method is deprecated and will not be available in the future. Use the \a GetStatistics instead
   */
   DEPRECATED (ScalarType GetScalarValue2ndMaxNoRecompute( unsigned int t = 0 ) const);
 
   /**
   \brief (DEPRECATED) Get the count of voxels with the smallest scalar value in the dataset
 
   \warning This method is deprecated and will not be available in the future. Use the \a GetStatistics instead
   */
   DEPRECATED (ScalarType GetCountOfMinValuedVoxels(int t = 0) const);
 
   /**
   \brief (DEPRECATED) Get the count of voxels with the largest scalar value in the dataset
 
   \warning This method is deprecated and will not be available in the future. Use the \a GetStatistics instead
   */
   DEPRECATED (ScalarType GetCountOfMaxValuedVoxels(int t = 0) const);
 
   /**
   \brief (DEPRECATED) Get the count of voxels with the largest scalar value in the dataset
 
   \warning This method is deprecated and will not be available in the future. Use the \a GetStatistics instead
   */
   DEPRECATED (unsigned int GetCountOfMaxValuedVoxelsNoRecompute( unsigned int t = 0 ) const);
 
   /**
   \brief (DEPRECATED) Get the count of voxels with the smallest scalar value in the dataset
 
   \warning This method is deprecated and will not be available in the future. Use the \a GetStatistics instead
   */
   DEPRECATED (unsigned int GetCountOfMinValuedVoxelsNoRecompute( unsigned int t = 0 ) const);
 
   /**
     \brief Returns a pointer to the ImageStatisticsHolder object that holds all statistics information for the image.
 
     All Get-methods for statistics properties formerly accessible directly from an Image object are now moved to the
     new \a ImageStatisticsHolder object.
     */
   StatisticsHolderPointer GetStatistics() const
   {
     return m_ImageStatistics;
   }
 
 protected:
 
   mitkCloneMacro(Self);
 
   int GetSliceIndex(int s = 0, int t = 0, int n = 0) const;
 
   int GetVolumeIndex(int t = 0, int n = 0) const;
 
   void ComputeOffsetTable();
 
   virtual bool IsValidTimeStep(int t) const;
 
   virtual void Expand( unsigned int timeSteps );
 
   virtual ImageDataItemPointer AllocateSliceData(int s = 0, int t = 0, int n = 0, void *data = NULL, ImportMemoryManagementType importMemoryManagement = CopyMemory);
 
   virtual ImageDataItemPointer AllocateVolumeData(int t = 0, int n = 0, void *data = NULL, ImportMemoryManagementType importMemoryManagement = CopyMemory);
 
   virtual ImageDataItemPointer AllocateChannelData(int n = 0, void *data = NULL, ImportMemoryManagementType importMemoryManagement = CopyMemory);
 
   Image();
 
   Image(const Image &other);
 
   virtual ~Image();
 
   virtual void Clear();
 
   //## @warning Has to be called by every Initialize method!
   virtual void Initialize();
 
   virtual void PrintSelf(std::ostream& os, itk::Indent indent) const;
 
   mutable ImageDataItemPointerArray m_Channels;
   mutable ImageDataItemPointerArray m_Volumes;
   mutable ImageDataItemPointerArray m_Slices;
 
   unsigned int m_Dimension;
 
   unsigned int* m_Dimensions;
 
   ImageDescriptor::Pointer m_ImageDescriptor;
 
   size_t *m_OffsetTable;
   ImageDataItemPointer m_CompleteData;
 
   // Image statistics Holder replaces the former implementation directly inside this class
   friend class ImageStatisticsHolder;
   StatisticsHolderPointer m_ImageStatistics;
 
 private:
 
   /** Stores all existing ImageReadAccessors */
   std::vector<ImageAccessorBase*> m_Readers;
   /** Stores all existing ImageWriteAccessors */
   std::vector<ImageAccessorBase*> m_Writers;
   /** Stores all existing ImageVtkAccessors */
   std::vector<ImageAccessorBase*> m_VtkReaders;
 
   /** A mutex, which needs to be locked to manage m_Readers and m_Writers */
   itk::SimpleFastMutexLock m_ReadWriteLock;
   /** A mutex, which needs to be locked to manage m_VtkReaders */
   itk::SimpleFastMutexLock m_VtkReadersLock;
 
 };
 
  /**
  * @brief Equal A function comparing two images for beeing equal in meta- and imagedata
  * @warning This method is deprecated and will not be available in the future. Use the \a bool mitk::Equal(const mitk::Image& i1, const mitk::Image& i2) instead.
  *
  * @ingroup MITKTestingAPI
  *
  * Following aspects are tested for equality:
  *  - dimension of the images
  *  - size of the images
  *  - pixel type
  *  - pixel values : pixel values are expected to be identical at each position ( for other options see mitk::CompareImageFilter )
  *
  * @param rightHandSide An image to be compared
  * @param leftHandSide An image to be compared
  * @param eps Tolarence for comparison. You can use mitk::eps in most cases.
  * @param verbose Flag indicating if the user wants detailed console output or not.
  * @return true, if all subsequent comparisons are true, false otherwise
  */
 DEPRECATED (MITK_CORE_EXPORT bool Equal( const mitk::Image* leftHandSide, const mitk::Image* rightHandSide, ScalarType eps, bool verbose ));
 
 /**
 * @brief Equal A function comparing two images for beeing equal in meta- and imagedata
 *
 * @ingroup MITKTestingAPI
 *
 * Following aspects are tested for equality:
 *  - dimension of the images
 *  - size of the images
 *  - pixel type
 *  - pixel values : pixel values are expected to be identical at each position ( for other options see mitk::CompareImageFilter )
 *
 * @param rightHandSide An image to be compared
 * @param leftHandSide An image to be compared
 * @param eps Tolarence for comparison. You can use mitk::eps in most cases.
 * @param verbose Flag indicating if the user wants detailed console output or not.
 * @return true, if all subsequent comparisons are true, false otherwise
 */
 MITK_CORE_EXPORT bool Equal( const mitk::Image& leftHandSide, const mitk::Image& rightHandSide, ScalarType eps, bool verbose );
 
 
 
 
 //}
 //##Documentation
 //## @brief Cast an itk::Image (with a specific type) to an mitk::Image.
 //##
 //## CastToMitkImage does not cast pixel types etc., just image data
 //## Needs "mitkImage.h" header included.
 //## If you get a compile error, try image.GetPointer();
 //## @ingroup Adaptor
 //## \sa mitkITKImageImport
 template <typename ItkOutputImageType>
 void CastToMitkImage(const itk::SmartPointer<ItkOutputImageType>& itkimage, itk::SmartPointer<mitk::Image>& mitkoutputimage)
 {
   if(mitkoutputimage.IsNull())
   {
     mitkoutputimage = mitk::Image::New();
   }
   mitkoutputimage->InitializeByItk(itkimage.GetPointer());
   mitkoutputimage->SetChannel(itkimage->GetBufferPointer());
 }
 
 //##Documentation
 //## @brief Cast an itk::Image (with a specific type) to an mitk::Image.
 //##
 //## CastToMitkImage does not cast pixel types etc., just image data
 //## Needs "mitkImage.h" header included.
 //## If you get a compile error, try image.GetPointer();
 //## @ingroup Adaptor
 //## \sa mitkITKImageImport
 template <typename ItkOutputImageType>
 void CastToMitkImage(const ItkOutputImageType* itkimage, itk::SmartPointer<mitk::Image>& mitkoutputimage)
 {
   if(mitkoutputimage.IsNull())
   {
     mitkoutputimage = mitk::Image::New();
   }
   mitkoutputimage->InitializeByItk(itkimage);
   mitkoutputimage->SetChannel(itkimage->GetBufferPointer());
 }
 } // namespace mitk
 
 #endif /* MITKIMAGE_H_HEADER_INCLUDED_C1C2FCD2 */
diff --git a/Core/Code/DataManagement/mitkImagePixelReadAccessor.h b/Core/Code/DataManagement/mitkImagePixelReadAccessor.h
index 252131513b..1fd6f79cf3 100644
--- a/Core/Code/DataManagement/mitkImagePixelReadAccessor.h
+++ b/Core/Code/DataManagement/mitkImagePixelReadAccessor.h
@@ -1,171 +1,171 @@
 /*===================================================================
 
 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 MITKIMAGEPIXELREADACCESSOR_H
 #define MITKIMAGEPIXELREADACCESSOR_H
 
 #include <algorithm>
 #include <itkIndex.h>
 #include <itkPoint.h>
 #include <itkSmartPointer.h>
 #include "mitkImageDataItem.h"
 #include "mitkPixelType.h"
 #include "mitkImage.h"
 #include "mitkImageReadAccessor.h"
 #include "mitkImagePixelAccessor.h"
 
 namespace mitk {
 
 class Image;
 
 typedef itk::SmartPointer<mitk::Image> ImagePointer;
 
 //##Documentation
 //## @brief Gives locked and index-based read access for a particular image part.
 //## The class provides several set- and get-methods, which allow an easy pixel access.
 //## It needs to know about pixel type and dimension of its image at compile time.
 //## @tparam TPixel defines the PixelType
 //## @tparam VDimension defines the dimension for accessing data
 //## @ingroup Data
 template <class TPixel, unsigned int VDimension = 3>
 class ImagePixelReadAccessor : public ImagePixelAccessor<TPixel, VDimension>
 {
   friend class Image;
 
 public:
    typedef ImagePixelAccessor<TPixel,VDimension> ImagePixelAccessorType;
 
   /** \brief Instantiates a mitk::ImageReadAccessor (see its doxygen page for more details)
      *  \param Image::Pointer specifies the associated Image
      *  \param ImageDataItem* specifies the allocated image part
      *  \param OptionFlags properties from mitk::ImageAccessorBase::Options can be chosen and assembled with bitwise unification.
      *  \throws mitk::Exception if the Constructor was created inappropriately
      *  \throws mitk::MemoryIsLockedException if requested image area is exclusively locked and mitk::ImageAccessorBase::ExceptionIfLocked is set in OptionFlags
      *
      *   Includes a check if typeid of PixelType coincides with templated TPixel
      *   and a check if VDimension equals to the Dimension of the Image.*/
   ImagePixelReadAccessor(
       ImagePointer iP,
       ImageDataItem* iDI = NULL,
       int OptionFlags = ImageAccessorBase::DefaultBehavior
       ) :
     ImagePixelAccessor<TPixel, VDimension>(iP,iDI),
     m_ReadAccessor(iP, iDI, OptionFlags)
   {
 
     // Check if Dimensions are correct
     if(ImagePixelAccessor<TPixel,VDimension>::m_ImageDataItem == NULL) {
       if(m_ReadAccessor.m_Image->GetDimension() != VDimension)
         mitkThrow() << "Invalid ImageAccessor: The Dimensions of ImageAccessor and Image are not equal. They have to be equal if an entire image is requested";
     }
     else {
       if(ImagePixelAccessor<TPixel,VDimension>::m_ImageDataItem->GetDimension() != VDimension)
         mitkThrow() << "Invalid ImageAccessor: The Dimensions of ImageAccessor and ImageDataItem are not equal.";
     }
 
     // Check if PixelType is correct
     if(!(m_ReadAccessor.m_Image->GetPixelType() ==  mitk::MakePixelType< itk::Image<TPixel, VDimension> >()) )
     {
       mitkThrow() << "Invalid ImageAccessor: PixelTypes of Image and ImageAccessor are not equal";
     }
 
 
   }
 
   /** Destructor informs Image to unlock memory. */
   virtual ~ImagePixelReadAccessor()
   {
   }
 
   /** Returns a const reference to the pixel at given index. */
   const TPixel & GetPixelByIndex(const itk::Index<VDimension>& idx) const
   {
      unsigned int offset = ImagePixelAccessorType::GetOffset(idx);
 
     return *(((TPixel*)m_ReadAccessor.m_AddressBegin) + offset);
   }
 
   /** Extends GetPixel by integrating index validation to prevent overflow.
     * \throws mitk::Exception in case of overflow
     */
   const TPixel & GetPixelByIndexSafe(const itk::Index<VDimension>& idx) const
   {
     unsigned int offset = ImagePixelAccessorType::GetOffset(idx);
 
     TPixel* targetAddress = ((TPixel*)m_ReadAccessor.m_AddressBegin) + offset;
 
     if(!(targetAddress >= m_ReadAccessor.m_AddressBegin && targetAddress < m_ReadAccessor.m_AddressEnd))
     {
       mitkThrow() << "ImageAccessor Overflow: image access exceeds the requested image area at " << idx << ".";
     }
 
     return *targetAddress;
   }
 
 
   /** Returns a const reference to the pixel at given world coordinate - works only with three-dimensional ImageAccessor */
   const TPixel & GetPixelByWorldCoordinates(mitk::Point3D position)
   {
-    Index3D itkIndex;
+    itk::Index<3> itkIndex;
     m_ReadAccessor.m_Image->GetGeometry()->WorldToIndex(position, itkIndex);
 
     return GetPixelByIndex( itkIndex);
   }
 
 
   /** Returns a const reference to the pixel at given world coordinate - works only with four-dimensional ImageAccessor */
   const TPixel & GetPixelByWorldCoordinates(mitk::Point3D position, unsigned int timestep)
   {
-    Index3D itkIndex;
+    itk::Index<3> itkIndex;
     m_ReadAccessor.m_Image->GetGeometry()->WorldToIndex(position, itkIndex);
     if (m_ReadAccessor.m_Image->GetTimeSteps() < timestep)
     {
       timestep = m_ReadAccessor.m_Image->GetTimeSteps();
     }
     itk::Index<4> itk4Index;
     for(int i=0; i<3; ++i)
       itk4Index[i] = itkIndex[i];
 
     itk4Index[3] = timestep;
     return GetPixelByIndex( itk4Index );
   }
 
 
   /** \brief Gives const access to the data. */
   virtual inline const TPixel * GetConstData()
   {
     return (TPixel*) m_ReadAccessor.m_AddressBegin;
   }
 
 protected:
 
   // protected members
 
 private:
 
   ImageReadAccessor m_ReadAccessor;
 
   ImagePixelReadAccessor& operator=(const ImagePixelReadAccessor&);  // Not implemented on purpose.
   ImagePixelReadAccessor(const ImagePixelReadAccessor&);
 
 };
 
 }
 
 #endif // MITKIMAGEPIXELREADACCESSOR_H
 
 
 
diff --git a/Core/Code/DataManagement/mitkImagePixelWriteAccessor.h b/Core/Code/DataManagement/mitkImagePixelWriteAccessor.h
index ccc2c58002..1e79de3cc6 100644
--- a/Core/Code/DataManagement/mitkImagePixelWriteAccessor.h
+++ b/Core/Code/DataManagement/mitkImagePixelWriteAccessor.h
@@ -1,171 +1,171 @@
 /*===================================================================
 
 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 MITKIMAGEPIXELWRITEACCESSOR_H
 #define MITKIMAGEPIXELWRITEACCESSOR_H
 
 #include "mitkImagePixelAccessor.h"
 #include "mitkImageWriteAccessor.h"
 
 namespace mitk {
 
 //##Documentation
 //## @brief Gives locked and index-based write access for a particular image part.
 //## The class provides several set- and get-methods, which allow an easy pixel access.
 //## It needs to know about pixel type and dimension of its image at compile time.
 //## @tparam TPixel defines the PixelType
 //## @tparam VDimension defines the dimension for accessing data
 //## @ingroup Data
 template <class TPixel, unsigned int VDimension = 3>
 class ImagePixelWriteAccessor : public ImagePixelAccessor<TPixel, VDimension>
 {
   friend class Image;
 
 public:
     typedef ImagePixelAccessor<TPixel,VDimension> ImagePixelAccessorType;
 
   /** \brief Instantiates a mitk::ImageWriteAccessor (see its doxygen page for more details)
      *  \param Image::Pointer specifies the associated Image
      *  \param ImageDataItem* specifies the allocated image part
      *  \param OptionFlags properties from mitk::ImageAccessorBase::Options can be chosen and assembled with bitwise unification.
      *  \throws mitk::Exception if the Constructor was created inappropriately
      *  \throws mitk::MemoryIsLockedException if requested image area is exclusively locked and mitk::ImageAccessorBase::ExceptionIfLocked is set in OptionFlags
      *
      *   Includes a check if typeid of PixelType coincides with templated TPixel
      *   and a check if VDimension equals to the Dimension of the Image.*/
   ImagePixelWriteAccessor(
       ImagePointer iP,
       ImageDataItem* iDI = NULL,
       int OptionFlags = ImageAccessorBase::DefaultBehavior
       ) :
     ImagePixelAccessor<TPixel, VDimension>(iP,iDI),
     m_WriteAccessor(iP , iDI, OptionFlags)
   {
 
     // Check if Dimensions are correct
     if(ImagePixelAccessor<TPixel,VDimension>::m_ImageDataItem == NULL) {
       if(m_WriteAccessor.m_Image->GetDimension() != VDimension)
         mitkThrow() << "Invalid ImageAccessor: The Dimensions of ImageAccessor and Image are not equal. They have to be equal if an entire image is requested";
     }
     else {
       if(ImagePixelAccessor<TPixel,VDimension>::m_ImageDataItem->GetDimension() != VDimension)
         mitkThrow() << "Invalid ImageAccessor: The Dimensions of ImageAccessor and ImageDataItem are not equal.";
     }
 
     // Check if PixelType is correct
     if(!(m_WriteAccessor.m_Image->GetPixelType() ==  mitk::MakePixelType< itk::Image<TPixel, VDimension> >()) )
     {
       mitkThrow() << "Invalid ImageAccessor: PixelTypes of Image and ImageAccessor are not equal";
     }
 
 
 
   }
 
 
 /** \brief Gives full data access. */
     virtual inline TPixel * GetData()
     {
       return (TPixel*) m_WriteAccessor.m_AddressBegin;
     }
 
 
   /// Sets a pixel value at given index.
   void SetPixelByIndex(const itk::Index<VDimension>& idx, const TPixel & value)
   {
     unsigned int offset = ImagePixelAccessor<TPixel,VDimension>::GetOffset(idx);
 
     *(((TPixel*)m_WriteAccessor.m_AddressBegin) + offset) = value;
   }
 
 
   /** Extends SetPixel by integrating index validation to prevent overflow. */
   void SetPixelByIndexSafe(const itk::Index<VDimension>& idx, const TPixel & value)
   {
     unsigned int offset = ImagePixelAccessorType::GetOffset(idx);
 
     TPixel* targetAddress = ((TPixel*)m_WriteAccessor.m_AddressBegin) + offset;
 
     if(targetAddress >= m_WriteAccessor.m_AddressBegin && targetAddress < m_WriteAccessor.m_AddressEnd)
     {
       *targetAddress = value;
     }
     else
     {
       //printf("image dimensions = %d, %d, %d\n", imageDims[0], imageDims[1], imageDims[2]);
       //printf("m_AddressBegin: %p, m_AddressEnd: %p, offset: %u\n", m_WriteAccessor.m_AddressBegin, m_WriteAccessor.m_AddressEnd, offset);
       mitkThrow() << "ImageAccessor Overflow: image access exceeds the requested image area at " << idx << ".";
     }
 
   }
 
 
   /** Returns a const reference to the pixel at given index. */
   const TPixel & GetPixelByIndex(const itk::Index<VDimension>& idx) const
   {
     unsigned int offset = ImagePixelAccessorType::GetOffset(idx);
 
     return *(((TPixel*)m_WriteAccessor.m_AddressBegin) + offset);
   }
 
 
   /** Extends GetPixel by integrating index validation to prevent overflow.
     * \throws mitk::Exception in case of overflow
     */
   const TPixel & GetPixelByIndexSafe(const itk::Index<VDimension>& idx) const
   {
     unsigned int offset = ImagePixelAccessorType::GetOffset(idx);
 
     TPixel* targetAddress = ((TPixel*)m_WriteAccessor.m_AddressBegin) + offset;
 
     if(!(targetAddress >= m_WriteAccessor.m_AddressBegin && targetAddress < m_WriteAccessor.m_AddressEnd))
     {
       mitkThrow() << "ImageAccessor Overflow: image access exceeds the requested image area at " << idx << ".";
     }
 
     return *targetAddress;
   }
 
 
   /** Returns a const reference to the pixel at given world coordinate - works only with three-dimensional ImageAccessor */
   const TPixel & GetPixelByWorldCoordinates(mitk::Point3D position)
   {
-    Index3D itkIndex;
+    itk::Index<3> itkIndex;
     m_WriteAccessor.m_Image->GetGeometry()->WorldToIndex(position, itkIndex);
 
     return GetPixelByIndex( itkIndex);
   }
 
   /** Returns a reference to the pixel at given world coordinate */
   void SetPixelByWorldCoordinates(const mitk::Point3D&, const TPixel & value, unsigned int timestep = 0);
 
   virtual ~ImagePixelWriteAccessor()
   {
 
   }
 
 
 private:
 
   ImageWriteAccessor m_WriteAccessor;
 
   ImagePixelWriteAccessor& operator=(const ImagePixelWriteAccessor&);  // Not implemented on purpose.
   ImagePixelWriteAccessor(const ImagePixelWriteAccessor &);
 
 };
 
 }
 #endif // MITKIMAGEWRITEACCESSOR_H
diff --git a/Core/Code/DataManagement/mitkTypedefs.h b/Core/Code/DataManagement/mitkTypedefs.h
index 0a9ef054f8..c492622cda 100644
--- a/Core/Code/DataManagement/mitkTypedefs.h
+++ b/Core/Code/DataManagement/mitkTypedefs.h
@@ -1,50 +1,46 @@
 /*===================================================================
 
 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 MITKTYPEDEFS_H_
 #define MITKTYPEDEFS_H_
 
 
 #include <itkIndex.h>
 #include <itkContinuousIndex.h>
 #include <itkVector.h>
 #include <itkMatrix.h>
 #include <itkTransform.h>
 #include <vnl/vnl_quaternion.h>
 #include <utility>
 
 #include "mitkTypeBasics.h"
 
 //template<class TCoordRep, unsigned int NPointDimension>  class Vector;
 
 namespace mitk {
 
 typedef vnl_matrix_fixed<ScalarType, 3, 3> VnlMatrix3D;
 
 typedef vnl_vector<ScalarType> VnlVector;
 typedef vnl_vector_ref<ScalarType> VnlVectorRef;
 
-typedef itk::Index<3> Index3D;
-typedef itk::ContinuousIndex<ScalarType, 3> ContinuousIndex3D;
 typedef vnl_quaternion<ScalarType> Quaternion;
 
 typedef itk::NumericTraits<mitk::ScalarType> ScalarTypeNumericTraits;
 
-typedef std::pair<std::string, bool> FileServiceOption;
-
 }
 
 #endif /* MITKTYPEDEFS_H_ */
diff --git a/Core/Code/Testing/mitkExtractSliceFilterTest.cpp b/Core/Code/Testing/mitkExtractSliceFilterTest.cpp
index 7d8a5f8e9a..5997c821f3 100644
--- a/Core/Code/Testing/mitkExtractSliceFilterTest.cpp
+++ b/Core/Code/Testing/mitkExtractSliceFilterTest.cpp
@@ -1,1169 +1,1169 @@
 /*===================================================================
 
 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 <mitkExtractSliceFilter.h>
 #include <mitkTestingMacros.h>
 #include <mitkItkImageFileReader.h>
 #include <itkImageRegionIterator.h>
 #include <mitkImageCast.h>
 #include <itkImage.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkStandardFileLocations.h>
 #include <mitkImageWriter.h>
 #include <mitkITKImageImport.h>
 #include <mitkImagePixelReadAccessor.h>
 #include <mitkRotationOperation.h>
 #include <mitkInteractionConst.h>
 #include <mitkTypes.h>
 
 #include <ctime>
 #include <cstdlib>
 #include <math.h>
 
 
 #include <mitkGeometry3D.h>
 
 #include <vtkImageData.h>
 #include <vtkSmartPointer.h>
 #include <vtkActor.h>
 #include <vtkRenderWindowInteractor.h>
 #include <vtkRenderWindow.h>
 #include <vtkInteractorStyleImage.h>
 #include <vtkRenderer.h>
 #include <vtkImageMapper.h>
 #include <vtkImageReslice.h>
 #include <vtkImageActor.h>
 #include <vtkImageMapToColors.h>
 #include <vtkLookupTable.h>
 #include <vtkTexture.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkPlaneSource.h>
 
 
 //use this to create the test volume on the fly
 #define CREATE_VOLUME
 
 //use this to save the created volume
 //#define SAVE_VOLUME
 
 //use this to calculate the error from the sphere mathematical model to our pixel based one
 //#define CALC_TESTFAILURE_DEVIATION
 
 //use this to render an oblique slice through a specified image
 //#define SHOW_SLICE_IN_RENDER_WINDOW
 
 //use this to have infos printed in mbilog
 //#define EXTRACTOR_DEBUG
 
 
 /*these are the deviations calculated by the function CalcTestFailureDeviation (see for details)*/
 #define Testfailure_Deviation_Mean_128 0.853842
 
 #define Testfailure_Deviation_Volume_128 0.145184
 #define Testfailure_Deviation_Diameter_128 1.5625
 
 
 
 #define Testfailure_Deviation_Mean_256 0.397693
 
 #define Testfailure_Deviation_Volume_256 0.0141357
 #define Testfailure_Deviation_Diameter_256 0.78125
 
 
 
 #define Testfailure_Deviation_Mean_512 0.205277
 
 #define Testfailure_Deviation_Volume_512 0.01993
 #define Testfailure_Deviation_Diameter_512 0.390625
 
 
 
 class mitkExtractSliceFilterTestClass{
 
 public:
 
 
   static void TestSlice(mitk::PlaneGeometry* planeGeometry, std::string testname)
   {
     TestPlane = planeGeometry;
     TestName = testname;
 
     mitk::ScalarType centerCoordValue = TestvolumeSize / 2.0;
     mitk::ScalarType center[3] = {centerCoordValue, centerCoordValue, centerCoordValue};
     mitk::Point3D centerIndex(center);
 
     double radius = TestvolumeSize / 4.0;
     if(TestPlane->Distance(centerIndex) >= radius ) return;//outside sphere
 
 
 
     //feed ExtractSliceFilter
     mitk::ExtractSliceFilter::Pointer slicer = mitk::ExtractSliceFilter::New();
 
     slicer->SetInput(TestVolume);
     slicer->SetWorldGeometry(TestPlane);
     slicer->Update();
 
     MITK_TEST_CONDITION_REQUIRED(slicer->GetOutput() != NULL, "Extractor returned a slice");
 
     mitk::Image::Pointer reslicedImage = slicer->GetOutput();
 
     AccessFixedDimensionByItk(reslicedImage, TestSphereRadiusByItk, 2);
     AccessFixedDimensionByItk(reslicedImage, TestSphereAreaByItk, 2);
 
     /*
     double devArea, devDiameter;
     if(TestvolumeSize == 128.0){ devArea = Testfailure_Deviation_Volume_128; devDiameter = Testfailure_Deviation_Diameter_128; }
     else if(TestvolumeSize == 256.0){devArea = Testfailure_Deviation_Volume_256; devDiameter = Testfailure_Deviation_Diameter_256;}
     else if (TestvolumeSize == 512.0){devArea = Testfailure_Deviation_Volume_512; devDiameter = Testfailure_Deviation_Diameter_512;}
     else{devArea = Testfailure_Deviation_Volume_128; devDiameter = Testfailure_Deviation_Diameter_128;}
     */
 
     std::string areatestName = TestName.append(" area");
     std::string diametertestName = TestName.append(" testing diameter");
 
     //TODO think about the deviation, 1% makes no sense at all
     MITK_TEST_CONDITION(std::abs(100 - testResults.percentageAreaCalcToPixel) < 1, areatestName );
     MITK_TEST_CONDITION(std::abs(100 - testResults.percentageRadiusToPixel) < 1, diametertestName );
 
   #ifdef EXTRACTOR_DEBUG
     MITK_INFO << TestName << " >>> " << "planeDistanceToSphereCenter: " << testResults.planeDistanceToSphereCenter;
     MITK_INFO << "area in pixels: " << testResults.areaInPixel << " <-> area in mm: " << testResults.areaCalculated << " = " << testResults.percentageAreaCalcToPixel << "%";
 
     MITK_INFO << "calculated diameter: " << testResults.diameterCalculated << " <-> diameter in mm: " << testResults.diameterInMM << " <-> diameter in pixel: " << testResults.diameterInPixel << " = " << testResults.percentageRadiusToPixel << "%";
   #endif
   }
 
 
   /*
    * get the radius of the slice of a sphere based on pixel distance from edge to edge of the circle.
    */
   template<typename TPixel, unsigned int VImageDimension>
   static void TestSphereRadiusByItk (itk::Image<TPixel, VImageDimension>* inputImage)
   {
     typedef itk::Image<TPixel, VImageDimension> InputImageType;
 
 
     //set the index to the middle of the image's edge at x and y axis
     typename InputImageType::IndexType currentIndexX;
     currentIndexX[0] = (int)(TestvolumeSize / 2.0);
     currentIndexX[1] = 0;
 
     typename InputImageType::IndexType currentIndexY;
     currentIndexY[0] = 0;
     currentIndexY[1] = (int)(TestvolumeSize / 2.0);
 
 
     //remember the last pixel value
     double lastValueX = inputImage->GetPixel(currentIndexX);
     double lastValueY = inputImage->GetPixel(currentIndexY);
 
 
     //storage for the index marks
                 std::vector<typename InputImageType::IndexType> indicesX;
                 std::vector<typename InputImageType::IndexType> indicesY;
 
 
     /*Get four indices on the edge of the circle*/
     while(currentIndexX[1] < TestvolumeSize && currentIndexX[0] < TestvolumeSize)
     {
       //move x direction
       currentIndexX[1] += 1;
 
       //move y direction
       currentIndexY[0] += 1;
 
       if(inputImage->GetPixel(currentIndexX) > lastValueX)
       {
         //mark the current index
         typename InputImageType::IndexType markIndex;
         markIndex[0] = currentIndexX[0];
         markIndex[1] = currentIndexX[1];
 
 
         indicesX.push_back(markIndex);
       }
       else if( inputImage->GetPixel(currentIndexX) < lastValueX)
       {
         //mark the current index
         typename InputImageType::IndexType markIndex;
         markIndex[0] = currentIndexX[0];
         markIndex[1] = currentIndexX[1] - 1;//value inside the sphere
 
 
         indicesX.push_back(markIndex);
       }
 
       if(inputImage->GetPixel(currentIndexY) > lastValueY)
       {
         //mark the current index
         typename InputImageType::IndexType markIndex;
         markIndex[0] = currentIndexY[0];
         markIndex[1] = currentIndexY[1];
 
 
         indicesY.push_back(markIndex);
       }
       else if( inputImage->GetPixel(currentIndexY) < lastValueY)
       {
         //mark the current index
         typename InputImageType::IndexType markIndex;
         markIndex[0] = currentIndexY[0];
         markIndex[1] = currentIndexY[1] - 1;//value inside the sphere
 
 
         indicesY.push_back(markIndex);
       }
 
 
       //found both marks?
       if(indicesX.size() == 2 && indicesY.size() == 2) break;
 
       //the new 'last' values
       lastValueX = inputImage->GetPixel(currentIndexX);
       lastValueY = inputImage->GetPixel(currentIndexY);
     }
 
     /*
      *If we are here we found the four marks on the edge of the circle.
      *For the case our plane is rotated and shifted, we have to calculate the center of the circle,
      *else the center is the intersection of both straight lines between the marks.
      *When we have the center, the diameter of the circle will be checked to the reference value(math!).
      */
 
     //each distance from the first mark of each direction to the center of the straight line between the marks
     double distanceToCenterX = std::abs(indicesX[0][1] - indicesX[1][1]) / 2.0;
     //double distanceToCenterY = std::abs(indicesY[0][0] - indicesY[1][0]) / 2.0;
 
 
     //the center of the straight lines
     typename InputImageType::IndexType centerX;
     //typename InputImageType::IndexType centerY;
 
     centerX[0] = indicesX[0][0];
     centerX[1] = indicesX[0][1] + distanceToCenterX;
     //TODO think about implicit cast to int. this is not the real center of the image, which could be between two pixels
 
     //centerY[0] = indicesY[0][0] + distanceToCenterY;
     //centerY[1] = inidcesY[0][1];
 
     typename InputImageType::IndexType currentIndex(centerX);
     lastValueX = inputImage->GetPixel(currentIndex);
 
     long sumpixels = 0;
 
                 std::vector<typename InputImageType::IndexType> diameterIndices;
 
     //move up
     while(currentIndex[1] < TestvolumeSize)
     {
       currentIndex[1] += 1;
 
       if( inputImage->GetPixel(currentIndex) != lastValueX)
       {
         typename InputImageType::IndexType markIndex;
         markIndex[0] = currentIndex[0];
         markIndex[1] = currentIndex[1] - 1;
 
         diameterIndices.push_back(markIndex);
         break;
       }
 
       sumpixels++;
       lastValueX = inputImage->GetPixel(currentIndex);
     }
 
     currentIndex[1] -= sumpixels; //move back to center to go in the other direction
     lastValueX = inputImage->GetPixel(currentIndex);
 
     //move down
     while(currentIndex[1] >= 0)
     {
       currentIndex[1] -= 1;
 
       if( inputImage->GetPixel(currentIndex) != lastValueX)
         {
         typename InputImageType::IndexType markIndex;
         markIndex[0] = currentIndex[0];
         markIndex[1] = currentIndex[1];//outside sphere because we want to calculate the distance from edge to edge
 
         diameterIndices.push_back(markIndex);
         break;
       }
 
       sumpixels++;
       lastValueX = inputImage->GetPixel(currentIndex);
     }
 
 
 
     /*
     *Now sumpixels should be the apromximate diameter of the circle. This is checked with the calculated diameter from the plane transformation(math).
     */
     mitk::Point3D volumeCenter;
     volumeCenter[0] = volumeCenter[1] = volumeCenter[2] = TestvolumeSize / 2.0;
 
 
     double planeDistanceToSphereCenter = TestPlane->Distance(volumeCenter);
 
 
     double sphereRadius = TestvolumeSize/4.0;
 
     //calculate the radius of the circle cut from the sphere by the plane
     double diameter = 2.0 * std::sqrt(std::pow(sphereRadius, 2) - std::pow( planeDistanceToSphereCenter  , 2));
 
     double percentageRadiusToPixel = 100 /  diameter  * sumpixels;
 
 
 
     /*
      *calculate the radius in mm by the both marks of the center line by using the world coordinates
      */
     //get the points as 3D coordinates
     mitk::Vector3D diameterPointRight, diameterPointLeft;
 
     diameterPointRight[2] = diameterPointLeft[2] = 0.0;
 
     diameterPointLeft[0] = diameterIndices[0][0];
     diameterPointLeft[1] = diameterIndices[0][1];
 
     diameterPointRight[0] = diameterIndices[1][0];
     diameterPointRight[1] = diameterIndices[1][1];
 
     //transform to worldcoordinates
     TestVolume->GetGeometry()->IndexToWorld(diameterPointLeft, diameterPointLeft);
     TestVolume->GetGeometry()->IndexToWorld(diameterPointRight, diameterPointRight);
 
     //euklidian distance
     double diameterInMM = ( (diameterPointLeft * -1.0) + diameterPointRight).GetNorm();
 
 
     testResults.diameterInMM = diameterInMM;
     testResults.diameterCalculated = diameter;
     testResults.diameterInPixel = sumpixels;
     testResults.percentageRadiusToPixel = percentageRadiusToPixel;
     testResults.planeDistanceToSphereCenter = planeDistanceToSphereCenter;
   }
 
 
 
 
 
   /*brute force the area pixel by pixel*/
   template<typename TPixel, unsigned int VImageDimension>
   static void TestSphereAreaByItk (itk::Image<TPixel, VImageDimension>* inputImage)
   {
     typedef itk::Image<TPixel, VImageDimension> InputImageType;
     typedef itk::ImageRegionConstIterator< InputImageType > ImageIterator;
 
 
     ImageIterator imageIterator( inputImage, inputImage->GetLargestPossibleRegion() );
     imageIterator.GoToBegin();
 
     int sumPixelsInArea = 0;
 
     while( !imageIterator.IsAtEnd() )
     {
       if(inputImage->GetPixel(imageIterator.GetIndex()) == pixelValueSet) sumPixelsInArea++;
       ++imageIterator;
     }
 
     mitk::Point3D volumeCenter;
     volumeCenter[0] = volumeCenter[1] = volumeCenter[2] = TestvolumeSize / 2.0;
 
 
     double planeDistanceToSphereCenter = TestPlane->Distance(volumeCenter);
 
     double sphereRadius = TestvolumeSize/4.0;
 
     //calculate the radius of the circle cut from the sphere by the plane
     double radius = std::sqrt(std::pow(sphereRadius, 2) - std::pow( planeDistanceToSphereCenter  , 2));
 
     double areaInMM = 3.14159265358979 * std::pow(radius, 2);
 
 
     testResults.areaCalculated = areaInMM;
     testResults.areaInPixel = sumPixelsInArea;
     testResults.percentageAreaCalcToPixel = 100 / areaInMM * sumPixelsInArea;
   }
 
 
 
   /*
    * random a voxel. define plane through this voxel. reslice at the plane. compare the pixel vaues of the voxel
    * in the volume with the pixel value in the resliced image.
    * there are some indice shifting problems which causes the test to fail for oblique planes. seems like the chosen
    * worldcoordinate is not corrresponding to the index in the 2D image. and so the pixel values are not the same as
    * expected.
    */
   static void PixelvalueBasedTest()
   {
     /* setup itk image */
     typedef itk::Image<unsigned short, 3> ImageType;
 
     typedef itk::ImageRegionConstIterator< ImageType > ImageIterator;
 
     ImageType::Pointer image = ImageType::New();
 
     ImageType::IndexType start;
     start[0] = start[1] = start[2] = 0;
 
     ImageType::SizeType size;
     size[0] = size[1] = size[2] = 32;
 
     ImageType::RegionType imgRegion;
     imgRegion.SetSize(size);
     imgRegion.SetIndex(start);
 
     image->SetRegions(imgRegion);
     image->SetSpacing(1.0);
     image->Allocate();
 
 
     ImageIterator imageIterator( image, image->GetLargestPossibleRegion() );
     imageIterator.GoToBegin();
 
 
     unsigned short pixelValue = 0;
 
     //fill the image with distinct values
     while ( !imageIterator.IsAtEnd() )
     {
       image->SetPixel(imageIterator.GetIndex(), pixelValue);
       ++imageIterator;
       ++pixelValue;
     }
     /* end setup itk image */
 
 
 
     mitk::Image::Pointer imageInMitk;
     CastToMitkImage(image, imageInMitk);
 
 
 
     /*mitk::ImageWriter::Pointer writer = mitk::ImageWriter::New();
     writer->SetInput(imageInMitk);
     std::string file = "C:\\Users\\schroedt\\Desktop\\cube.nrrd";
     writer->SetFileName(file);
     writer->Update();*/
 
                 PixelvalueBasedTestByPlane(imageInMitk, mitk::PlaneGeometry::Frontal);
                 PixelvalueBasedTestByPlane(imageInMitk, mitk::PlaneGeometry::Sagittal);
                 PixelvalueBasedTestByPlane(imageInMitk, mitk::PlaneGeometry::Axial);
 
   }
 
   static void PixelvalueBasedTestByPlane(mitk::Image* imageInMitk, mitk::PlaneGeometry::PlaneOrientation orientation){
 
     typedef itk::Image<unsigned short, 3> ImageType;
 
     //set the seed of the rand function
     srand((unsigned)time(0));
 
     /* setup a random orthogonal plane */
     int sliceindex = 17;//rand() % 32;
     bool isFrontside = true;
     bool isRotated = false;
 
 
                 if( orientation == mitk::PlaneGeometry::Axial)
     {
       /*isFrontside = false;
       isRotated = true;*/
     }
 
 
 
     mitk::PlaneGeometry::Pointer plane = mitk::PlaneGeometry::New();
 
 
     plane->InitializeStandardPlane(imageInMitk->GetGeometry(), orientation, sliceindex, isFrontside, isRotated);
 
     mitk::Point3D origin = plane->GetOrigin();
     mitk::Vector3D normal;
     normal = plane->GetNormal();
 
 
     normal.Normalize();
 
     origin += normal * 0.5;//pixelspacing is 1, so half the spacing is 0.5
 
     plane->SetOrigin(origin);
 
     //we dont need this any more, because we are only testing orthogonal planes
     /*mitk::Vector3D rotationVector;
     rotationVector[0] = randFloat();
     rotationVector[1] = randFloat();
     rotationVector[2] = randFloat();
 
 
     float degree = randFloat() * 180.0;
 
     mitk::RotationOperation* op = new mitk::RotationOperation(mitk::OpROTATE, plane->GetCenter(), rotationVector, degree);
     plane->ExecuteOperation(op);
     delete op;*/
 
     /* end setup plane */
 
 
     /* define a point in the 3D volume.
      * add the two axis vectors of the plane (each multiplied with a
      * random number) to the origin. now the two random numbers
      * become our index coordinates in the 2D image, because the
      * length of the axis vectors is 1.
      */
     mitk::Point3D planeOrigin =  plane->GetOrigin();
     mitk::Vector3D axis0, axis1;
     axis0 = plane->GetAxisVector(0);
     axis1 = plane->GetAxisVector(1);
     axis0.Normalize();
     axis1.Normalize();
 
 
     unsigned char n1 = 7;// rand() % 32;
     unsigned char n2 = 13;// rand() % 32;
 
 
     mitk::Point3D testPoint3DInWorld;
     testPoint3DInWorld = planeOrigin + (axis0 * n1) + (axis1 * n2);
 
     //get the index of the point in the 3D volume
     ImageType::IndexType testPoint3DInIndex;
     imageInMitk->GetGeometry()->WorldToIndex(testPoint3DInWorld, testPoint3DInIndex);
 
-    mitk::Index3D testPoint2DInIndex;
+    itk::Index<3> testPoint2DInIndex;
 
     /* end define a point in the 3D volume.*/
 
 
     //do reslicing at the plane
     mitk::ExtractSliceFilter::Pointer slicer = mitk::ExtractSliceFilter::New();
     slicer->SetInput(imageInMitk);
     slicer->SetWorldGeometry(plane);
 
     slicer->Update();
 
     mitk::Image::Pointer slice = slicer->GetOutput();
 
     // Get TestPoiont3D as Index in Slice
     slice->GetGeometry()->WorldToIndex(testPoint3DInWorld,testPoint2DInIndex);
 
 
     mitk::Point3D p, sliceIndexToWorld, imageIndexToWorld;
     p[0] = testPoint2DInIndex[0];
     p[1] = testPoint2DInIndex[1];
     p[2] = testPoint2DInIndex[2];
     slice->GetGeometry()->IndexToWorld(p, sliceIndexToWorld);
 
     p[0] = testPoint3DInIndex[0];
     p[1] = testPoint3DInIndex[1];
     p[2] = testPoint3DInIndex[2];
     imageInMitk->GetGeometry()->IndexToWorld(p, imageIndexToWorld);
 
     itk::Index<2> testPoint2DIn2DIndex;
     testPoint2DIn2DIndex[0] = testPoint2DInIndex[0];
     testPoint2DIn2DIndex[1] = testPoint2DInIndex[1];
 
     typedef mitk::ImagePixelReadAccessor< unsigned short, 3 > VolumeReadAccessorType;
     typedef mitk::ImagePixelReadAccessor< unsigned short, 2 > SliceReadAccessorType;
     VolumeReadAccessorType VolumeReadAccessor( imageInMitk );
     SliceReadAccessorType SliceReadAccessor( slice );
 
     //compare the pixelvalues of the defined point in the 3D volume with the value of the resliced image
     unsigned short valueAt3DVolume = VolumeReadAccessor.GetPixelByIndex( testPoint3DInIndex );
     unsigned short valueAtSlice = SliceReadAccessor.GetPixelByIndex( testPoint2DIn2DIndex );
 
     //valueAt3DVolume == valueAtSlice is not always working. because of rounding errors
     //indices are shifted
     MITK_TEST_CONDITION(valueAt3DVolume == valueAtSlice, "comparing pixelvalues for orthogonal plane");
 
 
     vtkSmartPointer<vtkImageData> imageInVtk = vtkSmartPointer<vtkImageData>::New();
     imageInVtk = imageInMitk->GetVtkImageData();
     vtkSmartPointer<vtkImageData> sliceInVtk = vtkSmartPointer<vtkImageData>::New();
     sliceInVtk = slice->GetVtkImageData();
 
     double PixelvalueByMitkOutput = sliceInVtk->GetScalarComponentAsDouble(n1, n2, 0, 0);
     //double valueVTKinImage = imageInVtk->GetScalarComponentAsDouble(testPoint3DInIndex[0], testPoint3DInIndex[1], testPoint3DInIndex[2], 0);
 
 
     /* Test that everything is working equally if vtkoutput is used instead of the default output
      * from mitk ImageToImageFilter
      */
     mitk::ExtractSliceFilter::Pointer slicerWithVtkOutput = mitk::ExtractSliceFilter::New();
     slicerWithVtkOutput->SetInput(imageInMitk);
     slicerWithVtkOutput->SetWorldGeometry(plane);
     slicerWithVtkOutput->SetVtkOutputRequest(true);
 
     slicerWithVtkOutput->Update();
     vtkSmartPointer<vtkImageData> vtkImageByVtkOutput = vtkSmartPointer<vtkImageData>::New();
     vtkImageByVtkOutput = slicerWithVtkOutput->GetVtkOutput();
     double PixelvalueByVtkOutput = vtkImageByVtkOutput->GetScalarComponentAsDouble(n1, n2, 0, 0);
 
     MITK_TEST_CONDITION(PixelvalueByMitkOutput == PixelvalueByVtkOutput, "testing convertion of image output vtk->mitk by reslicer");
 
 
 
 /*================ mbilog outputs ===========================*/
 #ifdef EXTRACTOR_DEBUG
     MITK_INFO << "\n" << "TESTINFO index: " << sliceindex << " orientation: " << orientation << " frontside: " << isFrontside << " rotated: " << isRotated;
     MITK_INFO << "\n" << "slice index to world: " << sliceIndexToWorld;
     MITK_INFO << "\n" << "image index to world: "  << imageIndexToWorld;
 
     MITK_INFO  << "\n" << "vtk: slice: " << PixelvalueByMitkOutput << ", image: "<< valueVTKinImage;
 
     MITK_INFO << "\n" << "testPoint3D InWorld" << testPoint3DInWorld << " is " << testPoint2DInIndex << " in 2D";
     MITK_INFO << "\n" << "randoms: " << ((int)n1) << ", " << ((int)n2);
     MITK_INFO << "\n" << "point is inside plane: " << plane->IsInside(testPoint3DInWorld) << " and volume: " << imageInMitk->GetGeometry()->IsInside(testPoint3DInWorld);
 
     MITK_INFO << "\n" << "volume idx: " << testPoint3DInIndex << " = " << valueAt3DVolume ;
     MITK_INFO << "\n" << "volume world: " << testPoint3DInWorld << " = " << valueAt3DVolumeByWorld ;
     MITK_INFO << "\n" << "slice idx: " << testPoint2DInIndex << " = " << valueAtSlice ;
 
-    mitk::Index3D curr;
+    itk::Index<3> curr;
     curr[0] = curr[1] = curr[2] = 0;
 
     for( int i = 0; i < 32 ; ++i){
       for( int j = 0; j < 32; ++j){
         ++curr[1];
         if(SliceReadAccessor.GetPixelByIndex( curr ) == valueAt3DVolume){
           MITK_INFO << "\n" << valueAt3DVolume << " MATCHED mitk " << curr;
         }
       }
       curr[1] = 0;
       ++curr[0];
     }
 
     typedef itk::Image<unsigned short, 2> Image2DType;
 
     Image2DType::Pointer img  = Image2DType::New();
     CastToItkImage(slice, img);
     typedef itk::ImageRegionConstIterator< Image2DType > Iterator2D;
 
     Iterator2D iter(img, img->GetLargestPossibleRegion());
     iter.GoToBegin();
     while( !iter.IsAtEnd() ){
 
       if(img->GetPixel(iter.GetIndex()) == valueAt3DVolume) MITK_INFO << "\n" << valueAt3DVolume << " MATCHED itk " << iter.GetIndex();
 
       ++iter;
     }
 #endif //EXTRACTOR_DEBUG
   }
 
 
   /* random a float value */
   static float randFloat(){ return (((float)rand()+1.0) / ((float)RAND_MAX + 1.0)) + (((float)rand()+1.0) / ((float)RAND_MAX + 1.0)) / ((float)RAND_MAX + 1.0);}
 
 
 
 
   /* create a sphere with the size of the given testVolumeSize*/
   static void InitializeTestVolume()
   {
 
   #ifdef CREATE_VOLUME
 
 
     //do sphere creation
     ItkVolumeGeneration();
 
     #ifdef SAVE_VOLUME
       //save in file
       mitk::ImageWriter::Pointer writer = mitk::ImageWriter::New();
       writer->SetInput(TestVolume);
 
 
       std::string file;
 
       std::ostringstream filename;
       filename << "C:\\home\\schroedt\\MITK\\Modules\\ImageExtraction\\Testing\\Data\\sphere_";
       filename << TestvolumeSize;
       filename << ".nrrd";
 
       file = filename.str();
 
       writer->SetFileName(file);
       writer->Update();
     #endif//SAVE_VOLUME
 
   #endif
 
 
   #ifndef CREATE_VOLUME //read from file
 
     mitk::StandardFileLocations::Pointer locator = mitk::StandardFileLocations::GetInstance();
 
     std::string filename = locator->FindFile("sphere_512.nrrd.mhd", "Modules/ImageExtraction/Testing/Data");
 
     mitk::ItkImageFileReader::Pointer reader = mitk::ItkImageFileReader::New();
     reader->SetFileName(filename);
 
     reader->Update();
     TestVolume = reader->GetOutput();
 
   #endif
 
   #ifdef CALC_TESTFAILURE_DEVIATION
     //get the TestFailureDeviation in %
     AccessFixedDimensionByItk(TestVolume, CalcTestFailureDeviation, 3);
   #endif
   }
 
 
   //the test result of the sphere reslice
   struct SliceProperties{
     double planeDistanceToSphereCenter;
     double diameterInMM;
     double diameterInPixel;
     double diameterCalculated;
     double percentageRadiusToPixel;
     double areaCalculated;
     double areaInPixel;
     double percentageAreaCalcToPixel;
   };
 
 
   static mitk::Image::Pointer TestVolume;
   static double TestvolumeSize;
   static mitk::PlaneGeometry::Pointer TestPlane;
   static std::string TestName;
   static unsigned char pixelValueSet;
   static SliceProperties testResults;
   static double TestFailureDeviation;
 
 
 
 private:
 
   /*
    * Generate a sphere with a radius of TestvolumeSize / 4.0
    */
   static void ItkVolumeGeneration ()
   {
     typedef itk::Image<unsigned char, 3> TestVolumeType;
 
     typedef itk::ImageRegionConstIterator< TestVolumeType > ImageIterator;
 
     TestVolumeType::Pointer sphereImage = TestVolumeType::New();
 
     TestVolumeType::IndexType start;
     start[0] = start[1] = start[2] = 0;
 
     TestVolumeType::SizeType size;
     size[0] = size[1] = size[2] = TestvolumeSize;
 
     TestVolumeType::RegionType imgRegion;
     imgRegion.SetSize(size);
     imgRegion.SetIndex(start);
 
     sphereImage->SetRegions(imgRegion);
     sphereImage->SetSpacing(1.0);
     sphereImage->Allocate();
 
     sphereImage->FillBuffer(0);
 
 
     mitk::Vector3D center;
     center[0] = center[1] = center[2] = TestvolumeSize / 2.0;
 
 
     double radius = TestvolumeSize / 4.0;
 
     double pixelValue = pixelValueSet;
 
     double distanceToCenter = 0.0;
 
 
     ImageIterator imageIterator( sphereImage, sphereImage->GetLargestPossibleRegion() );
     imageIterator.GoToBegin();
 
 
     mitk::Vector3D currentVoxelInIndex;
 
     while ( !imageIterator.IsAtEnd() )
     {
       currentVoxelInIndex[0] = imageIterator.GetIndex()[0];
       currentVoxelInIndex[1] = imageIterator.GetIndex()[1];
       currentVoxelInIndex[2] = imageIterator.GetIndex()[2];
 
       distanceToCenter = (center + ( currentVoxelInIndex * -1.0 )).GetNorm();
 
       //if distance to center is smaller then the radius of the sphere
       if( distanceToCenter < radius)
       {
         sphereImage->SetPixel(imageIterator.GetIndex(), pixelValue);
       }
 
       ++imageIterator;
     }
 
     CastToMitkImage(sphereImage, TestVolume);
   }
 
 
 
 
 
   /* calculate the devation of the voxel object to the mathematical sphere object.
    * this is use to make a statement about the accuracy of the resliced image, eg. the circle's diameter or area.
    */
   template<typename TPixel, unsigned int VImageDimension>
   static void CalcTestFailureDeviation (itk::Image<TPixel, VImageDimension>* inputImage)
   {
     typedef itk::Image<TPixel, VImageDimension> InputImageType;
     typedef itk::ImageRegionConstIterator< InputImageType > ImageIterator;
 
     ImageIterator iterator(inputImage, inputImage->GetLargestPossibleRegion());
     iterator.GoToBegin();
 
     int volumeInPixel = 0;
 
     while( !iterator.IsAtEnd() )
     {
       if(inputImage->GetPixel(iterator.GetIndex()) == pixelValueSet) volumeInPixel++;
       ++iterator;
     }
 
     double diameter  = TestvolumeSize / 2.0;
     double volumeCalculated = (1.0 / 6.0) * 3.14159265358979 * std::pow(diameter, 3);
 
 
     double volumeDeviation = std::abs( 100 - (100 / volumeCalculated * volumeInPixel) );
 
 
     typename InputImageType::IndexType index;
     index[0] = index[1] =  TestvolumeSize / 2.0;
     index[2] = 0;
 
     int sumpixels = 0;
     while (index[2] < TestvolumeSize )
     {
       if(inputImage->GetPixel(index) == pixelValueSet) sumpixels++;
       index[2] += 1;
     }
 
 
     double diameterDeviation = std::abs( 100 - (100 / diameter * sumpixels) );
   #ifdef DEBUG
     MITK_INFO << "volume deviation: " << volumeDeviation << " diameter deviation:" << diameterDeviation;
   #endif
     mitkExtractSliceFilterTestClass::TestFailureDeviation = (volumeDeviation + diameterDeviation) / 2.0;
   }
 
 
 };
 /*================ #END class ================*/
 
 
 
 
 
 /*================#BEGIN Instanciation of members ================*/
 mitk::Image::Pointer mitkExtractSliceFilterTestClass::TestVolume = mitk::Image::New();
 double mitkExtractSliceFilterTestClass::TestvolumeSize = 256.0;
 mitk::PlaneGeometry::Pointer mitkExtractSliceFilterTestClass::TestPlane = mitk::PlaneGeometry::New();
 std::string mitkExtractSliceFilterTestClass::TestName = "";
 unsigned char mitkExtractSliceFilterTestClass::pixelValueSet = 255;
 mitkExtractSliceFilterTestClass::SliceProperties mitkExtractSliceFilterTestClass::testResults = {-1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0};
 double mitkExtractSliceFilterTestClass::TestFailureDeviation = 0.0;
 /*================ #END Instanciation of members ================*/
 
 
 
 
 
 /*================ #BEGIN test main ================*/
 int mitkExtractSliceFilterTest(int argc, char* argv[])
 {
 
   MITK_TEST_BEGIN("mitkExtractSliceFilterTest")
 
 
   //pixelvalue based testing
   mitkExtractSliceFilterTestClass::PixelvalueBasedTest();
 
   //initialize sphere test volume
   mitkExtractSliceFilterTestClass::InitializeTestVolume();
 
 
   mitk::Vector3D spacing = mitkExtractSliceFilterTestClass::TestVolume->GetGeometry()->GetSpacing();
 
 
   //the center of the sphere = center of image
   double sphereCenter = mitkExtractSliceFilterTestClass::TestvolumeSize / 2.0;
 
   double planeSize = mitkExtractSliceFilterTestClass::TestvolumeSize;
 
 
 
   /* axial plane */
   mitk::PlaneGeometry::Pointer geometryAxial = mitk::PlaneGeometry::New();
         geometryAxial->InitializeStandardPlane(planeSize, planeSize, spacing, mitk::PlaneGeometry::Axial, sphereCenter, false, true);
   geometryAxial->ChangeImageGeometryConsideringOriginOffset(true);
 
   mitk::Point3D origin = geometryAxial->GetOrigin();
   mitk::Vector3D normal;
   normal = geometryAxial->GetNormal();
 
 
   normal.Normalize();
 
   origin += normal * 0.5;//pixelspacing is 1, so half the spacing is 0.5
 
   //geometryAxial->SetOrigin(origin);
 
   mitkExtractSliceFilterTestClass::TestSlice(geometryAxial, "Testing axial plane");
   /* end axial plane */
 
 
 
   /* sagittal plane */
   mitk::PlaneGeometry::Pointer geometrySagital = mitk::PlaneGeometry::New();
   geometrySagital->InitializeStandardPlane(planeSize, planeSize, spacing, mitk::PlaneGeometry::Sagittal, sphereCenter, true, false);
   geometrySagital->ChangeImageGeometryConsideringOriginOffset(true);
 
   origin = geometrySagital->GetOrigin();
   normal = geometrySagital->GetNormal();
 
 
   normal.Normalize();
 
   origin += normal * 0.5;//pixelspacing is 1, so half the spacing is 0.5
 
   //geometrySagital->SetOrigin(origin);
 
   mitkExtractSliceFilterTestClass::TestSlice(geometrySagital, "Testing sagittal plane");
   /* sagittal plane */
 
 
 
   /* sagittal shifted plane */
   mitk::PlaneGeometry::Pointer geometrySagitalShifted = mitk::PlaneGeometry::New();
   geometrySagitalShifted->InitializeStandardPlane(planeSize, planeSize, spacing, mitk::PlaneGeometry::Sagittal, (sphereCenter - 14), true, false);
   geometrySagitalShifted->ChangeImageGeometryConsideringOriginOffset(true);
 
   origin = geometrySagitalShifted->GetOrigin();
   normal = geometrySagitalShifted->GetNormal();
 
 
   normal.Normalize();
 
   origin += normal * 0.5;//pixelspacing is 1, so half the spacing is 0.5
 
   //geometrySagitalShifted->SetOrigin(origin);
 
   mitkExtractSliceFilterTestClass::TestSlice(geometrySagitalShifted, "Testing sagittal plane shifted");
   /* end sagittal shifted plane */
 
 
 
   /* coronal plane */
   mitk::PlaneGeometry::Pointer geometryCoronal = mitk::PlaneGeometry::New();
   geometryCoronal->InitializeStandardPlane(planeSize, planeSize, spacing, mitk::PlaneGeometry::Frontal, sphereCenter, true, false);
   geometryCoronal->ChangeImageGeometryConsideringOriginOffset(true);
 
   origin = geometryCoronal->GetOrigin();
   normal = geometryCoronal->GetNormal();
 
 
   normal.Normalize();
 
   origin += normal * 0.5;//pixelspacing is 1, so half the spacing is 0.5
 
   //geometryCoronal->SetOrigin(origin);
 
   mitkExtractSliceFilterTestClass::TestSlice(geometryCoronal, "Testing coronal plane");
   /* end coronal plane */
 
 
 
   /* oblique plane */
   mitk::PlaneGeometry::Pointer obliquePlane = mitk::PlaneGeometry::New();
   obliquePlane->InitializeStandardPlane(planeSize, planeSize, spacing, mitk::PlaneGeometry::Sagittal, sphereCenter, true, false);
   obliquePlane->ChangeImageGeometryConsideringOriginOffset(true);
 
   origin = obliquePlane->GetOrigin();
   normal = obliquePlane->GetNormal();
 
 
   normal.Normalize();
 
   origin += normal * 0.5;//pixelspacing is 1, so half the spacing is 0.5
 
   //obliquePlane->SetOrigin(origin);
 
   mitk::Vector3D rotationVector;
   rotationVector[0] = 0.2;
   rotationVector[1] = 0.4;
   rotationVector[2] = 0.62;
 
   float degree = 37.0;
 
   mitk::RotationOperation* op = new mitk::RotationOperation(mitk::OpROTATE, obliquePlane->GetCenter(), rotationVector, degree);
   obliquePlane->ExecuteOperation(op);
   delete op;
 
   mitkExtractSliceFilterTestClass::TestSlice(obliquePlane, "Testing oblique plane");
   /* end oblique plane */
 
 
 
   #ifdef SHOW_SLICE_IN_RENDER_WINDOW
     /*================ #BEGIN vtk render code ================*/
 
     //set reslicer for renderwindow
     mitk::ItkImageFileReader::Pointer reader = mitk::ItkImageFileReader::New();
 
     std::string filename =  "C:\\home\\Pics\\Pic3D.nrrd";
     reader->SetFileName(filename);
 
     reader->Update();
 
     mitk::Image::Pointer pic = reader->GetOutput();
     vtkSmartPointer<vtkImageReslice> slicer = vtkSmartPointer<vtkImageReslice>::New();
 
     slicer->SetInput(pic->GetVtkImageData());
 
 
     mitk::PlaneGeometry::Pointer obliquePl = mitk::PlaneGeometry::New();
                 obliquePl->InitializeStandardPlane(pic->GetGeometry(), mitk::PlaneGeometry::Sagittal, pic->GetGeometry()->GetCenter()[0], true, false);
     obliquePl->ChangeImageGeometryConsideringOriginOffset(true);
 
                mitk::Point3D origin2 = obliquePl->GetOrigin();
     mitk::Vector3D n;
     n = obliquePl->GetNormal();
 
 
     n.Normalize();
 
                 origin2 += n * 0.5;//pixelspacing is 1, so half the spacing is 0.5
 
                 obliquePl->SetOrigin(origin2);
 
     mitk::Vector3D rotation;
     rotation[0] = 0.534307;
     rotation[1] = 0.000439605;
     rotation[2] = 0.423017;
     MITK_INFO << rotation;
 
     float rotateDegree = 70;
 
     mitk::RotationOperation* operation = new mitk::RotationOperation(mitk::OpROTATE, obliquePl->GetCenter(), rotationVector, degree);
     obliquePl->ExecuteOperation(operation);
     delete operation;
 
 
     double origin[3];
     origin[0] = obliquePl->GetOrigin()[0];
     origin[1] = obliquePl->GetOrigin()[1];
     origin[2] = obliquePl->GetOrigin()[2];
     slicer->SetResliceAxesOrigin(origin);
 
 
     mitk::Vector3D right, bottom, normal;
     right  = obliquePl->GetAxisVector( 0 );
     bottom = obliquePl->GetAxisVector( 1 );
     normal = obliquePl->GetNormal();
 
     right.Normalize();
     bottom.Normalize();
     normal.Normalize();
 
     double cosines[9];
 
     mitk::vnl2vtk(right.GetVnlVector(), cosines);//x
 
     mitk::vnl2vtk(bottom.GetVnlVector(), cosines + 3);//y
 
     mitk::vnl2vtk(normal.GetVnlVector(), cosines + 6);//n
 
     slicer->SetResliceAxesDirectionCosines(cosines);
 
     slicer->SetOutputDimensionality(2);
     slicer->Update();
 
 
     //set vtk renderwindow
     vtkSmartPointer<vtkPlaneSource> vtkPlane = vtkSmartPointer<vtkPlaneSource>::New();
     vtkPlane->SetOrigin(0.0, 0.0, 0.0);
 
     //These two points define the axes of the plane in combination with the origin.
     //Point 1 is the x-axis and point 2 the y-axis.
     //Each plane is transformed according to the view (axial, coronal and saggital) afterwards.
     vtkPlane->SetPoint1(1.0, 0.0, 0.0); //P1: (xMax, yMin, depth)
     vtkPlane->SetPoint2(0.0, 1.0, 0.0); //P2: (xMin, yMax, depth)
     //these are not the correct values for all slices, only a square plane by now
 
     vtkSmartPointer<vtkPolyDataMapper> imageMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
     imageMapper->SetInputConnection(vtkPlane->GetOutputPort());
 
 
     vtkSmartPointer<vtkLookupTable> lookupTable = vtkSmartPointer<vtkLookupTable>::New();
 
     //built a default lookuptable
     lookupTable->SetRampToLinear();
     lookupTable->SetSaturationRange( 0.0, 0.0 );
     lookupTable->SetHueRange( 0.0, 0.0 );
     lookupTable->SetValueRange( 0.0, 1.0 );
     lookupTable->Build();
     //map all black values to transparent
     lookupTable->SetTableValue(0, 0.0, 0.0, 0.0, 0.0);
     lookupTable->SetRange(-255.0, 255.0);
     //lookupTable->SetRange(-1022.0, 1184.0);//pic3D range
 
     vtkSmartPointer<vtkTexture> texture = vtkSmartPointer<vtkTexture>::New();
 
 
     texture->SetInput(slicer->GetOutput());
 
     texture->SetLookupTable(lookupTable);
 
     texture->SetMapColorScalarsThroughLookupTable(true);
 
     vtkSmartPointer<vtkActor> imageActor = vtkSmartPointer<vtkActor>::New();
     imageActor->SetMapper(imageMapper);
     imageActor->SetTexture(texture);
 
 
     // Setup renderers
     vtkSmartPointer<vtkRenderer> renderer = vtkSmartPointer<vtkRenderer>::New();
     renderer->AddActor(imageActor);
 
     // Setup render window
     vtkSmartPointer<vtkRenderWindow> renderWindow = vtkSmartPointer<vtkRenderWindow>::New();
     renderWindow->AddRenderer(renderer);
 
     // Setup render window interactor
     vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor = vtkSmartPointer<vtkRenderWindowInteractor>::New();
     vtkSmartPointer<vtkInteractorStyleImage> style = vtkSmartPointer<vtkInteractorStyleImage>::New();
     renderWindowInteractor->SetInteractorStyle(style);
 
     // Render and start interaction
     renderWindowInteractor->SetRenderWindow(renderWindow);
     //renderer->AddViewProp(imageActor);
 
 
     renderWindow->Render();
     renderWindowInteractor->Start();
     // always end with this!
     /*================ #END vtk render code ================*/
   #endif //SHOW_SLICE_IN_RENDER_WINDOW
 
 
   MITK_TEST_END()
 }
diff --git a/Core/Code/Testing/mitkGeometry3DTest.cpp b/Core/Code/Testing/mitkGeometry3DTest.cpp
index 43b082089a..08c1b1ddf8 100644
--- a/Core/Code/Testing/mitkGeometry3DTest.cpp
+++ b/Core/Code/Testing/mitkGeometry3DTest.cpp
@@ -1,614 +1,614 @@
 /*===================================================================
 
 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 "mitkGeometry3D.h"
 
 #include <vnl/vnl_quaternion.h>
 #include <vnl/vnl_quaternion.txx>
 
 #include "mitkRotationOperation.h"
 #include "mitkInteractionConst.h"
 #include <mitkMatrixConvert.h>
 #include <mitkImageCast.h>
 
 #include "mitkTestingMacros.h"
 #include <fstream>
 #include <mitkTypes.h>
 
 bool testGetAxisVectorVariants(mitk::Geometry3D* geometry)
 {
    int direction;
    for(direction=0; direction<3; ++direction)
    {
       mitk::Vector3D frontToBack;
       switch(direction)
       {
       case 0: frontToBack = geometry->GetCornerPoint(false, false, false)-geometry->GetCornerPoint(true , false, false); break; //7-3
       case 1: frontToBack = geometry->GetCornerPoint(false, false, false)-geometry->GetCornerPoint(false, true , false); break; //7-5
       case 2: frontToBack = geometry->GetCornerPoint(false, false, false)-geometry->GetCornerPoint(false , false, true);  break; //7-2
       }
       std::cout << "Testing GetAxisVector(int) vs GetAxisVector(bool, bool, bool): ";
       if(mitk::Equal(geometry->GetAxisVector(direction), frontToBack) == false)
       {
          std::cout<<"[FAILED]"<<std::endl;
          return false;
       }
       std::cout<<"[PASSED]"<<std::endl;
    }
    return true;
 }
 
 bool testGetAxisVectorExtent(mitk::Geometry3D* geometry)
 {
    int direction;
    for(direction=0; direction<3; ++direction)
    {
       if(mitk::Equal(geometry->GetAxisVector(direction).GetNorm(), geometry->GetExtentInMM(direction)) == false)
       {
          std::cout<<"[FAILED]"<<std::endl;
          return false;
       }
       std::cout<<"[PASSED]"<<std::endl;
    }
    return true;
 }
 
 // a part of the test requires axis-parallel coordinates
 int testIndexAndWorldConsistency(mitk::Geometry3D* geometry3d)
 {
    MITK_TEST_OUTPUT( << "Testing consistency of index and world coordinate systems: ");
    mitk::Point3D origin = geometry3d->GetOrigin();
    mitk::Point3D dummy;
 
    MITK_TEST_OUTPUT( << " Testing index->world->index conversion consistency");
    geometry3d->WorldToIndex(origin, dummy);
    geometry3d->IndexToWorld(dummy, dummy);
    MITK_TEST_CONDITION_REQUIRED(dummy == origin, "");
 
    MITK_TEST_OUTPUT( << " Testing WorldToIndex(origin, mitk::Point3D)==(0,0,0)");
    mitk::Point3D globalOrigin;
    mitk::FillVector3D(globalOrigin, 0,0,0);
 
    mitk::Point3D originContinuousIndex;
    geometry3d->WorldToIndex(origin, originContinuousIndex);
    MITK_TEST_CONDITION_REQUIRED(originContinuousIndex == globalOrigin, "");
 
    MITK_TEST_OUTPUT( << " Testing WorldToIndex(origin, itk::Index)==(0,0,0)");
    itk::Index<3> itkindex;
    geometry3d->WorldToIndex(origin, itkindex);
    itk::Index<3> globalOriginIndex;
    mitk::vtk2itk(globalOrigin, globalOriginIndex);
    MITK_TEST_CONDITION_REQUIRED(itkindex == globalOriginIndex, "");
 
    MITK_TEST_OUTPUT( << " Testing WorldToIndex(origin-0.5*spacing, itk::Index)==(0,0,0)");
    mitk::Vector3D halfSpacingStep = geometry3d->GetSpacing()*0.5;
    mitk::Matrix3D rotation;
    mitk::Point3D originOffCenter = origin-halfSpacingStep;
    geometry3d->WorldToIndex(originOffCenter, itkindex);
    MITK_TEST_CONDITION_REQUIRED(itkindex == globalOriginIndex, "");
 
    MITK_TEST_OUTPUT( << " Testing WorldToIndex(origin+0.5*spacing-eps, itk::Index)==(0,0,0)");
    originOffCenter = origin+halfSpacingStep;
    originOffCenter -= 0.0001;
    geometry3d->WorldToIndex( originOffCenter, itkindex);
    MITK_TEST_CONDITION_REQUIRED(itkindex == globalOriginIndex, "");
 
    MITK_TEST_OUTPUT( << " Testing WorldToIndex(origin+0.5*spacing, itk::Index)==(1,1,1)");
    originOffCenter = origin+halfSpacingStep;
    itk::Index<3> global111;
    mitk::FillVector3D(global111, 1,1,1);
    geometry3d->WorldToIndex( originOffCenter, itkindex);
    MITK_TEST_CONDITION_REQUIRED(itkindex == global111, "");
 
    MITK_TEST_OUTPUT( << " Testing WorldToIndex(GetCenter())==BoundingBox.GetCenter: ");
    mitk::Point3D center = geometry3d->GetCenter();
    mitk::Point3D centerContIndex;
    geometry3d->WorldToIndex(center, centerContIndex);
    mitk::BoundingBox::ConstPointer boundingBox = geometry3d->GetBoundingBox();
    mitk::BoundingBox::PointType centerBounds = boundingBox->GetCenter();
    MITK_TEST_CONDITION_REQUIRED(mitk::Equal(centerContIndex,centerBounds), "");
 
    MITK_TEST_OUTPUT( << " Testing GetCenter()==IndexToWorld(BoundingBox.GetCenter): ");
    center = geometry3d->GetCenter();
    mitk::Point3D centerBoundsInWorldCoords;
    geometry3d->IndexToWorld(centerBounds, centerBoundsInWorldCoords);
    MITK_TEST_CONDITION_REQUIRED(mitk::Equal(center,centerBoundsInWorldCoords), "");
 
    return EXIT_SUCCESS;
 }
 
 int testIndexAndWorldConsistencyForVectors(mitk::Geometry3D* geometry3d)
 {
    MITK_TEST_OUTPUT( << "Testing consistency of index and world coordinate systems for vectors: ");
    mitk::Vector3D xAxisMM = geometry3d->GetAxisVector(0);
    mitk::Vector3D xAxisContinuousIndex;
    mitk::Vector3D xAxisContinuousIndexDeprecated;
 
    mitk::Point3D p, pIndex, origin;
    origin = geometry3d->GetOrigin();
    p[0] = xAxisMM[0];
    p[1] = xAxisMM[1];
    p[2] = xAxisMM[2];
 
    geometry3d->WorldToIndex(p,pIndex);
 
    geometry3d->WorldToIndex(xAxisMM, xAxisContinuousIndexDeprecated);
    geometry3d->WorldToIndex(xAxisMM,xAxisContinuousIndex);
    MITK_TEST_CONDITION_REQUIRED(xAxisContinuousIndex[0] == pIndex[0],"");
    MITK_TEST_CONDITION_REQUIRED(xAxisContinuousIndex[1] == pIndex[1],"");
    MITK_TEST_CONDITION_REQUIRED(xAxisContinuousIndex[2] == pIndex[2],"");
 
    MITK_TEST_CONDITION_REQUIRED(xAxisContinuousIndex[0] == xAxisContinuousIndexDeprecated[0],"");
    MITK_TEST_CONDITION_REQUIRED(xAxisContinuousIndex[1] == xAxisContinuousIndexDeprecated[1],"");
    MITK_TEST_CONDITION_REQUIRED(xAxisContinuousIndex[2] == xAxisContinuousIndexDeprecated[2],"");
 
    MITK_TEST_CONDITION_REQUIRED(xAxisContinuousIndexDeprecated[0] == pIndex[0],"");
    MITK_TEST_CONDITION_REQUIRED(xAxisContinuousIndexDeprecated[1] == pIndex[1],"");
    MITK_TEST_CONDITION_REQUIRED(xAxisContinuousIndexDeprecated[2] == pIndex[2],"");
 
    geometry3d->IndexToWorld(xAxisContinuousIndex,xAxisContinuousIndex);
    geometry3d->IndexToWorld(xAxisContinuousIndexDeprecated,xAxisContinuousIndexDeprecated);
    geometry3d->IndexToWorld(pIndex,p);
 
    MITK_TEST_CONDITION_REQUIRED(xAxisContinuousIndex == xAxisMM,"");
    MITK_TEST_CONDITION_REQUIRED(xAxisContinuousIndex[0] == p[0],"");
    MITK_TEST_CONDITION_REQUIRED(xAxisContinuousIndex[1] == p[1],"");
    MITK_TEST_CONDITION_REQUIRED(xAxisContinuousIndex[2] == p[2],"");
 
    MITK_TEST_CONDITION_REQUIRED(xAxisContinuousIndexDeprecated == xAxisMM,"");
    MITK_TEST_CONDITION_REQUIRED(xAxisContinuousIndexDeprecated[0] == p[0],"");
    MITK_TEST_CONDITION_REQUIRED(xAxisContinuousIndexDeprecated[1] == p[1],"");
    MITK_TEST_CONDITION_REQUIRED(xAxisContinuousIndexDeprecated[2] == p[2],"");
 
    return EXIT_SUCCESS;
 }
 
 int testIndexAndWorldConsistencyForIndex(mitk::Geometry3D* geometry3d)
 {
    MITK_TEST_OUTPUT( << "Testing consistency of index and world coordinate systems: ");
 
    // creating testing data
    itk::Index<4> itkIndex4, itkIndex4b;
    itk::Index<3> itkIndex3, itkIndex3b;
    itk::Index<2> itkIndex2, itkIndex2b;
-   mitk::Index3D mitkIndex, mitkIndexb;
+   itk::Index<3> mitkIndex, mitkIndexb;
 
    itkIndex4[0] = itkIndex4[1] = itkIndex4[2] = itkIndex4[3] = 4;
    itkIndex3[0] = itkIndex3[1] = itkIndex3[2] = 6;
    itkIndex2[0] = itkIndex2[1] = 2;
    mitkIndex[0] = mitkIndex[1] = mitkIndex[2] = 13;
 
    // check for constistency
    mitk::Point3D point;
    geometry3d->IndexToWorld(itkIndex2,point);
    geometry3d->WorldToIndex(point,itkIndex2b);
 
    MITK_TEST_CONDITION_REQUIRED(
       ((itkIndex2b[0] == itkIndex2[0]) &&
       (itkIndex2b[1] == itkIndex2[1])),
       "Testing itk::index<2> for IndexToWorld/WorldToIndex consistency");
 
    geometry3d->IndexToWorld(itkIndex3,point);
    geometry3d->WorldToIndex(point,itkIndex3b);
 
    MITK_TEST_CONDITION_REQUIRED(
       ((itkIndex3b[0] == itkIndex3[0]) &&
       (itkIndex3b[1] == itkIndex3[1]) &&
       (itkIndex3b[2] == itkIndex3[2])),
       "Testing itk::index<3> for IndexToWorld/WorldToIndex consistency");
 
    geometry3d->IndexToWorld(itkIndex4,point);
    geometry3d->WorldToIndex(point,itkIndex4b);
 
    MITK_TEST_CONDITION_REQUIRED(
       ((itkIndex4b[0] == itkIndex4[0]) &&
       (itkIndex4b[1] == itkIndex4[1]) &&
       (itkIndex4b[2] == itkIndex4[2]) &&
       (itkIndex4b[3] == 0)),
       "Testing itk::index<3> for IndexToWorld/WorldToIndex consistency");
 
    geometry3d->IndexToWorld(mitkIndex,point);
    geometry3d->WorldToIndex(point,mitkIndexb);
 
    MITK_TEST_CONDITION_REQUIRED(
       ((mitkIndexb[0] == mitkIndex[0]) &&
       (mitkIndexb[1] == mitkIndex[1]) &&
       (mitkIndexb[2] == mitkIndex[2])),
       "Testing mitk::Index for IndexToWorld/WorldToIndex consistency");
 
    return EXIT_SUCCESS;
 }
 
 #include <itkImage.h>
 
 int testItkImageIsCenterBased()
 {
    MITK_TEST_OUTPUT(<< "Testing whether itk::Image coordinates are center-based.");
    typedef itk::Image<int,3> ItkIntImage3D;
    ItkIntImage3D::Pointer itkintimage = ItkIntImage3D::New();
    ItkIntImage3D::SizeType size;
    size.Fill(10);
    mitk::Point3D origin;
    mitk::FillVector3D(origin, 2,3,7);
    itkintimage->Initialize();
    itkintimage->SetRegions(size);
    itkintimage->SetOrigin(origin);
    std::cout<<"[PASSED]"<<std::endl;
 
    MITK_TEST_OUTPUT( << " Testing itk::Image::TransformPhysicalPointToContinuousIndex(origin)==(0,0,0)");
    mitk::Point3D globalOrigin;
    mitk::FillVector3D(globalOrigin, 0,0,0);
 
    itk::ContinuousIndex<mitk::ScalarType, 3> originContinuousIndex;
    itkintimage->TransformPhysicalPointToContinuousIndex(origin, originContinuousIndex);
    MITK_TEST_CONDITION_REQUIRED(originContinuousIndex == globalOrigin, "");
 
    MITK_TEST_OUTPUT( << " Testing itk::Image::TransformPhysicalPointToIndex(origin)==(0,0,0)");
    itk::Index<3> itkindex;
    itkintimage->TransformPhysicalPointToIndex(origin, itkindex);
    itk::Index<3> globalOriginIndex;
    mitk::vtk2itk(globalOrigin, globalOriginIndex);
    MITK_TEST_CONDITION_REQUIRED(itkindex == globalOriginIndex, "");
 
    MITK_TEST_OUTPUT( << " Testing itk::Image::TransformPhysicalPointToIndex(origin-0.5*spacing)==(0,0,0)");
    mitk::Vector3D halfSpacingStep = itkintimage->GetSpacing()*0.5;
    mitk::Matrix3D rotation;
    mitk::Point3D originOffCenter = origin-halfSpacingStep;
    itkintimage->TransformPhysicalPointToIndex(originOffCenter, itkindex);
    MITK_TEST_CONDITION_REQUIRED(itkindex == globalOriginIndex, "");
 
    MITK_TEST_OUTPUT( << " Testing itk::Image::TransformPhysicalPointToIndex(origin+0.5*spacing-eps, itk::Index)==(0,0,0)");
    originOffCenter = origin+halfSpacingStep;
    originOffCenter -= 0.0001;
    itkintimage->TransformPhysicalPointToIndex( originOffCenter, itkindex);
    MITK_TEST_CONDITION_REQUIRED(itkindex == globalOriginIndex, "");
 
    MITK_TEST_OUTPUT( << " Testing itk::Image::TransformPhysicalPointToIndex(origin+0.5*spacing, itk::Index)==(1,1,1)");
    originOffCenter = origin+halfSpacingStep;
    itk::Index<3> global111;
    mitk::FillVector3D(global111, 1,1,1);
    itkintimage->TransformPhysicalPointToIndex( originOffCenter, itkindex);
    MITK_TEST_CONDITION_REQUIRED(itkindex == global111, "");
 
    MITK_TEST_OUTPUT( << "=> Yes, itk::Image coordinates are center-based.");
 
    return EXIT_SUCCESS;
 }
 
 int testGeometry3D(bool imageGeometry)
 {
    // Build up a new image Geometry
    mitk::Geometry3D::Pointer geometry3d = mitk::Geometry3D::New();
    float bounds[ ] = {-10.0, 17.0, -12.0, 188.0, 13.0, 211.0};
 
    MITK_TEST_OUTPUT( << "Initializing");
    geometry3d->Initialize();
 
    MITK_TEST_OUTPUT(<< "Setting ImageGeometry to " << imageGeometry);
    geometry3d->SetImageGeometry(imageGeometry);
 
    MITK_TEST_OUTPUT(<< "Setting bounds by SetFloatBounds(): " << bounds);
    geometry3d->SetFloatBounds(bounds);
 
    MITK_TEST_OUTPUT( << "Testing AxisVectors");
    if(testGetAxisVectorVariants(geometry3d) == false)
       return EXIT_FAILURE;
 
    if(testGetAxisVectorExtent(geometry3d) == false)
       return EXIT_FAILURE;
 
    MITK_TEST_OUTPUT( << "Creating an AffineTransform3D transform");
    mitk::AffineTransform3D::MatrixType matrix;
    matrix.SetIdentity();
    matrix(1,1) = 2;
    mitk::AffineTransform3D::Pointer transform;
    transform = mitk::AffineTransform3D::New();
    transform->SetMatrix(matrix);
 
    MITK_TEST_OUTPUT( << "Testing a SetIndexToWorldTransform");
    geometry3d->SetIndexToWorldTransform(transform);
 
    MITK_TEST_OUTPUT( << "Testing correctness of value returned by GetSpacing");
    const mitk::Vector3D& spacing1 = geometry3d->GetSpacing();
    mitk::Vector3D expectedSpacing;
    expectedSpacing.Fill(1.0);
    expectedSpacing[1] = 2;
    if( mitk::Equal(spacing1, expectedSpacing) == false )
    {
       MITK_TEST_OUTPUT( << " [FAILED]");
       return EXIT_FAILURE;
    }
 
    MITK_TEST_OUTPUT( << "Testing a Compose(transform)");
    geometry3d->Compose(transform);
 
    MITK_TEST_OUTPUT( << "Testing correctness of value returned by GetSpacing");
    const mitk::Vector3D& spacing2 = geometry3d->GetSpacing();
    expectedSpacing[1] = 4;
    if( mitk::Equal(spacing2, expectedSpacing) == false )
    {
       MITK_TEST_OUTPUT( << " [FAILED]");
       return EXIT_FAILURE;
    }
 
    MITK_TEST_OUTPUT( << "Testing correctness of SetSpacing");
    mitk::Vector3D newspacing;
    mitk::FillVector3D(newspacing, 1.5, 2.5, 3.5);
    geometry3d->SetSpacing(newspacing);
    const mitk::Vector3D& spacing3 = geometry3d->GetSpacing();
    if( mitk::Equal(spacing3, newspacing) == false )
    {
       MITK_TEST_OUTPUT( << " [FAILED]");
       return EXIT_FAILURE;
    }
 
    // Seperate Test function for Index and World consistency
    testIndexAndWorldConsistency(geometry3d);
    testIndexAndWorldConsistencyForVectors(geometry3d);
    testIndexAndWorldConsistencyForIndex(geometry3d);
 
    MITK_TEST_OUTPUT( << "Testing a rotation of the geometry");
    double angle = 35.0;
    mitk::Vector3D rotationVector; mitk::FillVector3D( rotationVector, 1, 0, 0 );
    mitk::Point3D center = geometry3d->GetCenter();
    mitk::RotationOperation* op = new mitk::RotationOperation( mitk::OpROTATE, center, rotationVector, angle );
    geometry3d->ExecuteOperation(op);
 
    MITK_TEST_OUTPUT( << "Testing mitk::GetRotation() and success of rotation");
    mitk::Matrix3D rotation;
    mitk::GetRotation(geometry3d, rotation);
    mitk::Vector3D voxelStep=rotation*newspacing;
    mitk::Vector3D voxelStepIndex;
    geometry3d->WorldToIndex(voxelStep, voxelStepIndex);
    mitk::Vector3D expectedVoxelStepIndex;
    expectedVoxelStepIndex.Fill(1);
    MITK_TEST_CONDITION_REQUIRED(mitk::Equal(voxelStepIndex,expectedVoxelStepIndex), "");
    delete op;
    std::cout<<"[PASSED]"<<std::endl;
 
    MITK_TEST_OUTPUT( << "Testing that ImageGeometry is still " << imageGeometry);
    MITK_TEST_CONDITION_REQUIRED(geometry3d->GetImageGeometry() == imageGeometry, "");
 
    //Test if the translate function moves the origin correctly.
    mitk::Point3D oldOrigin = geometry3d->GetOrigin();
 
    //use some random values for translation
    mitk::Vector3D translationVector;
    translationVector.SetElement(0, 17.5f);
    translationVector.SetElement(1, -32.3f);
    translationVector.SetElement(2, 4.0f);
    //compute ground truth
    mitk::Point3D tmpResult = geometry3d->GetOrigin() + translationVector;
    geometry3d->Translate(translationVector);
    MITK_TEST_CONDITION( mitk::Equal( geometry3d->GetOrigin(), tmpResult ), "Testing if origin was translated.");
 
    translationVector*=-1; //vice versa
    geometry3d->Translate(translationVector);
 
    MITK_TEST_CONDITION( mitk::Equal( geometry3d->GetOrigin(), oldOrigin ), "Testing if the translation could be done vice versa." );
 
    return EXIT_SUCCESS;
 }
 
 int testGeometryAfterCasting()
 {
    // Epsilon. Allowed difference for rotationvalue
    float eps = 0.0001;
 
    // Cast ITK and MITK images and see if geometry stays
    typedef itk::Image<double,2>  Image2DType;
    typedef itk::Image<double,3>  Image3DType;
 
    // Create 3D ITK Image from Scratch, cast to 3D MITK image, compare Geometries
    Image3DType::Pointer image3DItk = Image3DType::New();
    Image3DType::RegionType myRegion;
    Image3DType::SizeType mySize;
    Image3DType::IndexType myIndex;
    Image3DType::SpacingType mySpacing;
    Image3DType::DirectionType myDirection, rotMatrixX, rotMatrixY, rotMatrixZ;
    mySpacing[0] = 31;
    mySpacing[1] = 0.1;
    mySpacing[2] = 2.9;
    myIndex[0] = -15;
    myIndex[1] = 15;
    myIndex[2] = 12;
    mySize[0] = 10;
    mySize[1] = 2;
    mySize[2] = 555;
    myRegion.SetSize( mySize);
    myRegion.SetIndex( myIndex );
    image3DItk->SetSpacing(mySpacing);
    image3DItk->SetRegions( myRegion);
    image3DItk->Allocate();
    image3DItk->FillBuffer(0);
 
    myDirection.SetIdentity();
    rotMatrixX.SetIdentity();
    rotMatrixY.SetIdentity();
    rotMatrixZ.SetIdentity();
 
    mitk::Image::Pointer mitkImage;
 
    // direction [row] [coloum]
    MITK_TEST_OUTPUT( << "Casting a rotated 3D ITK Image to a MITK Image and check if Geometry is still same" );
    for (double rotX=0; rotX < (itk::Math::pi*2); rotX+=0.4 )
    {
       // Set Rotation X
       rotMatrixX[1][1] = cos( rotX );
       rotMatrixX[1][2] = -sin( rotX );
       rotMatrixX[2][1] = sin( rotX );
       rotMatrixX[2][2] = cos( rotX );
 
       for (double rotY=0; rotY < (itk::Math::pi*2); rotY+=0.33 )
       {
          // Set Rotation Y
          rotMatrixY[0][0] = cos( rotY );
          rotMatrixY[0][2] = sin( rotY );
          rotMatrixY[2][0] = -sin( rotY );
          rotMatrixY[2][2] = cos( rotY );
 
          for (double rotZ=0; rotZ < (itk::Math::pi*2); rotZ+=0.5 )
          {
             // Set Rotation Z
             rotMatrixZ[0][0] = cos( rotZ );
             rotMatrixZ[0][1] = -sin( rotZ );
             rotMatrixZ[1][0] = sin( rotZ );
             rotMatrixZ[1][1] = cos( rotZ );
 
             // Multiply matrizes
             myDirection = myDirection * rotMatrixX * rotMatrixY * rotMatrixZ;
             image3DItk->SetDirection(myDirection);
             mitk::CastToMitkImage(image3DItk, mitkImage);
             const mitk::AffineTransform3D::MatrixType& matrix = mitkImage->GetGeometry()->GetIndexToWorldTransform()->GetMatrix();
 
             for (int row=0; row<3; row++)
             {
                for (int col=0; col<3; col++)
                {
                   double mitkValue = matrix[row][col] / mitkImage->GetGeometry()->GetSpacing()[col];
                   double itkValue  = myDirection[row][col];
                   double diff = mitkValue - itkValue;
                   // if you decrease this value, you can see that there might be QUITE high inaccuracy!!!
                   if (diff > eps) // need to check, how exact it SHOULD be .. since it is NOT EXACT!
                   {
                      std::cout << "Had a difference of : " << diff;
                      std::cout << "Error: Casting altered Geometry!";
                      std::cout << "ITK Matrix:\n" << myDirection;
                      std::cout << "Mitk Matrix (With Spacing):\n" << matrix;
                      std::cout << "Mitk Spacing: " << mitkImage->GetGeometry()->GetSpacing();
                      MITK_TEST_CONDITION_REQUIRED(false == true, "");
                      return false;
                   }
                }
             }
          }
       }
    }
 
    // Create 2D ITK Image from Scratch, cast to 2D MITK image, compare Geometries
    Image2DType::Pointer image2DItk = Image2DType::New();
    Image2DType::RegionType myRegion2D;
    Image2DType::SizeType mySize2D;
    Image2DType::IndexType myIndex2D;
    Image2DType::SpacingType mySpacing2D;
    Image2DType::DirectionType myDirection2D, rotMatrix;
    mySpacing2D[0] = 31;
    mySpacing2D[1] = 0.1;
    myIndex2D[0] = -15;
    myIndex2D[1] = 15;
    mySize2D[0] = 10;
    mySize2D[1] = 2;
    myRegion2D.SetSize( mySize2D);
    myRegion2D.SetIndex( myIndex2D );
    image2DItk->SetSpacing(mySpacing2D);
    image2DItk->SetRegions( myRegion2D);
    image2DItk->Allocate();
    image2DItk->FillBuffer(0);
 
    myDirection2D.SetIdentity();
    rotMatrix.SetIdentity();
 
    // direction [row] [coloum]
    MITK_TEST_OUTPUT( << "Casting a rotated 2D ITK Image to a MITK Image and check if Geometry is still same" );
    for (double rotTheta=0; rotTheta < (itk::Math::pi*2); rotTheta+=0.1 )
    {
       // Set Rotation
       rotMatrix[0][0] = cos(rotTheta);
       rotMatrix[0][1] = -sin(rotTheta);
       rotMatrix[1][0] = sin(rotTheta);
       rotMatrix[1][1] = cos(rotTheta);
 
       // Multiply matrizes
       myDirection2D = myDirection2D * rotMatrix;
       image2DItk->SetDirection(myDirection2D);
       mitk::CastToMitkImage(image2DItk, mitkImage);
       const mitk::AffineTransform3D::MatrixType& matrix = mitkImage->GetGeometry()->GetIndexToWorldTransform()->GetMatrix();
 
       // Compare MITK and ITK matrix
       for (int row=0; row<3; row++)
       {
          for (int col=0; col<3; col++)
          {
             double mitkValue = matrix[row][col] / mitkImage->GetGeometry()->GetSpacing()[col];
             if ((row == 2) && (col == row))
             {
                if (mitkValue != 1)
                {
                   MITK_TEST_OUTPUT(<< "After casting a 2D ITK to 3D MITK images, MITK matrix values for 0|2, 1|2, 2|0, 2|1 MUST be 0 and value for 2|2 must be 1");
                   return false;
                }
             }
             else if ((row == 2) || (col == 2))
             {
                if (mitkValue != 0)
                {
                   MITK_TEST_OUTPUT(<< "After casting a 2D ITK to 3D MITK images, MITK matrix values for 0|2, 1|2, 2|0, 2|1 MUST be 0 and value for 2|2 must be 1");
                   return false;
                }
             }
             else
             {
                double itkValue  = myDirection2D[row][col];
                double diff = mitkValue - itkValue;
                // if you decrease this value, you can see that there might be QUITE high inaccuracy!!!
                if (diff > eps) // need to check, how exact it SHOULD be .. since it is NOT EXACT!
                {
                   std::cout << "Had a difference of : " << diff;
                   std::cout << "Error: Casting altered Geometry!";
                   std::cout << "ITK Matrix:\n" << myDirection2D;
                   std::cout << "Mitk Matrix (With Spacing):\n" << matrix;
                   std::cout << "Mitk Spacing: " << mitkImage->GetGeometry()->GetSpacing();
                   MITK_TEST_CONDITION_REQUIRED(false == true, "");
                   return false;
                }
             }
          }
       }
    }
 
    // THIS WAS TESTED:
    // 2D ITK -> 2D MITK,
    // 3D ITK -> 3D MITK,
 
    // Still  need to test: 2D MITK Image with ADDITIONAL INFORMATION IN MATRIX -> 2D ITK
    // 1. Possibility: 3x3 MITK matrix can be converted without loss into 2x2 ITK matrix
    // 2. Possibility: 3x3 MITK matrix can only be converted with loss into 2x2 ITK matrix
    // .. before implementing this, we wait for further development in geometry classes (e.g. Geoemtry3D::SetRotation(..))
 
    return EXIT_SUCCESS;
 }
 
 int mitkGeometry3DTest(int /*argc*/, char* /*argv*/[])
 {
    MITK_TEST_BEGIN(mitkGeometry3DTest);
 
    int result;
 
    MITK_TEST_CONDITION_REQUIRED( (result = testItkImageIsCenterBased()) == EXIT_SUCCESS, "");
 
    MITK_TEST_OUTPUT(<< "Running main part of test with ImageGeometry = false");
    MITK_TEST_CONDITION_REQUIRED( (result = testGeometry3D(false)) == EXIT_SUCCESS, "");
 
    MITK_TEST_OUTPUT(<< "Running main part of test with ImageGeometry = true");
    MITK_TEST_CONDITION_REQUIRED( (result = testGeometry3D(true)) == EXIT_SUCCESS, "");
 
    MITK_TEST_OUTPUT(<< "Running test to see if Casting MITK to ITK and the other way around destroys geometry");
    MITK_TEST_CONDITION_REQUIRED( (result = testGeometryAfterCasting()) == EXIT_SUCCESS, "");
 
    MITK_TEST_END();
 
    return EXIT_SUCCESS;
 }
diff --git a/Core/Code/Testing/mitkImageTest.cpp b/Core/Code/Testing/mitkImageTest.cpp
index ad3aedf736..2d542e9a67 100644
--- a/Core/Code/Testing/mitkImageTest.cpp
+++ b/Core/Code/Testing/mitkImageTest.cpp
@@ -1,526 +1,526 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // mitk includes
 #include <mitkImage.h>
 #include <mitkImageDataItem.h>
 #include <mitkImageCast.h>
 #include "mitkItkImageFileReader.h"
 #include <mitkTestingMacros.h>
 #include <mitkImageStatisticsHolder.h>
 #include "mitkImageGenerator.h"
 #include "mitkImageReadAccessor.h"
 #include "mitkException.h"
 #include "mitkPixelTypeMultiplex.h"
 #include "mitkImagePixelReadAccessor.h"
 
 #include "mitkImageSliceSelector.h"
 
 // itk includes
 #include <itkImage.h>
 #include <itkMersenneTwisterRandomVariateGenerator.h>
 
 // stl includes
 #include <fstream>
 
 // vtk includes
 #include <vtkImageData.h>
 
 // Checks if reference count is correct after using GetVtkImageData()
 bool ImageVtkDataReferenceCheck(const char* fname) {
 
   const std::string filename = std::string(fname);
   mitk::ItkImageFileReader::Pointer imageReader = mitk::ItkImageFileReader::New();
   try
   {
     imageReader->SetFileName(filename);
     imageReader->Update();
   }
   catch(...) {
     MITK_TEST_FAILED_MSG(<< "Could not read file for testing: " << filename);
     return false;
   }
 
   {
     mitk::Image::Pointer image = imageReader->GetOutput();
     vtkImageData* vtk = image->GetVtkImageData();
 
     if(vtk == NULL)
       return false;
   }
 
   return true;
 }
 
 template <class T>
 void TestRandomPixelAccess( const mitk::PixelType ptype, mitk::Image::Pointer image, mitk::Point3D & point, mitk::ScalarType & value )
 {
   // generate a random point in world coordinates
   mitk::Point3D xMax, yMax, zMax, xMaxIndex, yMaxIndex, zMaxIndex;
   xMaxIndex.Fill(0.0f);
   yMaxIndex.Fill(0.0f);
   zMaxIndex.Fill(0.0f);
   xMaxIndex[0] = image->GetLargestPossibleRegion().GetSize()[0];
   yMaxIndex[1] = image->GetLargestPossibleRegion().GetSize()[1];
   zMaxIndex[2] = image->GetLargestPossibleRegion().GetSize()[2];
   image->GetGeometry()->IndexToWorld(xMaxIndex, xMax);
   image->GetGeometry()->IndexToWorld(yMaxIndex, yMax);
   image->GetGeometry()->IndexToWorld(zMaxIndex, zMax);
   MITK_INFO << "Origin " << image->GetGeometry()->GetOrigin()[0] << " "<< image->GetGeometry()->GetOrigin()[1] << " "<< image->GetGeometry()->GetOrigin()[2] << "";
   MITK_INFO << "MaxExtend " << xMax[0] << " "<< yMax[1] << " "<< zMax[2] << "";
 
   itk::Statistics::MersenneTwisterRandomVariateGenerator::Pointer randomGenerator = itk::Statistics::MersenneTwisterRandomVariateGenerator::New();
   randomGenerator->Initialize( std::rand() );      // initialize with random value, to get sensible random points for the image
   point[0] = randomGenerator->GetUniformVariate( image->GetGeometry()->GetOrigin()[0], xMax[0]);
   point[1] = randomGenerator->GetUniformVariate( image->GetGeometry()->GetOrigin()[1], yMax[1]);
   point[2] = randomGenerator->GetUniformVariate( image->GetGeometry()->GetOrigin()[2], zMax[2]);
   MITK_INFO << "RandomPoint " << point[0] << " "<< point[1] << " "<< point[2] << "";
 
   // test values and max/min
   mitk::ScalarType imageMin = image->GetStatistics()->GetScalarValueMin();
   mitk::ScalarType imageMax = image->GetStatistics()->GetScalarValueMax();
 
   // test accessing PixelValue with coordinate leading to a negative index
   const mitk::Point3D geom_origin = image->GetGeometry()->GetOrigin();
   const mitk::Point3D geom_center = image->GetGeometry()->GetCenter();
 
   // shift position from origin outside of the image ( in the opposite direction to [center-origin] vector which points in the inside)
   mitk::Point3D position = geom_origin + (geom_origin - geom_center);
 
   MITK_INFO << "Testing access outside of the image";
   unsigned int dim = image->GetDimension();
   if(dim == 3 || dim == 4){
     mitk::ImagePixelReadAccessor<T,3> imAccess3(image,image->GetVolumeData(0));
 
     // Comparison ?>=0 not needed since all position[i] and timestep are unsigned int
     // (position[0]>=0 && position[1] >=0 && position[2]>=0 && timestep>=0)
     // bug-11978 : we still need to catch index with negative values
     if ( point[0] < 0 ||
          point[1] < 0 ||
          point[2] < 0 )
     {
       MITK_WARN << "Given position ("<< point << ") is out of image range, returning 0." ;
     }
     else {
       value = static_cast<mitk::ScalarType>(imAccess3.GetPixelByWorldCoordinates(point));
       MITK_TEST_CONDITION( (value >= imageMin && value <= imageMax), "Value returned is between max/min");
     }
-    mitk::Index3D itkIndex;
+    itk::Index<3> itkIndex;
     image->GetGeometry()->WorldToIndex(position, itkIndex);
     MITK_TEST_FOR_EXCEPTION_BEGIN(mitk::Exception);
     imAccess3.GetPixelByIndexSafe(itkIndex);
     MITK_TEST_FOR_EXCEPTION_END(mitk::Exception);
   }
   MITK_INFO << imageMin << " "<< imageMax << " "<< value << "";
 
 }
 
 class mitkImageTestClass
 {
 public:
   void SetClonedGeometry_None_ClonedEqualInput()
   {
     mitk::Image::Pointer image = mitk::ImageGenerator::GenerateRandomImage<float>(100, 100, 100, 1, 0.2, 0.3, 0.4);
 
     //-----------------
     // geometry information for image
     mitk::Point3D origin;
     mitk::Vector3D right, bottom;
     mitk::Vector3D spacing;
     mitk::FillVector3D(origin, 17.0, 19.92, 7.83);
     mitk::FillVector3D(right, 1.0, 2.0, 3.0);
     mitk::FillVector3D(bottom, 0.0, -3.0, 2.0);
     mitk::FillVector3D(spacing, 0.78, 0.91, 2.23);
 
     //InitializeStandardPlane(rightVector, downVector, spacing)
     mitk::PlaneGeometry::Pointer planegeometry = mitk::PlaneGeometry::New();
     planegeometry->InitializeStandardPlane(100, 100, right, bottom, &spacing);
     planegeometry->SetOrigin(origin);
     planegeometry->ChangeImageGeometryConsideringOriginOffset(true);
 
     image->SetClonedGeometry(planegeometry);
 
     mitk::Geometry3D::Pointer imageGeometry = image->GetGeometry();
     itk::ScalableAffineTransform<mitk::ScalarType,3>* frameNew = imageGeometry->GetIndexToWorldTransform();
     itk::ScalableAffineTransform<mitk::ScalarType,3>* frameOld = planegeometry->GetIndexToWorldTransform();
     bool matrixEqual = true;
     for (int i = 0; i < 16; ++i)
     {
       double valueNew = *(frameNew->GetMatrix()[i]);
       double valueOld = *(frameOld->GetMatrix()[i]);
 
       //MITK_INFO << "Index: " << i << " Old: " << valueOld << " New: " << valueNew << " Difference:" << valueOld-valueNew<< std::endl;
       matrixEqual = matrixEqual && mitk::Equal(valueNew, valueOld, mitk::eps);
     }
 
     // Disabled because this test fails on the dashboard. Does not fail on my machine.
     // See Bug 6505
     //    MITK_TEST_CONDITION(matrixEqual, "Matrix elements of cloned matrix equal original matrix");
 
   }
 };
 
 
 int mitkImageTest(int argc, char* argv[])
 {
 
   MITK_TEST_BEGIN(mitkImageTest);
 
   mitkImageTestClass tester;
   tester.SetClonedGeometry_None_ClonedEqualInput();
 
 
   //Create Image out of nowhere
   mitk::Image::Pointer imgMem = mitk::Image::New();
   mitk::PixelType pt = mitk::MakeScalarPixelType<int>();
   unsigned int dim[]={100,100,20};
 
   MITK_TEST_CONDITION_REQUIRED( imgMem.IsNotNull(), "An image was created. ");
 
   // Initialize image
   imgMem->Initialize( pt, 3, dim);
 
   MITK_TEST_CONDITION_REQUIRED( imgMem->IsInitialized(), "Image::IsInitialized() ?");
   MITK_TEST_CONDITION_REQUIRED( imgMem->GetPixelType() == pt, "PixelType was set correctly.");
 
 
   int *p = NULL;
   int *p2 = NULL;
   try
   {
     mitk::ImageReadAccessor imgMemAcc(imgMem);
     p = (int*)imgMemAcc.GetData();
   }
   catch (mitk::Exception& e)
   {
     MITK_ERROR << e.what();
   }
   MITK_TEST_CONDITION( p != NULL, "GetData() returned not-NULL pointer.");
 
   // filling image
   const unsigned int size = dim[0]*dim[1]*dim[2];
   for(unsigned int i=0; i<size; ++i, ++p)
     *p = (signed int)i;
 
   // Getting it again and compare with filled values:
   try
   {
     mitk::ImageReadAccessor imgMemAcc(imgMem);
     p2 = (int*)imgMemAcc.GetData();
   }
   catch (mitk::Exception &e)
   {
     MITK_ERROR << e.what();
   }
   MITK_TEST_CONDITION( p2 != NULL, "GetData() returned not-NULL pointer.");
 
   bool isEqual = true;
   for(unsigned int i=0; i<size; ++i, ++p2)
   {
     if(*p2 != (signed int) i )
     {
       isEqual = false;
     }
   }
   MITK_TEST_CONDITION( isEqual, "The values previously set as data are correct [pixelwise comparison].");
 
   // Testing GetSliceData() and compare with filled values:
 
   try
   {
     mitk::ImageReadAccessor imgMemAcc(imgMem, imgMem->GetSliceData(dim[2]/2));
     p2 = (int*)imgMemAcc.GetData();
   }
   catch (mitk::Exception& e)
   {
     MITK_ERROR << e.what();
   }
   MITK_TEST_CONDITION_REQUIRED( p2 != NULL, "Valid slice data returned");
 
   unsigned int xy_size = dim[0]*dim[1];
   unsigned int start_mid_slice = (dim[2]/2)*xy_size;
   isEqual = true;
   for(unsigned int i=0; i<xy_size; ++i, ++p2)
   {
     if(*p2!=(signed int)(i+start_mid_slice))
     {
       isEqual = false;
     }
   }
   MITK_TEST_CONDITION( isEqual, "The SliceData are correct [pixelwise comparison]. ");
 
   imgMem = mitk::Image::New();
 
   // testing re-initialization of test image
   mitk::PixelType pType = mitk::MakePixelType<int, int, 1>();
   imgMem->Initialize( pType , 3, dim);
   MITK_TEST_CONDITION_REQUIRED(imgMem->GetDimension()== 3, "Testing initialization parameter dimension!");
   MITK_TEST_CONDITION_REQUIRED(imgMem->GetPixelType() ==  pType, "Testing initialization parameter pixeltype!");
   MITK_TEST_CONDITION_REQUIRED(imgMem->GetDimension(0) == dim[0] &&
     imgMem->GetDimension(1)== dim[1] && imgMem->GetDimension(2)== dim[2], "Testing initialization of dimensions!");
   MITK_TEST_CONDITION( imgMem->IsInitialized(), "Image is initialized.");
 
   // Setting volume again:
   try
   {
     mitk::ImageReadAccessor imgMemAcc(imgMem);
     imgMem->SetVolume(imgMemAcc.GetData());
   }
   catch (mitk::Exception& e)
   {
     MITK_ERROR << e.what();
   }
 
   //-----------------
   // geometry information for image
   mitk::Point3D origin;
   mitk::Vector3D right, bottom;
   mitk::Vector3D spacing;
   mitk::FillVector3D(origin, 17.0, 19.92, 7.83);
   mitk::FillVector3D(right, 1.0, 2.0, 3.0);
   mitk::FillVector3D(bottom, 0.0, -3.0, 2.0);
   mitk::FillVector3D(spacing, 0.78, 0.91, 2.23);
 
   //InitializeStandardPlane(rightVector, downVector, spacing)
   mitk::PlaneGeometry::Pointer planegeometry = mitk::PlaneGeometry::New();
   planegeometry->InitializeStandardPlane(100, 100, right, bottom, &spacing);
   planegeometry->SetOrigin(origin);
 
   // Testing Initialize(const mitk::PixelType& type, const mitk::Geometry3D& geometry, unsigned int slices) with PlaneGeometry and GetData(): ";
   imgMem->Initialize( mitk::MakePixelType<int, int, 1>(), *planegeometry);
   MITK_TEST_CONDITION_REQUIRED( imgMem->GetGeometry()->GetOrigin() == static_cast<mitk::Geometry3D*>(planegeometry)->GetOrigin(), "Testing correct setting of geometry via initialize!");
 
   try
   {
     mitk::ImageReadAccessor imgMemAcc(imgMem);
     p = (int*)imgMemAcc.GetData();
   }
   catch (mitk::Exception& e)
   {
     MITK_ERROR << e.what();
   }
   MITK_TEST_CONDITION_REQUIRED( p!=NULL, "GetData() returned valid pointer.");
 
   // Testing Initialize(const mitk::PixelType& type, int sDim, const mitk::PlaneGeometry& geometry) and GetData(): ";
   imgMem->Initialize( mitk::MakePixelType<int, int, 1>() , 40, *planegeometry);
 
   try
   {
     mitk::ImageReadAccessor imgMemAcc(imgMem);
     p = (int*)imgMemAcc.GetData();
   }
   catch (mitk::Exception& e)
   {
     MITK_ERROR << e.what();
   }
   MITK_TEST_CONDITION_REQUIRED( p != NULL, "GetData() returned valid pointer.");
 
   //-----------------
   // testing origin information and methods
   MITK_TEST_CONDITION_REQUIRED(  mitk::Equal(imgMem->GetGeometry()->GetOrigin(), origin), "Testing correctness of origin via GetGeometry()->GetOrigin(): ");
 
   // Setting origin via SetOrigin(origin): ";
   mitk::FillVector3D(origin, 37.0, 17.92, 27.83);  imgMem->SetOrigin(origin);
 
   // Test origin
   MITK_TEST_CONDITION_REQUIRED(  mitk::Equal(imgMem->GetGeometry()->GetOrigin(), origin), "Testing correctness of changed origin via GetGeometry()->GetOrigin(): ");
   MITK_TEST_CONDITION_REQUIRED(  mitk::Equal(imgMem->GetSlicedGeometry()->GetGeometry2D(0)->GetOrigin(), origin),  "Testing correctness of changed origin via GetSlicedGeometry()->GetGeometry2D(0)->GetOrigin(): ");
 
   //-----------------
   // testing spacing information and methodsunsigned int dim[]={100,100,20};
   MITK_TEST_CONDITION_REQUIRED(mitk::Equal(imgMem->GetGeometry()->GetSpacing(), spacing), "Testing correct spacing from Geometry3D!");
 
   mitk::FillVector3D(spacing, 7.0, 0.92, 1.83);
   imgMem->SetSpacing(spacing);
   MITK_TEST_CONDITION_REQUIRED(  mitk::Equal(imgMem->GetGeometry()->GetSpacing(), spacing), "Testing correctness of changed spacing via GetGeometry()->GetSpacing(): ");
   MITK_TEST_CONDITION_REQUIRED(  mitk::Equal(imgMem->GetSlicedGeometry()->GetGeometry2D(0)->GetSpacing(), spacing), "Testing correctness of changed spacing via GetSlicedGeometry()->GetGeometry2D(0)->GetSpacing(): ");
 
   mitk::Image::Pointer vecImg = mitk::Image::New();
   try
   {
     mitk::ImageReadAccessor imgMemAcc(imgMem);
     vecImg->Initialize( imgMem->GetPixelType(), *imgMem->GetGeometry(), 2 /* #channels */, 0 /*tDim*/ );
     vecImg->SetImportChannel(const_cast<void*>(imgMemAcc.GetData()), 0, mitk::Image::CopyMemory );
     vecImg->SetImportChannel(const_cast<void*>(imgMemAcc.GetData()), 1, mitk::Image::CopyMemory );
 
     mitk::ImageReadAccessor vecImgAcc(vecImg);
     mitk::ImageReadAccessor vecImgAcc0(vecImg, vecImg->GetChannelData(0));
     mitk::ImageReadAccessor vecImgAcc1(vecImg, vecImg->GetChannelData(1));
 
     MITK_TEST_CONDITION_REQUIRED(vecImgAcc0.GetData() != NULL && vecImgAcc1.GetData() != NULL, "Testing set and return of channel data!");
 
     MITK_TEST_CONDITION_REQUIRED( vecImg->IsValidSlice(0,0,1) , "");
     MITK_TEST_OUTPUT(<< " Testing whether CopyMemory worked");
     MITK_TEST_CONDITION_REQUIRED(imgMemAcc.GetData() != vecImgAcc.GetData(), "");
     MITK_TEST_OUTPUT(<< " Testing destruction after SetImportChannel");
     vecImg = NULL;
     MITK_TEST_CONDITION_REQUIRED(vecImg.IsNull() , "testing destruction!");
   }
   catch (mitk::Exception& e)
   {
     MITK_ERROR << e.what();
   }
   //-----------------
   MITK_TEST_OUTPUT(<< "Testing initialization via vtkImageData");
   MITK_TEST_OUTPUT(<< " Setting up vtkImageData");
   vtkImageData* vtkimage = vtkImageData::New();
   vtkimage->Initialize();
   vtkimage->SetDimensions( 2, 3, 4);
   double vtkorigin[] =  {-350,-358.203, -1363.5};
   vtkimage->SetOrigin(vtkorigin);
   mitk::Point3D vtkoriginAsMitkPoint;
   mitk::vtk2itk(vtkorigin, vtkoriginAsMitkPoint);
   double vtkspacing[] =  {1.367, 1.367, 2};
   vtkimage->SetSpacing(vtkspacing);
   vtkimage->AllocateScalars(VTK_SHORT,1);
   std::cout<<"[PASSED]"<<std::endl;
 
   MITK_TEST_OUTPUT(<< " Testing mitk::Image::Initialize(vtkImageData*, ...)");
   mitk::Image::Pointer mitkByVtkImage = mitk::Image::New();
   mitkByVtkImage ->Initialize(vtkimage);
   MITK_TEST_CONDITION_REQUIRED(mitkByVtkImage->IsInitialized(), "");
   vtkimage->Delete();
 
   MITK_TEST_OUTPUT(<< " Testing whether spacing has been correctly initialized from vtkImageData");
   mitk::Vector3D spacing2 = mitkByVtkImage->GetGeometry()->GetSpacing();
   mitk::Vector3D vtkspacingAsMitkVector;
   mitk::vtk2itk(vtkspacing, vtkspacingAsMitkVector);
   MITK_TEST_CONDITION_REQUIRED(mitk::Equal(spacing2,vtkspacingAsMitkVector), "");
 
   MITK_TEST_OUTPUT(<< " Testing whether GetSlicedGeometry(0)->GetOrigin() has been correctly initialized from vtkImageData");
   mitk::Point3D origin2 = mitkByVtkImage->GetSlicedGeometry(0)->GetOrigin();
   MITK_TEST_CONDITION_REQUIRED(mitk::Equal(origin2,vtkoriginAsMitkPoint), "");
 
   MITK_TEST_OUTPUT(<< " Testing whether GetGeometry()->GetOrigin() has been correctly initialized from vtkImageData");
   origin2 = mitkByVtkImage->GetGeometry()->GetOrigin();
   MITK_TEST_CONDITION_REQUIRED(mitk::Equal(origin2,vtkoriginAsMitkPoint), "");
 
   // TODO test the following initializers on channel-incorporation
   //  void mitk::Image::Initialize(const mitk::PixelType& type, unsigned int dimension, unsigned int *dimensions, unsigned int channels)
   //  void mitk::Image::Initialize(const mitk::PixelType& type, int sDim, const mitk::Geometry2D& geometry2d, bool flipped, unsigned int channels, int tDim )
   //  void mitk::Image::Initialize(const mitk::Image* image)
   //  void mitk::Image::Initialize(const mitkIpPicDescriptor* pic, int channels, int tDim, int sDim)
 
   //mitk::Image::Pointer vecImg = mitk::Image::New();
   //vecImg->Initialize(PixelType(typeid(float), 6, itk::ImageIOBase::SYMMETRICSECONDRANKTENSOR), *imgMem->GetGeometry(), 2 /* #channels */, 0 /*tDim*/, false /*shiftBoundingBoxMinimumToZero*/ );
   //vecImg->Initialize(PixelType(typeid(itk::Vector<float,6>)), *imgMem->GetGeometry(), 2 /* #channels */, 0 /*tDim*/, false /*shiftBoundingBoxMinimumToZero*/ );
 
   // testing access by index coordinates and by world coordinates
 
   MITK_TEST_CONDITION_REQUIRED(argc == 2, "Check if test image is accessible!");
   const std::string filename = std::string(argv[1]);
   mitk::ItkImageFileReader::Pointer imageReader = mitk::ItkImageFileReader::New();
   try
   {
     imageReader->SetFileName(filename);
     imageReader->Update();
   }
   catch(...) {
     MITK_TEST_FAILED_MSG(<< "Could not read file for testing: " << filename);
     return 0;
   }
 
   mitk::Image::Pointer image = imageReader->GetOutput();
   mitk::Point3D point;
   mitk::ScalarType value = -1.;
 
   mitkPixelTypeMultiplex3(TestRandomPixelAccess,image->GetImageDescriptor()->GetChannelTypeById(0),image,point,value)
 
   {
     // testing the clone method of mitk::Image
     mitk::Image::Pointer cloneImage = image->Clone();
   MITK_TEST_CONDITION_REQUIRED(cloneImage->GetDimension() == image->GetDimension(), "Clone (testing dimension)");
   MITK_TEST_CONDITION_REQUIRED(cloneImage->GetPixelType() == image->GetPixelType(), "Clone (testing pixel type)");
   // After cloning an image the geometry of both images should be equal too
   MITK_TEST_CONDITION_REQUIRED(cloneImage->GetGeometry()->GetOrigin() == image->GetGeometry()->GetOrigin(), "Clone (testing origin)");
   MITK_TEST_CONDITION_REQUIRED(cloneImage->GetGeometry()->GetSpacing() == image->GetGeometry()->GetSpacing(), "Clone (testing spacing)");
   MITK_TEST_CONDITION_REQUIRED(mitk::MatrixEqualElementWise(cloneImage->GetGeometry()->GetIndexToWorldTransform()->GetMatrix(), image->GetGeometry()->GetIndexToWorldTransform()->GetMatrix()),
     "Clone (testing transformation matrix)");
   MITK_TEST_CONDITION_REQUIRED(mitk::MatrixEqualElementWise(cloneImage->GetTimeGeometry()->GetGeometryForTimeStep(cloneImage->GetDimension(3)-1)->GetIndexToWorldTransform()->GetMatrix(),
     cloneImage->GetTimeGeometry()->GetGeometryForTimeStep(image->GetDimension(3)-1)->GetIndexToWorldTransform()->GetMatrix()), "Clone(testing time sliced geometry)");
 
   for (unsigned int i = 0u; i < cloneImage->GetDimension(); ++i)
   {
     MITK_TEST_CONDITION_REQUIRED(cloneImage->GetDimension(i) == image->GetDimension(i), "Clone (testing dimension " << i << ")");
   }
   }
   //access via itk
   if(image->GetDimension()> 3)    // CastToItk only works with 3d images so we need to check for 4d images
   {
     mitk::ImageTimeSelector::Pointer selector = mitk::ImageTimeSelector::New();
     selector->SetTimeNr(0);
     selector->SetInput(image);
     selector->Update();
     image = selector->GetOutput();
   }
 
   if(image->GetDimension()==3)
   {
     typedef itk::Image<double,3> ItkFloatImage3D;
     ItkFloatImage3D::Pointer itkimage;
     try
     {
     mitk::CastToItkImage(image, itkimage);
     MITK_TEST_CONDITION_REQUIRED(itkimage.IsNotNull(), "Test conversion to itk::Image!");
     }
     catch (std::exception& e)
     {
       MITK_INFO << e.what();
     }
     mitk::Point3D itkPhysicalPoint;
     image->GetGeometry()->WorldToItkPhysicalPoint(point, itkPhysicalPoint);
     MITK_INFO << "ITKPoint " << itkPhysicalPoint[0] << " "<< itkPhysicalPoint[1] << " "<< itkPhysicalPoint[2] << "";
 
     mitk::Point3D backTransformedPoint;
     image->GetGeometry()->ItkPhysicalPointToWorld(itkPhysicalPoint, backTransformedPoint);
 
     MITK_TEST_CONDITION_REQUIRED( mitk::Equal(point,backTransformedPoint), "Testing world->itk-physical->world consistency");
 
     itk::Index<3> idx;
     bool status = itkimage->TransformPhysicalPointToIndex(itkPhysicalPoint, idx);
 
     MITK_INFO << "ITK Index " << idx[0] << " "<< idx[1] << " "<< idx[2] << "";
 
     if(status && value != -1.)
     {
       float valByItk = itkimage->GetPixel(idx);
       MITK_TEST_CONDITION_REQUIRED( mitk::Equal(valByItk, value), "Compare value of pixel returned by mitk in comparison to itk");
     }
     else
     {
       MITK_WARN<< "Index is out buffered region!";
     }
   }
   else
   {
     MITK_INFO << "Image does not contain three dimensions, some test cases are skipped!";
   }
 
   // clone generated 3D image with one slice in z direction (cf. bug 11058)
   unsigned int* threeDdim = new unsigned int[3];
   threeDdim[0] = 100;
   threeDdim[1] = 200;
   threeDdim[2] = 1;
   mitk::Image::Pointer threeDImage = mitk::Image::New();
   threeDImage->Initialize(mitk::MakeScalarPixelType<float>(), 3, threeDdim);
   mitk::Image::Pointer cloneThreeDImage = threeDImage->Clone();
   // check that the clone image has the same dimensionality as the source image
   MITK_TEST_CONDITION_REQUIRED( cloneThreeDImage->GetDimension() == 3, "Testing if the clone image initializes with 3D!");
 
   MITK_TEST_CONDITION_REQUIRED( ImageVtkDataReferenceCheck(argv[1]), "Checking reference count of Image after using GetVtkImageData()");
 
   MITK_TEST_END();
 }
diff --git a/Core/Documentation/Doxygen/Concepts/GeometryOverview.dox b/Core/Documentation/Doxygen/Concepts/GeometryOverview.dox
index e7876f2061..589e9140b8 100644
--- a/Core/Documentation/Doxygen/Concepts/GeometryOverview.dox
+++ b/Core/Documentation/Doxygen/Concepts/GeometryOverview.dox
@@ -1,132 +1,132 @@
 namespace mitk{
 /**
 \page GeometryOverviewPage Geometry Overview
 
 \tableofcontents
 
 \section GeometryOverviewPage_Introduction Introduction to Geometries
 
 Geometries are used to describe the geometrical properties of data objects in space and time.\n
 To use the geometry classes in the right way you have to understand the three different coordinate types present in MITK:\n\n
 \image html CoordinateTypes.png
 <center><b>The different coordinate types\n\n</b></center>\n
 	-# World coordinates:
 		- World coordinates are describing the actual spacial position of all MITK objects regarding a global coordinate system, normally specified by the imaging modality 
 		- World coordinates are represented by  mitk::Point3D objects.
 		- The geometry defines the offset, orientation, and scale of the considered data objects in reference to the world coordinate systems.
 		- World coordinates are always measured in mm
 		- If you are dealing with an image geometry, the origin of an image is pointing to the CENTER of the bottom-left-back voxel.\n 
 		- If you are NOT dealing with an image geometry (no defined discrete Voxels), the origin is pointing to the bottom-left-back CORNER
 		- Index coordinates can be converted to world coordinates by calling Geometry3D::IndexToWorld()\n\n
 
 \image html worldcoordinateSystem.png
 <center><b>Corner-based coordinates\n\n</b></center>
 \image html WorldcoordinateSystemCenterBased.png
 <center><b>Center-based image-coordinates\n\n</b></center>\n
 	-# Continuous index coordinates:
 		- Dividing world coordinates through the pixel spacing and simultanously taking the offset into account leads to continuous index coordinates inside your dataobject.\n
 		  So continuous coordinates can be float values!
 		- Continuous index coordinates are represented by  mitk::Point3D objects.
 		- They can be obtained by calling Geometry3D::WorldToIndex(), where &pt_mm is a point in worldcoordinates.\n 		
 	-# Index coordinate system:
 		- Index coordinates are discrete values that address voxels of a data object explicitly.
-		- Index coordinates are represented by  mitk::Index3D objects.
+		- Index coordinates are represented by  itk::Index<3> objects.
 		- Basically they are continuous index coordinates which are rounded from half integer up.
 		- E.g. (0,0) specifies the very first pixel of a 2D image, (0,1) the pixel of the next column in the same row
 		- If you have world coordinates, they can be converted to discrete index coordinates by calling
           Geometry3D::WorldToIndex()\n\n  
 
 \section GeometryOverviewPage_PointsAndVector Difference between Points and Vectors
 
 Like ITK, MITK differenciate between points and vectors. A point defines a position in a coordinate system while a 
 vector is the distance between two points. Therefore points and vectors behave different if a coordinate transformation
 is applied. An offest in a coordinate transformation will affect a transformed point but not a vector. 
 
 An Example:\n
 If two systems are given, which differ by a offset of (1,0,0). The point A(2,2,2) in system one will correspont to point A'(3,2,2) in the second system. 
 But a vector a(2,2,2) will correspond to the vector a'(2,2,2). 
 
           
 \section GeometryOverviewPage_Concept The Geometry Concept
 
 As the superclass of all MITK geometries Geometry3D holds:
 	- a spacial bounding box which is axes-parallel in index coordinates (often discrete indices of pixels), to be accessed by Geometry3D::GetBoundingBox()
 	- a time related bounding box which holds the temporal validity of the considered data object in milliseconds (start and end time), to be accessed by Geometry3D::GetTimeBounds().\n 
 	  The default for 3D geometries is minus infinity to plus infinity, meaning the object is always displayed independent of displayed time in MITK.
 	- position information in form of a Euclidean transform in respect to world coordinates (i.e. a linear transformation matrix and offset) to convert (discrete or continuous) index coordinates to world coordinates and vice versa,\n
        to be accessed by Geometry3D::GetIndexToWorldTransform()\n
 	   See also: \ref GeometryOverviewPage_Introduction "Introduction to Geometries"
 	- Many other properties (e.g. origin, extent, ...) which can be found in the \ref Geometry3D "class documentation"
 	- <b> VERY IMPORTANT:</b>\n A flag called <i>isImageGeometry</i>, which indicates whether the coordinates are center-based or not!\n 
 	  See also: \ref GeometryOverviewPage_Introduction "Introduction to Geometries" and \ref GeometryOverviewPage_Putting_Together "IMPORTANT: Putting it together for an Image"\n\n	
 
 
 Every data object (sub-)class of BaseData has a TimeGeometry which is accessed by BaseData::GetTimeGeometry(). This TimeGeometry holds one or more Geometry3D objects which describes the object at specific time points, e.g. provides conversion between world and index coordinates and contains bounding boxes covering the area in which the data are placed. There is the possibility of using different implementations of the abstract TimeGeometry class which may differ in how the time steps are saved and the times are calculated.
 
 There are two ways to represent a time, either by a TimePointType or a TimeStepType. The first is similar to the continous index coordinates and defines a Time Point in milliseconds from timepoint zero. The second type is similar to index coordinates. These are discrete values which specify the number of the current time step going from 0 to GetNumberOfTimeSteps(). The conversion between a time point and a time step is done by calling the method TimeGeometry::TimeStepToTimePoint() or TimeGeometry::TimePointToTimeStep(). Note that the duration of a time step may differ from object to object, so in general it is better to calculate the corresponding time steps by using time points. Also the distance of the time steps does not need to be equidistant over time, it depends on the used TimeGeometry implementation. 
 
 Each TimeGeometry has a bounding box covering the whole area in which the corresponding object is situated during all time steps. This bounding box may be accessed by calling TimeGeometry::GetBoundingBoxInWorld() and is always in world coordinates. The bounding box is calculated from all time steps, to manually start this calculation process call TimeGeometry::Update().  The bounding box is not updated if the getter is called. 
 
 The TimeGeometry does not provide a transformation of world coordinates into image coordinates since each time step may has a different transformation. If a conversion between image and world is needed, the Geometry3D for a specific time step or time point must be fetched either by TimeGeometry::GetGeometryForTimeStep() or TimeGeometry::GetGeometryForTimePoint() and then the conversion is calculated by using this geometry. 
 
 The TimeGeometry class is an abstract class therefore it is not possible to instantiate it. instead a derived class must be used. Currently the only class that can be chosen is ProportionalTimeGeometry() which assumes that the time steps are ordered equidistant. To initialize an object with given geometries call ProportionalTimeGeometry::Initialize() with an existing Geometry3D and the number of time steps. The given geometries will be copied and not referenced!
 
 SlicedGeometry3D is a sub-class of Geometry3D, which describes data objects consisting of slices, e.g., objects of type Image (or SlicedData, which is the super-class of Image). 
 Therefore, Image::GetTimeGeometry() will contain a list of SlicedGeometry3D instances. There is a special method SlicedData::GetSlicedGeometry(t) which directly returns\n
 a SlicedGeometry3D to avoid the need of casting.
 
 The class SlicedGeometry3D contains a list of Geometry2D objects describing the slices in the image.We have here spatial steps from 0 to GetSlices(). 
 SlicedGeometry3D::InitializeEvenlySpaced (Geometry2D *geometry2D, unsigned int slices) initializes a stack of slices with the same thickness, one starting at the position where the previous one ends.
 
 Geometry2D provides methods for working with 2D manifolds (i.e., simply spoken, an object that can be described using a 2D coordinate-system) in 3D space.\n
 For example it allows mapping of a 3D point on the 2D manifold using Geometry2D::Map(). A subclass of Geometry2D called PlaneGeometry, explicitly describes a 2D rectangular plane.\n
 Another important subclass of Geometry2D is the DisplayGeometry which describes the geometry of the display (the monitor screen). Basically it represents a rectangular view on a 2D world geometry\n
 The DisplayGeometry converts between screen and world coordinates, processes input events (e.g. mouse click) and provides methods for zooming and panning.\n
 \image html DisplayGeometry.png
 <center><b>Display Geometry\n\n</b></center>
 Finally there is the AbstractTransformGeometry which describes a 2D manifold in 3D space, defined by a vtkAbstractTransform. It is a abstract superclass for arbitrary user defined geometries\n
 An example is the ThinPlateSplineCurvedGeometry.\n
 
 \subsection GeometryOverviewPage_Putting_Together IMPORTANT: Putting it together for an Image
 
 Please read this section accurately if you are working with Images!
 
 The definition of the position of the corners of an image is different than the one of other data objects:
 
 As mentioned in the previous section, world coordinates of data objects (e.g. surfaces ) usually specify the bottom left back corner of an object.
 
 In contrast to that a geometry of an Image is center-based, which means that the world coordinates of a voxel belonging to an image points to the center of that voxel. 
 E.g:
 
 \image html PixelCenterBased.png
 <center><b>Center-based voxel\n\n</b></center>
 
 If the origin of e.g. a surface lies at (15,10,0) in world coordinates, the origin`s world coordinates for an image are internally calculated like the following:
 
 										<center>(15-0.5*X-Spacing\n
 										 10-0.5*Y-Spacing\n
 										   0-0.5*Z-Spacing)\n</center>
 										  
 If the image`s spacing is (x,y,z)=(1,1,3) then the corner coordinates are (14.5,9.5,-1.5).
 
 <b>If your geometry describes an image, the member variable <i>isImageGeometry</i> must be changed to true. This variable indicates also if your geometry is center-based or not.\n 
 The change can be done in two ways:\n
 	-#	You are sure that your origin is already center-based. Whether because you adjusted it manually or you copied it from another image.\n
 	    In that case, you can call the function <i>setImageGeometry(true)</i> or <i>imageGeometryOn()</i> to set the bool variable to true.
  	-#	You created a new geometry, did not manually adjust the origin to be center-based and have the bool value isImageGeometry set to false (default).\n 
  	    In that case, call the function  <i>ChangeImageGeometryConsideringOriginOffset(true)</i>. It will adjust your origin automatically and set the bool flag to true.\n
 
 If you experience displaced contours, figures or other stuff, it is an indicator that you have not considered the origin offset mentioned above.</b>\n\n
 
 An image has a TimeGeometry, which contains one or more SlicedGeometry3D instances (one for each time step), all of which contain one or more instances of (sub-classes of) Geometry2D (usually PlaneGeometry).\n
 As a reminder: Geometry instances referring to images need a slightly different definition of corners, see Geometry3D::SetImageGeometry. This is usualy automatically called by Image.\n\n
 
 \section GeometryOverviewPage_Connection Connection between MITK, ITK and VTK Geometries
 \image html ITK_VTK_MITK_Geometries.png
 \n\n
 	- VTK transformation for rendering
 	- ITK transformation for calculations
 	- Both automatically updated when one is changed\n
 Attention:<b>Not</b> automatically updated when changed hardcoded. Example: geometry->GetVtkMatrix()->Rotate(....)
 */
 }
\ No newline at end of file
diff --git a/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsNetworkCreator.cpp b/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsNetworkCreator.cpp
index ff5ffc92a4..a008440c8a 100644
--- a/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsNetworkCreator.cpp
+++ b/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsNetworkCreator.cpp
@@ -1,864 +1,864 @@
 /*===================================================================
 
 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 "mitkConnectomicsNetworkCreator.h"
 
 #include <sstream>
 #include <vector>
 
 #include "mitkConnectomicsConstantsManager.h"
 #include "mitkImageAccessByItk.h"
 #include "mitkImageStatisticsHolder.h"
 #include "mitkImageCast.h"
 
 #include "itkImageRegionIteratorWithIndex.h"
 
 // VTK
 #include <vtkPolyData.h>
 #include <vtkPolyLine.h>
 #include <vtkCellArray.h>
 
 mitk::ConnectomicsNetworkCreator::ConnectomicsNetworkCreator()
 : m_FiberBundle()
 , m_Segmentation()
 , m_ConNetwork( mitk::ConnectomicsNetwork::New() )
 , idCounter(0)
 , m_LabelToVertexMap()
 , m_LabelToNodePropertyMap()
 , allowLoops( false )
 , m_UseCoMCoordinates( false )
 , m_LabelsToCoordinatesMap()
 , m_MappingStrategy( EndElementPositionAvoidingWhiteMatter )
 , m_EndPointSearchRadius( 10.0 )
 , m_ZeroLabelInvalid( true )
 , m_AbortConnection( false )
 {
 }
 
 mitk::ConnectomicsNetworkCreator::ConnectomicsNetworkCreator( mitk::Image::Pointer segmentation, mitk::FiberBundleX::Pointer fiberBundle )
 : m_FiberBundle(fiberBundle)
 , m_Segmentation(segmentation)
 , m_ConNetwork( mitk::ConnectomicsNetwork::New() )
 , idCounter(0)
 , m_LabelToVertexMap()
 , m_LabelToNodePropertyMap()
 , allowLoops( false )
 , m_LabelsToCoordinatesMap()
 , m_MappingStrategy( EndElementPositionAvoidingWhiteMatter )
 , m_EndPointSearchRadius( 10.0 )
 , m_ZeroLabelInvalid( true )
 , m_AbortConnection( false )
 {
   mitk::CastToItkImage( segmentation, m_SegmentationItk );
 }
 
 mitk::ConnectomicsNetworkCreator::~ConnectomicsNetworkCreator()
 {
 }
 
 void mitk::ConnectomicsNetworkCreator::SetFiberBundle(mitk::FiberBundleX::Pointer fiberBundle)
 {
   m_FiberBundle = fiberBundle;
 }
 
 void mitk::ConnectomicsNetworkCreator::SetSegmentation(mitk::Image::Pointer segmentation)
 {
   m_Segmentation = segmentation;
   mitk::CastToItkImage( segmentation, m_SegmentationItk );
 }
 
 itk::Point<float, 3> mitk::ConnectomicsNetworkCreator::GetItkPoint(double point[3])
 {
   itk::Point<float, 3> itkPoint;
   itkPoint[0] = point[0];
   itkPoint[1] = point[1];
   itkPoint[2] = point[2];
   return itkPoint;
 }
 
 void mitk::ConnectomicsNetworkCreator::CreateNetworkFromFibersAndSegmentation()
 {
 
   //empty graph
   m_ConNetwork = mitk::ConnectomicsNetwork::New();
   m_LabelToVertexMap.clear();
   m_LabelToNodePropertyMap.clear();
   idCounter = 0;
 
   vtkSmartPointer<vtkPolyData> fiberPolyData = m_FiberBundle->GetFiberPolyData();
   vtkSmartPointer<vtkCellArray> vLines = fiberPolyData->GetLines();
   vLines->InitTraversal();
 
   int numFibers = m_FiberBundle->GetNumFibers();
   for( int fiberID( 0 ); fiberID < numFibers; fiberID++ )
   {
     vtkIdType   numPointsInCell(0);
     vtkIdType*  pointsInCell(NULL);
     vLines->GetNextCell ( numPointsInCell, pointsInCell );
 
     TractType::Pointer singleTract = TractType::New();
     for( int pointInCellID( 0 ); pointInCellID < numPointsInCell ; pointInCellID++)
     {
       // push back point
       PointType point = GetItkPoint( fiberPolyData->GetPoint( pointsInCell[ pointInCellID ] ) );
       singleTract->InsertElement( singleTract->Size(), point );
     }
 
     if ( singleTract && ( singleTract->Size() > 0 ) )
     {
       AddConnectionToNetwork(
         ReturnAssociatedVertexPairForLabelPair(
         ReturnLabelForFiberTract( singleTract, m_MappingStrategy )
         )
         );
       m_AbortConnection = false;
     }
   }
 
   // Prune unconnected nodes
   //m_ConNetwork->PruneUnconnectedSingleNodes();
 
   // provide network with geometry
   m_ConNetwork->SetGeometry( dynamic_cast<mitk::Geometry3D*>(m_Segmentation->GetGeometry()->Clone().GetPointer()) );
   m_ConNetwork->UpdateBounds();
   m_ConNetwork->SetIsModified( true );
 
   MBI_INFO << mitk::ConnectomicsConstantsManager::CONNECTOMICS_WARNING_INFO_NETWORK_CREATED;
 }
 
 void mitk::ConnectomicsNetworkCreator::AddConnectionToNetwork(ConnectionType newConnection)
 {
   if( m_AbortConnection )
   {
     MITK_DEBUG << "Connection aborted";
     return;
   }
 
   VertexType vertexA = newConnection.first;
   VertexType vertexB = newConnection.second;
 
   // check for loops (if they are not allowed)
   if( allowLoops || !( vertexA == vertexB ) )
   {
     // If the connection already exists, increment weight, else create connection
     if ( m_ConNetwork->EdgeExists( vertexA, vertexB ) )
     {
       m_ConNetwork->IncreaseEdgeWeight( vertexA, vertexB );
     }
     else
     {
       m_ConNetwork->AddEdge( vertexA, vertexB );
     }
   }
 }
 
 
 mitk::ConnectomicsNetworkCreator::VertexType mitk::ConnectomicsNetworkCreator::ReturnAssociatedVertexForLabel( ImageLabelType label )
 {
   if( m_ZeroLabelInvalid && ( label == 0 ) )
   {
     m_AbortConnection = true;
     return ULONG_MAX;
   }
 
   // if label is not known, create entry
   if( ! ( m_LabelToVertexMap.count( label ) > 0 ) )
   {
     VertexType newVertex = m_ConNetwork->AddVertex( idCounter );
     idCounter++;
     SupplyVertexWithInformation(label, newVertex);
     m_LabelToVertexMap.insert( std::pair< ImageLabelType, VertexType >( label, newVertex ) );
   }
 
   //return associated vertex
   return m_LabelToVertexMap.find( label )->second;
 }
 
 mitk::ConnectomicsNetworkCreator::ConnectionType mitk::ConnectomicsNetworkCreator::ReturnAssociatedVertexPairForLabelPair( ImageLabelPairType labelpair )
 {
   //hand both labels through to the single label function
   ConnectionType connection( ReturnAssociatedVertexForLabel(labelpair.first), ReturnAssociatedVertexForLabel(labelpair.second) );
 
   return connection;
 }
 
 mitk::ConnectomicsNetworkCreator::ImageLabelPairType mitk::ConnectomicsNetworkCreator::ReturnLabelForFiberTract( TractType::Pointer singleTract, mitk::ConnectomicsNetworkCreator::MappingStrategy strategy)
 {
   switch( strategy )
   {
   case EndElementPosition:
     {
       return EndElementPositionLabel( singleTract );
     }
   case JustEndPointVerticesNoLabel:
     {
       return JustEndPointVerticesNoLabelTest( singleTract );
     }
   case EndElementPositionAvoidingWhiteMatter:
     {
       return EndElementPositionLabelAvoidingWhiteMatter( singleTract );
     }
   case PrecomputeAndDistance:
     {
       return PrecomputeVertexLocationsBySegmentation( singleTract );
     }
   }
 
   // To remove warnings, this code should never be reached
   MBI_ERROR << mitk::ConnectomicsConstantsManager::CONNECTOMICS_ERROR_INVALID_MAPPING;
   ImageLabelPairType nullPair( 0,0 );
   return nullPair;
 }
 
 mitk::ConnectomicsNetworkCreator::ImageLabelPairType mitk::ConnectomicsNetworkCreator::EndElementPositionLabel( TractType::Pointer singleTract )
 {
   ImageLabelPairType labelpair;
 
   {// Note: .fib image tracts are safed using index coordinates
     mitk::Point3D firstElementFiberCoord, lastElementFiberCoord;
     mitk::Point3D firstElementSegCoord, lastElementSegCoord;
-    mitk::Index3D firstElementSegIndex, lastElementSegIndex;
+    itk::Index<3> firstElementSegIndex, lastElementSegIndex;
 
     if( singleTract->front().Size() != 3 )
     {
       MBI_ERROR << mitk::ConnectomicsConstantsManager::CONNECTOMICS_ERROR_INVALID_DIMENSION_NEED_3;
     }
     for( unsigned int index = 0; index < singleTract->front().Size(); index++ )
     {
       firstElementFiberCoord.SetElement( index, singleTract->front().GetElement( index ) );
       lastElementFiberCoord.SetElement( index, singleTract->back().GetElement( index ) );
     }
 
     // convert from fiber index coordinates to segmentation index coordinates
     FiberToSegmentationCoords( firstElementFiberCoord, firstElementSegCoord );
     FiberToSegmentationCoords( lastElementFiberCoord, lastElementSegCoord );
 
     for( int index = 0; index < 3; index++ )
     {
       firstElementSegIndex.SetElement( index, firstElementSegCoord.GetElement( index ) );
       lastElementSegIndex.SetElement( index, lastElementSegCoord.GetElement( index ) );
     }
 
     int firstLabel = m_SegmentationItk->GetPixel(firstElementSegIndex);
     int lastLabel = m_SegmentationItk->GetPixel(lastElementSegIndex );
 
     labelpair.first = firstLabel;
     labelpair.second = lastLabel;
 
     // Add property to property map
     CreateNewNode( firstLabel, firstElementSegIndex, m_UseCoMCoordinates );
     CreateNewNode( lastLabel, lastElementSegIndex, m_UseCoMCoordinates );
   }
 
   return labelpair;
 }
 
 mitk::ConnectomicsNetworkCreator::ImageLabelPairType mitk::ConnectomicsNetworkCreator::PrecomputeVertexLocationsBySegmentation( TractType::Pointer /*singleTract*/ )
 {
   ImageLabelPairType labelpair;
 
   return labelpair;
 }
 
 mitk::ConnectomicsNetworkCreator::ImageLabelPairType mitk::ConnectomicsNetworkCreator::EndElementPositionLabelAvoidingWhiteMatter( TractType::Pointer singleTract )
 {
   ImageLabelPairType labelpair;
 
   {// Note: .fib image tracts are safed using index coordinates
     mitk::Point3D firstElementFiberCoord, lastElementFiberCoord;
     mitk::Point3D firstElementSegCoord, lastElementSegCoord;
-    mitk::Index3D firstElementSegIndex, lastElementSegIndex;
+    itk::Index<3> firstElementSegIndex, lastElementSegIndex;
 
     if( singleTract->front().Size() != 3 )
     {
       MBI_ERROR << mitk::ConnectomicsConstantsManager::CONNECTOMICS_ERROR_INVALID_DIMENSION_NEED_3;
     }
     for( unsigned int index = 0; index < singleTract->front().Size(); index++ )
     {
       firstElementFiberCoord.SetElement( index, singleTract->front().GetElement( index ) );
       lastElementFiberCoord.SetElement( index, singleTract->back().GetElement( index ) );
     }
 
     // convert from fiber index coordinates to segmentation index coordinates
     FiberToSegmentationCoords( firstElementFiberCoord, firstElementSegCoord );
     FiberToSegmentationCoords( lastElementFiberCoord, lastElementSegCoord );
 
     for( int index = 0; index < 3; index++ )
     {
       firstElementSegIndex.SetElement( index, firstElementSegCoord.GetElement( index ) );
       lastElementSegIndex.SetElement( index, lastElementSegCoord.GetElement( index ) );
     }
 
     int firstLabel = m_SegmentationItk->GetPixel(firstElementSegIndex);
     int lastLabel = m_SegmentationItk->GetPixel(lastElementSegIndex );
 
     // Check whether the labels belong to the white matter (which means, that the fibers ended early)
     bool extendFront(false), extendEnd(false), retractFront(false), retractEnd(false);
     extendFront = !IsNonWhiteMatterLabel( firstLabel );
     extendEnd = !IsNonWhiteMatterLabel( lastLabel );
     retractFront = IsBackgroundLabel( firstLabel );
     retractEnd = IsBackgroundLabel( lastLabel );
 
     //if( extendFront || extendEnd )
     //{
     //MBI_INFO << "Before Start: " << firstLabel << " at " << firstElementSegIndex[ 0 ] << " " << firstElementSegIndex[ 1 ] << " " << firstElementSegIndex[ 2 ] << " End: " << lastLabel << " at " << lastElementSegIndex[ 0 ] << " " << lastElementSegIndex[ 1 ] << " " << lastElementSegIndex[ 2 ];
     //}
     if ( extendFront )
     {
       std::vector< int > indexVectorOfPointsToUse;
 
       //Use first two points for direction
       indexVectorOfPointsToUse.push_back( 1 );
       indexVectorOfPointsToUse.push_back( 0 );
 
       // label and coordinate temp storage
       int tempLabel( firstLabel );
-      mitk::Index3D tempIndex = firstElementSegIndex;
+      itk::Index<3> tempIndex = firstElementSegIndex;
 
       LinearExtensionUntilGreyMatter( indexVectorOfPointsToUse, singleTract, tempLabel, tempIndex );
 
       firstLabel = tempLabel;
       firstElementSegIndex = tempIndex;
 
     }
 
     if ( extendEnd )
     {
       std::vector< int > indexVectorOfPointsToUse;
 
       //Use last two points for direction
       indexVectorOfPointsToUse.push_back( singleTract->Size() - 2 );
       indexVectorOfPointsToUse.push_back( singleTract->Size() - 1 );
 
       // label and coordinate temp storage
       int tempLabel( lastLabel );
-      mitk::Index3D tempIndex = lastElementSegIndex;
+      itk::Index<3> tempIndex = lastElementSegIndex;
 
       LinearExtensionUntilGreyMatter( indexVectorOfPointsToUse, singleTract, tempLabel, tempIndex );
 
       lastLabel = tempLabel;
       lastElementSegIndex = tempIndex;
     }
         if ( retractFront )
     {
       // label and coordinate temp storage
       int tempLabel( firstLabel );
-      mitk::Index3D tempIndex = firstElementSegIndex;
+      itk::Index<3> tempIndex = firstElementSegIndex;
 
       RetractionUntilBrainMatter( true, singleTract, tempLabel, tempIndex );
 
       firstLabel = tempLabel;
       firstElementSegIndex = tempIndex;
 
     }
 
     if ( retractEnd )
     {
       // label and coordinate temp storage
       int tempLabel( lastLabel );
-      mitk::Index3D tempIndex = lastElementSegIndex;
+      itk::Index<3> tempIndex = lastElementSegIndex;
 
       RetractionUntilBrainMatter( false, singleTract, tempLabel, tempIndex );
 
       lastLabel = tempLabel;
       lastElementSegIndex = tempIndex;
     }
     //if( extendFront || extendEnd )
     //{
     //    MBI_INFO << "After Start: " << firstLabel << " at " << firstElementSegIndex[ 0 ] << " " << firstElementSegIndex[ 1 ] << " " << firstElementSegIndex[ 2 ] << " End: " << lastLabel << " at " << lastElementSegIndex[ 0 ] << " " << lastElementSegIndex[ 1 ] << " " << lastElementSegIndex[ 2 ];
     //}
 
     labelpair.first = firstLabel;
     labelpair.second = lastLabel;
 
     // Add property to property map
     CreateNewNode( firstLabel, firstElementSegIndex, m_UseCoMCoordinates );
     CreateNewNode( lastLabel, lastElementSegIndex, m_UseCoMCoordinates );
   }
 
   return labelpair;
 }
 
 mitk::ConnectomicsNetworkCreator::ImageLabelPairType mitk::ConnectomicsNetworkCreator::JustEndPointVerticesNoLabelTest( TractType::Pointer singleTract )
 {
   ImageLabelPairType labelpair;
 
    {// Note: .fib image tracts are safed using index coordinates
     mitk::Point3D firstElementFiberCoord, lastElementFiberCoord;
     mitk::Point3D firstElementSegCoord, lastElementSegCoord;
-    mitk::Index3D firstElementSegIndex, lastElementSegIndex;
+    itk::Index<3> firstElementSegIndex, lastElementSegIndex;
 
     if( singleTract->front().Size() != 3 )
     {
       MBI_ERROR << mitk::ConnectomicsConstantsManager::CONNECTOMICS_ERROR_INVALID_DIMENSION_NEED_3;
     }
     for( unsigned int index = 0; index < singleTract->front().Size(); index++ )
     {
       firstElementFiberCoord.SetElement( index, singleTract->front().GetElement( index ) );
       lastElementFiberCoord.SetElement( index, singleTract->back().GetElement( index ) );
     }
 
     // convert from fiber index coordinates to segmentation index coordinates
     FiberToSegmentationCoords( firstElementFiberCoord, firstElementSegCoord );
     FiberToSegmentationCoords( lastElementFiberCoord, lastElementSegCoord );
 
     for( int index = 0; index < 3; index++ )
     {
       firstElementSegIndex.SetElement( index, firstElementSegCoord.GetElement( index ) );
       lastElementSegIndex.SetElement( index, lastElementSegCoord.GetElement( index ) );
     }
 
     int firstLabel = 1 * firstElementSegIndex[ 0 ] + 1000 * firstElementSegIndex[ 1 ] + 1000000 * firstElementSegIndex[ 2 ];
     int lastLabel = 1 * firstElementSegIndex[ 0 ] + 1000 * firstElementSegIndex[ 1 ] + 1000000 * firstElementSegIndex[ 2 ];
 
     labelpair.first = firstLabel;
     labelpair.second = lastLabel;
 
     // Add property to property map
     CreateNewNode( firstLabel, firstElementSegIndex, m_UseCoMCoordinates );
     CreateNewNode( lastLabel, lastElementSegIndex, m_UseCoMCoordinates );
   }
 
   return labelpair;
 }
 
 void mitk::ConnectomicsNetworkCreator::SupplyVertexWithInformation( ImageLabelType& label, VertexType& vertex )
 { // supply a vertex with the additional information belonging to the label
 
   // TODO: Implement additional information acquisition
 
   m_ConNetwork->SetLabel( vertex, m_LabelToNodePropertyMap.find( label )->second.label );
   m_ConNetwork->SetCoordinates( vertex, m_LabelToNodePropertyMap.find( label )->second.coordinates );
 
 }
 
 std::string mitk::ConnectomicsNetworkCreator::LabelToString( ImageLabelType& label )
 {
   int tempInt = (int) label;
   std::stringstream ss;//create a stringstream
   std::string tempString;
   ss << tempInt;//add number to the stream
   tempString = ss.str();
   return tempString;//return a string with the contents of the stream
 }
 
 mitk::ConnectomicsNetwork::Pointer mitk::ConnectomicsNetworkCreator::GetNetwork()
 {
   return m_ConNetwork;
 }
 
 void mitk::ConnectomicsNetworkCreator::FiberToSegmentationCoords( mitk::Point3D& fiberCoord, mitk::Point3D& segCoord )
 {
   mitk::Point3D tempPoint;
 
   // convert from fiber index coordinates to segmentation index coordinates
   m_FiberBundle->GetGeometry()->IndexToWorld( fiberCoord, tempPoint );
   m_Segmentation->GetGeometry()->WorldToIndex( tempPoint, segCoord );
 }
 
 void mitk::ConnectomicsNetworkCreator::SegmentationToFiberCoords( mitk::Point3D& segCoord, mitk::Point3D& fiberCoord )
 {
   mitk::Point3D tempPoint;
 
   // convert from fiber index coordinates to segmentation index coordinates
   m_Segmentation->GetGeometry()->IndexToWorld( segCoord, tempPoint );
   m_FiberBundle->GetGeometry()->WorldToIndex( tempPoint, fiberCoord );
 }
 
 bool mitk::ConnectomicsNetworkCreator::IsNonWhiteMatterLabel( int labelInQuestion )
 {
   bool isWhite( false );
 
   isWhite = (
     ( labelInQuestion == freesurfer_Left_Cerebral_White_Matter )   ||
     ( labelInQuestion == freesurfer_Left_Cerebellum_White_Matter ) ||
     ( labelInQuestion == freesurfer_Right_Cerebral_White_Matter )  ||
     ( labelInQuestion == freesurfer_Right_Cerebellum_White_Matter )||
     ( labelInQuestion == freesurfer_Left_Cerebellum_Cortex )       ||
     ( labelInQuestion == freesurfer_Right_Cerebellum_Cortex )      ||
     ( labelInQuestion == freesurfer_Brain_Stem )
     );
 
   return !isWhite;
 }
 
 bool mitk::ConnectomicsNetworkCreator::IsBackgroundLabel( int labelInQuestion )
 {
   bool isBackground( false );
 
   isBackground = ( labelInQuestion == 0 );
 
   return isBackground;
 }
 
 void mitk::ConnectomicsNetworkCreator::LinearExtensionUntilGreyMatter(
   std::vector<int> & indexVectorOfPointsToUse,
   TractType::Pointer singleTract,
   int & label,
-  mitk::Index3D & mitkIndex )
+  itk::Index<3> & mitkIndex )
 {
   if( indexVectorOfPointsToUse.size() > singleTract->Size() )
   {
     MBI_WARN << mitk::ConnectomicsConstantsManager::CONNECTOMICS_WARNING_MORE_POINTS_THAN_PRESENT;
     return;
   }
 
   if( indexVectorOfPointsToUse.size() < 2 )
   {
     MBI_WARN << mitk::ConnectomicsConstantsManager::CONNECTOMICS_WARNING_ESTIMATING_LESS_THAN_2;
     return;
   }
 
   for( unsigned int index( 0 ); index < indexVectorOfPointsToUse.size(); index++ )
   {
     if( indexVectorOfPointsToUse[ index ] < 0 )
     {
       MBI_WARN << mitk::ConnectomicsConstantsManager::CONNECTOMICS_WARNING_ESTIMATING_BEYOND_START;
       return;
     }
     if( (unsigned int)indexVectorOfPointsToUse[ index ] > singleTract->Size() )
     {
       MBI_WARN << mitk::ConnectomicsConstantsManager::CONNECTOMICS_WARNING_ESTIMATING_BEYOND_END;
       return;
     }
   }
 
   mitk::Point3D startPoint, endPoint;
   std::vector< double > differenceVector;
   differenceVector.resize( singleTract->front().Size() );
 
   {
     // which points to use, currently only last two //TODO correct using all points
     int endPointIndex = indexVectorOfPointsToUse.size() - 1;
     int startPointIndex = indexVectorOfPointsToUse.size() - 2;
 
     // convert to segmentation coords
     mitk::Point3D startFiber, endFiber;
     for( unsigned int index = 0; index < singleTract->front().Size(); index++ )
     {
       endFiber.SetElement( index, singleTract->GetElement( indexVectorOfPointsToUse[ endPointIndex ] ).GetElement( index ) );
       startFiber.SetElement( index, singleTract->GetElement( indexVectorOfPointsToUse[ startPointIndex ] ).GetElement( index ) );
     }
 
     FiberToSegmentationCoords( endFiber, endPoint );
     FiberToSegmentationCoords( startFiber, startPoint );
 
     // calculate straight line
 
     for( unsigned int index = 0; index < singleTract->front().Size(); index++ )
     {
       differenceVector[ index ] = endPoint.GetElement( index ) - startPoint.GetElement( index );
     }
 
     // normalizing direction vector
 
     double length( 0.0 );
     double sum( 0.0 );
 
     for( unsigned int index = 0; index < differenceVector.size() ; index++ )
     {
       sum = sum + differenceVector[ index ] * differenceVector[ index ];
     }
 
     length = std::sqrt( sum );
 
     for( unsigned int index = 0; index < differenceVector.size() ; index++ )
     {
       differenceVector[ index ] = differenceVector[ index ] / length;
     }
 
     // follow line until first non white matter label
-    mitk::Index3D tempIndex;
+    itk::Index<3> tempIndex;
     int tempLabel( label );
 
     bool keepOn( true );
 
     itk::ImageRegion<3> itkRegion = m_SegmentationItk->GetLargestPossibleRegion();
 
     for( int parameter( 0 ) ; keepOn ; parameter++ )
     {
       if( parameter > 1000 )
       {
         MBI_WARN << mitk::ConnectomicsConstantsManager::CONNECTOMICS_WARNING_DID_NOT_FIND_WHITE;
         break;
       }
 
       for( int index( 0 ); index < 3; index++ )
       {
         tempIndex.SetElement( index, endPoint.GetElement( index ) + parameter * differenceVector[ index ] );
       }
 
       if( itkRegion.IsInside( tempIndex ) )
       {
         tempLabel = m_SegmentationItk->GetPixel( tempIndex );
       }
       else
       {
         tempLabel = -1;
       }
 
       if( IsNonWhiteMatterLabel( tempLabel ) )
       {
         if( tempLabel < 1 )
         {
           keepOn = false;
           //MBI_WARN << mitk::ConnectomicsConstantsManager::CONNECTOMICS_WARNING_NOT_EXTEND_TO_WHITE;
         }
         else
         {
           label = tempLabel;
           mitkIndex = tempIndex;
           keepOn = false;
         }
       }
     }
 
   }
 }
 
 void mitk::ConnectomicsNetworkCreator::RetractionUntilBrainMatter( bool retractFront, TractType::Pointer singleTract,
-                                                                  int & label, mitk::Index3D & mitkIndex )
+                                                                  int & label, itk::Index<3> & mitkIndex )
 {
   int retractionStartIndex( singleTract->Size() - 1 );
   int retractionStepIndexSize( -1 );
   int retractionTerminationIndex( 0 );
 
   if( retractFront )
   {
     retractionStartIndex = 0;
     retractionStepIndexSize = 1;
     retractionTerminationIndex = singleTract->Size() - 1;
   }
 
   int currentRetractionIndex = retractionStartIndex;
 
   bool keepRetracting( true );
 
   mitk::Point3D currentPoint, nextPoint;
   std::vector< double > differenceVector;
   differenceVector.resize( singleTract->front().Size() );
 
   while( keepRetracting && ( currentRetractionIndex != retractionTerminationIndex ) )
   {
     // convert to segmentation coords
     mitk::Point3D currentPointFiberCoord, nextPointFiberCoord;
     for( unsigned int index = 0; index < singleTract->front().Size(); index++ )
     {
       currentPointFiberCoord.SetElement( index, singleTract->GetElement( currentRetractionIndex ).GetElement( index ) );
       nextPointFiberCoord.SetElement( index, singleTract->GetElement( currentRetractionIndex + retractionStepIndexSize ).GetElement( index ) );
     }
 
     FiberToSegmentationCoords( currentPointFiberCoord, currentPoint );
     FiberToSegmentationCoords( nextPointFiberCoord, nextPoint );
 
     // calculate straight line
 
     for( unsigned int index = 0; index < singleTract->front().Size(); index++ )
     {
       differenceVector[ index ] = nextPoint.GetElement( index ) - currentPoint.GetElement( index );
     }
 
     // calculate length of direction vector
 
     double length( 0.0 );
     double sum( 0.0 );
 
     for( unsigned int index = 0; index < differenceVector.size() ; index++ )
     {
       sum = sum + differenceVector[ index ] * differenceVector[ index ];
     }
 
     length = std::sqrt( sum );
 
     // retract
-    mitk::Index3D tempIndex;
+    itk::Index<3> tempIndex;
     int tempLabel( label );
 
     for( int parameter( 0 ) ; parameter < length ; parameter++ )
     {
 
       for( int index( 0 ); index < 3; index++ )
       {
         tempIndex.SetElement( index,
           currentPoint.GetElement( index ) + ( 1.0 + parameter ) / ( 1.0 + length ) * differenceVector[ index ] );
       }
 
       tempLabel = m_SegmentationItk->GetPixel( tempIndex );
 
       if( !IsBackgroundLabel( tempLabel ) )
       {
         // check whether result is within the search space
         {
           mitk::Point3D endPoint, foundPointSegmentation, foundPointFiber;
           for( unsigned int index = 0; index < singleTract->front().Size(); index++ )
           {
             // this is in fiber (world) coordinates
             endPoint.SetElement( index, singleTract->GetElement( retractionStartIndex ).GetElement( index ) );
           }
 
           for( int index( 0 ); index < 3; index++ )
           {
             foundPointSegmentation.SetElement( index,
               currentPoint.GetElement( index ) + ( 1.0 + parameter ) / ( 1.0 + length ) * differenceVector[ index ] );
           }
 
           SegmentationToFiberCoords( foundPointSegmentation, foundPointFiber );
 
           std::vector< double > finalDistance;
           finalDistance.resize( singleTract->front().Size() );
           for( unsigned int index = 0; index < singleTract->front().Size(); index++ )
           {
             finalDistance[ index ] = foundPointFiber.GetElement( index ) - endPoint.GetElement( index );
           }
 
           // calculate length of direction vector
 
           double finalLength( 0.0 );
           double finalSum( 0.0 );
 
           for( unsigned int index = 0; index < finalDistance.size() ; index++ )
           {
             finalSum = finalSum + finalDistance[ index ] * finalDistance[ index ];
           }
           finalLength = std::sqrt( finalSum );
 
           if( finalLength > m_EndPointSearchRadius )
           {
             // the found point was not within the search space
             return;
           }
         }
 
         label = tempLabel;
         mitkIndex = tempIndex;
         return;
       }
       // hit next point without finding brain matter
       currentRetractionIndex = currentRetractionIndex + retractionStepIndexSize;
       if( ( currentRetractionIndex < 1 ) || ( (unsigned int)currentRetractionIndex > ( singleTract->Size() - 2 ) ) )
       {
         keepRetracting = false;
       }
     }
   }
 }
 
 void mitk::ConnectomicsNetworkCreator::CalculateCenterOfMass()
 {
 
   const int dimensions = 3;
   int max = m_Segmentation->GetStatistics()->GetScalarValueMax();
   int min = m_Segmentation->GetStatistics()->GetScalarValueMin();
 
   int range = max - min +1;
 
   // each label owns a vector of coordinates
   std::vector< std::vector< std::vector< double> > > coordinatesPerLabelVector;
   coordinatesPerLabelVector.resize( range );
 
   itk::ImageRegionIteratorWithIndex<ITKImageType> it_itkImage( m_SegmentationItk, m_SegmentationItk->GetLargestPossibleRegion() );
 
   for( it_itkImage.GoToBegin(); !it_itkImage.IsAtEnd(); ++it_itkImage )
   {
     std::vector< double > coordinates;
     coordinates.resize(dimensions);
 
     itk::Index< dimensions > index = it_itkImage.GetIndex();
 
     for( int loop(0); loop < dimensions; loop++)
     {
       coordinates.at( loop ) = index.GetElement( loop );
     }
 
     // add the coordinates to the corresponding label vector
     coordinatesPerLabelVector.at( it_itkImage.Value() - min ).push_back( coordinates );
   }
 
   for(int currentIndex(0), currentLabel( min ); currentIndex < range; currentIndex++, currentLabel++ )
   {
     std::vector< double > currentCoordinates;
     currentCoordinates.resize(dimensions);
 
     int numberOfPoints = coordinatesPerLabelVector.at( currentIndex ).size();
 
     std::vector< double > sumCoords;
     sumCoords.resize( dimensions );
 
     for( int loop(0); loop < numberOfPoints; loop++ )
     {
       for( int loopDimension( 0 ); loopDimension < dimensions; loopDimension++ )
       {
         sumCoords.at( loopDimension ) += coordinatesPerLabelVector.at( currentIndex ).at( loop ).at( loopDimension );
       }
     }
 
     for( int loopDimension( 0 ); loopDimension < dimensions; loopDimension++ )
     {
       currentCoordinates.at( loopDimension ) = sumCoords.at( loopDimension ) / numberOfPoints;
     }
 
     m_LabelsToCoordinatesMap.insert( std::pair< int, std::vector<double> >( currentLabel, currentCoordinates ) );
   }
 
   //can now use center of mass coordinates
   m_UseCoMCoordinates = true;
 }
 
 std::vector< double >  mitk::ConnectomicsNetworkCreator::GetCenterOfMass( int label )
 {
   // if label is not known, warn
   if( ! ( m_LabelsToCoordinatesMap.count( label ) > 0 ) )
   {
     MITK_ERROR << "Label " << label << " not found. Could not return coordinates.";
     std::vector< double > nullVector;
     nullVector.resize(3);
     return nullVector;
   }
 
   //return associated coordinates
   return m_LabelsToCoordinatesMap.find( label )->second;
 }
 
-void mitk::ConnectomicsNetworkCreator::CreateNewNode( int label, mitk::Index3D index, bool useCoM )
+void mitk::ConnectomicsNetworkCreator::CreateNewNode( int label, itk::Index<3> index, bool useCoM )
 {
   // Only create node if it does not exist yet
 
   if( ! ( m_LabelToNodePropertyMap.count( label ) > 0 ) )
   {
     NetworkNode newNode;
 
     newNode.coordinates.resize( 3 );
     if( !useCoM )
     {
       for( unsigned int loop = 0; loop < newNode.coordinates.size() ; loop++ )
       {
         newNode.coordinates[ loop ] = index[ loop ] ;
       }
     }
     else
     {
       std::vector<double> labelCoords = GetCenterOfMass( label );
       for( unsigned int loop = 0; loop < newNode.coordinates.size() ; loop++ )
       {
         newNode.coordinates[ loop ] = labelCoords.at( loop ) ;
       }
     }
 
     newNode.label = LabelToString( label );
 
     m_LabelToNodePropertyMap.insert( std::pair< ImageLabelType, NetworkNode >( label, newNode ) );
   }
 }
diff --git a/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsNetworkCreator.h b/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsNetworkCreator.h
index d6e00b460f..8a956f4c8b 100644
--- a/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsNetworkCreator.h
+++ b/Modules/DiffusionImaging/Connectomics/Algorithms/mitkConnectomicsNetworkCreator.h
@@ -1,249 +1,249 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef mitkConnectomicsNetworkCreator_h
 #define mitkConnectomicsNetworkCreator_h
 
 #include <itkObject.h>
 #include <itkObjectFactory.h>
 #include <itkMacro.h>
 
 #include "mitkCommon.h"
 #include "mitkImage.h"
 
 #include "mitkFiberBundleX.h"
 #include "mitkConnectomicsNetwork.h"
 
 #include <MitkConnectomicsExports.h>
 
 namespace mitk
 {
 
   /**
     * \brief Creates connectomics networks from fibers and parcellation
     *
     * This class needs a parcellation image and a fiber image to be set. Then you can create
     * a connectomics network from the two, using different strategies.
     */
 
   class MitkConnectomics_EXPORT ConnectomicsNetworkCreator : public itk::Object
   {
   public:
 
     /** Enum for different ways to create the mapping from fibers to network */
 
     enum MappingStrategy
     {
       EndElementPosition,
       EndElementPositionAvoidingWhiteMatter,
       JustEndPointVerticesNoLabel,
       PrecomputeAndDistance
     };
 
     /** Standard class typedefs. */
     /** Method for creation through the object factory. */
 
     mitkClassMacro(ConnectomicsNetworkCreator, itk::Object);
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
 
     /** Type for Images **/
     typedef itk::Image<int, 3 > ITKImageType;
 
     /** Types for the standardized Tract **/
     typedef itk::Point<float,3>                                          PointType;
     typedef itk::VectorContainer<unsigned int, PointType>                TractType;
     typedef itk::VectorContainer< unsigned int, TractType::Pointer >     TractContainerType; //init via smartpointer
 
 
     /** Types for Network **/
     typedef mitk::ConnectomicsNetwork::VertexDescriptorType VertexType;
     typedef mitk::ConnectomicsNetwork::EdgeDescriptorType EdgeType;
     typedef mitk::ConnectomicsNetwork::NetworkNode NetworkNode;
     typedef std::pair< VertexType, VertexType >       ConnectionType;
 
     /** Types for labels **/
     typedef int                                             ImageLabelType;
     typedef std::pair< ImageLabelType, ImageLabelType >     ImageLabelPairType;
 
     /** Given a fiber bundle and a parcellation are set, this will create a network from both */
     void CreateNetworkFromFibersAndSegmentation();
     void SetFiberBundle(mitk::FiberBundleX::Pointer fiberBundle);
     void SetSegmentation(mitk::Image::Pointer segmentation);
 
     mitk::ConnectomicsNetwork::Pointer GetNetwork();
 
     itkSetMacro(MappingStrategy, MappingStrategy);
     itkSetMacro(EndPointSearchRadius, double);
     itkSetMacro(ZeroLabelInvalid, bool);
 
     /** \brief Calculate the locations of vertices
      *
      * Calculate the center of mass for each label and store the information. This will need a set parcellation image.
      * Unless this function is called the first location where a label is encountered will be used. After calling this function
      * the center of mass will be used instead.
      */
     void CalculateCenterOfMass();
 
   protected:
 
     //////////////////// Functions ///////////////////////
     ConnectomicsNetworkCreator();
     ConnectomicsNetworkCreator( mitk::Image::Pointer segmentation, mitk::FiberBundleX::Pointer fiberBundle );
     ~ConnectomicsNetworkCreator();
 
     /** Add a connection to the network */
     void AddConnectionToNetwork(ConnectionType newConnection);
 
     /** Determine if a label is already identified with a vertex, otherwise create a new one */
     VertexType ReturnAssociatedVertexForLabel( ImageLabelType label );
 
     /** Return the vertexes associated with a pair of labels */
     ConnectionType ReturnAssociatedVertexPairForLabelPair( ImageLabelPairType labelpair );
 
     /** Return the pair of labels which identify the areas connected by a single fiber */
     ImageLabelPairType ReturnLabelForFiberTract( TractType::Pointer singleTract, MappingStrategy strategy );
 
     /** Assign the additional information which should be part of the vertex */
     void SupplyVertexWithInformation( ImageLabelType& label, VertexType& vertex );
 
     /** Create a string from the label */
     std::string LabelToString( ImageLabelType& label );
 
     /** Check whether the label in question belongs to white matter according to the freesurfer table */
     bool IsNonWhiteMatterLabel( int labelInQuestion );
 
     /** Check whether the label in question belongs to background according to the freesurfer table */
     bool IsBackgroundLabel( int labelInQuestion );
 
     /** Extend a straight line through the given points and look for the first non white matter label
 
     It will try extend in the direction of the points in the vector so a vector {B,C} will result in
     extending from C in the direction C-B */
     void LinearExtensionUntilGreyMatter( std::vector<int> & indexVectorOfPointsToUse, TractType::Pointer singleTract,
-      int & label, mitk::Index3D & mitkIndex );
+      int & label, itk::Index<3> & mitkIndex );
 
     /** Retract fiber until the first brain matter label is hit
 
     The bool parameter controls whether the front or the end is retracted */
     void RetractionUntilBrainMatter( bool retractFront, TractType::Pointer singleTract,
-      int & label, mitk::Index3D & mitkIndex );
+      int & label, itk::Index<3> & mitkIndex );
 
     /** \brief Get the location of the center of mass for a specific label
      * This can throw an exception if the label is not found.
      */
     std::vector< double > GetCenterOfMass( int label );
 
     /** Convert point to itk point */
     itk::Point<float, 3> GetItkPoint(double point[3]);
 
     /** \brief Creates a new node
      *
      * A new node will be created, using the label and either the supplied coordinates
      * or the center of mass coordinates, depending on the supplied bool.
      */
-    void CreateNewNode( int label, mitk::Index3D, bool useIndex );
+    void CreateNewNode( int label, itk::Index<3>, bool useIndex );
 
     ///////// Mapping strategies //////////
 
     /** Use the position of the end and starting element only to map to labels
 
     Map a fiber to a vertex by taking the value of the parcellation image at the same world coordinates as the last
     and first element of the tract.*/
     ImageLabelPairType EndElementPositionLabel( TractType::Pointer singleTract );
 
     /** Map by distance between elements and vertices depending on their volume
 
     First go through the parcellation and compute the coordinates of the future vertices. Assign a radius according on their volume.
     Then map an edge to a label by considering the nearest vertices and comparing the distance to them to their radii. */
     ImageLabelPairType PrecomputeVertexLocationsBySegmentation( TractType::Pointer singleTract );
 
         /** Use the position of the end and starting element only to map to labels
 
     Just take first and last position, no labelling, nothing */
     ImageLabelPairType JustEndPointVerticesNoLabelTest( TractType::Pointer singleTract );
 
     /** Use the position of the end and starting element unless it is in white matter, then search for nearby parcellation to map to labels
 
     Map a fiber to a vertex by taking the value of the parcellation image at the same world coordinates as the last
     and first element of the tract. If this happens to be white matter, then try to extend the fiber in a line and
     take the first non-white matter parcel, that is intersected. */
     ImageLabelPairType EndElementPositionLabelAvoidingWhiteMatter( TractType::Pointer singleTract );
 
     ///////// Conversions //////////
     /** Convert fiber index to segmentation index coordinates */
     void FiberToSegmentationCoords( mitk::Point3D& fiberCoord, mitk::Point3D& segCoord );
     /** Convert segmentation index to fiber index coordinates */
     void SegmentationToFiberCoords( mitk::Point3D& segCoord, mitk::Point3D& fiberCoord );
 
     /////////////////////// Variables ////////////////////////
     mitk::FiberBundleX::Pointer m_FiberBundle;
     mitk::Image::Pointer m_Segmentation;
     ITKImageType::Pointer m_SegmentationItk;
 
     // the graph itself
     mitk::ConnectomicsNetwork::Pointer m_ConNetwork;
 
     // the id counter
     int idCounter;
 
     // the map mapping labels to vertices
     std::map< ImageLabelType, VertexType > m_LabelToVertexMap;
 
     // mapping labels to additional information
     std::map< ImageLabelType, NetworkNode > m_LabelToNodePropertyMap;
 
     // toggles whether edges between a node and itself can exist
     bool allowLoops;
 
     // toggles whether to use the center of mass coordinates
     bool m_UseCoMCoordinates;
 
     // stores the coordinates of labels
     std::map< int, std::vector< double> > m_LabelsToCoordinatesMap;
 
     // the straty to use for mapping
     MappingStrategy m_MappingStrategy;
 
     // search radius for finding a non white matter/background area. Should be in mm
     double m_EndPointSearchRadius;
 
     // toggles whether a node with the label 0 may be present
     bool m_ZeroLabelInvalid;
 
     // used internally to communicate a connection should not be added if the a problem
     // is encountered while adding it
     bool m_AbortConnection;
 
     //////////////////////// IDs ////////////////////////////
 
     // These IDs are the freesurfer ids used in parcellation
 
     static const int freesurfer_Left_Cerebral_White_Matter = 2;
     static const int freesurfer_Left_Cerebellum_White_Matter = 7;
     static const int freesurfer_Left_Cerebellum_Cortex = 8;
     static const int freesurfer_Brain_Stem = 16;
     static const int freesurfer_Right_Cerebral_White_Matter = 41;
     static const int freesurfer_Right_Cerebellum_White_Matter = 46;
     static const int freesurfer_Right_Cerebellum_Cortex = 47;
 
 
   };
 
 }// end namespace mitk
 
 #endif // _mitkConnectomicsNetworkCreator_H_INCLUDED
diff --git a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssImporter.cpp b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssImporter.cpp
index e9d970dc83..ffd437fdb4 100644
--- a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssImporter.cpp
+++ b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkTbssImporter.cpp
@@ -1,137 +1,137 @@
 /*===================================================================
 
 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 __mitkTbssImporter_cpp
 #define __mitkTbssImporter_cpp
 
 #include "mitkTbssImporter.h"
 #include <mitkPixelTypeMultiplex.h>
 #include "mitkImagePixelReadAccessor.h"
 
 namespace mitk
 {
 
 TbssImage::Pointer TbssImporter::Import()
 {
   mitk::TbssImage::Pointer tbssImg = mitk::TbssImage::New();
   mitkPixelTypeMultiplex1( Import, m_InputVolume->GetPixelType(), tbssImg);
   return tbssImg;
 }
 
 template <typename TPixel>
 void TbssImporter::Import(const mitk::PixelType , mitk::TbssImage::Pointer tbssImg)
 {
   // read all images with all_*.nii.gz
   MITK_INFO << "called import ...";
   m_Data = DataImageType::New();
 
   mitk::Geometry3D* geo = m_InputVolume->GetGeometry();
   mitk::Vector3D spacing = geo->GetSpacing();
   mitk::Point3D origin = geo->GetOrigin();
 
   //Size size
   DataImageType::SizeType dataSize;
   dataSize[0] = m_InputVolume->GetDimension(0);
   dataSize[1] = m_InputVolume->GetDimension(1);
   dataSize[2] = m_InputVolume->GetDimension(2);
 
   m_Data->SetRegions(dataSize);
 
   // Set spacing
   DataImageType::SpacingType dataSpacing;
   dataSpacing[0] = spacing[0];
   dataSpacing[1] = spacing[1];
   dataSpacing[2] = spacing[2];
   m_Data->SetSpacing(dataSpacing);
 
   DataImageType::PointType dataOrigin;
   dataOrigin[0] = origin[0];
   dataOrigin[1] = origin[1];
   dataOrigin[2] = origin[2];
   m_Data->SetOrigin(dataOrigin);
 
   //Direction must be set
   DataImageType::DirectionType dir;
-  const itk::Transform<ScalarType, 3, 3>* transform3D = geo->GetParametricTransform();
+  const itk::Transform<mitk::ScalarType, 3, 3>* transform3D = geo->GetParametricTransform();
   itk::Transform<ScalarType,3,3>::ParametersType p = transform3D->GetParameters();
   int t=0;
   for(int i=0; i<3; i++)
   {
     for(int j=0; j<3; j++)
     {
       dir[i][j] = p[t]; // row-major order (where the column index varies the fastest)
       t++;
     }
   }
 
   m_Data->SetDirection(dir);
 
   // Set the length to one because otherwise allocate fails. Should be changed when groups/measurements are added
   m_Data->SetVectorLength(m_InputVolume->GetDimension(3));
   m_Data->Allocate();
 
   // Determine vector size of m_Data
 
   int vecSize = m_Data->GetVectorLength();
 
   MITK_INFO << "vecsize " <<vecSize;
   try {
     mitk::ImagePixelReadAccessor<TPixel,4> readTbss( m_InputVolume );
 
     for(unsigned int i=0; i<dataSize[0]; i++)
     {
       MITK_INFO << "i " << i << " / " << dataSize[0];
       for(unsigned int j=0; j<dataSize[1]; j++)
       {
         for(unsigned int k=0; k<dataSize[2]; k++)
         {
           itk::VariableLengthVector<float> pixel;
           itk::Index<3> id;
           itk::Index<4> ix;
 
           ix[0] = id[0] = i;
           ix[1] = id[1] = j;
           ix[2] = id[2] = k;
 
           pixel = m_Data->GetPixel(id);
 
           for(int z=0; z<vecSize; z++)
           {
             ix[3] = z;
             float value = readTbss.GetPixelByIndex(ix);
             pixel.SetElement(z, value);
           }
           m_Data->SetPixel(id, pixel);
         }
       }
     }
   }
   catch ( mitk::Exception& e )
   {
     MITK_ERROR << "TbssImporter::Import: No read access to tbss image: " << e.what() ;
   }
 
   tbssImg->SetGroupInfo(m_Groups);
   tbssImg->SetMeasurementInfo(m_MeasurementInfo);
   tbssImg->SetImage(m_Data);
 
   tbssImg->InitializeFromVectorImage();
 
 }
 
 
 }
 #endif // __mitkTbssImporter_cpp
diff --git a/Modules/Python/Testing/mitkCopyToPythonAsItkImageTest.cpp b/Modules/Python/Testing/mitkCopyToPythonAsItkImageTest.cpp
index 956aba53c4..c9d0e5cd32 100644
--- a/Modules/Python/Testing/mitkCopyToPythonAsItkImageTest.cpp
+++ b/Modules/Python/Testing/mitkCopyToPythonAsItkImageTest.cpp
@@ -1,72 +1,72 @@
 /*===================================================================
 
 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 <mitkCommon.h>
 #include <usModuleContext.h>
 #include <usGetModuleContext.h>
 #include <usServiceReference.h>
 #include <mitkTestingMacros.h>
 #include <mitkPythonService.h>
 #include <mitkIPythonService.h>
 #include <mitkIOUtil.h>
 
 #include <usModuleRegistry.h>
 #include <usModule.h>
 #include <usServiceReference.h>
 #include <mitkImagePixelReadAccessor.h>
 
 int mitkCopyToPythonAsItkImageTest(int /*argc*/, char* argv[])
 {
   MITK_TEST_BEGIN("mitkCopyToPythonAsItkImageTest")
 
   //get the context of the python module
   us::Module* module = us::ModuleRegistry::GetModule("MitkPython");
   us::ModuleContext* context = module->GetModuleContext();
   //get the service which is generated in the PythonModuleActivator
   us::ServiceReference<mitk::IPythonService> serviceRef = context->GetServiceReference<mitk::IPythonService>();
   mitk::PythonService* pythonService = dynamic_cast<mitk::PythonService*>( context->GetService(serviceRef) );
   MITK_TEST_CONDITION(pythonService->IsItkPythonWrappingAvailable() == true, "Is Python available?");
 
   mitk::Image::Pointer testImage = mitk::IOUtil::LoadImage(std::string(argv[1]));
 
   //give it a name in python
   std::string nameOfImageInPython("mitkImage");
 
   MITK_TEST_CONDITION( pythonService->CopyToPythonAsItkImage( testImage, nameOfImageInPython) == true, "Valid image copied to python import should return true.");
   mitk::Image::Pointer pythonImage = pythonService->CopyItkImageFromPython(nameOfImageInPython);
 
 
-  mitk::Index3D index;
+  itk::Index<3> index;
   index[0] = 128;
   index[1] = 128;
   index[2] = 24;
 
   try{
     // pic3D of type char
     mitk::ImagePixelReadAccessor<char,3> pythonImageAccesor(pythonImage);
 
     //TODO Use the assert comparison methods once we have them implemented and remove GetPixelValueByIndex
     MITK_TEST_CONDITION( pythonImageAccesor.GetDimension(0) == 256, "Is the 1st dimension of Pic3D still 256?");
     MITK_TEST_CONDITION( pythonImageAccesor.GetDimension(1) == 256, "Is the 2nd dimension of Pic3D still 256?");
     MITK_TEST_CONDITION( pythonImageAccesor.GetDimension(2) == 49, "Is the 3rd dimension of Pic3D still 49?");
 
     MITK_TEST_CONDITION( pythonImageAccesor.GetPixelByIndex(index) == 96, "Is the value of Pic3D at (128,128,24) still 96?");
   }catch(...)
   {
     MITK_TEST_CONDITION( false, "Image is not readable! ");
   }
 
   MITK_TEST_END()
 }
diff --git a/Modules/QtWidgets/QmitkStdMultiWidget.cpp b/Modules/QtWidgets/QmitkStdMultiWidget.cpp
index 5c852d8980..26f385fe7c 100644
--- a/Modules/QtWidgets/QmitkStdMultiWidget.cpp
+++ b/Modules/QtWidgets/QmitkStdMultiWidget.cpp
@@ -1,2200 +1,2200 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #define SMW_INFO MITK_INFO("widget.stdmulti")
 
 #include "QmitkStdMultiWidget.h"
 
 #include <QHBoxLayout>
 #include <QVBoxLayout>
 #include <QGridLayout>
 #include <qsplitter.h>
 #include <QMotifStyle>
 #include <QList>
 #include <QMouseEvent>
 #include <QTimer>
 
 #include "mitkProperties.h"
 #include "mitkGeometry2DDataMapper2D.h"
 #include "mitkGlobalInteraction.h"
 #include "mitkDisplayInteractor.h"
 #include "mitkPointSet.h"
 #include "mitkPositionEvent.h"
 #include "mitkStateEvent.h"
 #include "mitkLine.h"
 #include "mitkInteractionConst.h"
 #include "mitkDataStorage.h"
 #include "mitkOverlayManager.h"
 
 #include "mitkNodePredicateBase.h"
 #include "mitkNodePredicateDataType.h"
 
 #include "mitkNodePredicateNot.h"
 #include "mitkNodePredicateProperty.h"
 #include "mitkStatusBar.h"
 #include "mitkImage.h"
 
 #include "mitkVtkLayerController.h"
 
 #include <iomanip>
 
 QmitkStdMultiWidget::QmitkStdMultiWidget(QWidget* parent, Qt::WindowFlags f, mitk::RenderingManager* renderingManager, mitk::BaseRenderer::RenderingMode::Type renderingMode)
 : QWidget(parent, f),
 mitkWidget1(NULL),
 mitkWidget2(NULL),
 mitkWidget3(NULL),
 mitkWidget4(NULL),
 levelWindowWidget(NULL),
 QmitkStdMultiWidgetLayout(NULL),
 m_Layout(LAYOUT_DEFAULT),
 m_PlaneMode(PLANE_MODE_SLICING),
 m_RenderingManager(renderingManager),
 m_GradientBackgroundFlag(true),
 m_TimeNavigationController(NULL),
 m_MainSplit(NULL),
 m_LayoutSplit(NULL),
 m_SubSplit1(NULL),
 m_SubSplit2(NULL),
 mitkWidget1Container(NULL),
 mitkWidget2Container(NULL),
 mitkWidget3Container(NULL),
 mitkWidget4Container(NULL),
 m_PendingCrosshairPositionEvent(false),
 m_CrosshairNavigationEnabled(false)
 {
   /******************************************************
    * Use the global RenderingManager if none was specified
    * ****************************************************/
   if (m_RenderingManager == NULL)
   {
     m_RenderingManager = mitk::RenderingManager::GetInstance();
   }
   m_TimeNavigationController = m_RenderingManager->GetTimeNavigationController();
 
   /*******************************/
   //Create Widget manually
   /*******************************/
 
   //create Layouts
   QmitkStdMultiWidgetLayout = new QHBoxLayout( this );
   QmitkStdMultiWidgetLayout->setContentsMargins(0,0,0,0);
 
   //Set Layout to widget
   this->setLayout(QmitkStdMultiWidgetLayout);
 
 //  QmitkNavigationToolBar* toolBar = new QmitkNavigationToolBar();
 //  QmitkStdMultiWidgetLayout->addWidget( toolBar );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( Qt::Vertical, m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //create m_SubSplit1 and m_SubSplit2
   m_SubSplit1 = new QSplitter( m_LayoutSplit );
   m_SubSplit2 = new QSplitter( m_LayoutSplit );
 
   //creae Widget Container
   mitkWidget1Container = new QWidget(m_SubSplit1);
   mitkWidget2Container = new QWidget(m_SubSplit1);
   mitkWidget3Container = new QWidget(m_SubSplit2);
   mitkWidget4Container = new QWidget(m_SubSplit2);
 
   mitkWidget1Container->setContentsMargins(0,0,0,0);
   mitkWidget2Container->setContentsMargins(0,0,0,0);
   mitkWidget3Container->setContentsMargins(0,0,0,0);
   mitkWidget4Container->setContentsMargins(0,0,0,0);
 
   //create Widget Layout
   QHBoxLayout *mitkWidgetLayout1 = new QHBoxLayout(mitkWidget1Container);
   QHBoxLayout *mitkWidgetLayout2 = new QHBoxLayout(mitkWidget2Container);
   QHBoxLayout *mitkWidgetLayout3 = new QHBoxLayout(mitkWidget3Container);
   QHBoxLayout *mitkWidgetLayout4 = new QHBoxLayout(mitkWidget4Container);
 
   mitkWidgetLayout1->setMargin(0);
   mitkWidgetLayout2->setMargin(0);
   mitkWidgetLayout3->setMargin(0);
   mitkWidgetLayout4->setMargin(0);
 
   //set Layout to Widget Container
   mitkWidget1Container->setLayout(mitkWidgetLayout1);
   mitkWidget2Container->setLayout(mitkWidgetLayout2);
   mitkWidget3Container->setLayout(mitkWidgetLayout3);
   mitkWidget4Container->setLayout(mitkWidgetLayout4);
 
   //set SizePolicy
   mitkWidget1Container->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
   mitkWidget2Container->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
   mitkWidget3Container->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
   mitkWidget4Container->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
 
   //insert Widget Container into the splitters
   m_SubSplit1->addWidget( mitkWidget1Container );
   m_SubSplit1->addWidget( mitkWidget2Container );
 
   m_SubSplit2->addWidget( mitkWidget3Container );
   m_SubSplit2->addWidget( mitkWidget4Container );
 
   //  m_RenderingManager->SetGlobalInteraction( mitk::GlobalInteraction::GetInstance() );
 
   //Create RenderWindows 1
   mitkWidget1 = new QmitkRenderWindow(mitkWidget1Container, "stdmulti.widget1", NULL, m_RenderingManager,renderingMode);
   mitkWidget1->setMaximumSize(2000,2000);
   mitkWidget1->SetLayoutIndex( AXIAL );
   mitkWidgetLayout1->addWidget(mitkWidget1);
 
   //Create RenderWindows 2
   mitkWidget2 = new QmitkRenderWindow(mitkWidget2Container, "stdmulti.widget2", NULL, m_RenderingManager,renderingMode);
   mitkWidget2->setMaximumSize(2000,2000);
   mitkWidget2->setEnabled( TRUE );
   mitkWidget2->SetLayoutIndex( SAGITTAL );
   mitkWidgetLayout2->addWidget(mitkWidget2);
 
   //Create RenderWindows 3
   mitkWidget3 = new QmitkRenderWindow(mitkWidget3Container, "stdmulti.widget3", NULL, m_RenderingManager,renderingMode);
   mitkWidget3->setMaximumSize(2000,2000);
   mitkWidget3->SetLayoutIndex( CORONAL );
   mitkWidgetLayout3->addWidget(mitkWidget3);
 
   //Create RenderWindows 4
   mitkWidget4 = new QmitkRenderWindow(mitkWidget4Container, "stdmulti.widget4", NULL, m_RenderingManager,renderingMode);
   mitkWidget4->setMaximumSize(2000,2000);
   mitkWidget4->SetLayoutIndex( THREE_D );
   mitkWidgetLayout4->addWidget(mitkWidget4);
 
   //create SignalSlot Connection
   connect( mitkWidget1, SIGNAL( SignalLayoutDesignChanged(int) ), this, SLOT( OnLayoutDesignChanged(int) ) );
   connect( mitkWidget1, SIGNAL( ResetView() ), this, SLOT( ResetCrosshair() ) );
   connect( mitkWidget1, SIGNAL( ChangeCrosshairRotationMode(int) ), this, SLOT( SetWidgetPlaneMode(int) ) );
   connect( this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget1, SLOT(OnWidgetPlaneModeChanged(int)) );
 
   connect( mitkWidget2, SIGNAL( SignalLayoutDesignChanged(int) ), this, SLOT( OnLayoutDesignChanged(int) ) );
   connect( mitkWidget2, SIGNAL( ResetView() ), this, SLOT( ResetCrosshair() ) );
   connect( mitkWidget2, SIGNAL( ChangeCrosshairRotationMode(int) ), this, SLOT( SetWidgetPlaneMode(int) ) );
   connect( this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget2, SLOT(OnWidgetPlaneModeChanged(int)) );
 
   connect( mitkWidget3, SIGNAL( SignalLayoutDesignChanged(int) ), this, SLOT( OnLayoutDesignChanged(int) ) );
   connect( mitkWidget3, SIGNAL( ResetView() ), this, SLOT( ResetCrosshair() ) );
   connect( mitkWidget3, SIGNAL( ChangeCrosshairRotationMode(int) ), this, SLOT( SetWidgetPlaneMode(int) ) );
   connect( this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget3, SLOT(OnWidgetPlaneModeChanged(int)) );
 
   connect( mitkWidget4, SIGNAL( SignalLayoutDesignChanged(int) ), this, SLOT( OnLayoutDesignChanged(int) ) );
   connect( mitkWidget4, SIGNAL( ResetView() ), this, SLOT( ResetCrosshair() ) );
   connect( mitkWidget4, SIGNAL( ChangeCrosshairRotationMode(int) ), this, SLOT( SetWidgetPlaneMode(int) ) );
   connect( this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget4, SLOT(OnWidgetPlaneModeChanged(int)) );
 
   //Create Level Window Widget
   levelWindowWidget = new QmitkLevelWindowWidget( m_MainSplit ); //this
   levelWindowWidget->setObjectName(QString::fromUtf8("levelWindowWidget"));
   QSizePolicy sizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
   sizePolicy.setHorizontalStretch(0);
   sizePolicy.setVerticalStretch(0);
   sizePolicy.setHeightForWidth(levelWindowWidget->sizePolicy().hasHeightForWidth());
   levelWindowWidget->setSizePolicy(sizePolicy);
   levelWindowWidget->setMaximumSize(QSize(50, 2000));
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //resize Image.
   this->resize( QSize(364, 477).expandedTo(minimumSizeHint()) );
 
   //Initialize the widgets.
   this->InitializeWidget();
 
   //Activate Widget Menu
   this->ActivateMenuWidget( true );
 }
 
 void QmitkStdMultiWidget::InitializeWidget()
 {
   m_PositionTracker = NULL;
 
   // transfer colors in WorldGeometry-Nodes of the associated Renderer
   QColor qcolor;
   //float color[3] = {1.0f,1.0f,1.0f};
   mitk::DataNode::Pointer planeNode;
   mitk::IntProperty::Pointer  layer;
 
   // of widget 1
   planeNode = mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetCurrentWorldGeometry2DNode();
   planeNode->SetColor(1.0,0.0,0.0);
   layer = mitk::IntProperty::New(1000);
   planeNode->SetProperty("layer",layer);
 
   // ... of widget 2
   planeNode = mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->GetCurrentWorldGeometry2DNode();
   planeNode->SetColor(0.0,1.0,0.0);
   layer = mitk::IntProperty::New(1000);
   planeNode->SetProperty("layer",layer);
 
   // ... of widget 3
   planeNode = mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->GetCurrentWorldGeometry2DNode();
   planeNode->SetColor(0.0,0.0,1.0);
   layer = mitk::IntProperty::New(1000);
   planeNode->SetProperty("layer",layer);
 
   // ... of widget 4
   planeNode = mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->GetCurrentWorldGeometry2DNode();
   planeNode->SetColor(1.0,1.0,0.0);
   layer = mitk::IntProperty::New(1000);
   planeNode->SetProperty("layer",layer);
 
   mitk::OverlayManager::Pointer OverlayManager = mitk::OverlayManager::New();
   mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->SetOverlayManager(OverlayManager);
   mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->SetOverlayManager(OverlayManager);
   mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->SetOverlayManager(OverlayManager);
   mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->SetOverlayManager(OverlayManager);
 
   mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->SetMapperID(mitk::BaseRenderer::Standard3D);
   // Set plane mode (slicing/rotation behavior) to slicing (default)
   m_PlaneMode = PLANE_MODE_SLICING;
 
   // Set default view directions for SNCs
   mitkWidget1->GetSliceNavigationController()->SetDefaultViewDirection(
     mitk::SliceNavigationController::Axial );
   mitkWidget2->GetSliceNavigationController()->SetDefaultViewDirection(
     mitk::SliceNavigationController::Sagittal );
   mitkWidget3->GetSliceNavigationController()->SetDefaultViewDirection(
     mitk::SliceNavigationController::Frontal );
   mitkWidget4->GetSliceNavigationController()->SetDefaultViewDirection(
     mitk::SliceNavigationController::Original );
 
   /*************************************************/
   //Write Layout Names into the viewers -- hardCoded
 
   //Info for later:
   //int view = this->GetRenderWindow1()->GetSliceNavigationController()->GetDefaultViewDirection();
   //QString layoutName;
   //if( view == mitk::SliceNavigationController::Axial )
   //  layoutName = "Axial";
   //else if( view == mitk::SliceNavigationController::Sagittal )
   //  layoutName = "Sagittal";
   //else if( view == mitk::SliceNavigationController::Frontal )
   //  layoutName = "Coronal";
   //else if( view == mitk::SliceNavigationController::Original )
   //  layoutName = "Original";
   //if( view >= 0 && view < 4 )
   //  //write LayoutName --> Viewer 3D shoudn't write the layoutName.
 
   //Render Window 1 == axial
   m_CornerAnnotaions[0].cornerText = vtkCornerAnnotation::New();
   m_CornerAnnotaions[0].cornerText->SetText(0, "Axial");
   m_CornerAnnotaions[0].cornerText->SetMaximumFontSize(12);
   m_CornerAnnotaions[0].textProp = vtkTextProperty::New();
   m_CornerAnnotaions[0].textProp->SetColor( 1.0, 0.0, 0.0 );
   m_CornerAnnotaions[0].cornerText->SetTextProperty( m_CornerAnnotaions[0].textProp );
   m_CornerAnnotaions[0].ren = vtkRenderer::New();
   m_CornerAnnotaions[0].ren->AddActor(m_CornerAnnotaions[0].cornerText);
   m_CornerAnnotaions[0].ren->InteractiveOff();
   mitk::VtkLayerController::GetInstance(this->GetRenderWindow1()->GetRenderWindow())->InsertForegroundRenderer(m_CornerAnnotaions[0].ren,true);
 
   //Render Window 2 == sagittal
   m_CornerAnnotaions[1].cornerText = vtkCornerAnnotation::New();
   m_CornerAnnotaions[1].cornerText->SetText(0, "Sagittal");
   m_CornerAnnotaions[1].cornerText->SetMaximumFontSize(12);
   m_CornerAnnotaions[1].textProp = vtkTextProperty::New();
   m_CornerAnnotaions[1].textProp->SetColor( 0.0, 1.0, 0.0 );
   m_CornerAnnotaions[1].cornerText->SetTextProperty( m_CornerAnnotaions[1].textProp );
   m_CornerAnnotaions[1].ren = vtkRenderer::New();
   m_CornerAnnotaions[1].ren->AddActor(m_CornerAnnotaions[1].cornerText);
   m_CornerAnnotaions[1].ren->InteractiveOff();
   mitk::VtkLayerController::GetInstance(this->GetRenderWindow2()->GetRenderWindow())->InsertForegroundRenderer(m_CornerAnnotaions[1].ren,true);
 
   //Render Window 3 == coronal
   m_CornerAnnotaions[2].cornerText = vtkCornerAnnotation::New();
   m_CornerAnnotaions[2].cornerText->SetText(0, "Coronal");
   m_CornerAnnotaions[2].cornerText->SetMaximumFontSize(12);
   m_CornerAnnotaions[2].textProp = vtkTextProperty::New();
   m_CornerAnnotaions[2].textProp->SetColor( 0.295, 0.295, 1.0 );
   m_CornerAnnotaions[2].cornerText->SetTextProperty( m_CornerAnnotaions[2].textProp );
   m_CornerAnnotaions[2].ren = vtkRenderer::New();
   m_CornerAnnotaions[2].ren->AddActor(m_CornerAnnotaions[2].cornerText);
   m_CornerAnnotaions[2].ren->InteractiveOff();
   mitk::VtkLayerController::GetInstance(this->GetRenderWindow3()->GetRenderWindow())->InsertForegroundRenderer(m_CornerAnnotaions[2].ren,true);
 
   /*************************************************/
 
   // create a slice rotator
   // m_SlicesRotator = mitk::SlicesRotator::New();
   // @TODO next line causes sure memory leak
   // rotator will be created nonetheless (will be switched on and off)
   m_SlicesRotator = mitk::SlicesRotator::New("slices-rotator");
   m_SlicesRotator->AddSliceController(
     mitkWidget1->GetSliceNavigationController() );
   m_SlicesRotator->AddSliceController(
     mitkWidget2->GetSliceNavigationController() );
   m_SlicesRotator->AddSliceController(
     mitkWidget3->GetSliceNavigationController() );
 
   // create a slice swiveller (using the same state-machine as SlicesRotator)
   m_SlicesSwiveller = mitk::SlicesSwiveller::New("slices-rotator");
   m_SlicesSwiveller->AddSliceController(
     mitkWidget1->GetSliceNavigationController() );
   m_SlicesSwiveller->AddSliceController(
     mitkWidget2->GetSliceNavigationController() );
   m_SlicesSwiveller->AddSliceController(
     mitkWidget3->GetSliceNavigationController() );
 
   //connect to the "time navigation controller": send time via sliceNavigationControllers
   m_TimeNavigationController->ConnectGeometryTimeEvent(
     mitkWidget1->GetSliceNavigationController() , false);
   m_TimeNavigationController->ConnectGeometryTimeEvent(
     mitkWidget2->GetSliceNavigationController() , false);
   m_TimeNavigationController->ConnectGeometryTimeEvent(
     mitkWidget3->GetSliceNavigationController() , false);
   m_TimeNavigationController->ConnectGeometryTimeEvent(
     mitkWidget4->GetSliceNavigationController() , false);
   mitkWidget1->GetSliceNavigationController()
     ->ConnectGeometrySendEvent(mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow()));
 
   //reverse connection between sliceNavigationControllers and m_TimeNavigationController
   mitkWidget1->GetSliceNavigationController()
     ->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
   mitkWidget2->GetSliceNavigationController()
     ->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
   mitkWidget3->GetSliceNavigationController()
     ->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
   mitkWidget4->GetSliceNavigationController()
     ->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
 
   m_MouseModeSwitcher = mitk::MouseModeSwitcher::New();
 
   m_LastLeftClickPositionSupplier =
     mitk::CoordinateSupplier::New("navigation", NULL);
   mitk::GlobalInteraction::GetInstance()->AddListener(
     m_LastLeftClickPositionSupplier
     );
   // setup gradient background
   m_GradientBackground1 = mitk::GradientBackground::New();
   m_GradientBackground1->SetRenderWindow(
     mitkWidget1->GetRenderWindow() );
   m_GradientBackground1->Disable();
 
   m_GradientBackground2 = mitk::GradientBackground::New();
   m_GradientBackground2->SetRenderWindow(
     mitkWidget2->GetRenderWindow() );
   m_GradientBackground2->Disable();
 
   m_GradientBackground3 = mitk::GradientBackground::New();
   m_GradientBackground3->SetRenderWindow(
     mitkWidget3->GetRenderWindow() );
   m_GradientBackground3->Disable();
 
   m_GradientBackground4 = mitk::GradientBackground::New();
   m_GradientBackground4->SetRenderWindow(
     mitkWidget4->GetRenderWindow() );
   m_GradientBackground4->SetGradientColors(0.1,0.1,0.1,0.5,0.5,0.5);
   m_GradientBackground4->Enable();
 
   // setup the department logo rendering
   m_LogoRendering1 = mitk::ManufacturerLogo::New();
   m_LogoRendering1->SetRenderWindow(
     mitkWidget1->GetRenderWindow() );
   m_LogoRendering1->Disable();
 
   m_LogoRendering2 = mitk::ManufacturerLogo::New();
   m_LogoRendering2->SetRenderWindow(
     mitkWidget2->GetRenderWindow() );
   m_LogoRendering2->Disable();
 
   m_LogoRendering3 = mitk::ManufacturerLogo::New();
   m_LogoRendering3->SetRenderWindow(
     mitkWidget3->GetRenderWindow() );
   m_LogoRendering3->Disable();
 
   m_LogoRendering4 = mitk::ManufacturerLogo::New();
   m_LogoRendering4->SetRenderWindow(
     mitkWidget4->GetRenderWindow() );
   m_LogoRendering4->Enable();
 
   m_RectangleRendering1 = mitk::RenderWindowFrame::New();
   m_RectangleRendering1->SetRenderWindow(
     mitkWidget1->GetRenderWindow() );
   m_RectangleRendering1->Enable(1.0,0.0,0.0);
 
   m_RectangleRendering2 = mitk::RenderWindowFrame::New();
   m_RectangleRendering2->SetRenderWindow(
     mitkWidget2->GetRenderWindow() );
   m_RectangleRendering2->Enable(0.0,1.0,0.0);
 
   m_RectangleRendering3 = mitk::RenderWindowFrame::New();
   m_RectangleRendering3->SetRenderWindow(
     mitkWidget3->GetRenderWindow() );
   m_RectangleRendering3->Enable(0.0,0.0,1.0);
 
   m_RectangleRendering4 = mitk::RenderWindowFrame::New();
   m_RectangleRendering4->SetRenderWindow(
     mitkWidget4->GetRenderWindow() );
   m_RectangleRendering4->Enable(1.0,1.0,0.0);
 }
 
 QmitkStdMultiWidget::~QmitkStdMultiWidget()
 {
   DisablePositionTracking();
   DisableNavigationControllerEventListening();
 
   m_TimeNavigationController->Disconnect(mitkWidget1->GetSliceNavigationController());
   m_TimeNavigationController->Disconnect(mitkWidget2->GetSliceNavigationController());
   m_TimeNavigationController->Disconnect(mitkWidget3->GetSliceNavigationController());
   m_TimeNavigationController->Disconnect(mitkWidget4->GetSliceNavigationController());
 
   mitk::VtkLayerController::GetInstance(this->GetRenderWindow1()->GetRenderWindow())->RemoveRenderer( m_CornerAnnotaions[0].ren );
   mitk::VtkLayerController::GetInstance(this->GetRenderWindow2()->GetRenderWindow())->RemoveRenderer( m_CornerAnnotaions[1].ren );
   mitk::VtkLayerController::GetInstance(this->GetRenderWindow3()->GetRenderWindow())->RemoveRenderer( m_CornerAnnotaions[2].ren );
 
   //Delete CornerAnnotation
   m_CornerAnnotaions[0].cornerText->Delete();
   m_CornerAnnotaions[0].textProp->Delete();
   m_CornerAnnotaions[0].ren->Delete();
 
   m_CornerAnnotaions[1].cornerText->Delete();
   m_CornerAnnotaions[1].textProp->Delete();
   m_CornerAnnotaions[1].ren->Delete();
 
   m_CornerAnnotaions[2].cornerText->Delete();
   m_CornerAnnotaions[2].textProp->Delete();
   m_CornerAnnotaions[2].ren->Delete();
 }
 
 void QmitkStdMultiWidget::RemovePlanesFromDataStorage()
 {
   if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull() && m_PlaneNode3.IsNotNull() && m_Node.IsNotNull())
   {
     if(m_DataStorage.IsNotNull())
     {
       m_DataStorage->Remove(m_PlaneNode1);
       m_DataStorage->Remove(m_PlaneNode2);
       m_DataStorage->Remove(m_PlaneNode3);
       m_DataStorage->Remove(m_Node);
     }
   }
 }
 
 void QmitkStdMultiWidget::AddPlanesToDataStorage()
 {
   if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull() && m_PlaneNode3.IsNotNull() && m_Node.IsNotNull())
   {
     if (m_DataStorage.IsNotNull())
     {
       m_DataStorage->Add(m_Node);
       m_DataStorage->Add(m_PlaneNode1, m_Node);
       m_DataStorage->Add(m_PlaneNode2, m_Node);
       m_DataStorage->Add(m_PlaneNode3, m_Node);
       static_cast<mitk::Geometry2DDataMapper2D*>(m_PlaneNode1->GetMapper(mitk::BaseRenderer::Standard2D))->SetDatastorageAndGeometryBaseNode(m_DataStorage, m_Node);
       static_cast<mitk::Geometry2DDataMapper2D*>(m_PlaneNode2->GetMapper(mitk::BaseRenderer::Standard2D))->SetDatastorageAndGeometryBaseNode(m_DataStorage, m_Node);
       static_cast<mitk::Geometry2DDataMapper2D*>(m_PlaneNode3->GetMapper(mitk::BaseRenderer::Standard2D))->SetDatastorageAndGeometryBaseNode(m_DataStorage, m_Node);
     }
   }
 }
 
 void QmitkStdMultiWidget::changeLayoutTo2DImagesUp()
 {
   SMW_INFO << "changing layout to 2D images up... " << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //Set Layout to widget
   this->setLayout(QmitkStdMultiWidgetLayout);
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( Qt::Vertical, m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //create m_SubSplit1 and m_SubSplit2
   m_SubSplit1 = new QSplitter( m_LayoutSplit );
   m_SubSplit2 = new QSplitter( m_LayoutSplit );
 
   //insert Widget Container into splitter top
   m_SubSplit1->addWidget( mitkWidget1Container );
   m_SubSplit1->addWidget( mitkWidget2Container );
   m_SubSplit1->addWidget( mitkWidget3Container );
 
   //set SplitterSize for splitter top
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_SubSplit1->setSizes( splitterSize );
 
   //insert Widget Container into splitter bottom
   m_SubSplit2->addWidget( mitkWidget4Container );
 
   //set SplitterSize for splitter m_LayoutSplit
   splitterSize.clear();
   splitterSize.push_back(400);
   splitterSize.push_back(1000);
   m_LayoutSplit->setSizes( splitterSize );
 
   //show mainSplitt
   m_MainSplit->show();
 
   //show Widget if hidden
   if ( mitkWidget1->isHidden() ) mitkWidget1->show();
   if ( mitkWidget2->isHidden() ) mitkWidget2->show();
   if ( mitkWidget3->isHidden() ) mitkWidget3->show();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   //Change Layout Name
   m_Layout = LAYOUT_2D_IMAGES_UP;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_2D_IMAGES_UP );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_2D_IMAGES_UP );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_2D_IMAGES_UP );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_2D_IMAGES_UP );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutTo2DImagesLeft()
 {
   SMW_INFO << "changing layout to 2D images left... " << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //create m_SubSplit1 and m_SubSplit2
   m_SubSplit1 = new QSplitter( Qt::Vertical, m_LayoutSplit );
   m_SubSplit2 = new QSplitter( m_LayoutSplit );
 
   //insert Widget into the splitters
   m_SubSplit1->addWidget( mitkWidget1Container );
   m_SubSplit1->addWidget( mitkWidget2Container );
   m_SubSplit1->addWidget( mitkWidget3Container );
 
   //set splitterSize of SubSplit1
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_SubSplit1->setSizes( splitterSize );
 
   m_SubSplit2->addWidget( mitkWidget4Container );
 
   //set splitterSize of Layout Split
   splitterSize.clear();
   splitterSize.push_back(400);
   splitterSize.push_back(1000);
   m_LayoutSplit->setSizes( splitterSize );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show Widget if hidden
   if ( mitkWidget1->isHidden() ) mitkWidget1->show();
   if ( mitkWidget2->isHidden() ) mitkWidget2->show();
   if ( mitkWidget3->isHidden() ) mitkWidget3->show();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   //update Layout Name
   m_Layout = LAYOUT_2D_IMAGES_LEFT;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_2D_IMAGES_LEFT );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_2D_IMAGES_LEFT );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_2D_IMAGES_LEFT );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_2D_IMAGES_LEFT );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToDefault()
 {
   SMW_INFO << "changing layout to default... " << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( Qt::Vertical, m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //create m_SubSplit1 and m_SubSplit2
   m_SubSplit1 = new QSplitter( m_LayoutSplit );
   m_SubSplit2 = new QSplitter( m_LayoutSplit );
 
   //insert Widget container into the splitters
   m_SubSplit1->addWidget( mitkWidget1Container );
   m_SubSplit1->addWidget( mitkWidget2Container );
 
   m_SubSplit2->addWidget( mitkWidget3Container );
   m_SubSplit2->addWidget( mitkWidget4Container );
 
   //set splitter Size
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_SubSplit1->setSizes( splitterSize );
   m_SubSplit2->setSizes( splitterSize );
   m_LayoutSplit->setSizes( splitterSize );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show Widget if hidden
   if ( mitkWidget1->isHidden() ) mitkWidget1->show();
   if ( mitkWidget2->isHidden() ) mitkWidget2->show();
   if ( mitkWidget3->isHidden() ) mitkWidget3->show();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   m_Layout = LAYOUT_DEFAULT;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_DEFAULT );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_DEFAULT );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_DEFAULT );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_DEFAULT );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToBig3D()
 {
   SMW_INFO << "changing layout to big 3D ..." << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //add widget Splitter to main Splitter
   m_MainSplit->addWidget( mitkWidget4Container );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show/hide Widgets
   mitkWidget1->hide();
   mitkWidget2->hide();
   mitkWidget3->hide();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   m_Layout = LAYOUT_BIG_3D;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_BIG_3D );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_BIG_3D );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_BIG_3D );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_BIG_3D );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToWidget1()
 {
   SMW_INFO << "changing layout to big Widget1 ..." << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //add widget Splitter to main Splitter
   m_MainSplit->addWidget( mitkWidget1Container );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show/hide Widgets
   if ( mitkWidget1->isHidden() ) mitkWidget1->show();
   mitkWidget2->hide();
   mitkWidget3->hide();
   mitkWidget4->hide();
 
   m_Layout = LAYOUT_WIDGET1;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_WIDGET1 );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_WIDGET1 );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_WIDGET1 );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_WIDGET1 );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToWidget2()
 {
   SMW_INFO << "changing layout to big Widget2 ..." << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //add widget Splitter to main Splitter
   m_MainSplit->addWidget( mitkWidget2Container );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show/hide Widgets
   mitkWidget1->hide();
   if ( mitkWidget2->isHidden() ) mitkWidget2->show();
   mitkWidget3->hide();
   mitkWidget4->hide();
 
   m_Layout = LAYOUT_WIDGET2;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_WIDGET2 );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_WIDGET2 );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_WIDGET2 );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_WIDGET2 );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToWidget3()
 {
   SMW_INFO << "changing layout to big Widget3 ..." << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //add widget Splitter to main Splitter
   m_MainSplit->addWidget( mitkWidget3Container );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show/hide Widgets
   mitkWidget1->hide();
   mitkWidget2->hide();
   if ( mitkWidget3->isHidden() ) mitkWidget3->show();
   mitkWidget4->hide();
 
   m_Layout = LAYOUT_WIDGET3;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_WIDGET3 );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_WIDGET3 );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_WIDGET3 );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_WIDGET3 );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToRowWidget3And4()
 {
   SMW_INFO << "changing layout to Widget3 and 4 in a Row..." << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( Qt::Vertical, m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //add Widgets to splitter
   m_LayoutSplit->addWidget( mitkWidget3Container );
   m_LayoutSplit->addWidget( mitkWidget4Container );
 
   //set Splitter Size
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_LayoutSplit->setSizes( splitterSize );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show/hide Widgets
   mitkWidget1->hide();
   mitkWidget2->hide();
   if ( mitkWidget3->isHidden() ) mitkWidget3->show();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   m_Layout = LAYOUT_ROW_WIDGET_3_AND_4;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_ROW_WIDGET_3_AND_4 );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_ROW_WIDGET_3_AND_4 );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_ROW_WIDGET_3_AND_4 );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_ROW_WIDGET_3_AND_4 );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToColumnWidget3And4()
 {
   SMW_INFO << "changing layout to Widget3 and 4 in one Column..." << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //add Widgets to splitter
   m_LayoutSplit->addWidget( mitkWidget3Container );
   m_LayoutSplit->addWidget( mitkWidget4Container );
 
   //set SplitterSize
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_LayoutSplit->setSizes( splitterSize );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show/hide Widgets
   mitkWidget1->hide();
   mitkWidget2->hide();
   if ( mitkWidget3->isHidden() ) mitkWidget3->show();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   m_Layout = LAYOUT_COLUMN_WIDGET_3_AND_4;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_COLUMN_WIDGET_3_AND_4 );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_COLUMN_WIDGET_3_AND_4 );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_COLUMN_WIDGET_3_AND_4 );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_COLUMN_WIDGET_3_AND_4 );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToRowWidgetSmall3andBig4()
 {
   SMW_INFO << "changing layout to Widget3 and 4 in a Row..." << std::endl;
 
   this->changeLayoutToRowWidget3And4();
 
   m_Layout = LAYOUT_ROW_WIDGET_SMALL3_AND_BIG4;
 }
 
 void QmitkStdMultiWidget::changeLayoutToSmallUpperWidget2Big3and4()
 {
   SMW_INFO << "changing layout to Widget3 and 4 in a Row..." << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( Qt::Vertical, m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //create m_SubSplit1 and m_SubSplit2
   m_SubSplit1 = new QSplitter( Qt::Vertical, m_LayoutSplit );
   m_SubSplit2 = new QSplitter( m_LayoutSplit );
 
   //insert Widget into the splitters
   m_SubSplit1->addWidget( mitkWidget2Container );
 
   m_SubSplit2->addWidget( mitkWidget3Container );
   m_SubSplit2->addWidget( mitkWidget4Container );
 
   //set Splitter Size
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_SubSplit2->setSizes( splitterSize );
   splitterSize.clear();
   splitterSize.push_back(500);
   splitterSize.push_back(1000);
   m_LayoutSplit->setSizes( splitterSize );
 
   //show mainSplitt
   m_MainSplit->show();
 
   //show Widget if hidden
   mitkWidget1->hide();
   if ( mitkWidget2->isHidden() ) mitkWidget2->show();
   if ( mitkWidget3->isHidden() ) mitkWidget3->show();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   m_Layout = LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4 );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4 );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4 );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4 );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutTo2x2Dand3DWidget()
 {
   SMW_INFO << "changing layout to 2 x 2D and 3D Widget" << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //create m_SubSplit1 and m_SubSplit2
   m_SubSplit1 = new QSplitter( Qt::Vertical, m_LayoutSplit );
   m_SubSplit2 = new QSplitter( m_LayoutSplit );
 
   //add Widgets to splitter
   m_SubSplit1->addWidget( mitkWidget1Container );
   m_SubSplit1->addWidget( mitkWidget2Container );
   m_SubSplit2->addWidget( mitkWidget4Container );
 
   //set Splitter Size
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_SubSplit1->setSizes( splitterSize );
   m_LayoutSplit->setSizes( splitterSize );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show/hide Widgets
   if ( mitkWidget1->isHidden() ) mitkWidget1->show();
   if ( mitkWidget2->isHidden() ) mitkWidget2->show();
   mitkWidget3->hide();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   m_Layout = LAYOUT_2X_2D_AND_3D_WIDGET;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_2X_2D_AND_3D_WIDGET );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_2X_2D_AND_3D_WIDGET );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_2X_2D_AND_3D_WIDGET );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_2X_2D_AND_3D_WIDGET );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToLeft2Dand3DRight2D()
 {
   SMW_INFO << "changing layout to 2D and 3D left, 2D right Widget" << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //create m_SubSplit1 and m_SubSplit2
   m_SubSplit1 = new QSplitter( Qt::Vertical, m_LayoutSplit );
   m_SubSplit2 = new QSplitter( m_LayoutSplit );
 
   //add Widgets to splitter
   m_SubSplit1->addWidget( mitkWidget1Container );
   m_SubSplit1->addWidget( mitkWidget4Container );
   m_SubSplit2->addWidget( mitkWidget2Container );
 
   //set Splitter Size
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_SubSplit1->setSizes( splitterSize );
   m_LayoutSplit->setSizes( splitterSize );
 
   //show mainSplitt and add to Layout
   m_MainSplit->show();
 
   //show/hide Widgets
   if ( mitkWidget1->isHidden() ) mitkWidget1->show();
   if ( mitkWidget2->isHidden() ) mitkWidget2->show();
   mitkWidget3->hide();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   m_Layout = LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET );
 
   //update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutTo2DUpAnd3DDown()
 {
   SMW_INFO << "changing layout to 2D up and 3D down" << std::endl;
 
   //Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout ;
 
   //create Main Layout
   QmitkStdMultiWidgetLayout =  new QHBoxLayout( this );
 
   //Set Layout to widget
   this->setLayout(QmitkStdMultiWidgetLayout);
 
   //create main splitter
   m_MainSplit = new QSplitter( this );
   QmitkStdMultiWidgetLayout->addWidget( m_MainSplit );
 
   //create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter( Qt::Vertical, m_MainSplit );
   m_MainSplit->addWidget( m_LayoutSplit );
 
   //add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget( levelWindowWidget );
 
   //create m_SubSplit1 and m_SubSplit2
   m_SubSplit1 = new QSplitter( m_LayoutSplit );
   m_SubSplit2 = new QSplitter( m_LayoutSplit );
 
   //insert Widget Container into splitter top
   m_SubSplit1->addWidget( mitkWidget1Container );
 
   //set SplitterSize for splitter top
    QList<int> splitterSize;
 //   splitterSize.push_back(1000);
 //   splitterSize.push_back(1000);
 //   splitterSize.push_back(1000);
 //   m_SubSplit1->setSizes( splitterSize );
 
   //insert Widget Container into splitter bottom
   m_SubSplit2->addWidget( mitkWidget4Container );
 
   //set SplitterSize for splitter m_LayoutSplit
   splitterSize.clear();
   splitterSize.push_back(700);
   splitterSize.push_back(700);
   m_LayoutSplit->setSizes( splitterSize );
 
   //show mainSplitt
   m_MainSplit->show();
 
   //show/hide Widgets
   if ( mitkWidget1->isHidden() ) mitkWidget1->show();
   mitkWidget2->hide();
   mitkWidget3->hide();
   if ( mitkWidget4->isHidden() ) mitkWidget4->show();
 
   m_Layout = LAYOUT_2D_UP_AND_3D_DOWN;
 
   //update Layout Design List
   mitkWidget1->LayoutDesignListChanged( LAYOUT_2D_UP_AND_3D_DOWN );
   mitkWidget2->LayoutDesignListChanged( LAYOUT_2D_UP_AND_3D_DOWN );
   mitkWidget3->LayoutDesignListChanged( LAYOUT_2D_UP_AND_3D_DOWN );
   mitkWidget4->LayoutDesignListChanged( LAYOUT_2D_UP_AND_3D_DOWN );
 
   //update all Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::SetDataStorage( mitk::DataStorage* ds )
 {
   mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->SetDataStorage(ds);
   mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->SetDataStorage(ds);
   mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->SetDataStorage(ds);
   mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->SetDataStorage(ds);
   m_DataStorage = ds;
 }
 
 void QmitkStdMultiWidget::Fit()
 {
   vtkRenderer * vtkrenderer;
   mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetDisplayGeometry()->Fit();
   mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->GetDisplayGeometry()->Fit();
   mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->GetDisplayGeometry()->Fit();
   mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->GetDisplayGeometry()->Fit();
 
   int w = vtkObject::GetGlobalWarningDisplay();
   vtkObject::GlobalWarningDisplayOff();
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetVtkRenderer();
   if ( vtkrenderer!= NULL )
     vtkrenderer->ResetCamera();
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->GetVtkRenderer();
   if ( vtkrenderer!= NULL )
     vtkrenderer->ResetCamera();
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->GetVtkRenderer();
   if ( vtkrenderer!= NULL )
     vtkrenderer->ResetCamera();
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->GetVtkRenderer();
   if ( vtkrenderer!= NULL )
     vtkrenderer->ResetCamera();
 
   vtkObject::SetGlobalWarningDisplay(w);
 }
 
 void QmitkStdMultiWidget::InitPositionTracking()
 {
   //PoinSetNode for MouseOrientation
   m_PositionTrackerNode = mitk::DataNode::New();
   m_PositionTrackerNode->SetProperty("name", mitk::StringProperty::New("Mouse Position"));
   m_PositionTrackerNode->SetData( mitk::PointSet::New() );
   m_PositionTrackerNode->SetColor(1.0,0.33,0.0);
   m_PositionTrackerNode->SetProperty("layer", mitk::IntProperty::New(1001));
   m_PositionTrackerNode->SetVisibility(true);
   m_PositionTrackerNode->SetProperty("inputdevice", mitk::BoolProperty::New(true) );
   m_PositionTrackerNode->SetProperty("BaseRendererMapperID", mitk::IntProperty::New(0) );//point position 2D mouse
   m_PositionTrackerNode->SetProperty("baserenderer", mitk::StringProperty::New("N/A"));
 }
 
 void QmitkStdMultiWidget::AddDisplayPlaneSubTree()
 {
   // add the displayed planes of the multiwidget to a node to which the subtree
   // @a planesSubTree points ...
 
   float white[3] = {1.0f,1.0f,1.0f};
   mitk::Geometry2DDataMapper2D::Pointer mapper;
 
   // ... of widget 1
   m_PlaneNode1 = (mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow()))->GetCurrentWorldGeometry2DNode();
   m_PlaneNode1->SetColor(white, mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow()));
   m_PlaneNode1->SetProperty("visible", mitk::BoolProperty::New(true));
   m_PlaneNode1->SetProperty("name", mitk::StringProperty::New("widget1Plane"));
   m_PlaneNode1->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
   m_PlaneNode1->SetProperty("helper object", mitk::BoolProperty::New(true));
   mapper = mitk::Geometry2DDataMapper2D::New();
   m_PlaneNode1->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
 
   // ... of widget 2
   m_PlaneNode2 =( mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow()))->GetCurrentWorldGeometry2DNode();
   m_PlaneNode2->SetColor(white, mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow()));
   m_PlaneNode2->SetProperty("visible", mitk::BoolProperty::New(true));
   m_PlaneNode2->SetProperty("name", mitk::StringProperty::New("widget2Plane"));
   m_PlaneNode2->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
   m_PlaneNode2->SetProperty("helper object", mitk::BoolProperty::New(true));
   mapper = mitk::Geometry2DDataMapper2D::New();
   m_PlaneNode2->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
 
   // ... of widget 3
   m_PlaneNode3 = (mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow()))->GetCurrentWorldGeometry2DNode();
   m_PlaneNode3->SetColor(white, mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow()));
   m_PlaneNode3->SetProperty("visible", mitk::BoolProperty::New(true));
   m_PlaneNode3->SetProperty("name", mitk::StringProperty::New("widget3Plane"));
   m_PlaneNode3->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
   m_PlaneNode3->SetProperty("helper object", mitk::BoolProperty::New(true));
   mapper = mitk::Geometry2DDataMapper2D::New();
   m_PlaneNode3->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
 
   m_Node = mitk::DataNode::New();
   m_Node->SetProperty("name", mitk::StringProperty::New("Widgets"));
   m_Node->SetProperty("helper object", mitk::BoolProperty::New(true));
 }
 
 mitk::SliceNavigationController* QmitkStdMultiWidget::GetTimeNavigationController()
 {
   return m_TimeNavigationController;
 }
 
 void QmitkStdMultiWidget::EnableStandardLevelWindow()
 {
   levelWindowWidget->disconnect(this);
   levelWindowWidget->SetDataStorage(mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetDataStorage());
   levelWindowWidget->show();
 }
 
 void QmitkStdMultiWidget::DisableStandardLevelWindow()
 {
   levelWindowWidget->disconnect(this);
   levelWindowWidget->hide();
 }
 
 // CAUTION: Legacy code for enabling Qt-signal-controlled view initialization.
 // Use RenderingManager::InitializeViews() instead.
 bool QmitkStdMultiWidget::InitializeStandardViews( const mitk::Geometry3D * geometry )
 {
   return m_RenderingManager->InitializeViews( geometry );
 }
 
 void QmitkStdMultiWidget::RequestUpdate()
 {
   m_RenderingManager->RequestUpdate(mitkWidget1->GetRenderWindow());
   m_RenderingManager->RequestUpdate(mitkWidget2->GetRenderWindow());
   m_RenderingManager->RequestUpdate(mitkWidget3->GetRenderWindow());
   m_RenderingManager->RequestUpdate(mitkWidget4->GetRenderWindow());
 }
 
 void QmitkStdMultiWidget::ForceImmediateUpdate()
 {
   m_RenderingManager->ForceImmediateUpdate(mitkWidget1->GetRenderWindow());
   m_RenderingManager->ForceImmediateUpdate(mitkWidget2->GetRenderWindow());
   m_RenderingManager->ForceImmediateUpdate(mitkWidget3->GetRenderWindow());
   m_RenderingManager->ForceImmediateUpdate(mitkWidget4->GetRenderWindow());
 }
 
 void QmitkStdMultiWidget::wheelEvent( QWheelEvent * e )
 {
   emit WheelMoved( e );
 }
 
 void QmitkStdMultiWidget::mousePressEvent(QMouseEvent * e)
 {
    if (e->button() == Qt::LeftButton) {
        mitk::Point3D pointValue = this->GetLastLeftClickPosition();
        emit LeftMouseClicked(pointValue);
    }
 }
 
 void QmitkStdMultiWidget::moveEvent( QMoveEvent* e )
 {
   QWidget::moveEvent( e );
 
   // it is necessary to readjust the position of the overlays as the StdMultiWidget has moved
   // unfortunately it's not done by QmitkRenderWindow::moveEvent -> must be done here
   emit Moved();
 }
 
 void QmitkStdMultiWidget::leaveEvent ( QEvent * /*e*/  )
 {
   //set cursor back to initial state
   m_SlicesRotator->ResetMouseCursor();
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow1() const
 {
   return mitkWidget1;
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow2() const
 {
   return mitkWidget2;
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow3() const
 {
   return mitkWidget3;
 }
 
 QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow4() const
 {
   return mitkWidget4;
 }
 
 const mitk::Point3D& QmitkStdMultiWidget::GetLastLeftClickPosition() const
 {
   return m_LastLeftClickPositionSupplier->GetCurrentPoint();
 }
 
 const mitk::Point3D QmitkStdMultiWidget::GetCrossPosition() const
 {
   const mitk::PlaneGeometry *plane1 =
     mitkWidget1->GetSliceNavigationController()->GetCurrentPlaneGeometry();
   const mitk::PlaneGeometry *plane2 =
     mitkWidget2->GetSliceNavigationController()->GetCurrentPlaneGeometry();
   const mitk::PlaneGeometry *plane3 =
     mitkWidget3->GetSliceNavigationController()->GetCurrentPlaneGeometry();
 
   mitk::Line3D line;
   if ( (plane1 != NULL) && (plane2 != NULL)
     && (plane1->IntersectionLine( plane2, line )) )
   {
     mitk::Point3D point;
     if ( (plane3 != NULL)
       && (plane3->IntersectionPoint( line, point )) )
     {
       return point;
     }
   }
   return m_LastLeftClickPositionSupplier->GetCurrentPoint();
 }
 
 void QmitkStdMultiWidget::EnablePositionTracking()
 {
   if (!m_PositionTracker)
   {
     m_PositionTracker = mitk::PositionTracker::New("PositionTracker", NULL);
   }
   mitk::GlobalInteraction* globalInteraction = mitk::GlobalInteraction::GetInstance();
   if (globalInteraction)
   {
     if(m_DataStorage.IsNotNull())
       m_DataStorage->Add(m_PositionTrackerNode);
     globalInteraction->AddListener(m_PositionTracker);
   }
 }
 
 void QmitkStdMultiWidget::DisablePositionTracking()
 {
   mitk::GlobalInteraction* globalInteraction =
     mitk::GlobalInteraction::GetInstance();
 
   if(globalInteraction)
   {
     if (m_DataStorage.IsNotNull())
       m_DataStorage->Remove(m_PositionTrackerNode);
     globalInteraction->RemoveListener(m_PositionTracker);
   }
 }
 
 void QmitkStdMultiWidget::EnsureDisplayContainsPoint(
   mitk::DisplayGeometry* displayGeometry, const mitk::Point3D& p)
 {
   mitk::Point2D pointOnPlane;
   displayGeometry->Map( p, pointOnPlane );
 
   // point minus origin < width or height ==> outside ?
   mitk::Vector2D pointOnRenderWindow_MM;
   pointOnRenderWindow_MM = pointOnPlane.GetVectorFromOrigin()
     - displayGeometry->GetOriginInMM();
 
   mitk::Vector2D sizeOfDisplay( displayGeometry->GetSizeInMM() );
 
   if (   sizeOfDisplay[0] < pointOnRenderWindow_MM[0]
   ||                0 > pointOnRenderWindow_MM[0]
   || sizeOfDisplay[1] < pointOnRenderWindow_MM[1]
   ||                0 > pointOnRenderWindow_MM[1] )
   {
     // point is not visible -> move geometry
     mitk::Vector2D offset( (pointOnRenderWindow_MM - sizeOfDisplay / 2.0)
       / displayGeometry->GetScaleFactorMMPerDisplayUnit() );
 
     displayGeometry->MoveBy( offset );
   }
 }
 
 void QmitkStdMultiWidget::MoveCrossToPosition(const mitk::Point3D& newPosition)
 {
   // create a PositionEvent with the given position and
   // tell the slice navigation controllers to move there
 
   mitk::Point2D p2d;
   mitk::PositionEvent event( mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow()), 0, 0, 0,
     mitk::Key_unknown, p2d, newPosition );
   mitk::StateEvent stateEvent(mitk::EIDLEFTMOUSEBTN, &event);
   mitk::StateEvent stateEvent2(mitk::EIDLEFTMOUSERELEASE, &event);
 
   switch ( m_PlaneMode )
   {
   default:
   case PLANE_MODE_SLICING:
     mitkWidget1->GetSliceNavigationController()->HandleEvent( &stateEvent );
     mitkWidget2->GetSliceNavigationController()->HandleEvent( &stateEvent );
     mitkWidget3->GetSliceNavigationController()->HandleEvent( &stateEvent );
 
     // just in case SNCs will develop something that depends on the mouse
     // button being released again
     mitkWidget1->GetSliceNavigationController()->HandleEvent( &stateEvent2 );
     mitkWidget2->GetSliceNavigationController()->HandleEvent( &stateEvent2 );
     mitkWidget3->GetSliceNavigationController()->HandleEvent( &stateEvent2 );
     break;
 
   case PLANE_MODE_ROTATION:
     m_SlicesRotator->HandleEvent( &stateEvent );
 
     // just in case SNCs will develop something that depends on the mouse
     // button being released again
     m_SlicesRotator->HandleEvent( &stateEvent2 );
     break;
 
   case PLANE_MODE_SWIVEL:
     m_SlicesSwiveller->HandleEvent( &stateEvent );
 
     // just in case SNCs will develop something that depends on the mouse
     // button being released again
     m_SlicesSwiveller->HandleEvent( &stateEvent2 );
     break;
   }
 
   // determine if cross is now out of display
   // if so, move the display window
   EnsureDisplayContainsPoint( mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())
     ->GetDisplayGeometry(), newPosition );
   EnsureDisplayContainsPoint( mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())
     ->GetDisplayGeometry(), newPosition );
   EnsureDisplayContainsPoint( mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())
     ->GetDisplayGeometry(), newPosition );
 
   // update displays
   m_RenderingManager->RequestUpdateAll();
 }
 
 void QmitkStdMultiWidget::HandleCrosshairPositionEvent()
 {
   if(!m_PendingCrosshairPositionEvent)
   {
     m_PendingCrosshairPositionEvent=true;
     QTimer::singleShot(0,this,SLOT( HandleCrosshairPositionEventDelayed() ) );
   }
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetTopLayerNode(mitk::DataStorage::SetOfObjects::ConstPointer nodes)
 {
   mitk::Point3D crosshairPos = this->GetCrossPosition();
   mitk::DataNode::Pointer node;
   int  maxlayer = -32768;
 
   if(nodes.IsNotNull())
   {
     mitk::BaseRenderer* baseRenderer = this->mitkWidget1->GetSliceNavigationController()->GetRenderer();
     // find node with largest layer, that is the node shown on top in the render window
     for (unsigned int x = 0; x < nodes->size(); x++)
     {
     if ( (nodes->at(x)->GetData()->GetGeometry() != NULL) &&
          nodes->at(x)->GetData()->GetGeometry()->IsInside(crosshairPos) )
     {
       int layer = 0;
       if(!(nodes->at(x)->GetIntProperty("layer", layer))) continue;
       if(layer > maxlayer)
       {
         if( static_cast<mitk::DataNode::Pointer>(nodes->at(x))->IsVisible( baseRenderer ) )
         {
           node = nodes->at(x);
           maxlayer = layer;
         }
       }
     }
     }
   }
   return node;
 }
 
 void QmitkStdMultiWidget::HandleCrosshairPositionEventDelayed()
 {
   m_PendingCrosshairPositionEvent = false;
 
   // find image with highest layer
 
   mitk::TNodePredicateDataType<mitk::Image>::Pointer isImageData = mitk::TNodePredicateDataType<mitk::Image>::New();
   mitk::DataStorage::SetOfObjects::ConstPointer nodes = this->m_DataStorage->GetSubset(isImageData).GetPointer();
 
   mitk::DataNode::Pointer node;
   mitk::DataNode::Pointer topSourceNode;
   mitk::Image::Pointer image;
   bool isBinary = false;
   node = this->GetTopLayerNode(nodes);
   if(node.IsNotNull())
   {
     node->GetBoolProperty("binary",isBinary);
     if(isBinary)
     {
       mitk::DataStorage::SetOfObjects::ConstPointer sourcenodes = m_DataStorage->GetSources(node, NULL, true);
       if(!sourcenodes->empty())
       {
         topSourceNode = this->GetTopLayerNode(sourcenodes);
       }
       if(topSourceNode.IsNotNull())
       {
         image = dynamic_cast<mitk::Image*>(topSourceNode->GetData());
       }
       else
       {
         image = dynamic_cast<mitk::Image*>(node->GetData());
       }
     }
     else
     {
       image = dynamic_cast<mitk::Image*>(node->GetData());
     }
   }
 
   mitk::Point3D crosshairPos = this->GetCrossPosition();
   std::string statusText;
   std::stringstream stream;
-  mitk::Index3D p;
+  itk::Index<3> p;
   mitk::BaseRenderer* baseRenderer = this->mitkWidget1->GetSliceNavigationController()->GetRenderer();
   unsigned int timestep = baseRenderer->GetTimeStep();
 
   if(image.IsNotNull() && (image->GetTimeSteps() > timestep ))
   {
     image->GetGeometry()->WorldToIndex(crosshairPos, p);
     stream.precision(2);
     stream<<"Position: <" << std::fixed <<crosshairPos[0] << ", " << std::fixed << crosshairPos[1] << ", " << std::fixed << crosshairPos[2] << "> mm";
     stream<<"; Index: <"<<p[0] << ", " << p[1] << ", " << p[2] << "> ";
     mitk::ScalarType pixelValue = image->GetPixelValueByIndex(p, timestep);
     if (fabs(pixelValue)>1000000 || fabs(pixelValue) < 0.01)
     {
       stream<<"; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: "<< std::scientific<< pixelValue <<"  ";
     }
     else
     {
       stream<<"; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: "<< pixelValue <<"  ";
     }
   }
   else
   {
     stream << "No image information at this position!";
   }
 
   statusText = stream.str();
   mitk::StatusBar::GetInstance()->DisplayGreyValueText(statusText.c_str());
 }
 
 void QmitkStdMultiWidget::EnableNavigationControllerEventListening()
 {
   // Let NavigationControllers listen to GlobalInteraction
   mitk::GlobalInteraction *gi = mitk::GlobalInteraction::GetInstance();
 
   // Listen for SliceNavigationController
   mitkWidget1->GetSliceNavigationController()->crosshairPositionEvent.AddListener( mitk::MessageDelegate<QmitkStdMultiWidget>( this, &QmitkStdMultiWidget::HandleCrosshairPositionEvent ) );
   mitkWidget2->GetSliceNavigationController()->crosshairPositionEvent.AddListener( mitk::MessageDelegate<QmitkStdMultiWidget>( this, &QmitkStdMultiWidget::HandleCrosshairPositionEvent ) );
   mitkWidget3->GetSliceNavigationController()->crosshairPositionEvent.AddListener( mitk::MessageDelegate<QmitkStdMultiWidget>( this, &QmitkStdMultiWidget::HandleCrosshairPositionEvent ) );
 
   switch ( m_PlaneMode )
   {
   default:
   case PLANE_MODE_SLICING:
     gi->AddListener( mitkWidget1->GetSliceNavigationController() );
     gi->AddListener( mitkWidget2->GetSliceNavigationController() );
     gi->AddListener( mitkWidget3->GetSliceNavigationController() );
     gi->AddListener( mitkWidget4->GetSliceNavigationController() );
     break;
 
   case PLANE_MODE_ROTATION:
     gi->AddListener( m_SlicesRotator );
     break;
 
   case PLANE_MODE_SWIVEL:
     gi->AddListener( m_SlicesSwiveller );
     break;
   }
 
   gi->AddListener( m_TimeNavigationController );
   m_CrosshairNavigationEnabled = true;
 }
 
 void QmitkStdMultiWidget::DisableNavigationControllerEventListening()
 {
   // Do not let NavigationControllers listen to GlobalInteraction
   mitk::GlobalInteraction *gi = mitk::GlobalInteraction::GetInstance();
 
   switch ( m_PlaneMode )
   {
   default:
   case PLANE_MODE_SLICING:
     gi->RemoveListener( mitkWidget1->GetSliceNavigationController() );
     gi->RemoveListener( mitkWidget2->GetSliceNavigationController() );
     gi->RemoveListener( mitkWidget3->GetSliceNavigationController() );
     gi->RemoveListener( mitkWidget4->GetSliceNavigationController() );
     break;
 
   case PLANE_MODE_ROTATION:
     m_SlicesRotator->ResetMouseCursor();
     gi->RemoveListener( m_SlicesRotator );
     break;
 
   case PLANE_MODE_SWIVEL:
     m_SlicesSwiveller->ResetMouseCursor();
     gi->RemoveListener( m_SlicesSwiveller );
     break;
   }
 
   gi->RemoveListener( m_TimeNavigationController );
   m_CrosshairNavigationEnabled = false;
 }
 
 int QmitkStdMultiWidget::GetLayout() const
 {
   return m_Layout;
 }
 
 bool QmitkStdMultiWidget::GetGradientBackgroundFlag() const
 {
   return m_GradientBackgroundFlag;
 }
 
 void QmitkStdMultiWidget::EnableGradientBackground()
 {
   // gradient background is by default only in widget 4, otherwise
   // interferences between 2D rendering and VTK rendering may occur.
   //m_GradientBackground1->Enable();
   //m_GradientBackground2->Enable();
   //m_GradientBackground3->Enable();
   m_GradientBackground4->Enable();
   m_GradientBackgroundFlag = true;
 }
 
 void QmitkStdMultiWidget::DisableGradientBackground()
 {
   //m_GradientBackground1->Disable();
   //m_GradientBackground2->Disable();
   //m_GradientBackground3->Disable();
   m_GradientBackground4->Disable();
   m_GradientBackgroundFlag = false;
 }
 
 void QmitkStdMultiWidget::EnableDepartmentLogo()
 {
   m_LogoRendering4->Enable();
 }
 
 void QmitkStdMultiWidget::DisableDepartmentLogo()
 {
   m_LogoRendering4->Disable();
 }
 
 bool QmitkStdMultiWidget::IsDepartmentLogoEnabled() const
 {
   return m_LogoRendering4->IsEnabled();
 }
 
 bool QmitkStdMultiWidget::IsCrosshairNavigationEnabled() const
 {
   return m_CrosshairNavigationEnabled;
 }
 
 mitk::SlicesRotator * QmitkStdMultiWidget::GetSlicesRotator() const
 {
   return m_SlicesRotator;
 }
 
 mitk::SlicesSwiveller * QmitkStdMultiWidget::GetSlicesSwiveller() const
 {
   return m_SlicesSwiveller;
 }
 
 void QmitkStdMultiWidget::SetWidgetPlaneVisibility(const char* widgetName, bool visible, mitk::BaseRenderer *renderer)
 {
   if (m_DataStorage.IsNotNull())
   {
     mitk::DataNode* n = m_DataStorage->GetNamedNode(widgetName);
     if (n != NULL)
       n->SetVisibility(visible, renderer);
   }
 }
 
 void QmitkStdMultiWidget::SetWidgetPlanesVisibility(bool visible, mitk::BaseRenderer *renderer)
 {
   SetWidgetPlaneVisibility("widget1Plane", visible, renderer);
   SetWidgetPlaneVisibility("widget2Plane", visible, renderer);
   SetWidgetPlaneVisibility("widget3Plane", visible, renderer);
   m_RenderingManager->RequestUpdateAll();
 }
 
 void QmitkStdMultiWidget::SetWidgetPlanesLocked(bool locked)
 {
   //do your job and lock or unlock slices.
   GetRenderWindow1()->GetSliceNavigationController()->SetSliceLocked(locked);
   GetRenderWindow2()->GetSliceNavigationController()->SetSliceLocked(locked);
   GetRenderWindow3()->GetSliceNavigationController()->SetSliceLocked(locked);
 }
 
 void QmitkStdMultiWidget::SetWidgetPlanesRotationLocked(bool locked)
 {
   //do your job and lock or unlock slices.
   GetRenderWindow1()->GetSliceNavigationController()->SetSliceRotationLocked(locked);
   GetRenderWindow2()->GetSliceNavigationController()->SetSliceRotationLocked(locked);
   GetRenderWindow3()->GetSliceNavigationController()->SetSliceRotationLocked(locked);
 }
 
 void QmitkStdMultiWidget::SetWidgetPlanesRotationLinked( bool link )
 {
   m_SlicesRotator->SetLinkPlanes( link );
   m_SlicesSwiveller->SetLinkPlanes( link );
   emit WidgetPlanesRotationLinked( link );
 }
 
 void QmitkStdMultiWidget::SetWidgetPlaneMode( int userMode )
 {
   MITK_DEBUG << "Changing crosshair mode to " << userMode;
 
   // first of all reset left mouse button interaction to default if PACS interaction style is active
   m_MouseModeSwitcher->SelectMouseMode( mitk::MouseModeSwitcher::MousePointer );
 
   emit WidgetNotifyNewCrossHairMode( userMode );
 
   int mode = m_PlaneMode;
   bool link = false;
 
   // Convert user interface mode to actual mode
   {
     switch(userMode)
     {
       case 0:
         mode = PLANE_MODE_SLICING;
         link = false;
         break;
 
       case 1:
         mode = PLANE_MODE_ROTATION;
         link = false;
         break;
 
       case 2:
         mode = PLANE_MODE_ROTATION;
         link = true;
         break;
 
       case 3:
         mode = PLANE_MODE_SWIVEL;
         link = false;
         break;
     }
   }
 
   // Slice rotation linked
   m_SlicesRotator->SetLinkPlanes( link );
   m_SlicesSwiveller->SetLinkPlanes( link );
 
   // Do nothing if mode didn't change
   if ( m_PlaneMode == mode )
   {
     return;
   }
 
   mitk::GlobalInteraction *gi = mitk::GlobalInteraction::GetInstance();
 
   // Remove listeners of previous mode
   switch ( m_PlaneMode )
   {
   default:
   case PLANE_MODE_SLICING:
     // Notify MainTemplate GUI that this mode has been deselected
     emit WidgetPlaneModeSlicing( false );
 
     gi->RemoveListener( mitkWidget1->GetSliceNavigationController() );
     gi->RemoveListener( mitkWidget2->GetSliceNavigationController() );
     gi->RemoveListener( mitkWidget3->GetSliceNavigationController() );
     gi->RemoveListener( mitkWidget4->GetSliceNavigationController() );
     break;
 
   case PLANE_MODE_ROTATION:
     // Notify MainTemplate GUI that this mode has been deselected
     emit WidgetPlaneModeRotation( false );
 
     m_SlicesRotator->ResetMouseCursor();
     gi->RemoveListener( m_SlicesRotator );
     break;
 
   case PLANE_MODE_SWIVEL:
     // Notify MainTemplate GUI that this mode has been deselected
     emit WidgetPlaneModeSwivel( false );
 
     m_SlicesSwiveller->ResetMouseCursor();
     gi->RemoveListener( m_SlicesSwiveller );
     break;
   }
 
   // Set new mode and add corresponding listener to GlobalInteraction
   m_PlaneMode = mode;
   switch ( m_PlaneMode )
   {
   default:
   case PLANE_MODE_SLICING:
     // Notify MainTemplate GUI that this mode has been selected
     emit WidgetPlaneModeSlicing( true );
 
     // Add listeners
     gi->AddListener( mitkWidget1->GetSliceNavigationController() );
     gi->AddListener( mitkWidget2->GetSliceNavigationController() );
     gi->AddListener( mitkWidget3->GetSliceNavigationController() );
     gi->AddListener( mitkWidget4->GetSliceNavigationController() );
 
     m_RenderingManager->InitializeViews();
     break;
 
   case PLANE_MODE_ROTATION:
     // Notify MainTemplate GUI that this mode has been selected
     emit WidgetPlaneModeRotation( true );
 
     // Add listener
     gi->AddListener( m_SlicesRotator );
     break;
 
   case PLANE_MODE_SWIVEL:
     // Notify MainTemplate GUI that this mode has been selected
     emit WidgetPlaneModeSwivel( true );
 
     // Add listener
     gi->AddListener( m_SlicesSwiveller );
     break;
   }
   // Notify MainTemplate GUI that mode has changed
   emit WidgetPlaneModeChange(m_PlaneMode);
 }
 
 void QmitkStdMultiWidget::SetGradientBackgroundColors( const mitk::Color & upper, const mitk::Color & lower )
 {
   m_GradientBackground1->SetGradientColors(upper[0], upper[1], upper[2], lower[0], lower[1], lower[2]);
   m_GradientBackground2->SetGradientColors(upper[0], upper[1], upper[2], lower[0], lower[1], lower[2]);
   m_GradientBackground3->SetGradientColors(upper[0], upper[1], upper[2], lower[0], lower[1], lower[2]);
   m_GradientBackground4->SetGradientColors(upper[0], upper[1], upper[2], lower[0], lower[1], lower[2]);
   m_GradientBackgroundFlag = true;
 }
 
 void QmitkStdMultiWidget::SetDepartmentLogoPath( const char * path )
 {
   m_LogoRendering1->SetLogoSource(path);
   m_LogoRendering2->SetLogoSource(path);
   m_LogoRendering3->SetLogoSource(path);
   m_LogoRendering4->SetLogoSource(path);
 }
 
 void QmitkStdMultiWidget::SetWidgetPlaneModeToSlicing( bool activate )
 {
   if ( activate )
   {
     this->SetWidgetPlaneMode( PLANE_MODE_SLICING );
   }
 }
 
 void QmitkStdMultiWidget::SetWidgetPlaneModeToRotation( bool activate )
 {
   if ( activate )
   {
     this->SetWidgetPlaneMode( PLANE_MODE_ROTATION );
   }
 }
 
 void QmitkStdMultiWidget::SetWidgetPlaneModeToSwivel( bool activate )
 {
   if ( activate )
   {
     this->SetWidgetPlaneMode( PLANE_MODE_SWIVEL );
   }
 }
 
 void QmitkStdMultiWidget::OnLayoutDesignChanged( int layoutDesignIndex )
 {
   switch( layoutDesignIndex )
   {
   case LAYOUT_DEFAULT:
     {
       this->changeLayoutToDefault();
       break;
     }
   case LAYOUT_2D_IMAGES_UP:
     {
       this->changeLayoutTo2DImagesUp();
       break;
     }
   case LAYOUT_2D_IMAGES_LEFT:
     {
       this->changeLayoutTo2DImagesLeft();
       break;
     }
   case LAYOUT_BIG_3D:
     {
       this->changeLayoutToBig3D();
       break;
     }
   case LAYOUT_WIDGET1:
     {
       this->changeLayoutToWidget1();
       break;
     }
   case LAYOUT_WIDGET2:
     {
       this->changeLayoutToWidget2();
       break;
     }
   case LAYOUT_WIDGET3:
     {
       this->changeLayoutToWidget3();
       break;
     }
   case LAYOUT_2X_2D_AND_3D_WIDGET:
     {
       this->changeLayoutTo2x2Dand3DWidget();
       break;
     }
   case LAYOUT_ROW_WIDGET_3_AND_4:
     {
       this->changeLayoutToRowWidget3And4();
       break;
     }
   case LAYOUT_COLUMN_WIDGET_3_AND_4:
     {
       this->changeLayoutToColumnWidget3And4();
       break;
     }
   case LAYOUT_ROW_WIDGET_SMALL3_AND_BIG4:
     {
       this->changeLayoutToRowWidgetSmall3andBig4();
       break;
     }
   case LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4:
     {
       this->changeLayoutToSmallUpperWidget2Big3and4();
       break;
     }
   case LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET:
     {
       this->changeLayoutToLeft2Dand3DRight2D();
       break;
     }
   };
 }
 
 void QmitkStdMultiWidget::UpdateAllWidgets()
 {
   mitkWidget1->resize( mitkWidget1Container->frameSize().width()-1, mitkWidget1Container->frameSize().height() );
   mitkWidget1->resize( mitkWidget1Container->frameSize().width(), mitkWidget1Container->frameSize().height() );
 
   mitkWidget2->resize( mitkWidget2Container->frameSize().width()-1, mitkWidget2Container->frameSize().height() );
   mitkWidget2->resize( mitkWidget2Container->frameSize().width(), mitkWidget2Container->frameSize().height() );
 
   mitkWidget3->resize( mitkWidget3Container->frameSize().width()-1, mitkWidget3Container->frameSize().height() );
   mitkWidget3->resize( mitkWidget3Container->frameSize().width(), mitkWidget3Container->frameSize().height() );
 
   mitkWidget4->resize( mitkWidget4Container->frameSize().width()-1, mitkWidget4Container->frameSize().height() );
   mitkWidget4->resize( mitkWidget4Container->frameSize().width(), mitkWidget4Container->frameSize().height() );
 }
 
 void QmitkStdMultiWidget::HideAllWidgetToolbars()
 {
   mitkWidget1->HideRenderWindowMenu();
   mitkWidget2->HideRenderWindowMenu();
   mitkWidget3->HideRenderWindowMenu();
   mitkWidget4->HideRenderWindowMenu();
 }
 
 void QmitkStdMultiWidget::ActivateMenuWidget( bool state )
 {
   mitkWidget1->ActivateMenuWidget( state, this );
   mitkWidget2->ActivateMenuWidget( state, this );
   mitkWidget3->ActivateMenuWidget( state, this );
   mitkWidget4->ActivateMenuWidget( state, this );
 }
 
 bool QmitkStdMultiWidget::IsMenuWidgetEnabled() const
 {
   return mitkWidget1->GetActivateMenuWidgetFlag();
 }
 
 void QmitkStdMultiWidget::ResetCrosshair()
 {
   if (m_DataStorage.IsNotNull())
   {
     m_RenderingManager->InitializeViewsByBoundingObjects(m_DataStorage);
     //m_RenderingManager->InitializeViews( m_DataStorage->ComputeVisibleBoundingGeometry3D() );
     // reset interactor to normal slicing
     this->SetWidgetPlaneMode(PLANE_MODE_SLICING);
   }
 }
 
 void QmitkStdMultiWidget::EnableColoredRectangles()
 {
   m_RectangleRendering1->Enable(1.0, 0.0, 0.0);
   m_RectangleRendering2->Enable(0.0, 1.0, 0.0);
   m_RectangleRendering3->Enable(0.0, 0.0, 1.0);
   m_RectangleRendering4->Enable(1.0, 1.0, 0.0);
 }
 
 void QmitkStdMultiWidget::DisableColoredRectangles()
 {
   m_RectangleRendering1->Disable();
   m_RectangleRendering2->Disable();
   m_RectangleRendering3->Disable();
   m_RectangleRendering4->Disable();
 }
 
 bool QmitkStdMultiWidget::IsColoredRectanglesEnabled() const
 {
   return m_RectangleRendering1->IsEnabled();
 }
 
 mitk::MouseModeSwitcher* QmitkStdMultiWidget::GetMouseModeSwitcher()
 {
   return m_MouseModeSwitcher;
 }
 
 void QmitkStdMultiWidget::MouseModeSelected( mitk::MouseModeSwitcher::MouseMode mouseMode )
 {
   if ( mouseMode == 0 )
   {
     this->EnableNavigationControllerEventListening();
   }
   else
   {
     this->DisableNavigationControllerEventListening();
   }
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane1()
 {
   return this->m_PlaneNode1;
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane2()
 {
   return this->m_PlaneNode2;
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane3()
 {
   return this->m_PlaneNode3;
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane(int id)
 {
   switch(id)
   {
     case 1: return this->m_PlaneNode1;
     break;
     case 2: return this->m_PlaneNode2;
     break;
     case 3: return this->m_PlaneNode3;
     break;
     default: return NULL;
   }
 }
\ No newline at end of file
diff --git a/Modules/QtWidgetsExt/QmitkHistogramJSWidget.cpp b/Modules/QtWidgetsExt/QmitkHistogramJSWidget.cpp
index d5dee0a402..dc379b37b9 100644
--- a/Modules/QtWidgetsExt/QmitkHistogramJSWidget.cpp
+++ b/Modules/QtWidgetsExt/QmitkHistogramJSWidget.cpp
@@ -1,303 +1,303 @@
 /*===================================================================
 
 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 "QmitkHistogramJSWidget.h"
 #include "mitkPixelTypeMultiplex.h"
 #include <mitkImagePixelReadAccessor.h>
 #include "mitkRenderingManager.h"
 #include "mitkBaseRenderer.h"
 #include "mitkImageTimeSelector.h"
 #include "mitkExtractSliceFilter.h"
 
 
 QmitkHistogramJSWidget::QmitkHistogramJSWidget(QWidget *parent) :
   QWebView(parent)
 {
   // set histogram type to barchart in first instance
   m_UseLineGraph = false;
   m_Page = new QmitkJSWebPage(this);
   setPage(m_Page);
   // set html from source
   connect(page()->mainFrame(), SIGNAL(javaScriptWindowObjectCleared()), this, SLOT(AddJSObject()));
   QUrl myUrl = QUrl("qrc:/qmitk/Histogram.html");
   setUrl(myUrl);
 
   // set Scrollbars to be always disabled
   page()->mainFrame()->setScrollBarPolicy(Qt::Horizontal, Qt::ScrollBarAlwaysOff);
   page()->mainFrame()->setScrollBarPolicy(Qt::Vertical, Qt::ScrollBarAlwaysOff);
 
   m_ParametricPath = ParametricPathType::New();
 
 }
 
 QmitkHistogramJSWidget::~QmitkHistogramJSWidget()
 {
 }
 
 // adds an Object of Type QmitkHistogramJSWidget to the JavaScript, using QtWebkitBridge
 void QmitkHistogramJSWidget::AddJSObject()
 {
   page()->mainFrame()->addToJavaScriptWindowObject(QString("histogramData"), this);
 }
 
 // reloads WebView, everytime its size has been changed, so the size of the Histogram fits to the size of the widget
 void QmitkHistogramJSWidget::resizeEvent(QResizeEvent* resizeEvent)
 {
   QWebView::resizeEvent(resizeEvent);
 
   // workaround for Qt Bug: https://bugs.webkit.org/show_bug.cgi?id=75984
   page()->mainFrame()->evaluateJavaScript("disconnectSignals()");
   this->reload();
 }
 
 // method to expose data to JavaScript by using properties
 void QmitkHistogramJSWidget::ComputeHistogram(HistogramType* histogram)
 {
   m_Histogram = histogram;
   HistogramConstIteratorType startIt = m_Histogram->End();
   HistogramConstIteratorType endIt = m_Histogram->End();
   HistogramConstIteratorType it  = m_Histogram->Begin();
   ClearData();
   unsigned int i = 0;
   bool firstValue = false;
   // removes frequencies of 0, which are outside the first and last bin
   for (; it != m_Histogram->End(); ++it)
   {
     if (it.GetFrequency() > 0.0)
     {
       endIt = it;
       if (!firstValue)
       {
         firstValue = true;
         startIt = it;
       }
     }
   }
   ++endIt;
   // generating Lists of measurement and frequencies
   for (it = startIt ; it != endIt; ++it, ++i)
   {
     QVariant frequency = QVariant::fromValue(it.GetFrequency());
     QVariant measurement = it.GetMeasurementVector()[0];
     m_Frequency.insert(i, frequency);
     m_Measurement.insert(i, measurement);
   }
   m_IntensityProfile = false;
   this->SignalDataChanged();
 }
 
 void QmitkHistogramJSWidget::ClearData()
 {
   m_Frequency.clear();
   m_Measurement.clear();
 }
 
 void QmitkHistogramJSWidget::ClearHistogram()
 {
   this->ClearData();
   this->SignalDataChanged();
 }
 
 QList<QVariant> QmitkHistogramJSWidget::GetFrequency()
 {
   return m_Frequency;
 }
 
 QList<QVariant> QmitkHistogramJSWidget::GetMeasurement()
 {
   return m_Measurement;
 }
 
 bool QmitkHistogramJSWidget::GetUseLineGraph()
 {
   return m_UseLineGraph;
 }
 
 void QmitkHistogramJSWidget::OnBarRadioButtonSelected()
 {
   if (m_UseLineGraph)
   {
     m_UseLineGraph = false;
     this->SignalGraphChanged();
   }
 }
 
 void QmitkHistogramJSWidget::OnLineRadioButtonSelected()
 {
   if (!m_UseLineGraph)
   {
     m_UseLineGraph = true;
     this->SignalGraphChanged();
   }
 }
 
 void QmitkHistogramJSWidget::SetImage(mitk::Image* image)
 {
   m_Image = image;
 }
 
 void QmitkHistogramJSWidget::SetPlanarFigure(const mitk::PlanarFigure* planarFigure)
 {
   m_PlanarFigure = planarFigure;
 }
 
 template <class PixelType>
-void ReadPixel(mitk::PixelType ptype, mitk::Image::Pointer image, mitk::Index3D indexPoint, double& value)
+void ReadPixel(mitk::PixelType ptype, mitk::Image::Pointer image, itk::Index<3> indexPoint, double& value)
 {
   if (image->GetDimension() == 2)
   {
     mitk::ImagePixelReadAccessor<PixelType,2> readAccess(image, image->GetSliceData(0));
     itk::Index<2> idx;
     idx[0] = indexPoint[0];
     idx[1] = indexPoint[1];
     value = readAccess.GetPixelByIndex(idx);
   }
   else if (image->GetDimension() == 3)
   {
     mitk::ImagePixelReadAccessor<PixelType,3> readAccess(image, image->GetVolumeData(0));
     itk::Index<3> idx;
     idx[0] = indexPoint[0];
     idx[1] = indexPoint[1];
     idx[2] = indexPoint[2];
     value = readAccess.GetPixelByIndex(idx);
   }
   else
   {
     //unhandled
   }
 }
 
 void QmitkHistogramJSWidget::ComputeIntensityProfile(unsigned int timeStep)
 {
   this->ClearData();
   m_ParametricPath->Initialize();
 
   if (m_PlanarFigure.IsNull())
   {
     mitkThrow() << "PlanarFigure not set!";
   }
 
   if (m_Image.IsNull())
   {
     mitkThrow() << "Image not set!";
   }
 
   // Get 2D geometry frame of PlanarFigure
   mitk::Geometry2D* planarFigureGeometry2D = dynamic_cast<mitk::Geometry2D*>(m_PlanarFigure->GetGeometry(0));
   if (planarFigureGeometry2D == NULL)
   {
     mitkThrow() << "PlanarFigure has no valid geometry!";
   }
 
   // Get 3D geometry from Image (needed for conversion of point to index)
   mitk::Geometry3D* imageGeometry = m_Image->GetGeometry(0);
   if (imageGeometry == NULL)
   {
     mitkThrow() << "Image has no valid geometry!";
   }
 
   // Get first poly-line of PlanarFigure (other possible poly-lines in PlanarFigure
   // are not supported)
   const VertexContainerType vertexContainer = m_PlanarFigure->GetPolyLine(0);
 
   VertexContainerType::const_iterator it;
   for (it = vertexContainer.begin(); it != vertexContainer.end(); ++it)
   {
     // Map PlanarFigure 2D point to 3D point
     mitk::Point3D point3D;
     planarFigureGeometry2D->Map(it->Point, point3D);
 
     // Convert world to index coordinates
     mitk::Point3D indexPoint3D;
     imageGeometry->WorldToIndex(point3D, indexPoint3D);
 
     ParametricPathType::OutputType index;
     index[0] = indexPoint3D[0];
     index[1] = indexPoint3D[1];
     index[2] = indexPoint3D[2];
 
     // Add index to parametric path
     m_ParametricPath->AddVertex(index);
   }
 
   m_DerivedPath = m_ParametricPath;
 
   if (m_DerivedPath.IsNull())
   {
     mitkThrow() << "No path set!";
   }
 
   // Fill item model with line profile data
   double distance = 0.0;
   mitk::Point3D currentWorldPoint;
 
   double t;
   unsigned int i = 0;
   for (i = 0, t = m_DerivedPath->StartOfInput(); ;++i)
   {
     const PathType::OutputType &continousIndex = m_DerivedPath->Evaluate(t);
 
     mitk::Point3D worldPoint;
     imageGeometry->IndexToWorld(continousIndex, worldPoint);
 
     if (i == 0)
     {
       currentWorldPoint = worldPoint;
     }
 
 
     distance += currentWorldPoint.EuclideanDistanceTo(worldPoint);
-    mitk::Index3D indexPoint;
+    itk::Index<3> indexPoint;
     imageGeometry->WorldToIndex(worldPoint, indexPoint);
     const mitk::PixelType ptype = m_Image->GetPixelType();
     double intensity = 0.0;
     if (m_Image->GetDimension() == 4)
     {
       mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
       timeSelector->SetInput(m_Image);
       timeSelector->SetTimeNr(timeStep);
       timeSelector->Update();
       mitk::Image::Pointer image = timeSelector->GetOutput();
       mitkPixelTypeMultiplex3( ReadPixel, ptype, image, indexPoint, intensity);
     }
     else
     {
       mitkPixelTypeMultiplex3( ReadPixel, ptype, m_Image, indexPoint, intensity);
     }
 
     m_Measurement.insert(i, distance);
     m_Frequency.insert(i, intensity);
 
     // Go to next index; when iteration offset reaches zero, iteration is finished
     PathType::OffsetType offset = m_DerivedPath->IncrementInput(t);
     if (!(offset[0] || offset[1] || offset[2]))
     {
       break;
     }
 
     currentWorldPoint = worldPoint;
   }
 
   m_IntensityProfile = true;
   m_UseLineGraph = true;
   this->SignalDataChanged();
 }
 
 bool QmitkHistogramJSWidget::GetIntensityProfile()
 {
   return m_IntensityProfile;
 }
diff --git a/Modules/Segmentation/Testing/mitkOverwriteSliceFilterObliquePlaneTest.cpp b/Modules/Segmentation/Testing/mitkOverwriteSliceFilterObliquePlaneTest.cpp
index b7a97e7ca1..02184e6764 100644
--- a/Modules/Segmentation/Testing/mitkOverwriteSliceFilterObliquePlaneTest.cpp
+++ b/Modules/Segmentation/Testing/mitkOverwriteSliceFilterObliquePlaneTest.cpp
@@ -1,282 +1,282 @@
 /*===================================================================
 
 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 <mitkExtractSliceFilter.h>
 #include <mitkVtkImageOverwrite.h>
 #include <mitkImageCast.h>
 #include <mitkGeometry3D.h>
 #include <mitkRotationOperation.h>
 #include <mitkInteractionConst.h>
 #include <mitkImagePixelReadAccessor.h>
 
 #include <itkImage.h>
 #include <itkImageRegionIterator.h>
 
 #include <vtkImageData.h>
 #include <vtkSmartPointer.h>
 
 
 
 
 int ObliquePlaneTestVolumeSize = 128;
 
 
 
 
 static void OverwriteObliquePlaneTest(mitk::Image* workingImage, mitk::Image* refImg)
 {
 
 /*==============TEST WITHOUT MITK CONVERTION=============================*/
 
     /* ============= setup plane ============*/
   int sliceindex = (int)(ObliquePlaneTestVolumeSize /2);//rand() % 32;
   bool isFrontside = true;
   bool isRotated = false;
 
   mitk::PlaneGeometry::Pointer obliquePlane = mitk::PlaneGeometry::New();
   obliquePlane->InitializeStandardPlane(workingImage->GetGeometry(), mitk::PlaneGeometry::Axial, sliceindex, isFrontside, isRotated);
   mitk::Point3D origin = obliquePlane->GetOrigin();
   mitk::Vector3D normal;
   normal = obliquePlane->GetNormal();
   normal.Normalize();
   origin += normal * 0.5;//pixelspacing is 1, so half the spacing is 0.5
   obliquePlane->SetOrigin(origin);
 
   mitk::Vector3D rotationVector = obliquePlane->GetAxisVector(0);
   rotationVector.Normalize();
 
   float degree = 45.0;
 
   mitk::RotationOperation* op = new mitk::RotationOperation(mitk::OpROTATE, obliquePlane->GetCenter(), rotationVector, degree);
   obliquePlane->ExecuteOperation(op);
   delete op;
 
 
   /* ============= extract slice ============*/
   mitk::ExtractSliceFilter::Pointer slicer = mitk::ExtractSliceFilter::New();
   slicer->SetInput(workingImage);
   slicer->SetWorldGeometry(obliquePlane);
   slicer->SetVtkOutputRequest(true);
   slicer->Modified();
   slicer->Update();
 
   vtkSmartPointer<vtkImageData> slice = vtkSmartPointer<vtkImageData>::New();
   slice = slicer->GetVtkOutput();
 
 
 
   /* ============= overwrite slice ============*/
   vtkSmartPointer<mitkVtkImageOverwrite> resliceIdx = vtkSmartPointer<mitkVtkImageOverwrite>::New();
   mitk::ExtractSliceFilter::Pointer overwriter = mitk::ExtractSliceFilter::New(resliceIdx);
   resliceIdx->SetOverwriteMode(true);
   resliceIdx->SetInputSlice(slice);
   resliceIdx->Modified();
   overwriter->SetInput(workingImage);
   overwriter->SetWorldGeometry(obliquePlane);
   overwriter->SetVtkOutputRequest(true);
   overwriter->Modified();
   overwriter->Update();
 
   typedef mitk::ImagePixelReadAccessor< unsigned short, 3 > ReadAccessorType;
   ReadAccessorType refImgReadAccessor( refImg );
   ReadAccessorType workingImgReadAccessor( workingImage );
 
 
 
   /* ============= check ref == working ============*/
   bool areSame = true;
-  mitk::Index3D id;
+  itk::Index<3> id;
   id[0] = id[1] = id[2] = 0;
   for (int x = 0; x < ObliquePlaneTestVolumeSize ; ++x){
     id[0]  = x;
     for (int y = 0; y < ObliquePlaneTestVolumeSize ; ++y){
       id[1] = y;
       for (int z = 0; z < ObliquePlaneTestVolumeSize ; ++z){
         id[2] = z;
         areSame = refImgReadAccessor.GetPixelByIndex(id) == workingImgReadAccessor.GetPixelByIndex(id);
         if(!areSame)
           goto stop;
       }
     }
   }
 stop:
   MITK_TEST_CONDITION(areSame,"comparing images (no mitk convertion) [oblique]");
 
 
 
 
 
 /*==============TEST WITH MITK CONVERTION=============================*/
 
     /* ============= extract slice ============*/
   mitk::ExtractSliceFilter::Pointer slicer2 = mitk::ExtractSliceFilter::New();
   slicer2->SetInput(workingImage);
   slicer2->SetWorldGeometry(obliquePlane);
   slicer2->Modified();
   slicer2->Update();
 
 
   mitk::Image::Pointer sliceInMitk = slicer2->GetOutput();
   vtkSmartPointer<vtkImageData> slice2 = vtkSmartPointer<vtkImageData>::New();
   slice2 = sliceInMitk->GetVtkImageData();
 
 
   /* ============= overwrite slice ============*/
   vtkSmartPointer<mitkVtkImageOverwrite> resliceIdx2 = vtkSmartPointer<mitkVtkImageOverwrite>::New();
   mitk::ExtractSliceFilter::Pointer overwriter2 = mitk::ExtractSliceFilter::New(resliceIdx2);
   resliceIdx2->SetOverwriteMode(true);
   resliceIdx2->SetInputSlice(slice2);
   resliceIdx2->Modified();
   overwriter2->SetInput(workingImage);
   overwriter2->SetWorldGeometry(obliquePlane);
   overwriter2->SetVtkOutputRequest(true);
   overwriter2->Modified();
   overwriter2->Update();
 
 
 
   /* ============= check ref == working ============*/
   areSame = true;
   id[0] = id[1] = id[2] = 0;
   for (int x = 0; x < ObliquePlaneTestVolumeSize ; ++x){
     id[0]  = x;
     for (int y = 0; y < ObliquePlaneTestVolumeSize ; ++y){
       id[1] = y;
       for (int z = 0; z < ObliquePlaneTestVolumeSize ; ++z){
         id[2] = z;
         areSame = refImgReadAccessor.GetPixelByIndex(id) == workingImgReadAccessor.GetPixelByIndex(id);
         if(!areSame)
           goto stop2;
       }
     }
   }
 stop2:
   MITK_TEST_CONDITION(areSame,"comparing images (with mitk convertion) [oblique]");
 
 
 /*==============TEST EDIT WITHOUT MITK CONVERTION=============================*/
 
   /* ============= edit slice ============*/
   int idX = std::abs(ObliquePlaneTestVolumeSize -59);
   int idY = std::abs(ObliquePlaneTestVolumeSize -23);
   int idZ = 0;
   int component = 0;
   double val = 33.0;
 
   slice->SetScalarComponentFromDouble(idX,idY,idZ,component,val);
 
   mitk::Vector3D indx;
   indx[0] = idX; indx[1] = idY; indx[2] = idZ;
   sliceInMitk->GetGeometry()->IndexToWorld(indx, indx);
 
   /* ============= overwrite slice ============*/
 
   vtkSmartPointer<mitkVtkImageOverwrite> resliceIdx3 = vtkSmartPointer<mitkVtkImageOverwrite>::New();
   resliceIdx3->SetOverwriteMode(true);
   resliceIdx3->SetInputSlice(slice);
   mitk::ExtractSliceFilter::Pointer overwriter3 = mitk::ExtractSliceFilter::New(resliceIdx3);
   overwriter3->SetInput(workingImage);
   overwriter3->SetWorldGeometry(obliquePlane);
   overwriter3->SetVtkOutputRequest(true);
   overwriter3->Modified();
   overwriter3->Update();
 
 
 
 
   /* ============= check ============*/
   areSame = true;
 
   int x,y,z;
 
   for ( x = 0; x < ObliquePlaneTestVolumeSize ; ++x){
     id[0]  = x;
     for ( y = 0; y < ObliquePlaneTestVolumeSize ; ++y){
       id[1] = y;
       for ( z = 0; z < ObliquePlaneTestVolumeSize ; ++z){
         id[2] = z;
         areSame = refImgReadAccessor.GetPixelByIndex(id) == workingImgReadAccessor.GetPixelByIndex(id);
         if(!areSame)
           goto stop3;
       }
     }
   }
 stop3:
   //MITK_INFO << "index: [" << x << ", " << y << ", " << z << "]";
   //MITK_INFO << indx;
   MITK_TEST_CONDITION(x==idX && y==z,"overwrited the right index [oblique]");
 }
 
 
 
 
 /*================ #BEGIN test main ================*/
 int mitkOverwriteSliceFilterObliquePlaneTest(int argc, char* argv[])
 {
 
   MITK_TEST_BEGIN("mitkOverwriteSliceFilterObliquePlaneTest")
 
 
 
 
     typedef itk::Image<unsigned short, 3> ImageType;
 
     typedef itk::ImageRegionConstIterator< ImageType > ImageIterator;
 
     ImageType::Pointer image = ImageType::New();
 
     ImageType::IndexType start;
     start[0] = start[1] = start[2] = 0;
 
     ImageType::SizeType size;
     size[0] = size[1] = size[2] = ObliquePlaneTestVolumeSize ;
 
     ImageType::RegionType imgRegion;
     imgRegion.SetSize(size);
     imgRegion.SetIndex(start);
 
     image->SetRegions(imgRegion);
     image->SetSpacing(1.0);
     image->Allocate();
 
 
     ImageIterator imageIterator( image, image->GetLargestPossibleRegion() );
     imageIterator.GoToBegin();
 
 
     unsigned short pixelValue = 0;
 
     //fill the image with distinct values
     while ( !imageIterator.IsAtEnd() )
     {
       image->SetPixel(imageIterator.GetIndex(), pixelValue);
       ++imageIterator;
       ++pixelValue;
     }
     /* end setup itk image */
 
 
 
     mitk::Image::Pointer refImage;
     CastToMitkImage(image, refImage);
     mitk::Image::Pointer workingImg;
     CastToMitkImage(image, workingImg);
     OverwriteObliquePlaneTest(workingImg, refImage);
 
 
   MITK_TEST_END()
 }
diff --git a/Modules/Segmentation/Testing/mitkOverwriteSliceFilterTest.cpp b/Modules/Segmentation/Testing/mitkOverwriteSliceFilterTest.cpp
index ecd4edef8c..36f9f1a528 100644
--- a/Modules/Segmentation/Testing/mitkOverwriteSliceFilterTest.cpp
+++ b/Modules/Segmentation/Testing/mitkOverwriteSliceFilterTest.cpp
@@ -1,205 +1,205 @@
 /*===================================================================
 
 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 <mitkExtractSliceFilter.h>
 #include <mitkVtkImageOverwrite.h>
 #include <mitkImageCast.h>
 #include <mitkGeometry3D.h>
 #include <mitkRotationOperation.h>
 #include <mitkInteractionConst.h>
 #include <mitkImagePixelReadAccessor.h>
 
 #include <itkImage.h>
 #include <itkImageRegionIterator.h>
 
 #include <vtkImageData.h>
 #include <vtkSmartPointer.h>
 
 
 
 
 int VolumeSize = 128;
 
 
 
 
 /*================ #BEGIN test main ================*/
 int mitkOverwriteSliceFilterTest(int argc, char* argv[])
 {
 
   MITK_TEST_BEGIN("mitkOverwriteSliceFilterTest")
 
 
 
 
     typedef itk::Image<unsigned short, 3> ImageType;
 
     typedef itk::ImageRegionConstIterator< ImageType > ImageIterator;
 
     ImageType::Pointer image = ImageType::New();
 
     ImageType::IndexType start;
     start[0] = start[1] = start[2] = 0;
 
     ImageType::SizeType size;
     size[0] = size[1] = size[2] = VolumeSize;
 
     ImageType::RegionType imgRegion;
     imgRegion.SetSize(size);
     imgRegion.SetIndex(start);
 
     image->SetRegions(imgRegion);
     image->SetSpacing(1.0);
     image->Allocate();
 
 
     ImageIterator imageIterator( image, image->GetLargestPossibleRegion() );
     imageIterator.GoToBegin();
 
 
     unsigned short pixelValue = 0;
 
     //fill the image with distinct values
     while ( !imageIterator.IsAtEnd() )
     {
       image->SetPixel(imageIterator.GetIndex(), pixelValue);
       ++imageIterator;
       ++pixelValue;
     }
     /* end setup itk image */
 
 
 
     mitk::Image::Pointer referenceImage;
     CastToMitkImage(image, referenceImage);
     mitk::Image::Pointer workingImage;
     CastToMitkImage(image, workingImage);
 
     typedef mitk::ImagePixelReadAccessor< unsigned short, 3 > ReadAccessorType;
     ReadAccessorType refImgReadAccessor( referenceImage );
     ReadAccessorType workingImgReadAccessor( workingImage );
 
 
   /* ============= setup plane ============*/
   int sliceindex = 55;//rand() % 32;
   bool isFrontside = true;
   bool isRotated = false;
 
   mitk::PlaneGeometry::Pointer plane = mitk::PlaneGeometry::New();
   plane->InitializeStandardPlane(workingImage->GetGeometry(), mitk::PlaneGeometry::Axial, sliceindex, isFrontside, isRotated);
   mitk::Point3D origin = plane->GetOrigin();
   mitk::Vector3D normal;
   normal = plane->GetNormal();
   normal.Normalize();
   origin += normal * 0.5;//pixelspacing is 1, so half the spacing is 0.5
   plane->SetOrigin(origin);
 
 
 
   /* ============= extract slice ============*/
   vtkSmartPointer<mitkVtkImageOverwrite> resliceIdx = vtkSmartPointer<mitkVtkImageOverwrite>::New();
   mitk::ExtractSliceFilter::Pointer slicer = mitk::ExtractSliceFilter::New(resliceIdx);
   slicer->SetInput(workingImage);
   slicer->SetWorldGeometry(plane);
   slicer->SetVtkOutputRequest(true);
   slicer->Modified();
   slicer->Update();
 
   vtkSmartPointer<vtkImageData> slice = vtkSmartPointer<vtkImageData>::New();
   slice = slicer->GetVtkOutput();
 
 
 
   /* ============= overwrite slice ============*/
   resliceIdx->SetOverwriteMode(true);
   resliceIdx->Modified();
   slicer->Modified();
   slicer->Update();//implicit overwrite
 
 
 
   /* ============= check ref == working ============*/
   bool areSame = true;
-  mitk::Index3D id;
+  itk::Index<3> id;
   id[0] = id[1] = id[2] = 0;
   for (int x = 0; x < VolumeSize; ++x){
     id[0]  = x;
     for (int y = 0; y < VolumeSize; ++y){
       id[1] = y;
       for (int z = 0; z < VolumeSize; ++z){
         id[2] = z;
         areSame = refImgReadAccessor.GetPixelByIndex( id ) == workingImgReadAccessor.GetPixelByIndex( id );
         if(!areSame)
           goto stop;
       }
     }
   }
 stop:
   MITK_TEST_CONDITION(areSame,"test overwrite unmodified slice");
 
 
 
   /* ============= edit slice ============*/
   int idX = std::abs(VolumeSize-59);
   int idY = std::abs(VolumeSize-23);
   int idZ = 0;
   int component = 0;
   double val = 33.0;
 
   slice->SetScalarComponentFromDouble(idX,idY,idZ,component,val);
 
 
 
   /* ============= overwrite slice ============*/
 
   vtkSmartPointer<mitkVtkImageOverwrite> resliceIdx2 = vtkSmartPointer<mitkVtkImageOverwrite>::New();
   resliceIdx2->SetOverwriteMode(true);
   resliceIdx2->SetInputSlice(slice);
   mitk::ExtractSliceFilter::Pointer slicer2 = mitk::ExtractSliceFilter::New(resliceIdx2);
   slicer2->SetInput(workingImage);
   slicer2->SetWorldGeometry(plane);
   slicer2->SetVtkOutputRequest(true);
   slicer2->Modified();
   slicer2->Update();
 
 
 
 
   /* ============= check ============*/
   areSame = true;
 
   int xx,yy,zz;
 
   for ( xx = 0; xx < VolumeSize; ++xx){
     id[0]  = xx;
     for ( yy = 0; yy < VolumeSize; ++yy){
       id[1] = yy;
       for ( zz = 0; zz < VolumeSize; ++zz){
         id[2] = zz;
         areSame = refImgReadAccessor.GetPixelByIndex( id ) == workingImgReadAccessor.GetPixelByIndex( id );
         if(!areSame)
           goto stop2;
       }
     }
   }
 stop2:
   //MITK_INFO << "index: [" << x << ", " << y << ", " << z << "]";
   MITK_TEST_CONDITION(xx==idX && yy==idY && zz==sliceindex,"test overwrite modified slice");
 
 
   MITK_TEST_END()
 }
diff --git a/Modules/SegmentationUI/Qmitk/QmitkAdaptiveRegionGrowingToolGUI.cpp b/Modules/SegmentationUI/Qmitk/QmitkAdaptiveRegionGrowingToolGUI.cpp
index 93c4af6042..3e2f5b64e5 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkAdaptiveRegionGrowingToolGUI.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkAdaptiveRegionGrowingToolGUI.cpp
@@ -1,848 +1,848 @@
 /*===================================================================
 
 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 "QmitkAdaptiveRegionGrowingToolGUI.h"
 
 #include "QmitkStdMultiWidget.h"
 
 #include <qmessagebox.h>
 
 #include "mitkNodePredicateDataType.h"
 #include "mitkGlobalInteraction.h"
 #include "mitkPointSetInteractor.h"
 #include "mitkProperties.h"
 #include "mitkITKImageImport.h"
 #include "mitkImageAccessByItk.h"
 #include "mitkTransferFunctionProperty.h"
 #include "mitkImageTimeSelector.h"
 
 #include "mitkImageStatisticsHolder.h"
 
 #include <itkConnectedAdaptiveThresholdImageFilter.h>
 #include <itkMinimumMaximumImageCalculator.h>
 #include <itkBinaryThresholdImageFilter.h>
 #include <itkImageIterator.h>
 
 #include "itkOrImageFilter.h"
 #include "mitkImageCast.h"
 #include "QmitkConfirmSegmentationDialog.h"
 
 #include "mitkPixelTypeMultiplex.h"
 #include "mitkImagePixelReadAccessor.h"
 
 
 MITK_TOOL_GUI_MACRO( , QmitkAdaptiveRegionGrowingToolGUI, "")
 
 QmitkAdaptiveRegionGrowingToolGUI::QmitkAdaptiveRegionGrowingToolGUI(QWidget* parent) :
 QmitkToolGUI(), m_MultiWidget(NULL), m_UseVolumeRendering(false), m_UpdateSuggestedThreshold(true), m_SuggestedThValue(0.0), m_DataStorage(NULL)
 {
   this->setParent(parent);
 
   m_Controls.setupUi(this);
 
   m_Controls.m_ThresholdSlider->setDecimals(1);
   m_Controls.m_ThresholdSlider->setSpinBoxAlignment(Qt::AlignVCenter);
 
   m_Controls.m_PreviewSlider->setEnabled(false);
   m_Controls.m_PreviewSlider->setSingleStep(0.5);
   //Not yet available
   //m_Controls.m_PreviewSlider->InvertedAppearance(true);
 
   this->CreateConnections();
   this->SetDataNodeNames("labeledRGSegmentation","RGResult","RGFeedbackSurface");
 
   connect( this, SIGNAL(NewToolAssociated(mitk::Tool*)), this, SLOT(OnNewToolAssociated(mitk::Tool*)) );
 }
 
 
 
 QmitkAdaptiveRegionGrowingToolGUI::~QmitkAdaptiveRegionGrowingToolGUI()
 {
     //Removing the observer of the PointSet node
     if (m_RegionGrow3DTool->GetPointSetNode().IsNotNull())
     {
         m_RegionGrow3DTool->GetPointSetNode()->GetData()->RemoveObserver(m_PointSetAddObserverTag);
     }
     this->RemoveHelperNodes();
 }
 
 
 void QmitkAdaptiveRegionGrowingToolGUI::OnNewToolAssociated(mitk::Tool* tool)
 {
   m_RegionGrow3DTool = dynamic_cast<mitk::AdaptiveRegionGrowingTool*> (tool);
   if(m_RegionGrow3DTool.IsNotNull())
   {
     SetInputImageNode( this->m_RegionGrow3DTool->GetReferenceData() );
     this->m_DataStorage = this->m_RegionGrow3DTool->GetDataStorage();
     this->EnableControls(true);
 
     //Watch for point added or modified
     itk::SimpleMemberCommand<QmitkAdaptiveRegionGrowingToolGUI>::Pointer pointAddedCommand = itk::SimpleMemberCommand<QmitkAdaptiveRegionGrowingToolGUI>::New();
     pointAddedCommand->SetCallbackFunction(this, &QmitkAdaptiveRegionGrowingToolGUI::OnPointAdded);
     m_PointSetAddObserverTag = m_RegionGrow3DTool->GetPointSetNode()->GetData()->AddObserver( mitk::PointSetAddEvent(), pointAddedCommand);
   }
   else
   {
     this->EnableControls(false);
   }
 }
 
 
 void QmitkAdaptiveRegionGrowingToolGUI::RemoveHelperNodes()
 {
   mitk::DataNode::Pointer imageNode = m_DataStorage->GetNamedNode( m_NAMEFORLABLEDSEGMENTATIONIMAGE);
   if( imageNode.IsNotNull() )
   {
     m_DataStorage->Remove(imageNode);
   }
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::CreateConnections()
 {
     //Connecting GUI components
     connect( (QObject*) (m_Controls.m_pbRunSegmentation), SIGNAL(clicked()), this, SLOT(RunSegmentation()));
     connect( m_Controls.m_PreviewSlider, SIGNAL(valueChanged(double)), this, SLOT(ChangeLevelWindow(double)));
     connect( (QObject*) (m_Controls.m_pbConfirmSegementation), SIGNAL(clicked()), this, SLOT(ConfirmSegmentation()));
     connect( (QObject*) (m_Controls.m_cbVolumeRendering), SIGNAL(toggled(bool)), this, SLOT(UseVolumeRendering(bool) ));
     connect( m_Controls.m_ThresholdSlider, SIGNAL(maximumValueChanged(double)), this, SLOT(SetUpperThresholdValue(double)));
     connect( m_Controls.m_ThresholdSlider, SIGNAL(minimumValueChanged(double)), this, SLOT(SetLowerThresholdValue(double)));
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::SetDataNodeNames(std::string labledSegmentation, std::string binaryImage, std::string surface)
 {
   m_NAMEFORLABLEDSEGMENTATIONIMAGE = labledSegmentation;
   m_NAMEFORBINARYIMAGE = binaryImage;
   m_NAMEFORSURFACE = surface;
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::SetDataStorage(mitk::DataStorage* dataStorage)
 {
   m_DataStorage = dataStorage;
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::SetMultiWidget(QmitkStdMultiWidget* multiWidget)
 {
   m_MultiWidget = multiWidget;
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::SetInputImageNode(mitk::DataNode* node)
 {
   m_InputImageNode = node;
   mitk::Image* inputImage = dynamic_cast<mitk::Image*>(m_InputImageNode->GetData());
   if (inputImage)
   {
     mitk::ScalarType max = inputImage->GetStatistics()->GetScalarValueMax();
     mitk::ScalarType min = inputImage->GetStatistics()->GetScalarValueMin();
     m_Controls.m_ThresholdSlider->setMaximum(max);
     m_Controls.m_ThresholdSlider->setMinimum(min);
     // Just for initialization
     m_Controls.m_ThresholdSlider->setMaximumValue(max);
     m_Controls.m_ThresholdSlider->setMinimumValue(min);
   }
 }
 
 template <typename TPixel>
 static void AccessPixel(mitk::PixelType ptype, const mitk::Image::Pointer im, mitk::Point3D p, int & val)
 {
   mitk::ImagePixelReadAccessor<TPixel,3> access(im);
   val = access.GetPixelByWorldCoordinates(p);
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::OnPointAdded()
 {
   if (m_RegionGrow3DTool.IsNull())
     return;
 
   mitk::DataNode* node = m_RegionGrow3DTool->GetPointSetNode();
 
   if (node != NULL)
   {
       mitk::PointSet::Pointer pointSet = dynamic_cast<mitk::PointSet*>(node->GetData());
 
       if (pointSet.IsNull())
       {
           QMessageBox::critical(NULL, "QmitkAdaptiveRegionGrowingToolGUI", "PointSetNode does not contain a pointset");
           return;
       }
 
       m_Controls.m_lblSetSeedpoint->setText("");
 
       mitk::Image* image = dynamic_cast<mitk::Image*>(m_InputImageNode->GetData());
 
       mitk::Point3D seedPoint = pointSet->GetPointSet(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1") )->GetTimeStep())->GetPoints()->ElementAt(0);
 
       mitkPixelTypeMultiplex3(AccessPixel,image->GetChannelDescriptor().GetPixelType(),image,seedPoint,m_SeedpointValue);
 
       /* In this case the seedpoint is placed e.g. in the lung or bronchialtree
        * The lowerFactor sets the windowsize depending on the regiongrowing direction
        */
       m_CurrentRGDirectionIsUpwards = true;
       if (m_SeedpointValue < -500)
       {
           m_CurrentRGDirectionIsUpwards = false;
       }
 
       // Initializing the region by the area around the seedpoint
       m_SeedPointValueMean = 0;
 
-      mitk::Index3D currentIndex, runningIndex;
+      itk::Index<3> currentIndex, runningIndex;
       mitk::ScalarType pixelValues[125];
       unsigned int pos (0);
 
       image->GetGeometry(0)->WorldToIndex(seedPoint, currentIndex);
       runningIndex = currentIndex;
 
       for(int i = runningIndex[0]-2; i <= runningIndex[0]+2; i++)
       {
         for(int j = runningIndex[1]-2; j <= runningIndex[1]+2; j++)
         {
           for(int k = runningIndex[2]-2; k <= runningIndex[2]+2; k++)
           {
             currentIndex[0] = i;
             currentIndex[1] = j;
             currentIndex[2] = k;
 
             if(image->GetGeometry()->IsIndexInside(currentIndex))
             {
               pixelValues[pos] = image->GetPixelValueByIndex(currentIndex);
               pos++;
             }
             else
             {
               pixelValues[pos] = -10000000;
               pos++;
             }
           }
         }
       }
 
       //Now calculation mean of the pixelValues
       unsigned int numberOfValues(0);
       for (unsigned int i = 0; i < 125; i++)
       {
         if(pixelValues[i] > -10000000)
         {
           m_SeedPointValueMean += pixelValues[i];
           numberOfValues++;
         }
       }
 
       m_SeedPointValueMean = m_SeedPointValueMean/numberOfValues;
 
       /*
        * Here the upper- and lower threshold is calculated:
        * The windowSize is 20% of the maximum range of the intensity values existing in the current image
        * If the RG direction is upwards the lower TH is meanSeedValue-0.15*windowSize and upper TH is meanSeedValue+0.85*windowsSize
        * if the RG direction is downwards the lower TH is meanSeedValue-0.85*windowSize and upper TH is meanSeedValue+0.15*windowsSize
       */
       mitk::ScalarType min = image->GetStatistics()->GetScalarValueMin();
       mitk::ScalarType max = image->GetStatistics()->GetScalarValueMax();
       mitk::ScalarType windowSize = max - min;
 
       windowSize = 0.15*windowSize;
 
       if (m_CurrentRGDirectionIsUpwards)
       {
         m_LOWERTHRESHOLD = m_SeedPointValueMean;
         if (m_SeedpointValue < m_SeedPointValueMean)
           m_LOWERTHRESHOLD = m_SeedpointValue;
         m_UPPERTHRESHOLD = m_SeedpointValue + windowSize;
         if (m_UPPERTHRESHOLD > max)
           m_UPPERTHRESHOLD = max;
         m_Controls.m_ThresholdSlider->setMaximumValue(m_UPPERTHRESHOLD);
         m_Controls.m_ThresholdSlider->setMinimumValue(m_LOWERTHRESHOLD);
       }
       else
       {
         m_UPPERTHRESHOLD = m_SeedPointValueMean;
         if (m_SeedpointValue > m_SeedPointValueMean)
           m_UPPERTHRESHOLD = m_SeedpointValue;
         m_LOWERTHRESHOLD = m_SeedpointValue - windowSize;
         if (m_LOWERTHRESHOLD < min)
           m_LOWERTHRESHOLD = min;
         m_Controls.m_ThresholdSlider->setMinimumValue(m_LOWERTHRESHOLD);
         m_Controls.m_ThresholdSlider->setMaximumValue(m_UPPERTHRESHOLD);
       }
   }
 }
 
 
 
 void QmitkAdaptiveRegionGrowingToolGUI::RunSegmentation()
 {
   if (m_InputImageNode.IsNull())
   {
     QMessageBox::information( NULL, "Adaptive Region Growing functionality", "Please specify the image in Datamanager!");
     return;
   }
 
   mitk::DataNode::Pointer node = m_RegionGrow3DTool->GetPointSetNode();
 
   if (node.IsNull())
   {
     QMessageBox::information( NULL, "Adaptive Region Growing functionality", "Please insert a seed point inside the image.\n\nFirst press the \"Define Seed Point\" button,\nthen click left mouse button inside the image.");
     return;
   }
 
   //safety if no pointSet or pointSet empty
   mitk::PointSet::Pointer seedPointSet = dynamic_cast<mitk::PointSet*> (node->GetData());
   if (seedPointSet.IsNull())
   {
     m_Controls.m_pbRunSegmentation->setEnabled(true);
     QMessageBox::information( NULL, "Adaptive Region Growing functionality", "The seed point is empty! Please choose a new seed point.");
     return;
   }
 
   int timeStep = mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1") )->GetTimeStep();
 
   if (!(seedPointSet->GetSize(timeStep)))
   {
     m_Controls.m_pbRunSegmentation->setEnabled(true);
     QMessageBox::information( NULL, "Adaptive Region Growing functionality", "The seed point is empty! Please choose a new seed point.");
     return;
   }
 
   QApplication::setOverrideCursor( QCursor(Qt::WaitCursor) );
 
   mitk::PointSet::PointType seedPoint = seedPointSet->GetPointSet(timeStep)->GetPoints()->Begin().Value();
 
   mitk::Image::Pointer orgImage = dynamic_cast<mitk::Image*> (m_InputImageNode->GetData());
 
   if (orgImage.IsNotNull())
   {
       if (orgImage->GetDimension() == 4)
       {
           mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
           timeSelector->SetInput(orgImage);
           timeSelector->SetTimeNr( timeStep );
           timeSelector->UpdateLargestPossibleRegion();
           mitk::Image* timedImage = timeSelector->GetOutput();
           AccessByItk_2( timedImage , StartRegionGrowing, timedImage->GetGeometry(), seedPoint);
       }
       else if (orgImage->GetDimension() == 3)
       {
           //QApplication::setOverrideCursor(QCursor(Qt::WaitCursor)); //set the cursor to waiting
           AccessByItk_2(orgImage, StartRegionGrowing, orgImage->GetGeometry(), seedPoint);
           //QApplication::restoreOverrideCursor();//reset cursor
       }
       else
       {
           QApplication::restoreOverrideCursor();//reset cursor
           QMessageBox::information( NULL, "Adaptive Region Growing functionality", "Only images of dimension 3 or 4 can be processed!");
           return;
       }
   }
   EnableControls(true); // Segmentation ran successfully, so enable all controls.
   node->SetVisibility(true);
   QApplication::restoreOverrideCursor();//reset cursor
 
 }
 
 template<typename TPixel, unsigned int VImageDimension>
 void QmitkAdaptiveRegionGrowingToolGUI::StartRegionGrowing(itk::Image<TPixel, VImageDimension>* itkImage, mitk::Geometry3D* imageGeometry, mitk::PointSet::PointType seedPoint)
 {
   typedef itk::Image<TPixel, VImageDimension> InputImageType;
   typedef typename InputImageType::IndexType IndexType;
   typedef itk::ConnectedAdaptiveThresholdImageFilter<InputImageType, InputImageType> RegionGrowingFilterType;
   typename RegionGrowingFilterType::Pointer regionGrower = RegionGrowingFilterType::New();
   typedef itk::MinimumMaximumImageCalculator<InputImageType> MinMaxValueFilterType;
 
   if ( !imageGeometry->IsInside(seedPoint) )
   {
     QApplication::restoreOverrideCursor();//reset cursor to be able to click ok with the regular mouse cursor
     QMessageBox::information( NULL, "Segmentation functionality", "The seed point is outside of the image! Please choose a position inside the image!");
     return;
   }
 
   IndexType seedIndex;
   imageGeometry->WorldToIndex( seedPoint, seedIndex);// convert world coordinates to image indices
 
 
 
   if (m_SeedpointValue>m_UPPERTHRESHOLD || m_SeedpointValue<m_LOWERTHRESHOLD)
   {
     QApplication::restoreOverrideCursor();//reset cursor to be able to click ok with the regular mouse cursor
     QMessageBox::information( NULL, "Segmentation functionality", "The seed point is outside the defined thresholds! Please set a new seed point or adjust the thresholds.");
     MITK_INFO << "Mean: " <<m_SeedPointValueMean;
     return;
   }
 
   //Setting the direction of the regiongrowing. For dark structures e.g. the lung the regiongrowing
   //is performed starting at the upper value going to the lower one
   regionGrower->SetGrowingDirectionIsUpwards( m_CurrentRGDirectionIsUpwards );
   regionGrower->SetInput( itkImage );
   regionGrower->AddSeed( seedIndex );
   //In some cases we have to subtract 1 for the lower threshold and add 1 to the upper.
   //Otherwise no region growing is done. Maybe a bug in the ConnectiveAdaptiveThresholdFilter
   regionGrower->SetLower( m_LOWERTHRESHOLD-1 );
   regionGrower->SetUpper( m_UPPERTHRESHOLD+1);
 
   try
   {
     regionGrower->Update();
   }
     catch(itk::ExceptionObject &exc)
   {
     QMessageBox errorInfo;
     errorInfo.setWindowTitle("Adaptive RG Segmentation Functionality");
     errorInfo.setIcon(QMessageBox::Critical);
     errorInfo.setText("An error occurred during region growing!");
     errorInfo.setDetailedText(exc.what());
     errorInfo.exec();
     return; // can't work
   }
   catch( ... )
   {
     QMessageBox::critical( NULL, "Adaptive RG Segmentation Functionality", "An error occurred during region growing!");
     return;
   }
 
   mitk::Image::Pointer resultImage = mitk::ImportItkImage(regionGrower->GetOutput())->Clone();
   //initialize slider
   m_Controls.m_PreviewSlider->setMinimum(m_LOWERTHRESHOLD);
   mitk::ScalarType max = m_LOWERTHRESHOLD+resultImage->GetStatistics()->GetScalarValueMax();
   if (max < m_UPPERTHRESHOLD)
     m_Controls.m_PreviewSlider->setMaximum(max);
   else
     m_Controls.m_PreviewSlider->setMaximum(m_UPPERTHRESHOLD);
 
   this->m_DetectedLeakagePoint = regionGrower->GetLeakagePoint();
 
   if(m_CurrentRGDirectionIsUpwards)
   {
     m_Controls.m_PreviewSlider->setValue(m_SeedPointValueMean-1);
   }
   else
   {
     m_Controls.m_PreviewSlider->setValue(m_SeedPointValueMean+1);
   }
   this->m_SliderInitialized = true;
 
   //create new node and then delete the old one if there is one
   mitk::DataNode::Pointer newNode = mitk::DataNode::New();
   newNode->SetData( resultImage );
 
   // set some properties
   newNode->SetProperty("name", mitk::StringProperty::New(m_NAMEFORLABLEDSEGMENTATIONIMAGE));
   newNode->SetProperty("helper object", mitk::BoolProperty::New(true));
   newNode->SetProperty("color", mitk::ColorProperty::New(0.0,1.0,0.0));
   newNode->SetProperty("layer", mitk::IntProperty::New(1));
   newNode->SetProperty("opacity", mitk::FloatProperty::New(0.7));
 
   //delete the old image, if there was one:
   mitk::DataNode::Pointer binaryNode = m_DataStorage->GetNamedNode(m_NAMEFORLABLEDSEGMENTATIONIMAGE);
   m_DataStorage->Remove(binaryNode);
 
   // now add result to data tree
   m_DataStorage->Add( newNode, m_InputImageNode );
 
   this->InitializeLevelWindow();
 
   if(m_UseVolumeRendering)
     this->EnableVolumeRendering(true);
 
   m_UpdateSuggestedThreshold = true;// reset first stored threshold value
   //Setting progress to finished
   mitk::ProgressBar::GetInstance()->Progress(357);
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::InitializeLevelWindow()
 {
   //get the preview from the datatree
   mitk::DataNode::Pointer newNode = m_DataStorage->GetNamedNode( m_NAMEFORLABLEDSEGMENTATIONIMAGE);
 
   mitk::LevelWindow tempLevelWindow;
   newNode->GetLevelWindow(tempLevelWindow, NULL, "levelwindow");
 
   mitk::ScalarType* level = new mitk::ScalarType(0.0);
   mitk::ScalarType* window = new mitk::ScalarType(1.0);
 
   int upper;
   if (m_CurrentRGDirectionIsUpwards)
   {
     upper = m_UPPERTHRESHOLD - m_SeedpointValue;
   }
   else
   {
     upper = m_SeedpointValue - m_LOWERTHRESHOLD;
   }
 
   tempLevelWindow.SetRangeMinMax(mitk::ScalarType(0), mitk::ScalarType(upper));
 
   //get the suggested threshold from the detected leakage-point and adjust the slider
 
   if (m_CurrentRGDirectionIsUpwards)
   {
     this->m_Controls.m_PreviewSlider->setValue(m_SeedpointValue);
     *level = m_UPPERTHRESHOLD - (m_SeedpointValue) + 0.5;
   }
   else
   {
     this->m_Controls.m_PreviewSlider->setValue(m_SeedpointValue);
     *level = (m_SeedpointValue) - m_LOWERTHRESHOLD + 0.5;
   }
 
   tempLevelWindow.SetLevelWindow(*level, *window);
   newNode->SetLevelWindow(tempLevelWindow, NULL, "levelwindow");
   //update the widgets
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   m_SliderInitialized = true;
 
   //inquiry need to fix bug#1828
   static int lastSliderPosition = 0;
   if ((this->m_SeedpointValue + this->m_DetectedLeakagePoint - 1) == lastSliderPosition)
   {
     this->ChangeLevelWindow(lastSliderPosition);
   }
   lastSliderPosition = this->m_SeedpointValue + this->m_DetectedLeakagePoint-1;
 
   if(m_MultiWidget)
   {
     this->m_MultiWidget->levelWindowWidget->GetManager()->SetAutoTopMostImage(false);
     this->m_MultiWidget->levelWindowWidget->GetManager()->SetLevelWindowProperty(static_cast<mitk::LevelWindowProperty*>(newNode->GetProperty("levelwindow")));
   }
 
   if (m_UseVolumeRendering)
   this->UpdateVolumeRenderingThreshold((int) (*level + 0.5));//lower threshold for labeled image
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::ChangeLevelWindow(double newValue)
 {
   if (m_SliderInitialized)
   {
     //do nothing, if no preview exists
     mitk::DataNode::Pointer newNode = m_DataStorage->GetNamedNode( m_NAMEFORLABLEDSEGMENTATIONIMAGE);
     if (newNode.IsNull())
       return;
 
     mitk::LevelWindow tempLevelWindow;
 
     newNode->GetLevelWindow(tempLevelWindow, NULL, "levelwindow"); //get the levelWindow associated with the preview
 
     mitk::ScalarType level;// = this->m_UPPERTHRESHOLD - newValue + 0.5;
     mitk::ScalarType* window = new mitk::ScalarType(1);
 
     //adjust the levelwindow according to the position of the slider (newvalue)
     if (m_CurrentRGDirectionIsUpwards)
     {
       level = m_UPPERTHRESHOLD - newValue + 0.5;
       tempLevelWindow.SetLevelWindow(level, *window);
     }
     else
     {
       level = newValue - m_LOWERTHRESHOLD +0.5;
       tempLevelWindow.SetLevelWindow(level, *window);
     }
 
     newNode->SetLevelWindow(tempLevelWindow, NULL, "levelwindow");
 
     if (m_UseVolumeRendering)
     this->UpdateVolumeRenderingThreshold((int) (level - 0.5));//lower threshold for labeled image
     newNode->SetVisibility(true);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::DecreaseSlider()
 {
   //moves the slider one step to the left, when the "-"-button is pressed
   if (this->m_Controls.m_PreviewSlider->value() != this->m_Controls.m_PreviewSlider->minimum())
   {
     int newValue = this->m_Controls.m_PreviewSlider->value() - 1;
     this->ChangeLevelWindow(newValue);
     this->m_Controls.m_PreviewSlider->setValue(newValue);
   }
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::IncreaseSlider()
 {
   //moves the slider one step to the right, when the "+"-button is pressed
   if (this->m_Controls.m_PreviewSlider->value() != this->m_Controls.m_PreviewSlider->maximum())
   {
     int newValue = this->m_Controls.m_PreviewSlider->value() + 1;
     this->ChangeLevelWindow(newValue);
     this->m_Controls.m_PreviewSlider->setValue(newValue);
   }
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::ConfirmSegmentation()
 {
   //get image node
   if(m_InputImageNode.IsNull())
   {
     QMessageBox::critical( NULL, "Adaptive region growing functionality", "Please specify the image in Datamanager!");
     return;
   }
   //get image data
   mitk::Image::Pointer orgImage = dynamic_cast<mitk::Image*> (m_InputImageNode->GetData());
   if(orgImage.IsNull())
   {
     QMessageBox::critical( NULL, "Adaptive region growing functionality", "No Image found!");
     return;
   }
   //get labeled segmentation
   mitk::Image::Pointer labeledSeg = (mitk::Image*)m_DataStorage->GetNamedObject<mitk::Image>(m_NAMEFORLABLEDSEGMENTATIONIMAGE);
   if(labeledSeg.IsNull())
   {
     QMessageBox::critical( NULL, "Adaptive region growing functionality", "No Segmentation Preview found!");
     return;
   }
 
   mitk::DataNode::Pointer newNode = m_DataStorage->GetNamedNode( m_NAMEFORLABLEDSEGMENTATIONIMAGE);
   if (newNode.IsNull())
     return;
 
   QmitkConfirmSegmentationDialog dialog;
   QString segName = QString::fromStdString(m_RegionGrow3DTool->GetCurrentSegmentationName());
 
   dialog.SetSegmentationName(segName);
   int result = dialog.exec();
 
   switch(result)
   {
   case QmitkConfirmSegmentationDialog::CREATE_NEW_SEGMENTATION:
     m_RegionGrow3DTool->SetOverwriteExistingSegmentation(false);
     break;
   case QmitkConfirmSegmentationDialog::OVERWRITE_SEGMENTATION:
     m_RegionGrow3DTool->SetOverwriteExistingSegmentation(true);
     break;
   case QmitkConfirmSegmentationDialog::CANCEL_SEGMENTATION:
     return;
   }
 
 
   mitk::Image* img = dynamic_cast<mitk::Image*>(newNode->GetData());
   AccessByItk(img, ITKThresholding);
 
   // disable volume rendering preview after the segmentation node was created
   this->EnableVolumeRendering(false);
   newNode->SetVisibility(false);
   m_Controls.m_cbVolumeRendering->setChecked(false);
   //TODO disable slider etc...
 }
 
 template<typename TPixel, unsigned int VImageDimension>
 void QmitkAdaptiveRegionGrowingToolGUI::ITKThresholding(itk::Image<TPixel, VImageDimension>* itkImage)
 {
   mitk::Image::Pointer originalSegmentation = dynamic_cast<mitk::Image*>(this->m_RegionGrow3DTool->
                                                                          GetTargetSegmentationNode()->GetData());
 
   int timeStep = mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1") )->GetTimeStep();
 
   if (originalSegmentation)
   {
     typedef itk::Image<TPixel, VImageDimension> InputImageType;
     typedef itk::Image<unsigned char, VImageDimension> SegmentationType;
 
 
     //select single 3D volume if we have more than one time step
     typename SegmentationType::Pointer originalSegmentationInITK = SegmentationType::New();
     if(originalSegmentation->GetTimeGeometry()->CountTimeSteps() > 1)
     {
       mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
       timeSelector->SetInput( originalSegmentation );
       timeSelector->SetTimeNr( timeStep );
       timeSelector->UpdateLargestPossibleRegion();
       CastToItkImage( timeSelector->GetOutput(), originalSegmentationInITK );
     }
     else //use original
     {
       CastToItkImage( originalSegmentation, originalSegmentationInITK );
     }
 
     //Fill current preiview image in segmentation image
     originalSegmentationInITK->FillBuffer(0);
     itk::ImageRegionIterator<SegmentationType> itOutput( originalSegmentationInITK, originalSegmentationInITK->GetLargestPossibleRegion() );
     itk::ImageRegionIterator<InputImageType> itInput( itkImage, itkImage->GetLargestPossibleRegion() );
     itOutput.GoToBegin();
     itInput.GoToBegin();
 
     //calculate threhold from slider value
     int currentTreshold = 0;
     if (m_CurrentRGDirectionIsUpwards)
     {
       currentTreshold = m_UPPERTHRESHOLD - m_Controls.m_PreviewSlider->value() + 1;
     }
     else
     {
       currentTreshold = m_Controls.m_PreviewSlider->value() - m_LOWERTHRESHOLD;
     }
 
     //iterate over image and set pixel in segmentation according to thresholded labeled image
     while( !itOutput.IsAtEnd() && !itInput.IsAtEnd() )
     {
       //Use threshold slider to determine if pixel is set to 1
       if( itInput.Value() != 0 && itInput.Value() > currentTreshold )
       {
         itOutput.Set( 1 );
       }
 
       ++itOutput;
       ++itInput;
     }
 
 
     //combine current working segmentation image with our region growing result
     originalSegmentation->SetVolume( (void*)(originalSegmentationInITK->GetPixelContainer()->GetBufferPointer()), timeStep);
 
     originalSegmentation->Modified();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::EnableControls(bool enable)
 {
   if (m_RegionGrow3DTool.IsNull())
     return;
 
   // Check if seed point is already set, if not leave RunSegmentation disabled
   //if even m_DataStorage is NULL leave node NULL
   mitk::DataNode::Pointer node = m_RegionGrow3DTool->GetPointSetNode();
   if (node.IsNull()) {
     this->m_Controls.m_pbRunSegmentation->setEnabled(false);
   }
   else
   {
     this->m_Controls.m_pbRunSegmentation->setEnabled(enable);
   }
 
   // Check if a segmentation exists, if not leave segmentation dependent disabled.
   //if even m_DataStorage is NULL leave node NULL
   node = m_DataStorage?m_DataStorage->GetNamedNode(m_NAMEFORLABLEDSEGMENTATIONIMAGE):NULL;
   if (node.IsNull())
   {
       this->m_Controls.m_PreviewSlider->setEnabled(false);
       this->m_Controls.m_pbConfirmSegementation->setEnabled(false);
   }
   else
   {
       this->m_Controls.m_PreviewSlider->setEnabled(enable);
       this->m_Controls.m_pbConfirmSegementation->setEnabled(enable);
   }
 
   this->m_Controls.m_cbVolumeRendering->setEnabled(enable);
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::EnableVolumeRendering(bool enable)
 {
   mitk::DataNode::Pointer node = m_DataStorage->GetNamedNode( m_NAMEFORLABLEDSEGMENTATIONIMAGE);
 
   if(node.IsNull())
     return;
 
   if(m_MultiWidget)
      m_MultiWidget->SetWidgetPlanesVisibility(!enable);
 
 
   if (enable)
   {
     node->SetBoolProperty("volumerendering", enable);
     node->SetBoolProperty("volumerendering.uselod", true);
   }
   else
   {
     node->SetBoolProperty("volumerendering", enable);
   }
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::UpdateVolumeRenderingThreshold(int thValue)
 {
   mitk::DataNode::Pointer node = m_DataStorage->GetNamedNode( m_NAMEFORLABLEDSEGMENTATIONIMAGE);
 
   mitk::TransferFunction::Pointer tf = mitk::TransferFunction::New();
 
   if (m_UpdateSuggestedThreshold)
   {
     m_SuggestedThValue = thValue;
     m_UpdateSuggestedThreshold = false;
   }
 
   // grayvalue->opacity
   {
     vtkPiecewiseFunction *f = tf->GetScalarOpacityFunction();
     f->RemoveAllPoints();
     f->AddPoint(0, 0);
     f->AddPoint(thValue+0.5, 0);
     f->AddPoint(thValue+1.5, 1);
     f->AddPoint(1000, 1);
     f->ClampingOn();
     f->Modified();
   }
 
   // grayvalue->color
   {
     float a = 255.0;
     vtkColorTransferFunction *ctf = tf->GetColorTransferFunction();
     ctf->RemoveAllPoints();
     //ctf->AddRGBPoint(-1000, 0.0, 0.0, 0.0);
     ctf->AddRGBPoint(m_SuggestedThValue+1, 203/a, 104/a, 102/a);
     ctf->AddRGBPoint(m_SuggestedThValue, 255/a, 0/a, 0/a);
     ctf->ClampingOn();
     ctf->Modified();
   }
 
   // GradientOpacityFunction
   {
     vtkPiecewiseFunction *gof = tf->GetGradientOpacityFunction();
     gof->RemoveAllPoints();
     gof->AddPoint(-10000, 1);
     gof->AddPoint(10000, 1);
     gof->ClampingOn();
     gof->Modified();
   }
 
   mitk::TransferFunctionProperty::Pointer tfp = mitk::TransferFunctionProperty::New();
   tfp->SetValue(tf);
   node->SetProperty("TransferFunction", tfp);
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::UseVolumeRendering(bool on)
 {
   m_UseVolumeRendering = on;
 
   this->EnableVolumeRendering(on);
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::SetLowerThresholdValue( double lowerThreshold )
 {
   m_LOWERTHRESHOLD = lowerThreshold;
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::SetUpperThresholdValue( double upperThreshold)
 {
   m_UPPERTHRESHOLD = upperThreshold;
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::Deactivated()
 {
   // make the segmentation preview node invisible
   mitk::DataNode::Pointer node = m_DataStorage->GetNamedNode( m_NAMEFORLABLEDSEGMENTATIONIMAGE);
   if( node.IsNotNull() )
   {
     node->SetVisibility(false);
   }
 
   // disable volume rendering preview after the segmentation node was created
   this->EnableVolumeRendering(false);
   m_Controls.m_cbVolumeRendering->setChecked(false);
 }
 
 void QmitkAdaptiveRegionGrowingToolGUI::Activated()
 {
 }
diff --git a/Modules/SurfaceInterpolation/mitkComputeContourSetNormalsFilter.cpp b/Modules/SurfaceInterpolation/mitkComputeContourSetNormalsFilter.cpp
index c0430028d5..fc82af9c03 100644
--- a/Modules/SurfaceInterpolation/mitkComputeContourSetNormalsFilter.cpp
+++ b/Modules/SurfaceInterpolation/mitkComputeContourSetNormalsFilter.cpp
@@ -1,321 +1,321 @@
 /*===================================================================
 
 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 "mitkComputeContourSetNormalsFilter.h"
 
 #include "mitkImagePixelReadAccessor.h"
 
 
 mitk::ComputeContourSetNormalsFilter::ComputeContourSetNormalsFilter()
 {
   m_MaxSpacing = 5;
   this->m_UseProgressBar = false;
   this->m_ProgressStepSize = 1;
 
   mitk::Surface::Pointer output = mitk::Surface::New();
   this->SetNthOutput(0, output.GetPointer());
 }
 
 mitk::ComputeContourSetNormalsFilter::~ComputeContourSetNormalsFilter()
 {
 }
 
 void mitk::ComputeContourSetNormalsFilter::GenerateData()
 {
   unsigned int numberOfInputs = this->GetNumberOfIndexedInputs();
   this->CreateOutputsForAllInputs(numberOfInputs);
 
   //Iterating over each input
   for(unsigned int i = 0; i < numberOfInputs; i++)
   {
     //Getting the inputs polydata and polygons
     Surface* currentSurface = const_cast<Surface*>( this->GetInput(i) );
     vtkPolyData* polyData = currentSurface->GetVtkPolyData();
 
     vtkSmartPointer<vtkCellArray> existingPolys = polyData->GetPolys();
 
     vtkSmartPointer<vtkPoints> existingPoints = polyData->GetPoints();
 
     existingPolys->InitTraversal();
 
     vtkIdType* cell (NULL);
     vtkIdType cellSize (0);
 
     //The array that contains all the vertex normals of the current polygon
     vtkSmartPointer<vtkDoubleArray> normals = vtkSmartPointer<vtkDoubleArray>::New();
     normals->SetNumberOfComponents(3);
     normals->SetNumberOfTuples(polyData->GetNumberOfPoints());
 
     //If the current contour is an inner contour then the direction is -1
     //A contour lies inside another one if the pixel values in the direction of the normal is 1
     m_NegativeNormalCounter = 0;
     m_PositiveNormalCounter = 0;
     vtkIdType offSet (0);
 
     //Iterating over each polygon
     for( existingPolys->InitTraversal(); existingPolys->GetNextCell(cellSize, cell);)
     {
       if(cellSize < 3)continue;
 
       //First we calculate the current polygon's normal
       double polygonNormal[3] = {0.0};
 
       double p1[3];
       double p2[3];
 
       double v1[3];
       double v2[3];
 
       existingPoints->GetPoint(cell[0], p1);
       unsigned int index = cellSize*0.5;
       existingPoints->GetPoint(cell[index], p2);
 
       v1[0] = p2[0]-p1[0];
       v1[1] = p2[1]-p1[1];
       v1[2] = p2[2]-p1[2];
 
       for (vtkIdType k = 2; k < cellSize; k++)
       {
         index = cellSize*0.25;
         existingPoints->GetPoint(cell[index], p1);
         index = cellSize*0.75;
         existingPoints->GetPoint(cell[index], p2);
 
         v2[0] = p2[0]-p1[0];
         v2[1] = p2[1]-p1[1];
         v2[2] = p2[2]-p1[2];
 
         vtkMath::Cross(v1,v2,polygonNormal);
         if (vtkMath::Norm(polygonNormal) != 0)
           break;
       }
 
       vtkMath::Normalize(polygonNormal);
 
       //Now we start computing the normal for each vertex
 
       double vertexNormalTemp[3];
       existingPoints->GetPoint(cell[0], p1);
       existingPoints->GetPoint(cell[1], p2);
 
       v1[0] = p2[0]-p1[0];
       v1[1] = p2[1]-p1[1];
       v1[2] = p2[2]-p1[2];
 
       vtkMath::Cross(v1,polygonNormal,vertexNormalTemp);
 
       vtkMath::Normalize(vertexNormalTemp);
 
       double vertexNormal[3];
 
       for (vtkIdType j = 0; j < cellSize-2; j++)
       {
         existingPoints->GetPoint(cell[j+1], p1);
         existingPoints->GetPoint(cell[j+2], p2);
 
         v1[0] = p2[0]-p1[0];
         v1[1] = p2[1]-p1[1];
         v1[2] = p2[2]-p1[2];
 
         vtkMath::Cross(v1,polygonNormal,vertexNormal);
 
         vtkMath::Normalize(vertexNormal);
 
         double finalNormal[3];
 
         finalNormal[0] = (vertexNormal[0] + vertexNormalTemp[0])*0.5;
         finalNormal[1] = (vertexNormal[1] + vertexNormalTemp[1])*0.5;
         finalNormal[2] = (vertexNormal[2] + vertexNormalTemp[2])*0.5;
 
         //Here we determine the direction of the normal
         if (m_SegmentationBinaryImage)
         {
           Point3D worldCoord;
           worldCoord[0] = p1[0]+finalNormal[0]*m_MaxSpacing;
           worldCoord[1] = p1[1]+finalNormal[1]*m_MaxSpacing;
           worldCoord[2] = p1[2]+finalNormal[2]*m_MaxSpacing;
 
           double val = 0.0;
           mitk::ImagePixelReadAccessor<unsigned char> readAccess(m_SegmentationBinaryImage);
-          mitk::Index3D idx;
+          itk::Index<3> idx;
           m_SegmentationBinaryImage->GetGeometry()->WorldToIndex(worldCoord, idx);
           val = readAccess.GetPixelByIndexSafe(idx);
 
           if (val == 0.0)
           {
               ++m_PositiveNormalCounter;
           }
           else
           {
               ++m_NegativeNormalCounter;
           }
         }
 
         vertexNormalTemp[0] = vertexNormal[0];
         vertexNormalTemp[1] = vertexNormal[1];
         vertexNormalTemp[2] = vertexNormal[2];
 
         vtkIdType id = cell[j+1];
         normals->SetTuple(id,finalNormal);
       }
 
       existingPoints->GetPoint(cell[0], p1);
       existingPoints->GetPoint(cell[1], p2);
 
       v1[0] = p2[0]-p1[0];
       v1[1] = p2[1]-p1[1];
       v1[2] = p2[2]-p1[2];
 
       vtkMath::Cross(v1,polygonNormal,vertexNormal);
 
       vtkMath::Normalize(vertexNormal);
 
       vertexNormal[0] = (vertexNormal[0] + vertexNormalTemp[0])*0.5;
       vertexNormal[1] = (vertexNormal[1] + vertexNormalTemp[1])*0.5;
       vertexNormal[2] = (vertexNormal[2] + vertexNormalTemp[2])*0.5;
 
       vtkIdType id = cell[0];
       normals->SetTuple(id,vertexNormal);
       id = cell[cellSize-1];
       normals->SetTuple(id,vertexNormal);
 
       if(m_NegativeNormalCounter > m_PositiveNormalCounter)
       {
           for(vtkIdType n = 0; n < cellSize; n++)
           {
               double normal[3];
               normals->GetTuple(offSet+n, normal);
               normal[0] = (-1)*normal[0];
               normal[1] = (-1)*normal[1];
               normal[2] = (-1)*normal[2];
               normals->SetTuple(offSet+n, normal);
           }
       }
 
       m_NegativeNormalCounter = 0;
       m_PositiveNormalCounter = 0;
       offSet += cellSize;
 
 
     }//end for all cells
 
     Surface::Pointer surface = this->GetOutput(i);
     surface->GetVtkPolyData()->GetCellData()->SetNormals(normals);
   }//end for all inputs
 
   //Setting progressbar
   if (this->m_UseProgressBar)
     mitk::ProgressBar::GetInstance()->Progress(this->m_ProgressStepSize);
 }
 
 
 mitk::Surface::Pointer mitk::ComputeContourSetNormalsFilter::GetNormalsAsSurface()
 {
   //Just for debugging:
   vtkSmartPointer<vtkPolyData> newPolyData = vtkSmartPointer<vtkPolyData>::New();
   vtkSmartPointer<vtkCellArray> newLines = vtkSmartPointer<vtkCellArray>::New();
   vtkSmartPointer<vtkPoints> newPoints = vtkSmartPointer<vtkPoints>::New();
   unsigned int idCounter (0);
   //Debug end
 
   for (unsigned int i = 0; i < this->GetNumberOfIndexedOutputs(); i++)
   {
     Surface* currentSurface = const_cast<Surface*>( this->GetOutput(i) );
     vtkPolyData* polyData = currentSurface->GetVtkPolyData();
 
     vtkSmartPointer<vtkDoubleArray> currentCellNormals = vtkDoubleArray::SafeDownCast(polyData->GetCellData()->GetNormals());
 
     vtkSmartPointer<vtkCellArray> existingPolys = polyData->GetPolys();
 
     vtkSmartPointer<vtkPoints> existingPoints = polyData->GetPoints();
 
     existingPolys->InitTraversal();
 
     vtkIdType* cell (NULL);
     vtkIdType cellSize (0);
 
     for( existingPolys->InitTraversal(); existingPolys->GetNextCell(cellSize, cell);)
     {
       for ( vtkIdType j = 0; j < cellSize; j++ )
       {
         double currentNormal[3];
         currentCellNormals->GetTuple(cell[j], currentNormal);
         vtkSmartPointer<vtkLine> line = vtkSmartPointer<vtkLine>::New();
         line->GetPointIds()->SetNumberOfIds(2);
         double newPoint[3];
         double p0[3];
         existingPoints->GetPoint(cell[j], p0);
         newPoint[0] = p0[0] + currentNormal[0];
         newPoint[1] = p0[1] + currentNormal[1];
         newPoint[2] = p0[2] + currentNormal[2];
 
         line->GetPointIds()->SetId(0, idCounter);
         newPoints->InsertPoint(idCounter, p0);
         idCounter++;
 
         line->GetPointIds()->SetId(1, idCounter);
         newPoints->InsertPoint(idCounter, newPoint);
         idCounter++;
 
         newLines->InsertNextCell(line);
       }//end for all points
     }//end for all cells
   }//end for all outputs
 
   newPolyData->SetPoints(newPoints);
   newPolyData->SetLines(newLines);
   newPolyData->BuildCells();
 
 
   mitk::Surface::Pointer surface = mitk::Surface::New();
   surface->SetVtkPolyData(newPolyData);
 
   return surface;
 
 }
 
 void mitk::ComputeContourSetNormalsFilter::SetMaxSpacing(double maxSpacing)
 {
     m_MaxSpacing = maxSpacing;
 }
 
 void mitk::ComputeContourSetNormalsFilter::GenerateOutputInformation()
 {
   Superclass::GenerateOutputInformation();
 }
 
 void mitk::ComputeContourSetNormalsFilter::Reset()
 {
   for (unsigned int i = 0; i < this->GetNumberOfIndexedInputs(); i++)
   {
     this->PopBackInput();
   }
   this->SetNumberOfIndexedInputs(0);
   this->SetNumberOfIndexedOutputs(0);
 
   mitk::Surface::Pointer output = mitk::Surface::New();
   this->SetNthOutput(0, output.GetPointer());
 }
 
 void mitk::ComputeContourSetNormalsFilter::SetUseProgressBar(bool status)
 {
   this->m_UseProgressBar = status;
 }
 
 void mitk::ComputeContourSetNormalsFilter::SetProgressStepSize(unsigned int stepSize)
 {
   this->m_ProgressStepSize = stepSize;
 }
diff --git a/Modules/ToFProcessing/Testing/mitkToFCompositeFilterTest.cpp b/Modules/ToFProcessing/Testing/mitkToFCompositeFilterTest.cpp
index eef518f2b9..a04b4e4cf2 100644
--- a/Modules/ToFProcessing/Testing/mitkToFCompositeFilterTest.cpp
+++ b/Modules/ToFProcessing/Testing/mitkToFCompositeFilterTest.cpp
@@ -1,380 +1,380 @@
 /*===================================================================
 
 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 <mitkToFCompositeFilter.h>
 
 #include <mitkImage.h>
 #include <mitkImageCast.h>
 #include <itkBilateralImageFilter.h>
 #include <mitkToFProcessingCommon.h>
 #include <itkThresholdImageFilter.h>
 #include <itkImageRegionIterator.h>
 #include <itkMersenneTwisterRandomVariateGenerator.h>
 #include <mitkToFCompositeFilter.h>
 #include <itkMedianImageFilter.h>
 #include <mitkImagePixelReadAccessor.h>
 
 
 /**Documentation
 *  \brief test for the class "ToFCompositeFilter".
 *
 * Manually create filter pipeline and check if it is equivalent to composite filter
 */
 
 typedef mitk::ToFProcessingCommon::ToFPoint2D ToFPoint2D;
 typedef mitk::ToFProcessingCommon::ToFScalarType ToFScalarType;
 typedef itk::Image<ToFScalarType,2> ItkImageType_2D;
 typedef itk::Image<ToFScalarType,3> ItkImageType_3D;
 typedef itk::ImageRegionIterator<ItkImageType_2D> ItkImageRegionIteratorType2D;
 typedef itk::ImageRegionIterator<ItkImageType_3D> ItkImageRegionIteratorType3D;
 typedef itk::BilateralImageFilter<ItkImageType_2D,ItkImageType_2D> BilateralImageFilterType;
 typedef itk::ThresholdImageFilter<ItkImageType_2D> ThresholdFilterType;
 typedef itk::MedianImageFilter<ItkImageType_2D,ItkImageType_2D> MedianFilterType;
 
 
 static bool ApplyTemporalMedianFilter(mitk::Image::Pointer& image, ItkImageType_2D::Pointer& itkImage2D)
 {
 
   //initialize ITK output image
   unsigned int dimX = image->GetDimension(0);
   unsigned int dimY = image->GetDimension(1);
   unsigned int nbSlices = image->GetDimension(2);
 
   ItkImageType_2D::SizeType size;
   size[0] = dimX;
   size[1] = dimY;
 
   ItkImageType_2D::RegionType region;
   region.SetSize(size);
 
   ItkImageType_2D::SpacingType spacing;
   spacing[0] = 1.0;
   spacing[1] = 1.0;
 
   itkImage2D->SetRegions( region );
   itkImage2D->SetSpacing ( spacing );
   itkImage2D->Allocate();
 
   //initialize median filtering
   std::vector<ToFScalarType> allDistances;
-  mitk::Index3D curIdx3D;
+  itk::Index<3> curIdx3D;
   ItkImageType_2D::IndexType curIdx2D;
 
   //compute median over time for each (x,y)
   for(unsigned int i = 0; i<dimX; i++)
   {
     for(unsigned int j = 0; j < dimY; j++)
     {
       allDistances.clear();
 
       curIdx3D[0] = i; curIdx3D[1] = j;
       curIdx2D[0] = i; curIdx2D[1] = j;
       //gather all distances for one pixel
       mitk::ImagePixelReadAccessor<ToFScalarType,3> imageAcces(image, image->GetVolumeData());
       for(unsigned int k = 0; k < nbSlices; k++)
       {
         curIdx3D[2] = k;
         allDistances.push_back(imageAcces.GetPixelByIndex(curIdx3D));
       }
 
       //sort distances and compute median
       std::sort(allDistances.begin(),allDistances.end());
       unsigned int median_idx = nbSlices/2;
       if(nbSlices%2 == 1) //i.e., there is an odd number of slices
       {
         itkImage2D->SetPixel(curIdx2D,allDistances[median_idx]);
       } else
       {
         ToFScalarType upper = allDistances[median_idx];
         ToFScalarType lower = allDistances[median_idx+1];
         itkImage2D->SetPixel(curIdx2D,(upper+lower)/2.0);
       }
     }
   }
   return true;
 
 }
 
 static bool CompareImages(mitk::Image::Pointer image1, mitk::Image::Pointer image2)
 {
 
   unsigned int dimX = image1->GetDimension(0);
   unsigned int dimY = image1->GetDimension(1);
 
   //make sure images have the same dimensions
   if((dimX != image1->GetDimension(0)) || (dimY != image1->GetDimension(1)))
     return false;
 
   //compare all pixel values
   mitk::ImagePixelReadAccessor<ToFScalarType,2> image1Acces(image1, image1->GetSliceData(0));
   mitk::ImagePixelReadAccessor<ToFScalarType,2> image2Acces(image2, image2->GetSliceData(0));
   for(unsigned int i = 0; i<dimX; i++)
   {
     for(unsigned int j = 0; j < dimY; j++)
     {
       itk::Index<2> idx;
       idx[0] = i; idx[1] = j;
       if(!(mitk::Equal(image1Acces.GetPixelByIndex(idx), image2Acces.GetPixelByIndex(idx))))
       {
         return false;
       }
 
     }
   }
 
   //all pixels have identical values
   return true;
 }
 
 bool CreateRandomDistanceImage(unsigned int dimX, unsigned int dimY, ItkImageType_2D::Pointer& itkImage, mitk::Image::Pointer& mitkImage) //TODO warum ITK image?
 {
 
   //initialize ITK output image
   ItkImageType_2D::IndexType start;
   start[0] = 0;
   start[1] = 0;
   ItkImageType_2D::SizeType size;
   size[0] = dimX;
   size[1] = dimY;
   ItkImageType_2D::RegionType region;
   region.SetSize(size);
   region.SetIndex( start);
   ItkImageType_2D::SpacingType spacing;
   spacing[0] = 1.0;
   spacing[1] = 1.0;
 
   itkImage->SetRegions( region );
   itkImage->SetSpacing ( spacing );
   itkImage->Allocate();
 
 
   ItkImageRegionIteratorType2D imageIterator(itkImage,itkImage->GetLargestPossibleRegion());
   imageIterator.GoToBegin();
   itk::Statistics::MersenneTwisterRandomVariateGenerator::Pointer randomGenerator = itk::Statistics::MersenneTwisterRandomVariateGenerator::New();
 
 
   while (!imageIterator.IsAtEnd())
   {
     ToFScalarType pixelValue = randomGenerator->GetUniformVariate(0.0,1000.0);
     imageIterator.Set(pixelValue);
     ++imageIterator;
   }
 
   mitk::CastToMitkImage(itkImage,mitkImage);
 
   return true;
 }
 
 
 bool CreateRandomDistanceImageStack(unsigned int dimX, unsigned int dimY, unsigned int nbSlices, ItkImageType_3D::Pointer& itkImage, mitk::Image::Pointer& mitkImage)
 {
   //initialize ITK output image
   ItkImageType_3D::IndexType start;
   start[0] = 0;
   start[1] = 0;
   start[1] = 0;
   ItkImageType_3D::SizeType size;
   size[0] = dimX;
   size[1] = dimY;
   size[2] = nbSlices;
   ItkImageType_3D::RegionType region;
   region.SetSize(size);
   region.SetIndex( start);
   ItkImageType_3D::SpacingType spacing;
   spacing[0] = 1.0;
   spacing[1] = 1.0;
   spacing[2] = 1.0;
 
   itkImage->SetRegions( region );
   itkImage->SetSpacing ( spacing );
   itkImage->Allocate();
 
 
   //assign random pixel values
   ItkImageRegionIteratorType3D imageIterator(itkImage,itkImage->GetLargestPossibleRegion());
   imageIterator.GoToBegin();
   itk::Statistics::MersenneTwisterRandomVariateGenerator::Pointer randomGenerator = itk::Statistics::MersenneTwisterRandomVariateGenerator::New();
 
 
   while (!imageIterator.IsAtEnd())
   {
     ToFScalarType pixelValue = randomGenerator->GetUniformVariate(0.0,1000.0);
     imageIterator.Set(pixelValue);
     ++imageIterator;
   }
 
   //cast to MITK image
   mitk::CastToMitkImage(itkImage,mitkImage);
 
   return true;
 }
 
 
 int mitkToFCompositeFilterTest(int /* argc */, char* /*argv*/[])
 {
   MITK_TEST_BEGIN("ToFCompositeFilter");
 
   //initialize composite filter
   mitk::ToFCompositeFilter::Pointer compositeFilter = mitk::ToFCompositeFilter::New();
 
   //Initialize threshold filter
   ThresholdFilterType::Pointer thresholdFilter = ThresholdFilterType::New();
   int threshold_min = 5;
   int threshold_max = 100;
   thresholdFilter->SetOutsideValue(0.0);
   thresholdFilter->SetLower(threshold_min);
   thresholdFilter->SetUpper(threshold_max);
   compositeFilter->SetThresholdFilterParameter(threshold_min, threshold_max);
 
   //Initialize spatial median filter
   MedianFilterType::Pointer medianFilter = MedianFilterType::New();
 
   //Initialize bilateral filter
   BilateralImageFilterType::Pointer bilateralFilter = BilateralImageFilterType::New();
   float domainSigma = 4;
   float rangeSigma = 50;
   float kernelRadius = 3;
   bilateralFilter->SetDomainSigma(domainSigma);
   bilateralFilter->SetRangeSigma(rangeSigma);
   bilateralFilter->SetRadius(kernelRadius);
   compositeFilter->SetBilateralFilterParameter(domainSigma,rangeSigma,kernelRadius);
 
   //Initialize pipeline
   ItkImageType_2D::Pointer itkInputImage = ItkImageType_2D::New();
   mitk::Image::Pointer mitkInputImage = mitk::Image::New();
   CreateRandomDistanceImage(100,100,itkInputImage,mitkInputImage);
   ItkImageType_2D::Pointer itkOutputImage;
   compositeFilter->SetInput(mitkInputImage);
   mitk::Image::Pointer mitkOutputImage = compositeFilter->GetOutput();
 
 
   //-------------------------------------------------------------------------------------------------------
 
   //Apply first filter only (threshold)
 
   //standard variant
   thresholdFilter->SetInput(itkInputImage);
   itkOutputImage = thresholdFilter->GetOutput();
   itkOutputImage->Update();
 
   //variant with composite filter
   compositeFilter->SetApplyThresholdFilter(true);
   compositeFilter->SetApplyMedianFilter(false);
   compositeFilter->SetApplyTemporalMedianFilter(false);
   compositeFilter->SetApplyBilateralFilter(false);
   mitkOutputImage->Update();
 
   //compare output
   mitk::Image::Pointer itkOutputImageConverted;
   mitk::CastToMitkImage(itkOutputImage,itkOutputImageConverted);
 
   bool pipelineSuccess = CompareImages(itkOutputImageConverted,mitkOutputImage);
   MITK_TEST_CONDITION_REQUIRED(pipelineSuccess,"Test threshold filter in pipeline");
 
   //-------------------------------------------------------------------------------------------------------
 
   //Apply first and second filter
 
   //standard variant
   medianFilter->SetInput(thresholdFilter->GetOutput());
   itkOutputImage = medianFilter->GetOutput();
   itkOutputImage->Update();
 
   //variant with composite filter
   compositeFilter->SetApplyMedianFilter(true);
   mitkOutputImage->Update();
 
   //compare output
   mitk::CastToMitkImage(itkOutputImage,itkOutputImageConverted);
 
   pipelineSuccess = CompareImages(itkOutputImageConverted,mitkOutputImage);
   MITK_TEST_CONDITION_REQUIRED(pipelineSuccess,"Test threshold and median filter in pipeline");
 
 
   //-------------------------------------------------------------------------------------------------------
 
   //Apply first three filters
 
   //standard variant
   bilateralFilter->SetInput(medianFilter->GetOutput());
   itkOutputImage = bilateralFilter->GetOutput();
   itkOutputImage->Update();
 
   //variant with composite filter
   compositeFilter->SetApplyBilateralFilter(true);
   mitkOutputImage->Update();
 
   //compare output
   mitk::CastToMitkImage(itkOutputImage,itkOutputImageConverted);
 
   pipelineSuccess = CompareImages(itkOutputImageConverted,mitkOutputImage);
   MITK_TEST_CONDITION_REQUIRED(pipelineSuccess,"Test threshold filter, bilateral filter and temporal median filter in pipeline");
 
 
   //-------------------------------------------------------------------------------------------------------
 
   //Apply all filters
 
   //generate image stack
   ItkImageType_3D::Pointer itkInputImage3D = ItkImageType_3D::New();
   mitk::Image::Pointer mitkImage3D = mitk::Image::New();
   CreateRandomDistanceImageStack(100,100,12,itkInputImage3D,mitkImage3D);
 
   //standard variant
   ItkImageType_2D::Pointer medianFilteredImage = ItkImageType_2D::New();
   ApplyTemporalMedianFilter(mitkImage3D,medianFilteredImage);
   thresholdFilter->SetInput(medianFilteredImage);
   itkOutputImage->Update();
 
   //variant with composite filter
   compositeFilter->SetApplyTemporalMedianFilter(true);
   mitkOutputImage->Update();
 
   //compare output
   mitk::CastToMitkImage(itkOutputImage,itkOutputImageConverted);
   pipelineSuccess = CompareImages(itkOutputImageConverted,mitkOutputImage);
   MITK_TEST_CONDITION_REQUIRED(pipelineSuccess,"Test all filters in pipeline");
 
 
 //-------------------------------------------------------------------------------------------------------
 
   //Check set/get functions
   mitk::Image::Pointer newImage = mitk::Image::New();
   mitk::Image::Pointer returnedImage;
   compositeFilter->SetInput(newImage);
   returnedImage = compositeFilter->GetInput();
   MITK_TEST_CONDITION_REQUIRED(newImage == returnedImage,"Get/Set empty image");
 
   compositeFilter->SetApplyTemporalMedianFilter(false);
   MITK_TEST_CONDITION_REQUIRED(compositeFilter->GetApplyTemporalMedianFilter()==false,"Get/Set ApplyTemporalMedianFilter");
 
   compositeFilter->SetApplyMedianFilter(false);
   MITK_TEST_CONDITION_REQUIRED(compositeFilter->GetApplyMedianFilter()==false,"Get/Set ApplyMedianFilter");
 
   compositeFilter->SetApplyThresholdFilter(false);
   MITK_TEST_CONDITION_REQUIRED(compositeFilter->GetApplyThresholdFilter()==false,"Get/Set ApplyThresholdFilter");
 
   compositeFilter->SetApplyBilateralFilter(false);
   MITK_TEST_CONDITION_REQUIRED(compositeFilter->GetApplyBilateralFilter()==false,"Get/Set ApplyBilateralFilter");
 
 //-------------------------------------------------------------------------------------------------------
 
   MITK_TEST_END();
 
 }
 
 
diff --git a/Modules/ToFProcessing/Testing/mitkToFDistanceImageToPointSetFilterTest.cpp b/Modules/ToFProcessing/Testing/mitkToFDistanceImageToPointSetFilterTest.cpp
index 3af33a2480..1a95da350f 100644
--- a/Modules/ToFProcessing/Testing/mitkToFDistanceImageToPointSetFilterTest.cpp
+++ b/Modules/ToFProcessing/Testing/mitkToFDistanceImageToPointSetFilterTest.cpp
@@ -1,346 +1,346 @@
 /*===================================================================
 
 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 <mitkToFDistanceImageToPointSetFilter.h>
 #include <mitkToFDistanceImageToSurfaceFilter.h>
 
 #include <mitkImage.h>
 #include <mitkPointSet.h>
 #include <mitkSurface.h>
 #include <mitkToFProcessingCommon.h>
 #include <mitkToFTestingCommon.h>
 #include <mitkTypes.h>
 #include <mitkImagePixelReadAccessor.h>
 
 #include <itkImage.h>
 #include <itkImageRegionIterator.h>
 
 #include <vtkPolyData.h>
 
 /**Documentation
 *  test for the class "ToFDistanceImageToPointSetFilter".
 */
 mitk::PointSet::Pointer CreateTestPointSet()
 {
   mitk::PointSet::Pointer subSet = mitk::PointSet::New();
   mitk::Point3D point;
   point[0] = 10;
   point[1] = 20;
   point[2] = 0;
   subSet->InsertPoint(0,point);
   point[0] = 100;
   point[1] = 150;
   point[2] = 0;
   subSet->InsertPoint(1,point);
   point[0] = 110;
   point[1] = 30;
   point[2] = 0;
   subSet->InsertPoint(2,point);
   point[0] = 40;
   point[1] = 200;
   point[2] = 0;
   subSet->InsertPoint(3,point);
   return subSet;
 }
 
-std::vector<mitk::Index3D> CreateVectorPointSet()
+std::vector<itk::Index<3>> CreateVectorPointSet()
 {
-  std::vector<mitk::Index3D> subSet = std::vector<mitk::Index3D>();
-  mitk::Index3D point;
+  std::vector<itk::Index<3>> subSet = std::vector<itk::Index<3>>();
+  itk::Index<3> point;
   point[0] = 10;
   point[1] = 20;
   point[2] = 0;
   subSet.push_back(point);
   point[0] = 100;
   point[1] = 150;
   point[2] = 0;
   subSet.push_back(point);
   point[0] = 110;
   point[1] = 30;
   point[2] = 0;
   subSet.push_back(point);
   point[0] = 40;
   point[1] = 200;
   point[2] = 0;
   subSet.push_back(point);
   return subSet;
 }
 
 // Create image with pixelValue in every pixel except for the pixels in subSet, which get successively the values of distances
 inline static mitk::Image::Pointer CreateTestImageWithPointSet(float pixelValue, unsigned int dimX, unsigned int dimY, mitk::PointSet::Pointer subSet)
 {
   typedef itk::Image<float,2> ItkImageType2D;
   typedef itk::ImageRegionIterator<ItkImageType2D> ItkImageRegionIteratorType2D;
 
   ItkImageType2D::Pointer image = ItkImageType2D::New();
   ItkImageType2D::IndexType start;
   start[0] = 0;
   start[1] = 0;
   ItkImageType2D::SizeType size;
   size[0] = dimX;
   size[1] = dimY;
   ItkImageType2D::RegionType region;
   region.SetSize(size);
   region.SetIndex( start);
   ItkImageType2D::SpacingType spacing;
   spacing[0] = 1.0;
   spacing[1] = 1.0;
 
   image->SetRegions( region );
   image->SetSpacing ( spacing );
   image->Allocate();
 
   //Obtaining image data from ToF camera//
 
   //Correlate inten values to PixelIndex//
   ItkImageRegionIteratorType2D imageIterator(image,image->GetLargestPossibleRegion());
   imageIterator.GoToBegin();
 
   while (!imageIterator.IsAtEnd())
   {
     imageIterator.Set(pixelValue);
     ++imageIterator;
   }
   // distances varying from pixelValue
   std::vector<float> distances;
   distances.push_back(50);
   distances.push_back(500);
   distances.push_back(2050);
   distances.push_back(300);
   // set the pixel values for the subset
   for(int i=0; i<subSet->GetSize(); i++)
   {
     mitk::Point3D point = subSet->GetPoint(i);
     ItkImageType2D::IndexType index;
     index[0] = point[0];
     index[1] = point[1];
     float distance = distances.at(i);
     image->SetPixel(index,distance);
   }
   mitk::Image::Pointer mitkImage = mitk::Image::New();
   mitk::CastToMitkImage(image,mitkImage);
   return mitkImage;
 }
 
 int mitkToFDistanceImageToPointSetFilterTest(int /* argc */, char* /*argv*/[])
 {
   MITK_TEST_BEGIN("ToFDistanceImageToPointSetFilter");
 
   mitk::ToFDistanceImageToPointSetFilter::Pointer filter = mitk::ToFDistanceImageToPointSetFilter::New();
   //create test sub set
   MITK_INFO<<"Create test pointset";
   mitk::PointSet::Pointer subSet = CreateTestPointSet();
   //create test image
   unsigned int dimX = 204;
   unsigned int dimY = 204;
   MITK_INFO<<"Create test image";
   mitk::Image::Pointer image = CreateTestImageWithPointSet(1000.0f,dimX,dimY,subSet);
   //initialize intrinsic parameters
   //initialize intrinsic parameters with some arbitrary values
   mitk::ToFProcessingCommon::ToFPoint2D interPixelDistance;
   interPixelDistance[0] = 0.04564;
   interPixelDistance[1] = 0.0451564;
 
   mitk::ToFProcessingCommon::ToFScalarType focalLengthX = 295.78960;
   mitk::ToFProcessingCommon::ToFScalarType focalLengthY = 296.348535;
 
   mitk::ToFProcessingCommon::ToFScalarType focalLength = (focalLengthX*interPixelDistance[0]+focalLengthY*interPixelDistance[1])/2.0;
   mitk::ToFProcessingCommon::ToFScalarType k1=-0.36,k2=-0.14,p1=0.001,p2=-0.00;
 
   mitk::ToFProcessingCommon::ToFPoint2D principalPoint;
   principalPoint[0] = 103.576546;
   principalPoint[1] = 100.1532;
 
   mitk::CameraIntrinsics::Pointer cameraIntrinsics = mitk::CameraIntrinsics::New();
   cameraIntrinsics->SetFocalLength(focalLengthX,focalLengthY);
   cameraIntrinsics->SetPrincipalPoint(principalPoint[0],principalPoint[1]);
   cameraIntrinsics->SetDistorsionCoeffs(k1,k2,p1,p2);
 
   // test SetCameraIntrinsics()
   filter->SetCameraIntrinsics(cameraIntrinsics);
   MITK_TEST_CONDITION_REQUIRED((focalLengthX==filter->GetCameraIntrinsics()->GetFocalLengthX()),"Testing SetCameraIntrinsics with focalLength");
   mitk::ToFProcessingCommon::ToFPoint2D pp;
   pp[0] = filter->GetCameraIntrinsics()->GetPrincipalPointX();
   pp[1] = filter->GetCameraIntrinsics()->GetPrincipalPointY();
   MITK_TEST_CONDITION_REQUIRED(mitk::Equal(principalPoint,pp),"Testing SetCameraIntrinsics with principalPoint()");
 
   // test SetInterPixelDistance()
   filter->SetInterPixelDistance(interPixelDistance);
   mitk::ToFProcessingCommon::ToFPoint2D ipD = filter->GetInterPixelDistance();
   MITK_TEST_CONDITION_REQUIRED(mitk::Equal(ipD,interPixelDistance),"Testing Set/GetInterPixelDistance()");
 
   // test SetReconstructionMode()
   filter->SetReconstructionMode(false);
   MITK_TEST_CONDITION_REQUIRED(filter->GetReconstructionMode() == false,"Testing Set/GetReconstructionMode()");
 
   // test Set/GetInput()
   filter->SetInput(image);
   MITK_TEST_CONDITION_REQUIRED((image==filter->GetInput()),"Testing Set/GetInput()");
 
 
   // test filter without subset (without using the interpixeldistance)
   MITK_INFO<<"Test filter without subset without using the interpixeldistance";
   filter->SetReconstructionMode(true);
   mitk::PointSet::Pointer expectedResult = mitk::PointSet::New();
   unsigned int counter = 0;
   mitk::ImagePixelReadAccessor<float,2> imageAcces(image, image->GetSliceData(0));
   for (unsigned int j=0; j<dimY; j++)
   {
     for (unsigned int i=0; i<dimX; i++)
     {
       itk::Index<2> index;
       index[0] = i;
       index[1] = j;
       float distance = imageAcces.GetPixelByIndex(index);
       mitk::Point3D coordinate = mitk::ToFProcessingCommon::IndexToCartesianCoordinates(i,j,distance,focalLengthX,focalLengthY,principalPoint[0],principalPoint[1]);
       expectedResult->InsertPoint(counter,coordinate);
       counter++;
     }
   }
   filter->Update();
   mitk::PointSet::Pointer result = filter->GetOutput();
   MITK_TEST_CONDITION_REQUIRED((expectedResult->GetSize()==result->GetSize()),"Test if point set size is equal");
   MITK_TEST_CONDITION_REQUIRED(mitk::ToFTestingCommon::PointSetsEqual(expectedResult,result),"Testing filter without subset");
 
   // compare filter result with ToFDistanceImageToSurfaceFilter
   MITK_INFO<<"Compare filter result with ToFDistanceImageToSurfaceFilter";
   mitk::ToFDistanceImageToSurfaceFilter::Pointer surfaceFilter = mitk::ToFDistanceImageToSurfaceFilter::New();
   surfaceFilter->SetInput(image);
   surfaceFilter->SetInterPixelDistance(interPixelDistance);
   surfaceFilter->SetCameraIntrinsics(cameraIntrinsics);
   surfaceFilter->SetReconstructionMode(mitk::ToFDistanceImageToSurfaceFilter::WithOutInterPixelDistance);
   MITK_TEST_CONDITION_REQUIRED(filter->GetReconstructionMode() == mitk::ToFDistanceImageToSurfaceFilter::WithOutInterPixelDistance,"Testing Set/GetReconstructionMode()");
   mitk::Surface::Pointer surface = surfaceFilter->GetOutput();
   surface->Update();
   // create point set from surface
   mitk::PointSet::Pointer pointSet = mitk::ToFTestingCommon::VtkPolyDataToMitkPointSet(surface->GetVtkPolyData());
   //compare pointset against ground truth
   MITK_TEST_CONDITION_REQUIRED((pointSet->GetSize()==result->GetSize()),"Test if point set size is equal");
   MITK_TEST_CONDITION_REQUIRED(mitk::ToFTestingCommon::PointSetsEqual(pointSet,result),"Compare with surface points");
 
   // test filter without subset (with using the interpixeldistance)
   MITK_INFO<<"Test filter without subset with using the interpixeldistance";
   filter->Modified();
   filter->SetReconstructionMode(false);
   expectedResult = mitk::PointSet::New();
   counter = 0;
   for (unsigned int j=0; j<dimY; j++)
   {
     for (unsigned int i=0; i<dimX; i++)
     {
       itk::Index<2> index;
       index[0] = i;
       index[1] = j;
       float distance = imageAcces.GetPixelByIndex(index);
       mitk::Point3D coordinate = mitk::ToFProcessingCommon::IndexToCartesianCoordinatesWithInterpixdist(i,j,distance,focalLength,interPixelDistance,principalPoint);
       expectedResult->InsertPoint(counter,coordinate);
       counter++;
     }
   }
   filter->Update();
   result = filter->GetOutput();
   MITK_TEST_CONDITION_REQUIRED((expectedResult->GetSize()==result->GetSize()),"Test if point set size is equal");
   MITK_TEST_CONDITION_REQUIRED(mitk::ToFTestingCommon::PointSetsEqual(expectedResult,result),"Testing filter without subset");
 
   // compare filter result with ToFDistanceImageToSurfaceFilter
   MITK_INFO<<"Compare filter result with ToFDistanceImageToSurfaceFilter";
   surfaceFilter = mitk::ToFDistanceImageToSurfaceFilter::New();
   surfaceFilter->SetInput(image);
   surfaceFilter->SetInterPixelDistance(interPixelDistance);
   surfaceFilter->SetCameraIntrinsics(cameraIntrinsics);
   surfaceFilter->SetReconstructionMode(mitk::ToFDistanceImageToSurfaceFilter::WithInterPixelDistance);
   MITK_TEST_CONDITION_REQUIRED(surfaceFilter->GetReconstructionMode() == mitk::ToFDistanceImageToSurfaceFilter::WithInterPixelDistance,"Testing Set/GetReconstructionMode()");
   surface = surfaceFilter->GetOutput();
   surface->Update();
   // create point set from surface
   pointSet = mitk::ToFTestingCommon::VtkPolyDataToMitkPointSet(surface->GetVtkPolyData());
   //compare against ground truth
   MITK_TEST_CONDITION_REQUIRED((pointSet->GetSize()==result->GetSize()),"Test if point set size is equal");
   MITK_TEST_CONDITION_REQUIRED(mitk::ToFTestingCommon::PointSetsEqual(pointSet,result),"Compare with surface points");
 
 
   // test filter with subset (without using the interpixeldistance)
   MITK_INFO<<"Test filter with subset without using the interpixeldistance";
   filter = mitk::ToFDistanceImageToPointSetFilter::New();
   filter->SetInput(image);
   filter->SetInterPixelDistance(interPixelDistance);
   filter->SetCameraIntrinsics(cameraIntrinsics);
   filter->SetReconstructionMode(true);
   expectedResult = mitk::PointSet::New();
   counter = 0;
   for(int i=0; i<subSet->GetSize(); i++)
   {
     mitk::Point3D point = subSet->GetPoint(i);
     itk::Index<2> index;
     index[0] = point[0];
     index[1] = point[1];
     float distance = imageAcces.GetPixelByIndex(index);
     mitk::Point3D coordinate = mitk::ToFProcessingCommon::IndexToCartesianCoordinates(point[0],point[1],
                                                                                       distance,focalLengthX,focalLengthY,principalPoint[0],principalPoint[1]);
     expectedResult->InsertPoint(counter,coordinate);
     counter++;
   }
   filter->SetSubset(subSet);
   filter->Modified();
   filter->Update();
   result = filter->GetOutput();
   MITK_TEST_CONDITION_REQUIRED((expectedResult->GetSize()==result->GetSize()),"Test if point set size is equal");
   MITK_TEST_CONDITION_REQUIRED(mitk::ToFTestingCommon::PointSetsEqual(expectedResult,result),"Testing filter with subset");
 
 
   // test filter with subset (with using the interpixeldistance)
   MITK_INFO<<"Test filter with subset with using the interpixeldistance";
   filter = mitk::ToFDistanceImageToPointSetFilter::New();
   filter->SetInput(image);
   filter->SetInterPixelDistance(interPixelDistance);
   filter->SetCameraIntrinsics(cameraIntrinsics);
   filter->SetReconstructionMode(false);
   expectedResult = mitk::PointSet::New();
   counter = 0;
   for(int i=0; i<subSet->GetSize(); i++)
   {
     mitk::Point3D point = subSet->GetPoint(i);
     itk::Index<2> index;
     index[0] = point[0];
     index[1] = point[1];
     float distance = imageAcces.GetPixelByIndex(index);
     mitk::Point3D coordinate = mitk::ToFProcessingCommon::IndexToCartesianCoordinatesWithInterpixdist(point[0],point[1],
                                                                                       distance,focalLength,interPixelDistance,principalPoint);
     expectedResult->InsertPoint(counter,coordinate);
     counter++;
   }
   filter->SetSubset(subSet);
   filter->Modified();
   filter->Update();
   result = filter->GetOutput();
   MITK_TEST_CONDITION_REQUIRED((expectedResult->GetSize()==result->GetSize()),"Test if point set size is equal");
   MITK_TEST_CONDITION_REQUIRED(mitk::ToFTestingCommon::PointSetsEqual(expectedResult,result),"Testing filter with subset");
 
   // Test case to reproduce and check fix of bug 13933.
-  std::vector<mitk::Index3D> vecSubset = CreateVectorPointSet();
+  std::vector<itk::Index<3>> vecSubset = CreateVectorPointSet();
   filter = mitk::ToFDistanceImageToPointSetFilter::New();
   try
   {
     filter->SetSubset(vecSubset);
   }
   catch (...)
   {
     MITK_TEST_CONDITION_REQUIRED(false, "Caught an exception while setting point subset!");
   }
 
   MITK_TEST_END();
 }
diff --git a/Modules/ToFProcessing/Testing/mitkToFProcessingCommonTest.cpp b/Modules/ToFProcessing/Testing/mitkToFProcessingCommonTest.cpp
index c7c914d4b1..7a4a432408 100644
--- a/Modules/ToFProcessing/Testing/mitkToFProcessingCommonTest.cpp
+++ b/Modules/ToFProcessing/Testing/mitkToFProcessingCommonTest.cpp
@@ -1,91 +1,91 @@
 /*===================================================================
 
 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 <mitkToFProcessingCommon.h>
 #include <mitkLogMacros.h>
 /**Documentation
  *  test for the class "ToFProcessingCommon".
  */
 int mitkToFProcessingCommonTest(int /* argc */, char* /*argv*/[])
 {
   MITK_TEST_BEGIN("ToFProcessingCommon");
 
   unsigned int i = 10;
   unsigned int j = 50;
   float distance = 1000;
   float focalLength = 10;
   mitk::Point2D focalLength_XY;
   focalLength_XY[0] = 200;
   focalLength_XY[1] = 200;
   mitk::Point2D interPixelDistance;
   interPixelDistance[0] = 0.05;
   interPixelDistance[1] = 0.05;
   mitk::Point2D principalPoint;
   principalPoint[0] = 100;
   principalPoint[1] = 100;
   // expected coordinate
   mitk::ToFProcessingCommon::ToFPoint3D expectedCoordinate;
   expectedCoordinate[0] = -400.0988;
   expectedCoordinate[1] = -222.2771;
   expectedCoordinate[2] =  889.1084;
   // resulting coordinate without using the interpixeldistance
   mitk::ToFProcessingCommon::ToFPoint3D resultingCoordinate = mitk::ToFProcessingCommon::IndexToCartesianCoordinates(i,j,distance,focalLength_XY,principalPoint);
   MITK_TEST_CONDITION_REQUIRED(mitk::Equal(expectedCoordinate,resultingCoordinate,1e-3),"Testing IndexToCartesianCoordinates()");
   // resulting coordinate with using the interpixeldistance
   mitk::ToFProcessingCommon::ToFPoint3D resultingCoordinateInterpix = mitk::ToFProcessingCommon::IndexToCartesianCoordinatesWithInterpixdist(i,j,distance,focalLength,interPixelDistance,principalPoint);
 
   MITK_TEST_CONDITION_REQUIRED(mitk::Equal(expectedCoordinate,resultingCoordinateInterpix,1e-3),"Testing IndexToCartesianCoordinatesWithInterpixdist()");
   // expected index
   mitk::ToFProcessingCommon::ToFPoint3D expectedIndex;
   expectedIndex[0] = i;
   expectedIndex[1] = j;
   expectedIndex[2] = 1000;
   mitk::ToFProcessingCommon::ToFPoint3D resultingIndex = mitk::ToFProcessingCommon::CartesianToIndexCoordinates(expectedCoordinate,focalLength_XY,principalPoint);
   MITK_TEST_CONDITION_REQUIRED(mitk::Equal(expectedIndex,resultingIndex,1e-3),"Testing CartesianToIndexCoordinates()");
 
   mitk::ToFProcessingCommon::ToFPoint3D resultingIndexInterpix = mitk::ToFProcessingCommon::CartesianToIndexCoordinatesWithInterpixdist(expectedCoordinate,focalLength,interPixelDistance,principalPoint);
   MITK_TEST_CONDITION_REQUIRED(mitk::Equal(expectedIndex,resultingIndexInterpix,1e-3),"Testing CartesianToIndexCoordinatesWithInterpixdist()");
 
   //########## Kinect Reconstruction #############
   mitk::ToFProcessingCommon::ToFPoint3D expectedKinectCoordinate;
   expectedKinectCoordinate[0] = -450.0;
   expectedKinectCoordinate[1] = -250.0;
   expectedKinectCoordinate[2] = 1000.0;
 
-  mitk::Index3D index;
+  itk::Index<3> index;
   index[0] = i;
   index[1] = j;
   index[2] = 0;
 
   mitk::ToFProcessingCommon::ToFPoint3D kinectReconstructionResult = mitk::ToFProcessingCommon::KinectIndexToCartesianCoordinates(index,distance, focalLength_XY,principalPoint);
   MITK_TEST_CONDITION_REQUIRED(mitk::Equal(expectedKinectCoordinate,kinectReconstructionResult),"Compare the expected result with the result of reconstruction from KinectIndexToCartesianCoordinates()");
 
   mitk::ToFProcessingCommon::ToFPoint3D kinectReconstructionResultBackward = mitk::ToFProcessingCommon::CartesianToKinectIndexCoordinates(kinectReconstructionResult, focalLength_XY, principalPoint);
 
   MITK_TEST_CONDITION_REQUIRED(mitk::Equal(expectedIndex,kinectReconstructionResultBackward),"Transform everything back to distance image and compare it to the original input");
 
   mitk::Point2D continuousIndex;
   continuousIndex[0] = i;
   continuousIndex[1] = j;
   mitk::ToFProcessingCommon::ToFPoint3D continuousKinectReconstructionResult = mitk::ToFProcessingCommon::ContinuousKinectIndexToCartesianCoordinates(continuousIndex,distance, focalLength_XY[0], focalLength_XY[1], principalPoint[0], principalPoint[1]);
 
   MITK_TEST_CONDITION_REQUIRED(mitk::Equal(expectedKinectCoordinate,continuousKinectReconstructionResult),"Compare the expected result with the result of reconstruction from ContinuousKinectIndexToCartesianCoordinates(). Since the index is not continuous, the result has to be the same like for KinectIndexToCartesianCoordinates().");
 
   //########## End Kinect Reconstruction #############
 
   MITK_TEST_END();
 }
diff --git a/Modules/ToFProcessing/mitkToFDistanceImageToPointSetFilter.cpp b/Modules/ToFProcessing/mitkToFDistanceImageToPointSetFilter.cpp
index 34c622fb0a..a718d79a15 100644
--- a/Modules/ToFProcessing/mitkToFDistanceImageToPointSetFilter.cpp
+++ b/Modules/ToFProcessing/mitkToFDistanceImageToPointSetFilter.cpp
@@ -1,218 +1,218 @@
 /*===================================================================
 
 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 "mitkToFDistanceImageToPointSetFilter.h"
 
 #include "mitkImageDataItem.h"
 #include "mitkPointSet.h"
 #include <mitkImagePixelReadAccessor.h>
 #include "mitkToFProcessingCommon.h"
 
 mitk::ToFDistanceImageToPointSetFilter::ToFDistanceImageToPointSetFilter()
 : m_Subset(NULL), m_CameraIntrinsics(), m_InterPixelDistance()
 {
   m_InterPixelDistance.Fill(0.045);
   m_CameraIntrinsics = mitk::CameraIntrinsics::New();
   m_CameraIntrinsics->SetFocalLength(5.9421434211923247e+02,5.9104053696870778e+02);
   m_CameraIntrinsics->SetPrincipalPoint(3.3930780975300314e+02,2.4273913761751615e+02);
   m_CameraIntrinsics->SetDistorsionCoeffs(-0.36874385358645773f,-0.14339503290129013,0.0033210108720361795,-0.004277703352074105);
   m_ReconstructionMode = true;
 }
 
 mitk::ToFDistanceImageToPointSetFilter::~ToFDistanceImageToPointSetFilter()
 {
 }
 
 void mitk::ToFDistanceImageToPointSetFilter::SetInput(const mitk::Image* distanceImage )
 {
   this->SetInput(0,distanceImage);
 }
 
 void mitk::ToFDistanceImageToPointSetFilter::SetInput( unsigned int idx,const mitk::Image* distanceImage )
 {
   if ((distanceImage == NULL) && (idx == this->GetNumberOfInputs() - 1)) // if the last input is set to NULL, reduce the number of inputs by one
   {
     this->SetNumberOfInputs(this->GetNumberOfInputs() - 1);
   }
   else
   {
     this->ProcessObject::SetNthInput(idx, const_cast<mitk::Image*>(distanceImage));   // Process object is not const-correct so the const_cast is required here
     this->CreateOutputsForAllInputs();
   }
 }
 
 mitk::Image* mitk::ToFDistanceImageToPointSetFilter::GetInput()
 {
   return this->GetInput(0);
 }
 
 mitk::Image* mitk::ToFDistanceImageToPointSetFilter::GetInput( unsigned int idx )
 {
   if (this->GetNumberOfInputs() < 1)
     return NULL;
 
   return static_cast< mitk::Image*>(this->ProcessObject::GetInput(idx));
 }
 
-void mitk::ToFDistanceImageToPointSetFilter::SetSubset(std::vector<mitk::Index3D> subset)
+void mitk::ToFDistanceImageToPointSetFilter::SetSubset(std::vector<itk::Index<3>> subset)
 {
   // check if points of PointSet are inside the input image
   mitk::Image::Pointer input = this->GetInput();
 
   unsigned int xDim = UINT_MAX;
   unsigned int yDim = UINT_MAX;
   if(input.IsNotNull() && input->IsInitialized())
   {
     unsigned int xDim = input->GetDimension(0);
     unsigned int yDim = input->GetDimension(1);
   }
 
   bool pointSetValid = true;
   for (unsigned int i=0; i<subset.size(); i++)
   {
-    mitk::Index3D currentIndex = subset.at(i);
+    itk::Index<3> currentIndex = subset.at(i);
     if (currentIndex[0]<0||currentIndex[0]>xDim||currentIndex[1]<0||currentIndex[1]>yDim)
     {
       pointSetValid = false;
     }
   }
   if (pointSetValid)
   {
     m_Subset = subset;
   }
   else
   {
     MITK_ERROR<<"One or more indizes are located outside the image domain";
   }
 }
 
 void mitk::ToFDistanceImageToPointSetFilter::SetSubset( mitk::PointSet::Pointer pointSet)
 {
-  std::vector<mitk::Index3D> subset;
+  std::vector<itk::Index<3>> subset;
   for (int i=0; i<pointSet->GetSize(); i++)
   {
     mitk::Point3D currentPoint = pointSet->GetPoint(i);
-    mitk::Index3D currentIndex;
+    itk::Index<3> currentIndex;
     currentIndex[0] = currentPoint[0];
     currentIndex[1] = currentPoint[1];
     currentIndex[2] = currentPoint[2];
     subset.push_back(currentIndex);
   }
   this->SetSubset(subset);
 }
 
 void mitk::ToFDistanceImageToPointSetFilter::GenerateData()
 {
   //calculate world coordinates
   mitk::ToFProcessingCommon::ToFPoint2D focalLengthInPixelUnits;
   mitk::ToFProcessingCommon::ToFScalarType focalLengthInMm;
   if (m_ReconstructionMode)
   {
     focalLengthInPixelUnits[0] = m_CameraIntrinsics->GetFocalLengthX();
     focalLengthInPixelUnits[1] = m_CameraIntrinsics->GetFocalLengthY();
   }
   else
     focalLengthInMm = (m_CameraIntrinsics->GetFocalLengthX()*m_InterPixelDistance[0]+m_CameraIntrinsics->GetFocalLengthY()*m_InterPixelDistance[1])/2.0;
 
   mitk::ToFProcessingCommon::ToFPoint2D principalPoint;
   principalPoint[0] = m_CameraIntrinsics->GetPrincipalPointX();
   principalPoint[1] = m_CameraIntrinsics->GetPrincipalPointY();
 
   mitk::PointSet::Pointer output = this->GetOutput();
   assert(output);
   mitk::Image::Pointer input = this->GetInput();
   assert(input);
 
   //compute subset of points if input PointSet is defined
   if (m_Subset.size()!=0)
   {
     mitk::ImagePixelReadAccessor<float,2> imageAcces(input, input->GetSliceData(0));
     for (unsigned int i=0; i<m_Subset.size(); i++)
     {
-      mitk::Index3D currentIndex = m_Subset.at(i);
+      itk::Index<3> currentIndex = m_Subset.at(i);
       itk::Index<2> index2D;
       index2D[0] = currentIndex[0];
       index2D[1] = currentIndex[1];
       mitk::ToFProcessingCommon::ToFScalarType distance = (double)imageAcces.GetPixelByIndex(index2D);
 
       mitk::Point3D currentPoint;
       if (m_ReconstructionMode)
         currentPoint = mitk::ToFProcessingCommon::IndexToCartesianCoordinates(currentIndex,distance,focalLengthInPixelUnits,principalPoint);
       else
         currentPoint = mitk::ToFProcessingCommon::IndexToCartesianCoordinatesWithInterpixdist(currentIndex,distance,focalLengthInMm,m_InterPixelDistance,principalPoint);
 
       output->InsertPoint(i,currentPoint);
     }
   }
   else //compute PointSet holding cartesian coordinates for every image point
   {
     int xDimension = (int)input->GetDimension(0);
     int yDimension = (int)input->GetDimension(1);
     int pointCount = 0;
     mitk::ImagePixelReadAccessor<float,2> imageAcces(input, input->GetSliceData(0));
     for (int j=0; j<yDimension; j++)
     {
       for (int i=0; i<xDimension; i++)
       {
         itk::Index<2> pixel;
         pixel[0] = i;
         pixel[1] = j;
 
         mitk::ToFProcessingCommon::ToFScalarType distance = (double)imageAcces.GetPixelByIndex(pixel);
 
       mitk::Point3D currentPoint;
       if (m_ReconstructionMode)
         currentPoint = mitk::ToFProcessingCommon::IndexToCartesianCoordinates(i,j,distance,focalLengthInPixelUnits,principalPoint);
       else
         currentPoint = mitk::ToFProcessingCommon::IndexToCartesianCoordinatesWithInterpixdist(i,j,distance,focalLengthInMm,m_InterPixelDistance,principalPoint);
 
         if (distance>mitk::eps)
         {
           output->InsertPoint( pointCount, currentPoint );
           pointCount++;
         }
       }
     }
   }
 }
 
 void mitk::ToFDistanceImageToPointSetFilter::CreateOutputsForAllInputs()
 {
   this->SetNumberOfOutputs(this->GetNumberOfInputs());  // create outputs for all inputs
   for (unsigned int idx = 0; idx < this->GetNumberOfIndexedOutputs(); ++idx)
     if (this->GetOutput(idx) == NULL)
     {
       DataObjectPointer newOutput = this->MakeOutput(idx);
       this->SetNthOutput(idx, newOutput);
     }
     this->Modified();
 }
 
 void mitk::ToFDistanceImageToPointSetFilter::GenerateOutputInformation()
 {
   this->GetOutput();
   itkDebugMacro(<<"GenerateOutputInformation()");
 }
 
 void mitk::ToFDistanceImageToPointSetFilter::SetReconstructionMode(bool withoutInterpixdist)
 {
   this->m_ReconstructionMode = withoutInterpixdist;
 }
 
 bool mitk::ToFDistanceImageToPointSetFilter::GetReconstructionMode()
 {
   return (this->m_ReconstructionMode);
 }
diff --git a/Modules/ToFProcessing/mitkToFProcessingCommon.h b/Modules/ToFProcessing/mitkToFProcessingCommon.h
index 92e89d9c72..1a5808d72d 100644
--- a/Modules/ToFProcessing/mitkToFProcessingCommon.h
+++ b/Modules/ToFProcessing/mitkToFProcessingCommon.h
@@ -1,345 +1,345 @@
 /*===================================================================
 
 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 MITKTOFPROCESSINGCOMMON_H
 #define MITKTOFPROCESSINGCOMMON_H
 
 #include <MitkToFProcessingExports.h>
 #include <mitkCameraIntrinsics.h>
 #include "mitkTypes.h"
 #include <vnl/vnl_math.h>
 
 namespace mitk
 {
   /**
   * @brief Helper class providing functions which are useful for multiple usage
   *
   * Currently the following methods are provided:
   * <ul>
   * <li> Conversion from 2D image coordinates to 3D world coordinates (IndexToCartesianCoordinates())
   * <li> Conversion from 3D world coordinates to 2D image coordinates (CartesianToIndexCoordinates())
   * </ul>
   * The coordinate conversion follows the model of a common pinhole camera where the origin of the camera
   * coordinate system (world coordinates) is at the pinhole
   * \image html ../Modules/ToFProcessing/Documentation/PinholeCameraModel.png
   * The definition of the image plane and its coordinate systems (pixel and mm) is depicted in the following image
   * \image html ../Modules/ToFProcessing/Documentation/ImagePlane.png
   * @ingroup ToFProcessing
   */
   class MitkToFProcessing_EXPORT ToFProcessingCommon
   {
   public:
     typedef double ToFScalarType;
     typedef itk::Point<ToFScalarType, 2> ToFPoint2D;
     typedef itk::Point<ToFScalarType, 3> ToFPoint3D;
     typedef itk::Vector<ToFScalarType, 2> ToFVector2D;
     typedef itk::Vector<ToFScalarType, 3> ToFVector3D;
 
     /*!
     \brief Convert index based distances to cartesian coordinates
     \param i index in x direction of image plane
     \param j index in y direction of image plane
     \param distance distance value at given index in mm
     \param focalLengthX focal length of optical system in pixel units in x-direction (mostly obtained from camera calibration)
     \param focalLengthY focal length of optical system in pixel units in y-direction (mostly obtained from camera calibration)
     \param principalPointX x coordinate of principal point on image plane in pixel
     \param principalPointY y coordinate of principal point on image plane in pixel
     \return cartesian coordinates for current index will be written here
     */
     static ToFPoint3D IndexToCartesianCoordinates(unsigned int i, unsigned int j, ToFScalarType distance,
       ToFScalarType focalLengthX, ToFScalarType focalLengthY, ToFScalarType principalPointX, ToFScalarType principalPointY);
 
     /*!
     \brief Convert index based distances to cartesian coordinates
     \param i index in x direction of image plane
     \param j index in y direction of image plane
     \param distance distance value at given index in mm
     \param focalLength focal length of optical system in pixel units (mostly obtained from camera calibration)
     \param principalPoint coordinates of principal point on image plane in pixel
     \return cartesian coordinates for current index will be written here
     */
     inline static ToFPoint3D IndexToCartesianCoordinates(unsigned int i, unsigned int j, ToFScalarType distance,
       ToFPoint2D focalLength, ToFPoint2D principalPoint)
     {
       return IndexToCartesianCoordinates(i,j,distance,focalLength[0],focalLength[1],principalPoint[0],principalPoint[1]);
     }
 
     /*!
     \brief Convert index based distances to cartesian coordinates
     \param index index coordinates
     \param distance distance value at given index in mm
     \param focalLength focal length of optical system in pixel units (mostly obtained from camera calibration)
     \param principalPoint coordinates of principal point on image plane in pixel
     \return cartesian coordinates for current index will be written here
     */
-    inline static ToFPoint3D IndexToCartesianCoordinates(mitk::Index3D index, ToFScalarType distance,
+    inline static ToFPoint3D IndexToCartesianCoordinates(itk::Index<3> index, ToFScalarType distance,
       ToFPoint2D focalLength, ToFPoint2D principalPoint)
     {
       return IndexToCartesianCoordinates(index[0],index[1],distance,focalLength[0],focalLength[1],principalPoint[0], principalPoint[1]);
     }
     /*!
     \brief Convenience method to convert index based distances to cartesian coordinates using array as input
     \param i index in x direction of image plane
     \param j index in y direction of image plane
     \param distance distance value at given index in mm
     \param focalLength focal length of optical system in pixel units (mostly obtained from camera calibration)
     \param principalPoint coordinates of principal point on image plane in pixel
     \return cartesian coordinates for current index will be written here
     */
     inline static ToFPoint3D IndexToCartesianCoordinates(unsigned int i, unsigned int j, ToFScalarType distance,
       ToFScalarType focalLength[2], ToFScalarType principalPoint[2])
     {
       return IndexToCartesianCoordinates(i,j,distance,focalLength[0],focalLength[1],principalPoint[0],principalPoint[1]);
     }
 
 
     /*!
     \brief Convert index based distances to cartesian coordinates
     \param i index in x direction of image plane
     \param j index in y direction of image plane
     \param distance distance value at given index in mm
     \param focalLength focal length of optical system in mm (mostly obtained from camera calibration)
     \param interPixelDistanceX distance in x direction between adjacent pixels in mm
     \param interPixelDistanceY distance in y direction between adjacent pixels in mm
     \param principalPointX x coordinate of principal point on image plane in pixel
     \param principalPointY y coordinate of principal point on image plane in pixel
     \return cartesian coordinates for current index will be written here
     */
     static ToFPoint3D IndexToCartesianCoordinatesWithInterpixdist(unsigned int i, unsigned int j, ToFScalarType distance, ToFScalarType focalLength,
       ToFScalarType interPixelDistanceX, ToFScalarType interPixelDistanceY, ToFScalarType principalPointX, ToFScalarType principalPointY);
 
     /*!
     \brief Convert index based distances to cartesian coordinates
     \param i index in x direction of image plane
     \param j index in y direction of image plane
     \param distance distance value at given index in mm
     \param focalLength focal length of optical system in mm (mostly obtained from camera calibration)
     \param interPixelDistance distance between adjacent pixels in mm
     \param principalPoint coordinates of principal point on image plane in pixel
     \return cartesian coordinates for current index will be written here
     */
     inline static ToFPoint3D IndexToCartesianCoordinatesWithInterpixdist(unsigned int i, unsigned int j, ToFScalarType distance, ToFScalarType focalLength,
       ToFPoint2D interPixelDistance, ToFPoint2D principalPoint)
     {
       return IndexToCartesianCoordinatesWithInterpixdist(i,j,distance,focalLength,interPixelDistance[0],interPixelDistance[1],principalPoint[0],principalPoint[1]);
     }
     /*!
     \brief Convert index based distances to cartesian coordinates
     \param index index coordinates
     \param distance distance value at given index in mm
     \param focalLength focal length of optical system (mostly obtained from camera calibration)
     \param interPixelDistance distance between adjacent pixels in mm for x and y direction
     \param principalPoint coordinates of principal point on image plane in pixel
     \return cartesian coordinates for current index will be written here
     */
-    inline static ToFPoint3D IndexToCartesianCoordinatesWithInterpixdist(mitk::Index3D index, ToFScalarType distance, ToFScalarType focalLength,
+    inline static ToFPoint3D IndexToCartesianCoordinatesWithInterpixdist(itk::Index<3> index, ToFScalarType distance, ToFScalarType focalLength,
       ToFPoint2D interPixelDistance, ToFPoint2D principalPoint)
     {
       return IndexToCartesianCoordinatesWithInterpixdist(index[0],index[1],distance,focalLength,interPixelDistance[0], interPixelDistance[1],principalPoint[0], principalPoint[1]);
     }
     /*!
     \brief Convenience method to convert index based distances to cartesian coordinates using array as input
     \param i index in x direction of image plane
     \param j index in y direction of image plane
     \param distance distance value at given index in mm
     \param focalLength focal length of optical system in mm (mostly obtained from camera calibration)
     \param interPixelDistance distance between adjacent pixels in mm
     \param principalPoint coordinates of principal point on image plane in pixel
     \return cartesian coordinates for current index will be written here
     */
     inline static ToFPoint3D IndexToCartesianCoordinatesWithInterpixdist(unsigned int i, unsigned int j, ToFScalarType distance, ToFScalarType focalLength,
       ToFScalarType interPixelDistance[2], ToFScalarType principalPoint[2])
     {
       return IndexToCartesianCoordinatesWithInterpixdist(i,j,distance,focalLength,interPixelDistance[0],interPixelDistance[1],principalPoint[0],principalPoint[1]);
     }
 
 
     /*!
     \brief Convert cartesian coordinates to index based distances
     \param cartesianPointX x coordinate of point (of a surface or point set) to convert in 3D coordinates
     \param cartesianPointY y coordinate of point (of a surface or point set) to convert in 3D coordinates
     \param cartesianPointZ z coordinate of point (of a surface or point set) to convert in 3D coordinates
     \param focalLengthX focal length of optical system in pixel units in x-direction (mostly obtained from camera calibration)
     \param focalLengthY focal length of optical system in pixel units in y-direction (mostly obtained from camera calibration)
     \param principalPointX x coordinate of principal point on image plane in pixel
     \param principalPointY y coordinate of principal point on image plane in pixel
     \param calculateDistance if this flag is set, the distance value is stored in the z position of the output otherwise z=0
     \return a ToFPoint3D. (int)ToFPoint3D[0]+0.5 and (int)ToFPoint3D[0]+0.5 will return the x and y index coordinates. ToFPoint3D[2] contains the distance value
     */
     static ToFPoint3D CartesianToIndexCoordinates(ToFScalarType cartesianPointX, ToFScalarType cartesianPointY,ToFScalarType cartesianPointZ,
                                                   ToFScalarType focalLengthX, ToFScalarType focalLengthY,
                                                   ToFScalarType principalPointX, ToFScalarType principalPointY, bool calculateDistance=true);
 
     /*!
     \brief Convenience method to convert cartesian coordinates to index based distances using arrays
     \param cartesianPoint point (of a surface or point set) to convert in 3D coordinates
     \param focalLength focal length of optical system in pixel units (mostly obtained from camera calibration)
     \param principalPoint coordinates of principal point on image plane in pixel
     \param calculateDistance if this flag is set, the distance value is stored in the z position of the output otherwise z=0
     \return a ToFPoint3D. (int)ToFPoint3D[0]+0.5 and (int)ToFPoint3D[0]+0.5 will return the x and y index coordinates. ToFPoint3D[2] contains the distance value
     */
     inline static ToFPoint3D CartesianToIndexCoordinates(ToFScalarType cartesianPoint[3], ToFScalarType focalLength[2],
                                                          ToFScalarType principalPoint[2], bool calculateDistance=true)
     {
       return CartesianToIndexCoordinates(cartesianPoint[0],cartesianPoint[1],cartesianPoint[2],focalLength[0], focalLength[1],
                                          principalPoint[0],principalPoint[1],calculateDistance);
     }
     /*!
     \brief Convert cartesian coordinates to index based distances
     \param cartesianPoint point (of a surface or point set) to convert in 3D coordinates
     \param focalLength focal length of optical system in pixel units (mostly obtained from camera calibration)
     \param principalPoint coordinates of principal point on image plane in pixel
     \param calculateDistance if this flag is set, the distance value is stored in the z position of the output otherwise z=0
     \return a ToFPoint3D. (int)ToFPoint3D[0]+0.5 and (int)ToFPoint3D[0]+0.5 will return the x and y index coordinates. ToFPoint3D[2] contains the distance value
     */
     inline static ToFPoint3D CartesianToIndexCoordinates(ToFPoint3D cartesianPoint, ToFPoint2D focalLength,
       ToFPoint2D principalPoint, bool calculateDistance=true)
     {
       return CartesianToIndexCoordinates(cartesianPoint[0],cartesianPoint[1],cartesianPoint[2],focalLength[0], focalLength[1],
         principalPoint[0],principalPoint[1],calculateDistance);
     }
 
 
     /*!
     \brief Convert cartesian coordinates to index based distances
     \param cartesianPointX x coordinate of point (of a surface or point set) to convert in 3D coordinates
     \param cartesianPointY y coordinate of point (of a surface or point set) to convert in 3D coordinates
     \param cartesianPointZ z coordinate of point (of a surface or point set) to convert in 3D coordinates
     \param focalLength focal length of optical system in mm (mostly obtained from camera calibration)
     \param interPixelDistanceX distance in x direction between adjacent pixels in mm
     \param interPixelDistanceY distance in y direction between adjacent pixels in mm
     \param principalPointX x coordinate of principal point on image plane in pixel
     \param principalPointY y coordinate of principal point on image plane in pixel
     \param calculateDistance if this flag is set, the distance value is stored in the z position of the output otherwise z=0
     \return a ToFPoint3D. (int)ToFPoint3D[0]+0.5 and (int)ToFPoint3D[0]+0.5 will return the x and y index coordinates. ToFPoint3D[2] contains the distance value
     */
     static ToFPoint3D CartesianToIndexCoordinatesWithInterpixdist(ToFScalarType cartesianPointX, ToFScalarType cartesianPointY,ToFScalarType cartesianPointZ,
                                                   ToFScalarType focalLength, ToFScalarType interPixelDistanceX, ToFScalarType interPixelDistanceY,
                                                   ToFScalarType principalPointX, ToFScalarType principalPointY, bool calculateDistance=true);
 
     /*!
     \brief Convenience method to convert cartesian coordinates to index based distances using arrays
     \param cartesianPoint point (of a surface or point set) to convert in 3D coordinates
     \param focalLength focal length of optical system in mm (mostly obtained from camera calibration)
     \param interPixelDistance distance between adjacent pixels in mm for x and y direction
     \param principalPoint coordinates of principal point on image plane in pixel
     \param calculateDistance if this flag is set, the distance value is stored in the z position of the output otherwise z=0
     \return a ToFPoint3D. (int)ToFPoint3D[0]+0.5 and (int)ToFPoint3D[0]+0.5 will return the x and y index coordinates. ToFPoint3D[2] contains the distance value
     */
     inline static ToFPoint3D CartesianToIndexCoordinatesWithInterpixdist(ToFScalarType cartesianPoint[3], ToFScalarType focalLength,
                                                          ToFScalarType interPixelDistance[2], ToFScalarType principalPoint[2],
                                                          bool calculateDistance=true)
     {
       return CartesianToIndexCoordinatesWithInterpixdist(cartesianPoint[0],cartesianPoint[1],cartesianPoint[2],focalLength,
                                          interPixelDistance[0],interPixelDistance[1],principalPoint[0],principalPoint[1],calculateDistance);
     }
     /*!
     \brief Convert cartesian coordinates to index based distances
     \param cartesianPoint point (of a surface or point set) to convert in 3D coordinates
     \param focalLength focal length of optical system in mm (mostly obtained from camera calibration)
     \param interPixelDistance distance between adjacent pixels in mm for x and y direction
     \param principalPoint coordinates of principal point on image plane in pixel
     \param calculateDistance if this flag is set, the distance value is stored in the z position of the output otherwise z=0
     \return a ToFPoint3D. (int)ToFPoint3D[0]+0.5 and (int)ToFPoint3D[0]+0.5 will return the x and y index coordinates. ToFPoint3D[2] contains the distance value
     */
     inline static ToFPoint3D CartesianToIndexCoordinatesWithInterpixdist(ToFPoint3D cartesianPoint, ToFScalarType focalLength,
       ToFPoint2D interPixelDistance, ToFPoint2D principalPoint, bool calculateDistance=true)
     {
       return CartesianToIndexCoordinatesWithInterpixdist(cartesianPoint[0],cartesianPoint[1],cartesianPoint[2],focalLength,
         interPixelDistance[0],interPixelDistance[1],principalPoint[0],principalPoint[1],calculateDistance);
     }
 
     /** \ingroup KinectReconstruction
      * @{
      *
      * @brief KinectIndexToCartesianCoordinates Convert a pixel (i,j) with value d to a 3D world point. This conversion is meant for Kinect and slightly different then ToF reconstruction. See also "Hacking the Kinect" - Jeff Kramer, Matt Parker, Daniel Herrera C., Nicolas Burrus, Florian Echtler, Chapter 7, Part 1 "Moving from Depth Map to Point Cloud.
      * @param i Pixel index i.
      * @param j Pixel index j.
      * @param distance Distance value d in mm as obtained from OpenNI.
      * @param focalLengthX Focallength from calibration.
      * @param focalLengthY Focallength from calibration.
      * @param principalPointX Principal point from calibration.
      * @param principalPointY Principal point from calibration.
      * @return a ToFPoint3D. The point in world coordinates (mm).
      */
     static ToFProcessingCommon::ToFPoint3D KinectIndexToCartesianCoordinates(unsigned int i, unsigned int j, ToFScalarType distance, ToFScalarType focalLengthX, ToFScalarType focalLengthY, ToFScalarType principalPointX, ToFScalarType principalPointY);
 
     inline static ToFPoint3D KinectIndexToCartesianCoordinates(unsigned int i, unsigned int j, ToFScalarType distance,
       ToFScalarType focalLength[2], ToFScalarType principalPoint[2])
     {
       return KinectIndexToCartesianCoordinates(i,j,distance,focalLength[0],focalLength[1],principalPoint[0],principalPoint[1]);
     }
 
     inline static ToFPoint3D KinectIndexToCartesianCoordinates(unsigned int i, unsigned int j, ToFScalarType distance,
       ToFPoint2D focalLength, ToFPoint2D principalPoint)
     {
       return KinectIndexToCartesianCoordinates(i,j,distance,focalLength[0],focalLength[1],principalPoint[0],principalPoint[1]);
     }
 
-    inline static ToFPoint3D KinectIndexToCartesianCoordinates(mitk::Index3D index, ToFScalarType distance, ToFPoint2D focalLength, ToFPoint2D principalPoint)
+    inline static ToFPoint3D KinectIndexToCartesianCoordinates(itk::Index<3> index, ToFScalarType distance, ToFPoint2D focalLength, ToFPoint2D principalPoint)
     {
         return KinectIndexToCartesianCoordinates(index[0],index[1],distance,focalLength[0],focalLength[1],principalPoint[0], principalPoint[1]);
     }
     /** @}*/
     /** \ingroup KinectReconstructionInverse
      * @{
      * @brief CartesianCoordinatesToKinectIndexCoordinates Transform a 3D world point back to distance image pixel coordinates.
      * @param cartesianPointX x value of the cartesian point.
      * @param cartesianPointY y value of the cartesian point.
      * @param cartesianPointZ z value of the cartesian point.
      * @param focalLengthX x value of the focal length (from calibration).
      * @param focalLengthY y value of the focal length (from calibration).
      * @param principalPointX x value of the principal point (from calibration).
      * @param principalPointY y value of the principal point (from calibration).
      * @param calculateDistance Do you want to compute also the distance of the distance image? For Kinect, this value is always the same in cartesian and index coordinates.
      * @return A ToFPoint3D containing the pixel indices (i,j) in [0] and [1] and (optionally) the distance value in [2] (or just 0.0).
      */
     static ToFPoint3D CartesianToKinectIndexCoordinates(ToFScalarType cartesianPointX, ToFScalarType cartesianPointY,
                                                                    ToFScalarType cartesianPointZ, ToFScalarType focalLengthX,
                                                                    ToFScalarType focalLengthY, ToFScalarType principalPointX,
                                                                    ToFScalarType principalPointY, bool calculateDistance=true);
 
     inline static ToFProcessingCommon::ToFPoint3D CartesianToKinectIndexCoordinates(ToFPoint3D cartesianPoint, ToFPoint2D focalLength, ToFPoint2D  principalPoint, bool calculateDistance=true)
     {
       return CartesianToKinectIndexCoordinates( cartesianPoint[0], cartesianPoint[1], cartesianPoint[2], focalLength[0], focalLength[1], principalPoint[0], principalPoint[1], calculateDistance);
     }
     /** @}*/
     /**
      * @brief ContinuousKinectIndexToCartesianCoordinates This method is escpially meant for reconstructing a Kinect point
      * with continuous index coordinates (i.e. not exactly a pixel position, but a point interpolated between two pixels).
      * The only difference to KinectIndexToCartesianCoordinates() is that ContinuousKinectIndexToCartesianCoordinates does not
      * cast to unsigned int for the index.
      * @param continuousIndex The continuous coordinates (e.g. 0.5; 0.5).
      * @param distance Distance value d in mm as obtained from OpenNI.
      * @param focalLengthX x value of the focal length (from calibration).
      * @param focalLengthY y value of the focal length (from calibration)
      * @param principalPointX x value of the principal point (from calibration).
      * @param principalPointY y value of the principal point (from calibration).
      * @return a ToFPoint3D. The point in world coordinates (mm).
      */
     static ToFProcessingCommon::ToFPoint3D ContinuousKinectIndexToCartesianCoordinates(mitk::Point2D continuousIndex, ToFScalarType distance, ToFScalarType focalLengthX, ToFScalarType focalLengthY, ToFScalarType principalPointX, ToFScalarType principalPointY);
 
     /**
     \brief Calculates the horizontal view angle of the camera with the given intrinsics
     \param intrinsics intrinsic parameters of the camera
     \param dimX dimension of the image in horizontal direction
 
     angle = atan(principalPoint[0]/focalLength[0]) + atan((dimX-principalPoint[0]/focalLength[0]))
     **/
     static ToFScalarType CalculateViewAngle(mitk::CameraIntrinsics::Pointer intrinsics, unsigned int dimX);
   };
 }
 #endif