diff --git a/Core/Code/Controllers/mitkSliceNavigationController.cpp b/Core/Code/Controllers/mitkSliceNavigationController.cpp
index 3e277092f3..9d90d14409 100644
--- a/Core/Code/Controllers/mitkSliceNavigationController.cpp
+++ b/Core/Code/Controllers/mitkSliceNavigationController.cpp
@@ -1,737 +1,747 @@
 /*===================================================================
 
 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 "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_InputWorldGeometry( 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::SetInputWorldGeometry( const Geometry3D *geometry )
 {
   if ( geometry != NULL )
   {
     if ( const_cast< BoundingBox * >( geometry->GetBoundingBox())
          ->GetDiagonalLength2() < eps )
     {
       itkWarningMacro( "setting an empty bounding-box" );
       geometry = NULL;
     }
   }
   if ( m_InputWorldGeometry != geometry )
   {
     m_InputWorldGeometry = geometry;
     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;
 }
 
 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 )
 {
   const TimeSlicedGeometry* worldTimeSlicedGeometry =
     dynamic_cast< const TimeSlicedGeometry * >(
       m_InputWorldGeometry.GetPointer() );
 
   if( m_BlockUpdate ||
       m_InputWorldGeometry.IsNull() ||
       ( (worldTimeSlicedGeometry != NULL) && (worldTimeSlicedGeometry->GetTimeSteps() == 0) )
     )
   {
     return;
   }
 
   m_BlockUpdate = true;
 
   if ( m_LastUpdateTime < m_InputWorldGeometry->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;
 
     m_CreatedWorldGeometry = NULL;
     switch ( viewDirection )
     {
     case Original:
       if ( worldTimeSlicedGeometry != NULL )
       {
         m_CreatedWorldGeometry = static_cast< TimeSlicedGeometry * >(
           m_InputWorldGeometry->Clone().GetPointer() );
 
         worldTimeSlicedGeometry = m_CreatedWorldGeometry.GetPointer();
 
         slicedWorldGeometry = dynamic_cast< SlicedGeometry3D * >(
           m_CreatedWorldGeometry->GetGeometry3D( this->GetTime()->GetPos() ) );
 
         if ( slicedWorldGeometry.IsNotNull() )
         {
           break;
         }
       }
       else
       {
         const SlicedGeometry3D *worldSlicedGeometry =
           dynamic_cast< const SlicedGeometry3D * >(
             m_InputWorldGeometry.GetPointer());
 
         if ( worldSlicedGeometry != NULL )
         {
           slicedWorldGeometry = static_cast< SlicedGeometry3D * >(
             m_InputWorldGeometry->Clone().GetPointer());
           break;
         }
       }
       //else: use Axial: no "break" here!!
 
     case Axial:
       slicedWorldGeometry = SlicedGeometry3D::New();
       slicedWorldGeometry->InitializePlanes(
         m_InputWorldGeometry, PlaneGeometry::Axial,
         top, frontside, rotated );
       slicedWorldGeometry->SetSliceNavigationController( this );
       break;
 
     case Frontal:
       slicedWorldGeometry = SlicedGeometry3D::New();
       slicedWorldGeometry->InitializePlanes( m_InputWorldGeometry,
         PlaneGeometry::Frontal, top, frontside, rotated );
       slicedWorldGeometry->SetSliceNavigationController( this );
       break;
 
     case Sagittal:
       slicedWorldGeometry = SlicedGeometry3D::New();
       slicedWorldGeometry->InitializePlanes( m_InputWorldGeometry,
         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 TimeSlicedGeometry
       m_CreatedWorldGeometry = TimeSlicedGeometry::New();
     }
     if ( worldTimeSlicedGeometry == NULL )
     {
       m_CreatedWorldGeometry->InitializeEvenlyTimed( slicedWorldGeometry, 1 );
       m_Time->SetSteps( 0 );
       m_Time->SetPos( 0 );
       m_Time->InvalidateRange();
     }
     else
     {
       m_BlockUpdate = true;
       m_Time->SetSteps( worldTimeSlicedGeometry->GetTimeSteps() );
       m_Time->SetPos( 0 );
 
       const TimeBounds &timeBounds = worldTimeSlicedGeometry->GetTimeBounds();
       m_Time->SetRange( timeBounds[0], timeBounds[1] );
 
       m_BlockUpdate = false;
 
       assert( worldTimeSlicedGeometry->GetGeometry3D( this->GetTime()->GetPos() ) != NULL );
 
       slicedWorldGeometry->SetTimeBounds(
         worldTimeSlicedGeometry->GetGeometry3D( this->GetTime()->GetPos() )->GetTimeBounds() );
 
       //@todo implement for non-evenly-timed geometry!
       m_CreatedWorldGeometry->InitializeEvenlyTimed(
         slicedWorldGeometry, worldTimeSlicedGeometry->GetTimeSteps() );
     }
   }
 
   // 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 );
 
   TimeSlicedGeometry *timeSlicedGeometry = timeEvent->GetTimeSlicedGeometry();
   assert( timeSlicedGeometry != NULL );
 
   if ( m_CreatedWorldGeometry.IsNotNull() )
   {
     int timeStep = (int) timeEvent->GetPos();
     ScalarType timeInMS;
     timeInMS = timeSlicedGeometry->TimeStepToMS( timeStep );
     timeStep = m_CreatedWorldGeometry->MSToTimeStep( 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->GetGeometry3D( this->GetTime()->GetPos() ) );
 
   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();
 }
 
 
 
 const mitk::TimeSlicedGeometry *
 SliceNavigationController::GetCreatedWorldGeometry()
 {
   return m_CreatedWorldGeometry;
 }
 
 
 const mitk::Geometry3D *
 SliceNavigationController::GetCurrentGeometry3D()
 {
   if ( m_CreatedWorldGeometry.IsNotNull() )
   {
     return m_CreatedWorldGeometry->GetGeometry3D( 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( (float) direction[i] ) < 0.000000001 ) { ++c; }
     else { k = i; }
   }
 
   if ( c == 2 )
   {
     ScalarType min = m_InputWorldGeometry->GetOrigin()[k];
     ScalarType max = min + m_InputWorldGeometry->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;
     }
   }
 }
 
 // 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;
                 // find image with largest layer, that is the image shown on top in the render window
                 for (unsigned int x = 0; x < nodes->size(); x++)
                 {
                   //Just consider image data that is no helper object. E.g. do not consider nodes created for the slice interpolation
                   bool isHelper (false);
                   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))
                       {
                         image3D = dynamic_cast<mitk::Image*>(nodes->at(x)->GetData());
                         maxlayer = layer;
                       }
                     }
                   }
                 }
 
                 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;
                   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)
                   {
                     stream<<"; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: "<<std::scientific<<image3D->GetPixelValueByIndex(p, baseRenderer->GetTimeStep())<<"  ";
                   }
                   else
                   {
                     stream<<"; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: "<<image3D->GetPixelValueByIndex(p, baseRenderer->GetTimeStep())<<"  ";
                   }
                 }
                 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/mitkApplyTransformMatrixOperation.cpp b/Core/Code/DataManagement/mitkApplyTransformMatrixOperation.cpp
new file mode 100644
index 0000000000..f8202b335b
--- /dev/null
+++ b/Core/Code/DataManagement/mitkApplyTransformMatrixOperation.cpp
@@ -0,0 +1,44 @@
+/*===================================================================
+
+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 "mitkApplyTransformMatrixOperation.h"
+
+namespace mitk
+{
+
+ApplyTransformMatrixOperation
+::ApplyTransformMatrixOperation( OperationType operationType, vtkSmartPointer<vtkMatrix4x4> matrix, Point3D refPoint )
+: Operation(operationType), m_vtkMatrix( matrix ), m_referencePoint( refPoint )
+{
+}
+
+ApplyTransformMatrixOperation
+::~ApplyTransformMatrixOperation()
+{
+}
+
+vtkSmartPointer<vtkMatrix4x4> ApplyTransformMatrixOperation::GetMatrix()
+{
+  return m_vtkMatrix;
+}
+
+Point3D ApplyTransformMatrixOperation::GetReferencePoint()
+{
+  return m_referencePoint;
+}
+
+} // namespace mitk
diff --git a/Core/Code/DataManagement/mitkApplyTransformMatrixOperation.h b/Core/Code/DataManagement/mitkApplyTransformMatrixOperation.h
new file mode 100644
index 0000000000..e659572e85
--- /dev/null
+++ b/Core/Code/DataManagement/mitkApplyTransformMatrixOperation.h
@@ -0,0 +1,56 @@
+/*===================================================================
+
+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 mitkApplyTransformMatrixOperation_h_Included
+#define mitkApplyTransformMatrixOperation_h_Included
+
+#include "mitkCommon.h"
+#include "mitkPointOperation.h"
+
+#include <vtkMatrix4x4.h>
+#include <vtkSmartPointer.h>
+
+
+
+namespace mitk {
+
+class MITK_CORE_EXPORT ApplyTransformMatrixOperation : public Operation
+{
+  public:
+  //##Documentation
+  //##@brief Operation that applies a new vtk transform matrix.
+  //##
+  //## @param operationType is the type of the operation (see mitkOperation.h; e.g. move or add; Information for StateMachine::ExecuteOperation());
+  //## @param matrix is the vtk 4x4 vtk matrix of the transformation
+  //## @param refPoint is the reference point for realigning the plane stack
+
+    ApplyTransformMatrixOperation(OperationType operationType, vtkSmartPointer<vtkMatrix4x4> matrix, mitk::Point3D refPoint);
+
+    virtual ~ApplyTransformMatrixOperation();
+
+    vtkSmartPointer<vtkMatrix4x4> GetMatrix();
+
+    mitk::Point3D GetReferencePoint();
+
+  private:
+
+    vtkSmartPointer<vtkMatrix4x4> m_vtkMatrix;
+    mitk::Point3D m_referencePoint;
+
+};
+}//namespace mitk
+#endif
diff --git a/Core/Code/DataManagement/mitkGeometry3D.cpp b/Core/Code/DataManagement/mitkGeometry3D.cpp
index 2e0a97722c..c98589b548 100644
--- a/Core/Code/DataManagement/mitkGeometry3D.cpp
+++ b/Core/Code/DataManagement/mitkGeometry3D.cpp
@@ -1,771 +1,777 @@
 /*===================================================================
 
 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 <sstream>
 
 #include "mitkGeometry3D.h"
 #include "mitkMatrixConvert.h"
 #include "mitkRotationOperation.h"
 #include "mitkRestorePlanePositionOperation.h"
+#include "mitkApplyTransformMatrixOperation.h"
 #include "mitkPointOperation.h"
 #include "mitkInteractionConst.h"
 //#include "mitkStatusBar.h"
 
 #include <vtkMatrixToLinearTransform.h>
 #include <vtkMatrix4x4.h>
 
 // Standard constructor for the New() macro. Sets the geometry to 3 dimensions
 mitk::Geometry3D::Geometry3D()
   : m_ParametricBoundingBox(NULL),
     m_ImageGeometry(false), m_Valid(true), m_FrameOfReferenceID(0), m_IndexToWorldTransformLastModified(0)
 {
   FillVector3D(m_FloatSpacing, 1,1,1);
   m_VtkMatrix = vtkMatrix4x4::New();
   m_VtkIndexToWorldTransform = vtkMatrixToLinearTransform::New();
   m_VtkIndexToWorldTransform->SetInput(m_VtkMatrix);
   Initialize();
 }
 mitk::Geometry3D::Geometry3D(const Geometry3D& other) : Superclass(), mitk::OperationActor(), m_ParametricBoundingBox(other.m_ParametricBoundingBox),m_TimeBounds(other.m_TimeBounds),
   m_ImageGeometry(other.m_ImageGeometry), m_Valid(other.m_Valid), m_FrameOfReferenceID(other.m_FrameOfReferenceID), m_IndexToWorldTransformLastModified(other.m_IndexToWorldTransformLastModified), m_RotationQuaternion( other.m_RotationQuaternion ) , m_Origin(other.m_Origin)
 {
   // AffineGeometryFrame
   SetBounds(other.GetBounds());
   //SetIndexToObjectTransform(other.GetIndexToObjectTransform());
   //SetObjectToNodeTransform(other.GetObjectToNodeTransform());
   //SetIndexToWorldTransform(other.GetIndexToWorldTransform());
   // this is not used in AffineGeometryFrame of ITK, thus there are not Get and Set methods
   // m_IndexToNodeTransform = other.m_IndexToNodeTransform;
   // m_InvertedTransform = TransformType::New();
   // m_InvertedTransform = TransformType::New();
   // m_InvertedTransform->DeepCopy(other.m_InvertedTransform);
   m_VtkMatrix = vtkMatrix4x4::New();
   m_VtkMatrix->DeepCopy(other.m_VtkMatrix);
   if (other.m_ParametricBoundingBox.IsNotNull())
   {
     m_ParametricBoundingBox = other.m_ParametricBoundingBox->DeepCopy();
   }
   FillVector3D(m_FloatSpacing,other.m_FloatSpacing[0],other.m_FloatSpacing[1],other.m_FloatSpacing[2]);
   m_VtkIndexToWorldTransform = vtkMatrixToLinearTransform::New();
   m_VtkIndexToWorldTransform->DeepCopy(other.m_VtkIndexToWorldTransform);
   m_VtkIndexToWorldTransform->SetInput(m_VtkMatrix);
   other.InitializeGeometry(this);
 }
 
 mitk::Geometry3D::~Geometry3D()
 {
   m_VtkMatrix->Delete();
   m_VtkIndexToWorldTransform->Delete();
 }
 
 
 static void CopySpacingFromTransform(mitk::AffineTransform3D* transform, mitk::Vector3D& spacing, float floatSpacing[3])
 {
   mitk::AffineTransform3D::MatrixType::InternalMatrixType vnlmatrix;
   vnlmatrix = transform->GetMatrix().GetVnlMatrix();
 
   spacing[0]=vnlmatrix.get_column(0).magnitude();
   spacing[1]=vnlmatrix.get_column(1).magnitude();
   spacing[2]=vnlmatrix.get_column(2).magnitude();
   floatSpacing[0]=spacing[0];
   floatSpacing[1]=spacing[1];
   floatSpacing[2]=spacing[2];
 }
 
 
 void mitk::Geometry3D::Initialize()
 {
   float b[6] = {0,1,0,1,0,1};
   SetFloatBounds(b);
 
   m_IndexToObjectTransform = TransformType::New();
   m_ObjectToNodeTransform = TransformType::New();
 
   if(m_IndexToWorldTransform.IsNull())
     m_IndexToWorldTransform = TransformType::New();
   else
     m_IndexToWorldTransform->SetIdentity();
   CopySpacingFromTransform(m_IndexToWorldTransform, m_Spacing, m_FloatSpacing);
   vtk2itk(m_IndexToWorldTransform->GetOffset(), m_Origin);
 
   m_VtkMatrix->Identity();
 
   m_TimeBounds[0]=ScalarTypeNumericTraits::NonpositiveMin(); m_TimeBounds[1]=ScalarTypeNumericTraits::max();
 
   m_FrameOfReferenceID = 0;
 
   m_ImageGeometry = false;
 }
 
 void mitk::Geometry3D::TransferItkToVtkTransform()
 {
   // copy m_IndexToWorldTransform into m_VtkIndexToWorldTransform
   TransferItkTransformToVtkMatrix(m_IndexToWorldTransform.GetPointer(), m_VtkMatrix);
   m_VtkIndexToWorldTransform->Modified();
 }
 
 void mitk::Geometry3D::TransferVtkToItkTransform()
 {
   TransferVtkMatrixToItkTransform(m_VtkMatrix, m_IndexToWorldTransform.GetPointer());
   CopySpacingFromTransform(m_IndexToWorldTransform, m_Spacing, m_FloatSpacing);
   vtk2itk(m_IndexToWorldTransform->GetOffset(), m_Origin);
 }
 
 void mitk::Geometry3D::SetIndexToWorldTransformByVtkMatrix(vtkMatrix4x4* vtkmatrix)
 {
   m_VtkMatrix->DeepCopy(vtkmatrix);
   TransferVtkToItkTransform();
 }
 
 void mitk::Geometry3D::SetTimeBounds(const TimeBounds& timebounds)
 {
   if(m_TimeBounds != timebounds)
   {
     m_TimeBounds = timebounds;
     Modified();
   }
 }
 
 void mitk::Geometry3D::SetFloatBounds(const float bounds[6])
 {
   mitk::BoundingBox::BoundsArrayType b;
   const float *input = bounds;
   int i=0;
   for(mitk::BoundingBox::BoundsArrayType::Iterator it = b.Begin(); i < 6 ;++i) *it++ = (mitk::ScalarType)*input++;
   SetBoundsArray(b, m_BoundingBox);
 }
 
 void mitk::Geometry3D::SetFloatBounds(const double bounds[6])
 {
   mitk::BoundingBox::BoundsArrayType b;
   const double *input = bounds;
   int i=0;
   for(mitk::BoundingBox::BoundsArrayType::Iterator it = b.Begin(); i < 6 ;++i) *it++ = (mitk::ScalarType)*input++;
   SetBoundsArray(b, m_BoundingBox);
 }
 
 void mitk::Geometry3D::SetParametricBounds(const BoundingBox::BoundsArrayType& bounds)
 {
   SetBoundsArray(bounds, m_ParametricBoundingBox);
 }
 
 void mitk::Geometry3D::WorldToIndex(const mitk::Point3D &pt_mm, mitk::Point3D &pt_units) const
 {
   BackTransform(pt_mm, pt_units);
 }
 
 void mitk::Geometry3D::IndexToWorld(const mitk::Point3D &pt_units, mitk::Point3D &pt_mm) const
 {
   pt_mm = m_IndexToWorldTransform->TransformPoint(pt_units);
 }
 
 void mitk::Geometry3D::WorldToIndex(const mitk::Point3D & /*atPt3d_mm*/, const mitk::Vector3D &vec_mm, mitk::Vector3D &vec_units) const
 {
   MITK_WARN<<"Warning! Call of the deprecated function Geometry3D::WorldToIndex(point, vec, vec). Use Geometry3D::WorldToIndex(vec, vec) instead!";
   //BackTransform(atPt3d_mm, vec_mm, vec_units);
   this->WorldToIndex(vec_mm, vec_units);
 }
 
 void mitk::Geometry3D::WorldToIndex( const mitk::Vector3D &vec_mm, mitk::Vector3D &vec_units) const
 {
   BackTransform( vec_mm, vec_units);
 }
 
 void mitk::Geometry3D::IndexToWorld(const mitk::Point3D &/*atPt3d_units*/, const mitk::Vector3D &vec_units, mitk::Vector3D &vec_mm) const
 {
   MITK_WARN<<"Warning! Call of the deprecated function Geometry3D::IndexToWorld(point, vec, vec). Use Geometry3D::IndexToWorld(vec, vec) instead!";
   //vec_mm = m_IndexToWorldTransform->TransformVector(vec_units);
   this->IndexToWorld(vec_units, vec_mm);
 }
 
 void mitk::Geometry3D::IndexToWorld(const mitk::Vector3D &vec_units, mitk::Vector3D &vec_mm) const
 {
   vec_mm = m_IndexToWorldTransform->TransformVector(vec_units);
 }
 
 void mitk::Geometry3D::SetIndexToWorldTransform(mitk::AffineTransform3D* transform)
 {
   if(m_IndexToWorldTransform.GetPointer() != transform)
   {
     Superclass::SetIndexToWorldTransform(transform);
     CopySpacingFromTransform(m_IndexToWorldTransform, m_Spacing, m_FloatSpacing);
     vtk2itk(m_IndexToWorldTransform->GetOffset(), m_Origin);
     TransferItkToVtkTransform();
     Modified();
   }
 }
 
 mitk::AffineGeometryFrame3D::Pointer mitk::Geometry3D::Clone() const
 {
   Self::Pointer newGeometry = new Self(*this);
   newGeometry->UnRegister();
   return newGeometry.GetPointer();
 }
 /*
 void mitk::Geometry3D::InitializeGeometry(Geometry3D * newGeometry) const
 {
   Superclass::InitializeGeometry(newGeometry);
 
   newGeometry->SetTimeBounds(m_TimeBounds);
 
   //newGeometry->GetVtkTransform()->SetMatrix(m_VtkIndexToWorldTransform->GetMatrix()); IW
   //newGeometry->TransferVtkToItkTransform(); //MH
 
   newGeometry->SetFrameOfReferenceID(GetFrameOfReferenceID());
   newGeometry->m_ImageGeometry = m_ImageGeometry;
 }
 */
 void mitk::Geometry3D::SetExtentInMM(int direction, ScalarType extentInMM)
 {
   ScalarType len = GetExtentInMM(direction);
   if(fabs(len - extentInMM)>=mitk::eps)
   {
     AffineTransform3D::MatrixType::InternalMatrixType vnlmatrix;
     vnlmatrix = m_IndexToWorldTransform->GetMatrix().GetVnlMatrix();
     if(len>extentInMM)
       vnlmatrix.set_column(direction, vnlmatrix.get_column(direction)/len*extentInMM);
     else
       vnlmatrix.set_column(direction, vnlmatrix.get_column(direction)*extentInMM/len);
     Matrix3D matrix;
     matrix = vnlmatrix;
     m_IndexToWorldTransform->SetMatrix(matrix);
     Modified();
   }
 }
 
 mitk::BoundingBox::Pointer mitk::Geometry3D::CalculateBoundingBoxRelativeToTransform(const mitk::AffineTransform3D* transform) const
 {
   mitk::BoundingBox::PointsContainer::Pointer pointscontainer=mitk::BoundingBox::PointsContainer::New();
 
   mitk::BoundingBox::PointIdentifier pointid=0;
 
   unsigned char i;
   if(transform!=NULL)
   {
     mitk::AffineTransform3D::Pointer inverse = mitk::AffineTransform3D::New();
     transform->GetInverse(inverse);
     for(i=0; i<8; ++i)
       pointscontainer->InsertElement( pointid++, inverse->TransformPoint( GetCornerPoint(i) ));
   }
   else
   {
     for(i=0; i<8; ++i)
       pointscontainer->InsertElement( pointid++, GetCornerPoint(i) );
   }
 
   mitk::BoundingBox::Pointer result = mitk::BoundingBox::New();
   result->SetPoints(pointscontainer);
   result->ComputeBoundingBox();
 
   return result;
 }
 
 #include <vtkTransform.h>
 void mitk::Geometry3D::ExecuteOperation(Operation* operation)
 {
   vtkTransform *vtktransform = vtkTransform::New();
   vtktransform->SetMatrix(m_VtkMatrix);
   switch (operation->GetOperationType())
   {
   case OpNOTHING:
     break;
   case OpMOVE:
     {
       mitk::PointOperation *pointOp = dynamic_cast<mitk::PointOperation *>(operation);
       if (pointOp == NULL)
       {
         //mitk::StatusBar::GetInstance()->DisplayText("received wrong type of operation!See mitkAffineInteractor.cpp", 10000);
         return;
       }
       mitk::Point3D newPos = pointOp->GetPoint();
       ScalarType data[3];
       vtktransform->GetPosition(data);
       vtktransform->PostMultiply();
       vtktransform->Translate(newPos[0], newPos[1], newPos[2]);
       vtktransform->PreMultiply();
       break;
     }
   case OpSCALE:
     {
       mitk::PointOperation *pointOp = dynamic_cast<mitk::PointOperation *>(operation);
       if (pointOp == NULL)
       {
         //mitk::StatusBar::GetInstance()->DisplayText("received wrong type of operation!See mitkAffineInteractor.cpp", 10000);
         return;
       }
       mitk::Point3D newScale = pointOp->GetPoint();
       ScalarType data[3];
       /* calculate new scale: newscale = oldscale * (oldscale + scaletoadd)/oldscale */
       data[0] = 1 + (newScale[0] / GetMatrixColumn(0).magnitude());
       data[1] = 1 + (newScale[1] / GetMatrixColumn(1).magnitude());
       data[2] = 1 + (newScale[2] / GetMatrixColumn(2).magnitude());
 
       mitk::Point3D center = const_cast<mitk::BoundingBox*>(m_BoundingBox.GetPointer())->GetCenter();
       ScalarType pos[3];
       vtktransform->GetPosition(pos);
       vtktransform->PostMultiply();
       vtktransform->Translate(-pos[0], -pos[1], -pos[2]);
       vtktransform->Translate(-center[0], -center[1], -center[2]);
       vtktransform->PreMultiply();
       vtktransform->Scale(data[0], data[1], data[2]);
       vtktransform->PostMultiply();
       vtktransform->Translate(+center[0], +center[1], +center[2]);
       vtktransform->Translate(pos[0], pos[1], pos[2]);
       vtktransform->PreMultiply();
       break;
     }
   case OpROTATE:
     {
       mitk::RotationOperation *rotateOp = dynamic_cast<mitk::RotationOperation *>(operation);
       if (rotateOp == NULL)
       {
         //mitk::StatusBar::GetInstance()->DisplayText("received wrong type of operation!See mitkAffineInteractor.cpp", 10000);
         return;
       }
       Vector3D rotationVector = rotateOp->GetVectorOfRotation();
       Point3D center = rotateOp->GetCenterOfRotation();
       ScalarType angle = rotateOp->GetAngleOfRotation();
       vtktransform->PostMultiply();
       vtktransform->Translate(-center[0], -center[1], -center[2]);
       vtktransform->RotateWXYZ(angle, rotationVector[0], rotationVector[1], rotationVector[2]);
       vtktransform->Translate(center[0], center[1], center[2]);
       vtktransform->PreMultiply();
       break;
     }
   case OpRESTOREPLANEPOSITION:
   {
       //Copy necessary to avoid vtk warning
       vtkMatrix4x4* matrix = vtkMatrix4x4::New();
       TransferItkTransformToVtkMatrix(dynamic_cast<mitk::RestorePlanePositionOperation*>(operation)->GetTransform().GetPointer(), matrix);
       vtktransform->SetMatrix(matrix);
       break;
   }
-
+  case OpAPPLYTRANSFORMMATRIX:
+  {
+    ApplyTransformMatrixOperation *applyMatrixOp = dynamic_cast< ApplyTransformMatrixOperation* >( operation );
+    vtktransform->SetMatrix(applyMatrixOp->GetMatrix());
+    break;
+  }
   default:
     vtktransform->Delete();
     return;
   }
   m_VtkMatrix->DeepCopy(vtktransform->GetMatrix());
   TransferVtkToItkTransform();
   Modified();
   vtktransform->Delete();
 }
 
 void mitk::Geometry3D::BackTransform(const mitk::Point3D &in, mitk::Point3D& out) const
 {
   ScalarType temp[3];
   unsigned int i, j;
   const TransformType::OffsetType& offset = m_IndexToWorldTransform->GetOffset();
 
   // Remove offset
   for (j = 0; j < 3; j++)
   {
     temp[j] = in[j] - offset[j];
   }
 
   // Get WorldToIndex transform
   if (m_IndexToWorldTransformLastModified != m_IndexToWorldTransform->GetMTime())
   {
     m_InvertedTransform = TransformType::New();
     if (!m_IndexToWorldTransform->GetInverse( m_InvertedTransform.GetPointer() ))
     {
       itkExceptionMacro( "Internal ITK matrix inversion error, cannot proceed." );
     }
     m_IndexToWorldTransformLastModified = m_IndexToWorldTransform->GetMTime();
   }
 
   // Check for valid matrix inversion
   const TransformType::MatrixType& inverse = m_InvertedTransform->GetMatrix();
   if(inverse.GetVnlMatrix().has_nans())
   {
     itkExceptionMacro( "Internal ITK matrix inversion error, cannot proceed. Matrix was: " << std::endl
       << m_IndexToWorldTransform->GetMatrix() << "Suggested inverted matrix is:" << std::endl
       << inverse );
   }
 
   // Transform point
   for (i = 0; i < 3; i++)
   {
     out[i] = 0.0;
     for (j = 0; j < 3; j++)
     {
       out[i] += inverse[i][j]*temp[j];
     }
   }
 }
 
 void mitk::Geometry3D::BackTransform(const mitk::Point3D &/*at*/, const mitk::Vector3D &in, mitk::Vector3D& out) const
 {
   MITK_INFO<<"Warning! Call of the deprecated function Geometry3D::BackTransform(point, vec, vec). Use Geometry3D::BackTransform(vec, vec) instead!";
   //// Get WorldToIndex transform
   //if (m_IndexToWorldTransformLastModified != m_IndexToWorldTransform->GetMTime())
   //{
   //  m_InvertedTransform = TransformType::New();
   //  if (!m_IndexToWorldTransform->GetInverse( m_InvertedTransform.GetPointer() ))
   //  {
   //    itkExceptionMacro( "Internal ITK matrix inversion error, cannot proceed." );
   //  }
   //  m_IndexToWorldTransformLastModified = m_IndexToWorldTransform->GetMTime();
   //}
 
   //// Check for valid matrix inversion
   //const TransformType::MatrixType& inverse = m_InvertedTransform->GetMatrix();
   //if(inverse.GetVnlMatrix().has_nans())
   //{
   //  itkExceptionMacro( "Internal ITK matrix inversion error, cannot proceed. Matrix was: " << std::endl
   //    << m_IndexToWorldTransform->GetMatrix() << "Suggested inverted matrix is:" << std::endl
   //    << inverse );
   //}
 
   //// Transform vector
   //for (unsigned int i = 0; i < 3; i++)
   //{
   //  out[i] = 0.0;
   //  for (unsigned int j = 0; j < 3; j++)
   //  {
   //    out[i] += inverse[i][j]*in[j];
   //  }
   //}
   this->BackTransform(in, out);
 }
 
 void mitk::Geometry3D::BackTransform(const mitk::Vector3D& in, mitk::Vector3D& out) const
 {
   // Get WorldToIndex transform
   if (m_IndexToWorldTransformLastModified != m_IndexToWorldTransform->GetMTime())
   {
     m_InvertedTransform = TransformType::New();
     if (!m_IndexToWorldTransform->GetInverse( m_InvertedTransform.GetPointer() ))
     {
       itkExceptionMacro( "Internal ITK matrix inversion error, cannot proceed." );
     }
     m_IndexToWorldTransformLastModified = m_IndexToWorldTransform->GetMTime();
   }
 
   // Check for valid matrix inversion
   const TransformType::MatrixType& inverse = m_InvertedTransform->GetMatrix();
   if(inverse.GetVnlMatrix().has_nans())
   {
     itkExceptionMacro( "Internal ITK matrix inversion error, cannot proceed. Matrix was: " << std::endl
       << m_IndexToWorldTransform->GetMatrix() << "Suggested inverted matrix is:" << std::endl
       << inverse );
   }
 
   // Transform vector
   for (unsigned int i = 0; i < 3; i++)
   {
     out[i] = 0.0;
     for (unsigned int j = 0; j < 3; j++)
     {
       out[i] += inverse[i][j]*in[j];
     }
   }
 }
 
 const float* mitk::Geometry3D::GetFloatSpacing() const
 {
   return m_FloatSpacing;
 }
 
 void mitk::Geometry3D::SetSpacing(const mitk::Vector3D& aSpacing)
 {
   if(mitk::Equal(m_Spacing, aSpacing) == false)
   {
     assert(aSpacing[0]>0 && aSpacing[1]>0 && aSpacing[2]>0);
 
     m_Spacing = aSpacing;
 
     AffineTransform3D::MatrixType::InternalMatrixType vnlmatrix;
 
     vnlmatrix = m_IndexToWorldTransform->GetMatrix().GetVnlMatrix();
 
     mitk::VnlVector col;
     col = vnlmatrix.get_column(0); col.normalize(); col*=aSpacing[0]; vnlmatrix.set_column(0, col);
     col = vnlmatrix.get_column(1); col.normalize(); col*=aSpacing[1]; vnlmatrix.set_column(1, col);
     col = vnlmatrix.get_column(2); col.normalize(); col*=aSpacing[2]; vnlmatrix.set_column(2, col);
 
     Matrix3D matrix;
     matrix = vnlmatrix;
 
     AffineTransform3D::Pointer transform = AffineTransform3D::New();
     transform->SetMatrix(matrix);
     transform->SetOffset(m_IndexToWorldTransform->GetOffset());
 
     SetIndexToWorldTransform(transform.GetPointer());
 
     itk2vtk(m_Spacing, m_FloatSpacing);
   }
 }
 
 void mitk::Geometry3D::SetOrigin(const Point3D & origin)
 {
   if(origin!=GetOrigin())
   {
     m_Origin = origin;
     m_IndexToWorldTransform->SetOffset(m_Origin.GetVectorFromOrigin());
     Modified();
     TransferItkToVtkTransform();
   }
 }
 
 void mitk::Geometry3D::Translate(const Vector3D & vector)
 {
   if((vector[0] != 0) || (vector[1] != 0) || (vector[2] != 0))
   {
     m_IndexToWorldTransform->SetOffset(m_IndexToWorldTransform->GetOffset()+vector);
     TransferItkToVtkTransform();
     Modified();
   }
 }
 
 void mitk::Geometry3D::SetIdentity()
 {
   m_IndexToWorldTransform->SetIdentity();
   m_Origin.Fill(0);
   Modified();
   TransferItkToVtkTransform();
 }
 
 void mitk::Geometry3D::Compose( const mitk::AffineGeometryFrame3D::TransformType * other, bool pre )
 {
   m_IndexToWorldTransform->Compose(other, pre);
   CopySpacingFromTransform(m_IndexToWorldTransform, m_Spacing, m_FloatSpacing);
   vtk2itk(m_IndexToWorldTransform->GetOffset(), m_Origin);
   Modified();
   TransferItkToVtkTransform();
 }
 
 void mitk::Geometry3D::Compose( const vtkMatrix4x4 * vtkmatrix, bool pre )
 {
   mitk::AffineGeometryFrame3D::TransformType::Pointer itkTransform = mitk::AffineGeometryFrame3D::TransformType::New();
   TransferVtkMatrixToItkTransform(vtkmatrix, itkTransform.GetPointer());
   Compose(itkTransform, pre);
 }
 
 const std::string mitk::Geometry3D::GetTransformAsString( TransformType* transformType )
 {
   std::ostringstream out;
 
   out << '[';
 
   for( int i=0; i<3; ++i )
   {
     out << '[';
     for( int j=0; j<3; ++j )
       out << transformType->GetMatrix().GetVnlMatrix().get(i, j) << ' ';
     out << ']';
   }
 
   out << "][";
 
   for( int i=0; i<3; ++i )
     out << transformType->GetOffset()[i] << ' ';
 
   out << "]\0";
 
   return out.str();
 }
 
 void mitk::Geometry3D::PrintSelf(std::ostream& os, itk::Indent indent) const
 {
   os << indent << " IndexToWorldTransform: ";
   if(m_IndexToWorldTransform.IsNull())
     os << "NULL" << std::endl;
   else
   {
     // from itk::MatrixOffsetTransformBase
     unsigned int i, j;
     os << std::endl;
     os << indent << "Matrix: " << std::endl;
     for (i = 0; i < 3; i++)
     {
       os << indent.GetNextIndent();
       for (j = 0; j < 3; j++)
       {
         os << m_IndexToWorldTransform->GetMatrix()[i][j] << " ";
       }
       os << std::endl;
     }
 
     os << indent << "Offset: " << m_IndexToWorldTransform->GetOffset() << std::endl;
     os << indent << "Center: " << m_IndexToWorldTransform->GetCenter() << std::endl;
     os << indent << "Translation: " << m_IndexToWorldTransform->GetTranslation() << std::endl;
 
     os << indent << "Inverse: " << std::endl;
     for (i = 0; i < 3; i++)
     {
       os << indent.GetNextIndent();
       for (j = 0; j < 3; j++)
       {
         os << m_IndexToWorldTransform->GetInverseMatrix()[i][j] << " ";
       }
       os << std::endl;
     }
 
     // from itk::ScalableAffineTransform
     os << indent << "Scale : ";
     for (i = 0; i < 3; i++)
     {
       os << m_IndexToWorldTransform->GetScale()[i] << " ";
     }
     os << std::endl;
   }
 
   os << indent << " BoundingBox: ";
   if(m_BoundingBox.IsNull())
     os << "NULL" << std::endl;
   else
   {
     os << indent << "( ";
     for (unsigned int i=0; i<3; i++)
     {
       os << m_BoundingBox->GetBounds()[2*i] << "," << m_BoundingBox->GetBounds()[2*i+1] << " ";
     }
     os << " )" << std::endl;
   }
 
   os << indent << " Origin: " << m_Origin << std::endl;
   os << indent << " ImageGeometry: " << m_ImageGeometry << std::endl;
   os << indent << " Spacing: " << m_Spacing << std::endl;
   os << indent << " TimeBounds: " << m_TimeBounds << std::endl;
 }
 
 mitk::Point3D mitk::Geometry3D::GetCornerPoint(int id) const
 {
   assert(id >= 0);
   assert(m_BoundingBox.IsNotNull());
 
   BoundingBox::BoundsArrayType bounds = m_BoundingBox->GetBounds();
 
   Point3D cornerpoint;
   switch(id)
   {
   case 0: FillVector3D(cornerpoint, bounds[0],bounds[2],bounds[4]); break;
   case 1: FillVector3D(cornerpoint, bounds[0],bounds[2],bounds[5]); break;
   case 2: FillVector3D(cornerpoint, bounds[0],bounds[3],bounds[4]); break;
   case 3: FillVector3D(cornerpoint, bounds[0],bounds[3],bounds[5]); break;
   case 4: FillVector3D(cornerpoint, bounds[1],bounds[2],bounds[4]); break;
   case 5: FillVector3D(cornerpoint, bounds[1],bounds[2],bounds[5]); break;
   case 6: FillVector3D(cornerpoint, bounds[1],bounds[3],bounds[4]); break;
   case 7: FillVector3D(cornerpoint, bounds[1],bounds[3],bounds[5]); break;
   default:
     {
       itkExceptionMacro(<<"A cube only has 8 corners. These are labeled 0-7.");
       return NULL;
     }
   }
   if(m_ImageGeometry)
   {
     // Here i have to adjust the 0.5 offset manually, because the cornerpoint is the corner of the
     // bounding box. The bounding box itself is no image, so it is corner-based
     FillVector3D(cornerpoint, cornerpoint[0]-0.5, cornerpoint[1]-0.5, cornerpoint[2]-0.5);
   }
   return m_IndexToWorldTransform->TransformPoint(cornerpoint);
 }
 
 mitk::Point3D mitk::Geometry3D::GetCornerPoint(bool xFront, bool yFront, bool zFront) const
 {
   assert(m_BoundingBox.IsNotNull());
   BoundingBox::BoundsArrayType bounds = m_BoundingBox->GetBounds();
 
   Point3D cornerpoint;
   cornerpoint[0] = (xFront ? bounds[0] : bounds[1]);
   cornerpoint[1] = (yFront ? bounds[2] : bounds[3]);
   cornerpoint[2] = (zFront ? bounds[4] : bounds[5]);
   if(m_ImageGeometry)
   {
     // Here i have to adjust the 0.5 offset manually, because the cornerpoint is the corner of the
     // bounding box. The bounding box itself is no image, so it is corner-based
     FillVector3D(cornerpoint, cornerpoint[0]-0.5, cornerpoint[1]-0.5, cornerpoint[2]-0.5);
   }
 
   return m_IndexToWorldTransform->TransformPoint(cornerpoint);
 }
 
 void
 mitk::Geometry3D::ResetSubTransforms()
 {
 }
 
 void
 mitk::Geometry3D::ChangeImageGeometryConsideringOriginOffset( const bool isAnImageGeometry )
 {
   // If Geometry is switched to ImageGeometry, you have to put an offset to the origin, because
   // imageGeometries origins are pixel-center-based
   // ... and remove the offset, if you switch an imageGeometry back to a normal geometry
   // For more information please see the Geometry documentation page
 
   if(m_ImageGeometry == isAnImageGeometry)
     return;
 
   const BoundingBox::BoundsArrayType& boundsarray =
     this->GetBoundingBox()->GetBounds();
 
   Point3D  originIndex;
   FillVector3D(originIndex,  boundsarray[0], boundsarray[2], boundsarray[4]);
 
   if(isAnImageGeometry == true)
     FillVector3D( originIndex,
       originIndex[0] + 0.5,
       originIndex[1] + 0.5,
       originIndex[2] + 0.5 );
   else
     FillVector3D( originIndex,
       originIndex[0] - 0.5,
       originIndex[1] - 0.5,
       originIndex[2] - 0.5 );
 
   Point3D originWorld;
 
   originWorld = GetIndexToWorldTransform()
     ->TransformPoint( originIndex );
   // instead could as well call  IndexToWorld(originIndex,originWorld);
 
   SetOrigin(originWorld);
 
   this->SetImageGeometry(isAnImageGeometry);
 }
 
 
 bool mitk::Geometry3D::Is2DConvertable()
 {
    bool isConvertableWithoutLoss = true;
    do
    {
       if (this->GetSpacing()[2] != 1)
       {
          isConvertableWithoutLoss = false;
          break;
       }
       if (this->GetOrigin()[2] != 0)
       {
          isConvertableWithoutLoss = false;
          break;
       }
       mitk::Vector3D col0, col1, col2;
       col0.Set_vnl_vector(this->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(0));
       col1.Set_vnl_vector(this->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(1));
       col2.Set_vnl_vector(this->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(2));
 
       if ((col0[2] != 0) || (col1[2] != 0) || (col2[0] != 0) || (col2[1] != 0) || (col2[2] != 1))
       {
          isConvertableWithoutLoss = false;
          break;
       }
    } while (0);
 
    return isConvertableWithoutLoss;
 }
diff --git a/Core/Code/DataManagement/mitkSlicedGeometry3D.cpp b/Core/Code/DataManagement/mitkSlicedGeometry3D.cpp
index 06a3d7f416..1a1777636b 100644
--- a/Core/Code/DataManagement/mitkSlicedGeometry3D.cpp
+++ b/Core/Code/DataManagement/mitkSlicedGeometry3D.cpp
@@ -1,1026 +1,1052 @@
 /*===================================================================
 
 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 "mitkSlicedGeometry3D.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkRotationOperation.h"
 #include "mitkPlaneOperation.h"
 #include "mitkRestorePlanePositionOperation.h"
+#include "mitkApplyTransformMatrixOperation.h"
 #include "mitkInteractionConst.h"
 #include "mitkSliceNavigationController.h"
 
 const float PI = 3.14159265359;
 
 mitk::SlicedGeometry3D::SlicedGeometry3D()
 : m_EvenlySpaced( true ),
   m_Slices( 0 ),
   m_ReferenceGeometry( NULL ),
   m_SliceNavigationController( NULL )
 {
    m_DirectionVector.Fill(0);
   this->InitializeSlicedGeometry( m_Slices );
 }
 
 mitk::SlicedGeometry3D::SlicedGeometry3D(const SlicedGeometry3D& other)
 : Superclass(other),
   m_EvenlySpaced( other.m_EvenlySpaced ),
   m_Slices( other.m_Slices ),
   m_ReferenceGeometry( other.m_ReferenceGeometry ),
   m_SliceNavigationController( other.m_SliceNavigationController )
 {
    m_DirectionVector.Fill(0);
   SetSpacing( other.GetSpacing() );
   SetDirectionVector( other.GetDirectionVector() );
 
   if ( m_EvenlySpaced )
   {
     AffineGeometryFrame3D::Pointer geometry = other.m_Geometry2Ds[0]->Clone();
     Geometry2D* geometry2D = dynamic_cast<Geometry2D*>(geometry.GetPointer());
     assert(geometry2D!=NULL);
     SetGeometry2D(geometry2D, 0);
   }
   else
   {
     unsigned int s;
     for ( s = 0; s < other.m_Slices; ++s )
     {
       if ( other.m_Geometry2Ds[s].IsNull() )
       {
         assert(other.m_EvenlySpaced);
         m_Geometry2Ds[s] = NULL;
       }
       else
       {
         AffineGeometryFrame3D::Pointer geometry = other.m_Geometry2Ds[s]->Clone();
         Geometry2D* geometry2D = dynamic_cast<Geometry2D*>(geometry.GetPointer());
         assert(geometry2D!=NULL);
         SetGeometry2D(geometry2D, s);
       }
     }
   }
 }
 
 mitk::SlicedGeometry3D::~SlicedGeometry3D()
 {
 }
 
 
 mitk::Geometry2D *
 mitk::SlicedGeometry3D::GetGeometry2D( int s ) const
 {
   mitk::Geometry2D::Pointer geometry2D = NULL;
 
   if ( this->IsValidSlice(s) )
   {
     geometry2D = m_Geometry2Ds[s];
 
     // If (a) m_EvenlySpaced==true, (b) we don't have a Geometry2D stored
     // for the requested slice, and (c) the first slice (s=0)
     // is a PlaneGeometry instance, then we calculate the geometry of the
     // requested as the plane of the first slice shifted by m_Spacing[2]*s
     // in the direction of m_DirectionVector.
     if ( (m_EvenlySpaced) && (geometry2D.IsNull()) )
     {
       PlaneGeometry *firstSlice = dynamic_cast< PlaneGeometry * > (
         m_Geometry2Ds[0].GetPointer() );
 
       if ( firstSlice != NULL )
       {
         if ( (m_DirectionVector[0] == 0.0)
           && (m_DirectionVector[1] == 0.0)
           && (m_DirectionVector[2] == 0.0) )
         {
           m_DirectionVector = firstSlice->GetNormal();
           m_DirectionVector.Normalize();
         }
 
         Vector3D direction;
         direction = m_DirectionVector * m_Spacing[2];
 
         mitk::PlaneGeometry::Pointer requestedslice;
         requestedslice = static_cast< mitk::PlaneGeometry * >(
           firstSlice->Clone().GetPointer() );
 
         requestedslice->SetOrigin(
           requestedslice->GetOrigin() + direction * s );
 
         geometry2D = requestedslice;
         m_Geometry2Ds[s] = geometry2D;
       }
     }
     return geometry2D;
   }
   else
   {
     return NULL;
   }
 }
 
 const mitk::BoundingBox *
 mitk::SlicedGeometry3D::GetBoundingBox() const
 {
   assert(m_BoundingBox.IsNotNull());
   return m_BoundingBox.GetPointer();
 }
 
 
 bool
 mitk::SlicedGeometry3D::SetGeometry2D( mitk::Geometry2D *geometry2D, int s )
 {
   if ( this->IsValidSlice(s) )
   {
     m_Geometry2Ds[s] = geometry2D;
     m_Geometry2Ds[s]->SetReferenceGeometry( m_ReferenceGeometry );
     return true;
   }
   return false;
 }
 
 
 void
 mitk::SlicedGeometry3D::InitializeSlicedGeometry( unsigned int slices )
 {
   Superclass::Initialize();
   m_Slices = slices;
 
   Geometry2D::Pointer gnull = NULL;
   m_Geometry2Ds.assign( m_Slices, gnull );
 
   Vector3D spacing;
   spacing.Fill( 1.0 );
   this->SetSpacing( spacing );
 
   m_DirectionVector.Fill( 0 );
 }
 
 
 void
 mitk::SlicedGeometry3D::InitializeEvenlySpaced(
   mitk::Geometry2D* geometry2D, unsigned int slices, bool flipped )
 {
   assert( geometry2D != NULL );
   this->InitializeEvenlySpaced(
     geometry2D, geometry2D->GetExtentInMM(2)/geometry2D->GetExtent(2),
     slices, flipped );
 }
 
 
 void
 mitk::SlicedGeometry3D::InitializeEvenlySpaced(
   mitk::Geometry2D* geometry2D, mitk::ScalarType zSpacing,
   unsigned int slices, bool flipped )
 {
   assert( geometry2D != NULL );
   assert( geometry2D->GetExtent(0) > 0 );
   assert( geometry2D->GetExtent(1) > 0 );
 
   geometry2D->Register();
 
   Superclass::Initialize();
   m_Slices = slices;
 
   BoundingBox::BoundsArrayType bounds = geometry2D->GetBounds();
   bounds[4] = 0;
   bounds[5] = slices;
 
   // clear and reserve
   Geometry2D::Pointer gnull = NULL;
   m_Geometry2Ds.assign( m_Slices, gnull );
 
   Vector3D directionVector = geometry2D->GetAxisVector(2);
   directionVector.Normalize();
   directionVector *= zSpacing;
 
   if ( flipped == false )
   {
     // Normally we should use the following four lines to create a copy of
     // the transform contrained in geometry2D, because it may not be changed
     // by us. But we know that SetSpacing creates a new transform without
     // changing the old (coming from geometry2D), so we can use the fifth
     // line instead. We check this at (**).
     //
     // AffineTransform3D::Pointer transform = AffineTransform3D::New();
     // transform->SetMatrix(geometry2D->GetIndexToWorldTransform()->GetMatrix());
     // transform->SetOffset(geometry2D->GetIndexToWorldTransform()->GetOffset());
     // SetIndexToWorldTransform(transform);
 
     m_IndexToWorldTransform = const_cast< AffineTransform3D * >(
       geometry2D->GetIndexToWorldTransform() );
   }
   else
   {
     directionVector *= -1.0;
     m_IndexToWorldTransform = AffineTransform3D::New();
     m_IndexToWorldTransform->SetMatrix(
       geometry2D->GetIndexToWorldTransform()->GetMatrix() );
 
     AffineTransform3D::OutputVectorType scaleVector;
     FillVector3D(scaleVector, 1.0, 1.0, -1.0);
     m_IndexToWorldTransform->Scale(scaleVector, true);
     m_IndexToWorldTransform->SetOffset(
       geometry2D->GetIndexToWorldTransform()->GetOffset() );
   }
 
   mitk::Vector3D spacing;
   FillVector3D( spacing,
     geometry2D->GetExtentInMM(0) / bounds[1],
     geometry2D->GetExtentInMM(1) / bounds[3],
     zSpacing );
 
   // Ensure that spacing differs from m_Spacing to make SetSpacing change the
   // matrix.
   m_Spacing[2] = zSpacing - 1;
 
   this->SetDirectionVector( directionVector );
   this->SetBounds( bounds );
   this->SetGeometry2D( geometry2D, 0 );
   this->SetSpacing( spacing );
   this->SetEvenlySpaced();
   this->SetTimeBounds( geometry2D->GetTimeBounds() );
 
   assert(m_IndexToWorldTransform.GetPointer()
          != geometry2D->GetIndexToWorldTransform()); // (**) see above.
 
   this->SetFrameOfReferenceID( geometry2D->GetFrameOfReferenceID() );
   this->SetImageGeometry( geometry2D->GetImageGeometry() );
 
   geometry2D->UnRegister();
 }
 
 
 void
 mitk::SlicedGeometry3D::InitializePlanes(
   const mitk::Geometry3D *geometry3D,
   mitk::PlaneGeometry::PlaneOrientation planeorientation,
   bool top, bool frontside, bool rotated )
 {
   m_ReferenceGeometry = const_cast< Geometry3D * >( geometry3D );
 
   PlaneGeometry::Pointer planeGeometry = mitk::PlaneGeometry::New();
   planeGeometry->InitializeStandardPlane(
     geometry3D, top, planeorientation, frontside, rotated );
 
   ScalarType viewSpacing = 1;
   unsigned int slices = 1;
 
   switch ( planeorientation )
   {
     case PlaneGeometry::Axial:
       viewSpacing = geometry3D->GetSpacing()[2];
       slices = (unsigned int) geometry3D->GetExtent( 2 );
       break;
 
     case PlaneGeometry::Frontal:
       viewSpacing = geometry3D->GetSpacing()[1];
       slices = (unsigned int) geometry3D->GetExtent( 1 );
       break;
 
     case PlaneGeometry::Sagittal:
       viewSpacing = geometry3D->GetSpacing()[0];
       slices = (unsigned int) geometry3D->GetExtent( 0 );
       break;
 
     default:
       itkExceptionMacro("unknown PlaneOrientation");
   }
 
   mitk::Vector3D normal = this->AdjustNormal( planeGeometry->GetNormal() );
 
 
   ScalarType directedExtent =
       fabs( m_ReferenceGeometry->GetExtentInMM( 0 ) * normal[0] )
     + fabs( m_ReferenceGeometry->GetExtentInMM( 1 ) * normal[1] )
     + fabs( m_ReferenceGeometry->GetExtentInMM( 2 ) * normal[2] );
 
   if ( directedExtent >= viewSpacing )
   {
     slices = static_cast< int >(directedExtent / viewSpacing + 0.5);
   }
   else
   {
     slices = 1;
   }
 
   bool flipped = (top == false);
 
   if ( frontside == false )
   {
     flipped = !flipped;
   }
   if ( planeorientation == PlaneGeometry::Frontal )
   {
     flipped = !flipped;
   }
 
   this->InitializeEvenlySpaced( planeGeometry, viewSpacing, slices, flipped );
 }
 
 
 void
 mitk::SlicedGeometry3D
 ::ReinitializePlanes( const Point3D &center, const Point3D &referencePoint )
 {
   // Need a reference frame to align the rotated planes
   if ( !m_ReferenceGeometry )
   {
     return;
   }
 
   // Get first plane of plane stack
   PlaneGeometry *firstPlane =
     dynamic_cast< PlaneGeometry * >( m_Geometry2Ds[0].GetPointer() );
 
   // If plane stack is empty, exit
   if ( firstPlane == NULL )
   {
     return;
   }
 
   // Calculate the "directed" spacing when taking the plane (defined by its axes
   // vectors and normal) as the reference coordinate frame.
   //
   // This is done by calculating the radius of the ellipsoid defined by the
   // original volume spacing axes, in the direction of the respective axis of the
   // reference frame.
   mitk::Vector3D axis0 = firstPlane->GetAxisVector(0);
   mitk::Vector3D axis1 = firstPlane->GetAxisVector(1);
   mitk::Vector3D normal = firstPlane->GetNormal();
   normal.Normalize();
 
   Vector3D spacing;
   spacing[0] = this->CalculateSpacing( axis0 );
   spacing[1] = this->CalculateSpacing( axis1 );
   spacing[2] = this->CalculateSpacing( normal );
 
   Superclass::SetSpacing( spacing );
 
 
   // Now we need to calculate the number of slices in the plane's normal
   // direction, so that the entire volume is covered. This is done by first
   // calculating the dot product between the volume diagonal (the maximum
   // distance inside the volume) and the normal, and dividing this value by
   // the directed spacing calculated above.
   ScalarType directedExtent =
       fabs( m_ReferenceGeometry->GetExtentInMM( 0 ) * normal[0] )
     + fabs( m_ReferenceGeometry->GetExtentInMM( 1 ) * normal[1] )
     + fabs( m_ReferenceGeometry->GetExtentInMM( 2 ) * normal[2] );
 
   if ( directedExtent >= spacing[2] )
   {
     m_Slices = static_cast< unsigned int >(directedExtent / spacing[2] + 0.5);
   }
   else
   {
     m_Slices = 1;
   }
 
   // The origin of our "first plane" needs to be adapted to this new extent.
   // To achieve this, we first calculate the current distance to the volume's
   // center, and then shift the origin in the direction of the normal by the
   // difference between this distance and half of the new extent.
   double centerOfRotationDistance =
     firstPlane->SignedDistanceFromPlane( center );
 
   if ( centerOfRotationDistance > 0 )
   {
     firstPlane->SetOrigin( firstPlane->GetOrigin()
       + normal * (centerOfRotationDistance - directedExtent / 2.0)
     );
     m_DirectionVector = normal;
   }
   else
   {
     firstPlane->SetOrigin( firstPlane->GetOrigin()
       + normal * (directedExtent / 2.0 + centerOfRotationDistance)
     );
     m_DirectionVector = -normal;
   }
 
   // Now we adjust this distance according with respect to the given reference
   // point: we need to make sure that the point is touched by one slice of the
   // new slice stack.
   double referencePointDistance =
     firstPlane->SignedDistanceFromPlane( referencePoint );
 
   int referencePointSlice = static_cast< int >(
     referencePointDistance / spacing[2]);
 
   double alignmentValue =
     referencePointDistance / spacing[2] - referencePointSlice;
 
   firstPlane->SetOrigin(
     firstPlane->GetOrigin() + normal * alignmentValue * spacing[2] );
 
 
   // Finally, we can clear the previous geometry stack and initialize it with
   // our re-initialized "first plane".
   m_Geometry2Ds.assign( m_Slices, Geometry2D::Pointer( NULL ) );
 
   if ( m_Slices > 0 )
   {
     m_Geometry2Ds[0] = firstPlane;
   }
 
   // Reinitialize SNC with new number of slices
   m_SliceNavigationController->GetSlice()->SetSteps( m_Slices );
 
   this->Modified();
 }
 
 
 double
 mitk::SlicedGeometry3D::CalculateSpacing( const mitk::Vector3D &d ) const
 {
    // Need the spacing of the underlying dataset / geometry
    if ( !m_ReferenceGeometry )
    {
       return 1.0;
    }
 
    const mitk::Vector3D &spacing = m_ReferenceGeometry->GetSpacing();
    return SlicedGeometry3D::CalculateSpacing( spacing, d );
 }
 
 double mitk::SlicedGeometry3D::CalculateSpacing( const mitk::Vector3D spacing, const mitk::Vector3D &d )
 {
   // The following can be derived from the ellipsoid equation
   //
   //   1 = x^2/a^2 + y^2/b^2 + z^2/c^2
   //
   // where (a,b,c) = spacing of original volume (ellipsoid radii)
   // and   (x,y,z) = scaled coordinates of vector d (according to ellipsoid)
   //
   double scaling = d[0]*d[0] / (spacing[0] * spacing[0])
     + d[1]*d[1] / (spacing[1] * spacing[1])
     + d[2]*d[2] / (spacing[2] * spacing[2]);
 
   scaling = sqrt( scaling );
 
   return ( sqrt( d[0]*d[0] + d[1]*d[1] + d[2]*d[2] ) / scaling );
 }
 
 mitk::Vector3D
 mitk::SlicedGeometry3D::AdjustNormal( const mitk::Vector3D &normal ) const
 {
   Geometry3D::TransformType::Pointer inverse = Geometry3D::TransformType::New();
   m_ReferenceGeometry->GetIndexToWorldTransform()->GetInverse( inverse );
 
   Vector3D transformedNormal = inverse->TransformVector( normal );
 
   transformedNormal.Normalize();
   return transformedNormal;
 }
 
 
 void
 mitk::SlicedGeometry3D::SetImageGeometry( const bool isAnImageGeometry )
 {
   Superclass::SetImageGeometry( isAnImageGeometry );
 
   mitk::Geometry3D* geometry;
 
   unsigned int s;
   for ( s = 0; s < m_Slices; ++s )
   {
     geometry = m_Geometry2Ds[s];
     if ( geometry!=NULL )
     {
       geometry->SetImageGeometry( isAnImageGeometry );
     }
   }
 }
 
 void
 mitk::SlicedGeometry3D::ChangeImageGeometryConsideringOriginOffset( const bool isAnImageGeometry )
 {
   mitk::Geometry3D* geometry;
 
   unsigned int s;
   for ( s = 0; s < m_Slices; ++s )
   {
     geometry = m_Geometry2Ds[s];
     if ( geometry!=NULL )
     {
       geometry->ChangeImageGeometryConsideringOriginOffset( isAnImageGeometry );
     }
   }
 
   Superclass::ChangeImageGeometryConsideringOriginOffset( isAnImageGeometry );
 }
 
 
 bool
 mitk::SlicedGeometry3D::IsValidSlice( int s ) const
 {
   return ((s >= 0) && (s < (int)m_Slices));
 }
 
 void
 mitk::SlicedGeometry3D::SetReferenceGeometry( Geometry3D *referenceGeometry )
 {
   m_ReferenceGeometry = referenceGeometry;
 
   std::vector<Geometry2D::Pointer>::iterator it;
 
   for ( it = m_Geometry2Ds.begin(); it != m_Geometry2Ds.end(); ++it )
   {
     (*it)->SetReferenceGeometry( referenceGeometry );
   }
 }
 
 void
 mitk::SlicedGeometry3D::SetSpacing( const mitk::Vector3D &aSpacing )
 {
   bool hasEvenlySpacedPlaneGeometry = false;
   mitk::Point3D origin;
   mitk::Vector3D rightDV, bottomDV;
   BoundingBox::BoundsArrayType bounds;
 
   assert(aSpacing[0]>0 && aSpacing[1]>0 && aSpacing[2]>0);
 
   // In case of evenly-spaced data: re-initialize instances of Geometry2D,
   // since the spacing influences them
   if ((m_EvenlySpaced) && (m_Geometry2Ds.size() > 0))
   {
     mitk::Geometry2D::ConstPointer firstGeometry =
       m_Geometry2Ds[0].GetPointer();
 
     const PlaneGeometry *planeGeometry =
       dynamic_cast< const PlaneGeometry * >( firstGeometry.GetPointer() );
 
     if (planeGeometry != NULL )
     {
       this->WorldToIndex( planeGeometry->GetOrigin(), origin );
       this->WorldToIndex( planeGeometry->GetAxisVector(0), rightDV );
       this->WorldToIndex( planeGeometry->GetAxisVector(1), bottomDV );
 
       bounds = planeGeometry->GetBounds();
       hasEvenlySpacedPlaneGeometry = true;
     }
   }
 
   Superclass::SetSpacing(aSpacing);
 
   mitk::Geometry2D::Pointer firstGeometry;
 
   // In case of evenly-spaced data: re-initialize instances of Geometry2D,
   // since the spacing influences them
   if ( hasEvenlySpacedPlaneGeometry )
   {
     //create planeGeometry according to new spacing
     this->IndexToWorld( origin, origin );
     this->IndexToWorld( rightDV, rightDV );
     this->IndexToWorld( bottomDV, bottomDV );
 
     mitk::PlaneGeometry::Pointer planeGeometry = mitk::PlaneGeometry::New();
     planeGeometry->SetImageGeometry( this->GetImageGeometry() );
 
     planeGeometry->SetReferenceGeometry( m_ReferenceGeometry );
     planeGeometry->InitializeStandardPlane(
       rightDV.Get_vnl_vector(), bottomDV.Get_vnl_vector(), &m_Spacing );
     planeGeometry->SetOrigin(origin);
     planeGeometry->SetBounds(bounds);
 
     firstGeometry = planeGeometry;
   }
   else if ( (m_EvenlySpaced) && (m_Geometry2Ds.size() > 0) )
   {
     firstGeometry = m_Geometry2Ds[0].GetPointer();
   }
 
   //clear and reserve
   Geometry2D::Pointer gnull=NULL;
   m_Geometry2Ds.assign(m_Slices, gnull);
 
   if ( m_Slices > 0 )
   {
     m_Geometry2Ds[0] = firstGeometry;
   }
 
   this->Modified();
 }
 
 
 void
 mitk::SlicedGeometry3D
 ::SetSliceNavigationController( SliceNavigationController *snc )
 {
   m_SliceNavigationController = snc;
 }
 
 
 mitk::SliceNavigationController *
 mitk::SlicedGeometry3D::GetSliceNavigationController()
 {
   return m_SliceNavigationController;
 }
 
 void
 mitk::SlicedGeometry3D::SetEvenlySpaced(bool on)
 {
   if(m_EvenlySpaced!=on)
   {
     m_EvenlySpaced=on;
     this->Modified();
   }
 }
 
 
 void
 mitk::SlicedGeometry3D
 ::SetDirectionVector( const mitk::Vector3D& directionVector )
 {
    Vector3D newDir = directionVector;
    newDir.Normalize();
    if ( newDir != m_DirectionVector )
   {
       m_DirectionVector = newDir;
     this->Modified();
   }
 }
 
 
 void
 mitk::SlicedGeometry3D::SetTimeBounds( const mitk::TimeBounds& timebounds )
 {
   Superclass::SetTimeBounds( timebounds );
 
   unsigned int s;
   for ( s = 0; s < m_Slices; ++s )
   {
     if(m_Geometry2Ds[s].IsNotNull())
     {
       m_Geometry2Ds[s]->SetTimeBounds( timebounds );
     }
   }
   m_TimeBounds = timebounds;
 }
 
 
 mitk::AffineGeometryFrame3D::Pointer
 mitk::SlicedGeometry3D::Clone() const
 {
   Self::Pointer newGeometry = new SlicedGeometry3D(*this);
   newGeometry->UnRegister();
   return newGeometry.GetPointer();
 }
 
 void
 mitk::SlicedGeometry3D::PrintSelf( std::ostream& os, itk::Indent indent ) const
 {
   Superclass::PrintSelf(os,indent);
   os << indent << " EvenlySpaced: " << m_EvenlySpaced << std::endl;
   if ( m_EvenlySpaced )
   {
     os << indent << " DirectionVector: " << m_DirectionVector << std::endl;
   }
   os << indent << " Slices: " << m_Slices << std::endl;
 
   os << std::endl;
   os << indent << " GetGeometry2D(0): ";
   if ( this->GetGeometry2D(0) == NULL )
   {
     os << "NULL" << std::endl;
   }
   else
   {
     this->GetGeometry2D(0)->Print(os, indent);
   }
 }
 
 void
 mitk::SlicedGeometry3D::ExecuteOperation(Operation* operation)
 {
   switch ( operation->GetOperationType() )
   {
   case OpNOTHING:
     break;
 
   case OpROTATE:
     if ( m_EvenlySpaced )
     {
       // Need a reference frame to align the rotation
       if ( m_ReferenceGeometry )
       {
         // Clear all generated geometries and then rotate only the first slice.
         // The other slices will be re-generated on demand
 
         // Save first slice
         Geometry2D::Pointer geometry2D = m_Geometry2Ds[0];
 
         RotationOperation *rotOp = dynamic_cast< RotationOperation * >( operation );
 
         // Generate a RotationOperation using the dataset center instead of
         // the supplied rotation center. This is necessary so that the rotated
         // zero-plane does not shift away. The supplied center is instead used
         // to adjust the slice stack afterwards.
         Point3D center = m_ReferenceGeometry->GetCenter();
 
         RotationOperation centeredRotation(
           rotOp->GetOperationType(),
           center,
           rotOp->GetVectorOfRotation(),
           rotOp->GetAngleOfRotation()
         );
 
         // Rotate first slice
         geometry2D->ExecuteOperation( &centeredRotation );
 
         // Clear the slice stack and adjust it according to the center of
         // the dataset and the supplied rotation center (see documentation of
         // ReinitializePlanes)
         this->ReinitializePlanes( center, rotOp->GetCenterOfRotation() );
 
         geometry2D->SetSpacing(this->GetSpacing());
 
         if ( m_SliceNavigationController )
         {
           m_SliceNavigationController->SelectSliceByPoint(
             rotOp->GetCenterOfRotation() );
           m_SliceNavigationController->AdjustSliceStepperRange();
         }
 
         Geometry3D::ExecuteOperation( &centeredRotation );
       }
       else
       {
         // we also have to consider the case, that there is no reference geometry available.
         if ( m_Geometry2Ds.size() > 0 )
         {
            // Reach through to all slices in my container
            for (std::vector<Geometry2D::Pointer>::iterator iter = m_Geometry2Ds.begin();
               iter != m_Geometry2Ds.end();
               ++iter)
            {
               (*iter)->ExecuteOperation(operation);
            }
 
           // rotate overall geometry
           RotationOperation *rotOp = dynamic_cast< RotationOperation * >( operation );
           Geometry3D::ExecuteOperation( rotOp);
         }
 
       }
     }
     else
     {
       // Reach through to all slices
       for (std::vector<Geometry2D::Pointer>::iterator iter = m_Geometry2Ds.begin();
           iter != m_Geometry2Ds.end();
           ++iter)
       {
         (*iter)->ExecuteOperation(operation);
       }
     }
     break;
 
   case OpORIENT:
     if ( m_EvenlySpaced )
     {
        // get operation data
       PlaneOperation *planeOp = dynamic_cast< PlaneOperation * >( operation );
 
       // Get first slice
       Geometry2D::Pointer geometry2D = m_Geometry2Ds[0];
       PlaneGeometry *planeGeometry = dynamic_cast< PlaneGeometry * >(
         geometry2D.GetPointer() );
 
       // Need a PlaneGeometry, a PlaneOperation and a reference frame to
       // carry out the re-orientation. If not all avaialble, stop here
       if ( !m_ReferenceGeometry || !planeGeometry || !planeOp )
       {
          break;
       }
 
       // General Behavior:
       // Clear all generated geometries and then rotate only the first slice.
       // The other slices will be re-generated on demand
 
       //
       // 1st Step: Reorient Normal Vector of first plane
       //
       Point3D center = planeOp->GetPoint(); //m_ReferenceGeometry->GetCenter();
       mitk::Vector3D currentNormal = planeGeometry->GetNormal();
       mitk::Vector3D newNormal;
       if (planeOp->AreAxisDefined())
       {
          // If planeOp was defined by one centerpoint and two axis vectors
          newNormal = CrossProduct(planeOp->GetAxisVec0(), planeOp->GetAxisVec1());
       }
       else
       {
          // If planeOp was defined by one centerpoint and one normal vector
          newNormal = planeOp->GetNormal();
       }
 
       // Get Rotation axis und angle
       currentNormal.Normalize();
       newNormal.Normalize();
       float rotationAngle = angle(currentNormal.Get_vnl_vector(),newNormal.Get_vnl_vector());
 
       rotationAngle *= 180.0 / vnl_math::pi; // from rad to deg
       Vector3D rotationAxis = itk::CrossProduct( currentNormal, newNormal );
       if (abs(rotationAngle-180) < mitk::eps )
       {
          // current Normal and desired normal are not linear independent!!(e.g 1,0,0 and -1,0,0).
          // Rotation Axis should be ANY vector that is 90° to current Normal
          mitk::Vector3D helpNormal;
          helpNormal = currentNormal;
          helpNormal[0] += 1;
          helpNormal[1] -= 1;
          helpNormal[2] += 1;
          helpNormal.Normalize();
          rotationAxis = itk::CrossProduct( helpNormal, currentNormal );
       }
 
       RotationOperation centeredRotation(
          mitk::OpROTATE,
          center,
          rotationAxis,
          rotationAngle
          );
 
       // Rotate first slice
       geometry2D->ExecuteOperation( &centeredRotation );
 
       // Reinitialize planes and select slice, if my rotations are all done.
       if (!planeOp->AreAxisDefined())
       {
          // Clear the slice stack and adjust it according to the center of
          // rotation and plane position (see documentation of ReinitializePlanes)
          this->ReinitializePlanes( center, planeOp->GetPoint() );
 
          if ( m_SliceNavigationController )
          {
             m_SliceNavigationController->SelectSliceByPoint( planeOp->GetPoint() );
             m_SliceNavigationController->AdjustSliceStepperRange();
          }
       }
 
       // Also apply rotation on the slicedGeometry - Geometry3D (Bounding geometry)
       Geometry3D::ExecuteOperation( &centeredRotation );
 
       //
       // 2nd step. If axis vectors were defined, rotate the plane around its normal to fit these
       //
 
       if (planeOp->AreAxisDefined())
       {
          mitk::Vector3D vecAxixNew = planeOp->GetAxisVec0();
          vecAxixNew.Normalize();
          mitk::Vector3D VecAxisCurr = geometry2D->GetAxisVector(0);
          VecAxisCurr.Normalize();
 
          float rotationAngle = angle(VecAxisCurr.Get_vnl_vector(),vecAxixNew.Get_vnl_vector());
          rotationAngle = rotationAngle * 180 / PI; // Rad to Deg
 
          // we rotate around the normal of the plane, but we do not know, if we need to rotate clockwise
          // or anti-clockwise. So we rotate around the crossproduct of old and new Axisvector.
          // Since both axis vectors lie in the plane, the crossproduct is the planes normal or the negative planes normal
 
          rotationAxis = itk::CrossProduct( VecAxisCurr, vecAxixNew  );
          if (abs(rotationAngle-180) < mitk::eps )
          {
             // current axisVec and desired axisVec are not linear independent!!(e.g 1,0,0 and -1,0,0).
             // Rotation Axis can be just plane Normal. (have to rotate by 180°)
             rotationAxis = newNormal;
          }
 
          // Perfom Rotation
          mitk::RotationOperation op(mitk::OpROTATE, center, rotationAxis, rotationAngle);
          geometry2D->ExecuteOperation( &op );
 
          // Apply changes on first slice to whole slice stack
          this->ReinitializePlanes( center, planeOp->GetPoint() );
 
          if ( m_SliceNavigationController )
          {
             m_SliceNavigationController->SelectSliceByPoint( planeOp->GetPoint() );
             m_SliceNavigationController->AdjustSliceStepperRange();
          }
 
          // Also apply rotation on the slicedGeometry - Geometry3D (Bounding geometry)
          Geometry3D::ExecuteOperation( &op );
       }
     }
     else
     {
       // Reach through to all slices
       for (std::vector<Geometry2D::Pointer>::iterator iter = m_Geometry2Ds.begin();
           iter != m_Geometry2Ds.end();
           ++iter)
       {
         (*iter)->ExecuteOperation(operation);
       }
     }
     break;
 
   case OpRESTOREPLANEPOSITION:
     if ( m_EvenlySpaced )
     {
       // Save first slice
       Geometry2D::Pointer geometry2D = m_Geometry2Ds[0];
 
       PlaneGeometry* planeGeometry = dynamic_cast< PlaneGeometry * >(
         geometry2D.GetPointer() );
 
       RestorePlanePositionOperation *restorePlaneOp = dynamic_cast< RestorePlanePositionOperation* >( operation );
 
       // Need a PlaneGeometry, a PlaneOperation and a reference frame to
       // carry out the re-orientation
       if ( m_ReferenceGeometry && planeGeometry && restorePlaneOp )
       {
         // Clear all generated geometries and then rotate only the first slice.
         // The other slices will be re-generated on demand
 
         // Rotate first slice
         geometry2D->ExecuteOperation( restorePlaneOp );
 
         m_DirectionVector = restorePlaneOp->GetDirectionVector();
 
         double centerOfRotationDistance =
           planeGeometry->SignedDistanceFromPlane( m_ReferenceGeometry->GetCenter() );
 
         if ( centerOfRotationDistance > 0 )
         {
           m_DirectionVector = m_DirectionVector;
         }
         else
         {
           m_DirectionVector = -m_DirectionVector;
         }
 
         Vector3D spacing = restorePlaneOp->GetSpacing();
 
         Superclass::SetSpacing( spacing );
 
         // /*Now we need to calculate the number of slices in the plane's normal
         // direction, so that the entire volume is covered. This is done by first
         // calculating the dot product between the volume diagonal (the maximum
         // distance inside the volume) and the normal, and dividing this value by
         // the directed spacing calculated above.*/
         ScalarType directedExtent =
           fabs( m_ReferenceGeometry->GetExtentInMM( 0 ) * m_DirectionVector[0] )
           + fabs( m_ReferenceGeometry->GetExtentInMM( 1 ) * m_DirectionVector[1] )
           + fabs( m_ReferenceGeometry->GetExtentInMM( 2 ) * m_DirectionVector[2] );
 
         if ( directedExtent >= spacing[2] )
         {
           m_Slices = static_cast< unsigned int >(directedExtent / spacing[2] + 0.5);
         }
         else
         {
           m_Slices = 1;
         }
 
          m_Geometry2Ds.assign( m_Slices, Geometry2D::Pointer( NULL ) );
 
          if ( m_Slices > 0 )
          {
            m_Geometry2Ds[0] = geometry2D;
          }
 
         m_SliceNavigationController->GetSlice()->SetSteps( m_Slices );
 
         this->Modified();
 
         //End Reinitialization
 
         if ( m_SliceNavigationController )
         {
           m_SliceNavigationController->GetSlice()->SetPos( restorePlaneOp->GetPos() );
           m_SliceNavigationController->AdjustSliceStepperRange();
         }
         Geometry3D::ExecuteOperation(restorePlaneOp);
       }
     }
     else
     {
       // Reach through to all slices
       for (std::vector<Geometry2D::Pointer>::iterator iter = m_Geometry2Ds.begin();
           iter != m_Geometry2Ds.end();
           ++iter)
       {
         (*iter)->ExecuteOperation(operation);
       }
     }
     break;
 
+  case OpAPPLYTRANSFORMMATRIX:
+
+    // Clear all generated geometries and then transform only the first slice.
+    // The other slices will be re-generated on demand
+
+    // Save first slice
+    Geometry2D::Pointer geometry2D = m_Geometry2Ds[0];
+
+    ApplyTransformMatrixOperation *applyMatrixOp = dynamic_cast< ApplyTransformMatrixOperation* >( operation );
+
+    // Apply transformation to first plane
+    geometry2D->ExecuteOperation( applyMatrixOp );
+
+    // Generate a ApplyTransformMatrixOperation using the dataset center instead of
+    // the supplied rotation center. The supplied center is instead used to adjust the
+    // slice stack afterwards (see OpROTATE).
+    Point3D center = m_ReferenceGeometry->GetCenter();
+
+    // Clear the slice stack and adjust it according to the center of
+    // the dataset and the supplied rotation center (see documentation of
+    // ReinitializePlanes)
+    this->ReinitializePlanes( center, applyMatrixOp->GetReferencePoint() );
+
+    Geometry3D::ExecuteOperation( applyMatrixOp );
+    break;
   }
 
   this->Modified();
 }
 
diff --git a/Core/Code/Interactions/mitkInteractionConst.h b/Core/Code/Interactions/mitkInteractionConst.h
index 7e96db76cb..77f46cbfcd 100644
--- a/Core/Code/Interactions/mitkInteractionConst.h
+++ b/Core/Code/Interactions/mitkInteractionConst.h
@@ -1,783 +1,784 @@
 /*===================================================================
 
 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 MITKINTERACTCONST_H
 #define MITKINTERACTCONST_H
 
 //##Documentation
 //## @file mitkInteractionConst.h
 //## @brief Constants for most interaction classes, due to the generic StateMachines.
 //##
 //## Changes in Type, ButtonState or Key has to be don in mitkEventMapper.cpp, too.
 //## @ingroup Interaction
 
 /*Prefixes for Constants:
 E = Enumeration
 EID = EventId's
 Op = Operations
 Ac = Action
 Type_ = Type of Event
 BS_ = ButtonStates and Buttons
 Key_ = Keys like in QT
 */
 namespace mitk{
 
 //Constants for EventIds; use the according constant to through an event in the code
 enum EEventIds
 {
   EIDNULLEVENT = 0,
   EIDLEFTMOUSEBTN = 1,
   EIDRIGHTMOUSEBTN = 2,
   EIDLEFTMOUSEBTNANDSHIFT = 3,
   EIDMIDDLEMOUSEBTN = 4,
   EIDLEFTMOUSEBTNANDCTRL = 5,
   EIDMIDDLEMOUSEBTNANDCTRL = 6,
   EIDRIGHTMOUSEBTNANDCTRL = 7,
   EIDLEFTMOUSEBTNDOUBLECLICK = 8,
   EIDMOUSEWHEEL = 9,
   EIDLEFTMOUSERELEASE = 505,
   EIDMIDDLEMOUSERELEASE = 506,
   EIDRIGHTMOUSERELEASE = 507,
   EIDLEFTMOUSERELEASEANDSHIFT = 508,
   EIDMOUSEMOVE = 520,
   EIDLEFTMOUSEBTNANDMOUSEWHEEL = 521,
   EIDRIGHTMOUSEBTNANDMOUSEWHEEL = 522,
   EIDMIDDLEMOUSEBTNANDMOUSEWHEEL = 523,
   EIDLEFTMOUSEBTNANDMOUSEMOVE = 530,
   EIDRIGHTMOUSEBTNANDMOUSEMOVE = 531,
   EIDMIDDLEMOUSEBTNANDMOUSEMOVE = 533,
   EIDCTRLANDLEFTMOUSEBTNANDMOUSEMOVE = 534,
   EIDCTRLANDRIGHTMOUSEBTNANDMOUSEMOVE = 535,
   EIDCTRLANDMIDDLEMOUSEBTNANDMOUSEMOVE = 536,
   EIDCTRLANDLEFTMOUSEBTNRELEASE = 537,
   EIDCTRLANDRIGHTMOUSEBTNRELEASE = 538,
   EIDCTRLANDMIDDLEMOUSEBTNRELEASE = 539,
   EIDSHIFTANDCTRLANDMIDDLEMOUSEBTN = 540,
   EIDSHIFTANDLEFTMOUSEBTNANDMOUSEMOVE = 541,
   EIDSHIFTANDCTRLANDMOUSEMOVE = 542,
   EIDSHIFTANDCTRLANDMOUSERELEASE = 543,
   EIDALTANDLEFTMOUSEBTN = 600,
   EIDALTANDLEFTMOUSEBTNANDMOUSEMOVE = 610,
   EIDALTANDLEFTMOUSERELEASE = 620,
   EIDCTRLANDLEFTMOUSEWHEEL = 630,
   EIDALTANDMOUSEWHEEL = 640,
   EIDALTANDMIDDLEMOUSEBTN = 641,
   EIDALTANDMIDDLEMOUSEBTNANDMOVE = 642,
   EIDALTANDMIDDLEMOUSEBTNRELEASE = 643,
   EIDALTANDSHIFTANDRIGHTMOUSEBTN = 644,
   EIDALTANDSHIFTANDRIGHTMOUSEBTNANDMOUSEMOVE = 645,
   EIDALTANDSHIFTANDRIGHTMOUSEBTNRELEASE = 646,
   EIDSHIFTANDRIGHTMOUSEPRESS = 2000,
   EIDSHIFTANDRIGHTMOUSEMOVE = 2001,
   EIDSHIFTANDRIGHTMOUSERELEASE = 2002,
   EIDSHIFTANDMIDDLEMOUSEPRESS = 2003,
   EIDSHIFTANDMIDDLEMOUSEMOVE = 2004,
   EIDSHIFTANDMIDDLEMOUSERELEASE = 2005,
   EIDSPACENAVIGATORINPUT = 4001, // 3d Mouse, SpaceNavigator input
   EIDSPACENAVIGATORKEYDOWN = 4002, // 3d Mouse, KeyDown
   EIDWIIMOTEINPUT = 4003, // WiiMote input
   EIDWIIMOTEBUTTON = 4004, // WiiMote home button
   EIDWIIMOTEBUTTONB = 4005, // WiiMote b button
   EIDSTRGANDN = 10,
   EIDSTRGANDE = 11,
   EIDDELETE = 12,
   EIDN = 13,
   EIDESCAPE = 14,
   EIDP = 15,
   EIDR = 16,
   EIDT = 17,
   EIDS = 18,
   EIDE = 19,
   EIDSTRGANDALTANDA = 20,
   EIDSTRGANDALTANDB = 21,
   EIDH = 22,
   EIDRETURN = 23,
   EIDENTER = 24,
   EIDSPACE = 25,
   EIDPLUS = 26,
   EIDMINUS = 27,
   EIDSTRGANDALTANDH = 30,
   EIDSTRGANDALTANDI = 31,
   EIDSTRGANDALTANDS = 40,
   EIDALT = 90,
   EIDSTRGANDB = 91,
   EIDNEW = 1000,
   EIDOLD = 1001,
   EIDFINISHED = 1002,
   EIDNO = 1003,
   EIDYES = 1004,
   EIDSAME = 1005,
   EIDNOANDLASTOBJECT = 1006,
   EIDNOANDNOTLASTOBJECT = 1007,
   EIDLAST = 1008,
   EIDNOTLAST = 1009,
   EIDSTSMALERNMINUS1 = 1010,
   EIDSTLARGERNMINUS1 = 1011,
   EIDPOSITIONEVENT = 1012,
   EIDEDIT = 1013,
   EIDSMALLERN = 1014,
   EIDEQUALSN = 1015,
   EIDLARGERN = 1016,
   EIDEMPTY = 1017,
   EIDSUBDESELECT = 1020,
   EIDSMTOSELECTED = 1030,
   EIDSMTODESELECTED = 1031,
   EIDTIP = 1050,
   EIDHEAD = 1051,
   EIDBODY = 1052,
   EIDCLEAR = 1100,
   EIDACTIVATETOOL = 1300,
   EIDPRINT = 3001,
   EV_INIT = 5551001,
   EV_PREVIOUS = 5551002,
   EV_PATH_COLLECTION_SELECTED = 5551003,
   EV_NAVIGATION_SELECTED = 5551004,
   EV_LESS_THEN_MIN_COUNT = 5551005,
   EV_READY = 5551006,
   EV_NEXT = 5551007,
   EV_DONE = 5551008,
   EV_NEW_LANDMARK = 5551009,
   EV_REMOVE_LANDMARK = 5551010,
   EIDINSIDE = 2500,
   EIDA = 4001,
   EIDB = 4002,
   EIDC = 4003,
   EIDD = 4004,
   EIDF = 4005,
   EIDG = 4006,
   EIDI = 4007,
   EIDJ = 4008,
   EIDK = 4009,
   EIDL = 4010,
   EIDM = 4011,
   EIDO = 4012,
   EIDQ = 4013,
   EIDU = 4014,
   EIDV = 4015,
   EIDW = 4016,
   EIDX = 4017,
   EIDY = 4018,
   EIDZ = 4019,
   EID1 = 4020,
   EID2 = 4021,
   EID3 = 4022,
   EID4 = 4023,
   EID5 = 4024,
   EID6 = 4025,
   EID7 = 4026,
   EID8 = 4027,
   EID9 = 4028,
   EID0 = 4029,
   EIDFIGUREHOVER = 12340,
   EIDNOFIGUREHOVER = 12341
 };
 
 //##Constants for Operations
 //## xomments are always examples of the usage
 enum EOperations
 {
   OpNOTHING = 0,
   OpTEST = 1,
   OpNEWCELL = 10, //add a new cell
   OpADD = 100, //add a point or a vessel
   OpUNDOADD = 101,
   OpADDLINE = 1001, //add a line
   OpINSERT = 200, //insert a point at position
   OpINSERTLINE = 201, //insert a line at position
   OpINSERTPOINT = 202,
   OpCLOSECELL = 250, //close a cell (to a polygon)
   OpOPENCELL = 251, //close a cell (to a polygon)
   OpMOVE = 300, //move a point
   OpMOVELINE = 301, //move a line
   OpMOVECELL = 302, //move a line
   OpUNDOMOVE = 303,
   OpMOVEPOINTUP = 304,
   OpMOVEPOINTDOWN = 305,
   OpREMOVE = 400, //remove a point at position
   OpREMOVELINE = 401, //remove a line at position
   OpREMOVECELL = 402, //remove a cell
   OpREMOVEPOINT = 403,
   OpDELETE = 500, //delete
   OpDELETELINE = 501, //delete the last line in a cell
   OpUNDELETE = 502,
   OpDELETECELL = 505,
   OpSTATECHANGE = 600, //change a state
   OpTIMECHANGE = 601, //change a state
   OpTERMINATE = 666, //change a state
   OpSELECTPOINT = 700,
   OpSELECTLINE = 701,
   OpSELECTCELL = 702,
   OpSELECTSUBOBJECT = 703, //for VesselGraphInteractor
   //OpSELECTNEWSUBOBJECT = 704, //for VesselGraphInteractor
   OpSELECT = 705,
   OpDESELECTPOINT = 800,
   OpDESELECTLINE = 801,
   OpDESELECTCELL = 802,
   OpDESELECTSUBOBJECT = 803,  //for VesselGraphInteractor
   OpDESELECTALL = 804,     //for VesselGraphInteractor
   OpDESELECT = 805,
   OpNAVIGATE = 900,
   OpZOOM = 1000,
   OpSCALE = 1100,
   OpROTATE = 1200,
   OpORIENT = 1201,
   OpRESTOREPLANEPOSITION = 1202,
+  OpAPPLYTRANSFORMMATRIX = 1203,
   OpSETPOINTTYPE = 1210,
   OpMODECHANGE = 1500,
   OpSENDCOORDINATES = 1600,
   OpPERIPHERYSEARCH = 2000,  //used in VesselGraphInteractor
   OpROOTSEARCH = 2001,        //used in VesselGraphInteractor
   OpTHICKSTVESSELSEARCH = 2002,       //used in VesselGraphInteractor
   OpSHORTESTPATHSEARCH = 2003,       //used in VesselGraphInteractor
   OpATTRIBUTATION = 2004,       //used in VesselGraphInteractor
   OpDEFAULT = 2006,                  //used in VesselGraphInteractor
   OpSURFACECHANGED = 3000,  // used for changing polydata in surfaces
 };
 
 //##Constants for EventMapping...
 //##connects the statemachine.xml-File with the implemented conditions.
 //##within one statemachine the choice of the actionconstants is freely
 //##
 //## ActionId
 enum EActions
 {
   AcDONOTHING = 0,
   AcINITNEWOBJECT = 5,
   AcINITEDITOBJECT = 6,
   AcINITEDITGROUP = 7,
   AcINITMOVEMENT = 8,
   AcINITMOVE = 9,
   AcINITFOREGROUND = 45,  // used in SeedsInteractor for setting the foreground seeds
   AcINITBACKGROUND = 46,  // used in SeedsInteractor for setting the background seeds
   AcINITNEUTRAL = 47,  // used in SeedsInteractor for setting the neutral seeds (rubber)
   AcINITUPDATE = 1235,  // For shape model deformation
   AcADDPOINT = 10,
   AcADDPOINTRMB = 6000, // in mitralPointSetInteractor used to set a different type of point
   AcADD = 11,
   AcADDLINE = 12,
   AcADDANDFINISH = 13,
   AcADDSELECTEDTOGROUP = 64,
   AcCHECKPOINT = 21,
   AcCHECKLINE = 22,
   AcCHECKCELL = 23,
   AcCHECKELEMENT = 30,  // check if there is a element close enough (picking)
   AcCHECKOBJECT = 31,  // check if an object is hit
   AcCHECKNMINUS1 = 32,  // check if the number of elements is equal to N-1
   AcCHECKEQUALS1 = 33,  // check if the number of elements in the data is equal to 1
   AcCHECKNUMBEROFPOINTS = 330, //check the number of elements in the data
   AcCHECKSELECTED = 34,  // check if the given element is selected or not
   AcCHECKONESELECTED = 340, //check if there is an element that is selected
   AcCHECKHOVERING = 341, //check if there is an element that is selected
   AcCHECKGREATERZERO = 35,  // check if the current number of elements is greater than 0
   AcCHECKGREATERTWO = 36,  // check if the current number of elements is greater than two
   AcCHECKOPERATION = 37,  // check if the operation is of one spectial type
   AcCHECKONESUBINTERACTOR = 38,
   AcCHECKSUBINTERACTORS = 39,
   AcFINISHOBJECT = 40,
   AcFINISHGROUP = 41,
   AcFINISHMOVEMENT = 42,
   AcFINISHMOVE = 43,
   AcFINISH = 44,
   AcSEARCHOBJECT = 50,
   AcSEARCHGROUP = 51,
   AcSEARCHANOTHEROBJECT = 52,  // one object is selected and another object is to be added to selection
   AcSELECTPICKEDOBJECT = 60,  // select the picked object and deselect others
   AcSELECTANOTHEROBJECT = 61,
   AcSELECTGROUP = 62,
   AcSELECTALL = 63,
   AcSELECT = 65,
   AcSELECTPOINT = 66,
   AcSELECTLINE = 68,
   AcSELECTCELL = 67,
   AcSELECTSUBOBJECT = 69,  // used in VesselGraphInteractor
   AcDESELECTOBJECT = 70,  // deselect picked from group
   AcDESELECTALL = 72,
   AcDESELECT = 75,
   AcDESELECTPOINT = 76,
   AcDESELECTLINE = 78,
   AcDESELECTCELL = 77,
   AcNEWPOINT = 80,
   AcNEWSUBOBJECT = 81,
   AcMOVEPOINT = 90,
   AcMOVESELECTED = 91,
   AcMOVE = 92,
   AcMOVEPOINTUP = 93,
   AcMOVEPOINTDOWN = 94,
   AcREMOVEPOINT = 100,
   AcREMOVE = 101,
   AcREMOVELINE = 102,
   AcREMOVEALL = 103,
   AcREMOVESELECTEDSUBOBJECT = 104,  // used in VesselGraphInteractor
   AcWHEEL = 105,
   AcPLUS = 106,
   AcMINUS = 107,
   AcDELETEPOINT = 120,
   AcCLEAR = 130,  // clear all elements from a list
   AcINSERTPOINT = 110,
   AcINSERTLINE = 111,
   AC_SET_NEXT_BUTTON_VISIBLE = 5550001,
   AC_SET_NEXT_BUTTON_INVISIBLE = 5550002,
   AC_SET_PREVIOUS_BUTTON_VISIBLE = 5550003,
   AC_SET_PREVIOUS_BUTTON_INVISIBLE = 5550004,
   AC_SET_ASSISTAND_WIDGET_STECK = 5550005,
   AC_SETMAX_COUNT_REF_POINTS = 5550006,
   AC_SET_NEXT_BUTTON_TEXT = 5550007,
   AC_CHECK_LANDMARK_COUNT = 5550008,
   AC_SET_DONE_FALSE = 5550009,
   AC_INIT = 55500010,
   AC_SET_APPLICATION_SELECTED_FALSE = 55500011,
   AC_SENSOR_ATTACHED = 55500012,
   AC_CLOSE_ASSISTENT = 55500013,
   AC_START_APPLICATION_TEXT = 55500014,
   AC_START_NAVIGATION = 55500015,
   AC_START_PATHCOLLECTION = 55500016,
   AC_LOAD_LANDMARKS = 55500017,
   AC_CALCULATE_LANDMARK_TRANSFORM = 55500018,
   AcTERMINATE_INTERACTION = 666,
   AcTRANSLATESTART = 1000,
   AcTRANSLATE = 1001,
   AcSCALESTART = 1002,
   AcSCALE = 1003,
   AcROTATESTART = 1004,
   AcROTATE = 1005,
   AcINITAFFINEINTERACTIONS = 1006,
   AcFINISHAFFINEINTERACTIONS = 1007,
   AcTRANSLATEEND = 1008,
   AcSCALEEND = 1009,
   AcROTATEEND = 1010,
   AcINITZOOM = 1011,
   AcZOOM = 1012,
   AcSCROLL = 1013,
   AcLEVELWINDOW = 1014,
   AcSCROLLMOUSEWHEEL = 1015,
   AcSETSTARTPOINT = 1050,
   AcMODEDESELECT = 1100,  // set interactor in not selected mode
   AcMODESELECT = 1101,  // set interactor in selected mode
   AcMODESUBSELECT = 1102,  // set interacor in sub selected mode
   AcINFORMLISTENERS = 1200,  // GlobalInteraction
   AcASKINTERACTORS = 1201,  // GlobalInteraction
   AcCHECKGREATERONE = 1500,
   AcCHECKBOUNDINGBOX = 1510,
   AcFORCESUBINTERACTORS = 1550,
   AcSENDCOORDINATES = 1600,
   AcTRANSMITEVENT = 2000,  // to transmit an event to a lower Interactor/Statemachine
   AcPERIPHERYSEARCH = 3000,  // used in VesselGraphInteractor
   AcROOTSEARCH = 3001,  // used in VesselGraphInteractor
   AcTHICKSTVESSELSEARCH = 3002,  // used in VesselGraphInteractor
   AcSHORTESTPATHSEARCH = 3003,  // used in VesselGraphInteractor
   AcSINGLE = 3004,  // used in VesselGraphInteractor
   AcATTRIBUTATION = 3005,  // used in VesselGraphInteractor
   AcDEFAULT = 3007,  // used in VesselGraphInteractor
   AcSETVESSELELEMENT = 3008,  // used in VesselGraphInteractor
   AcCHECKBARRIERSTATUS = 3010,  // used in VesselGraphInteractor
   AcUPDATEMESH = 1234,  // For Shape Model Interaction
   AcINCREASE = 49012,
   AcDECREASE = 49013,
   AcMODIFY = 49014,
   AcUNDOUPDATE = 1236,  // For restoring a mesh after an update
   AcENTEROBJECT = 48000,
   AcLEAVEOBJECT = 48001,
   AcSWITCHOBJECT = 48002,
   AcUPDATELINE = 48003,
   AcINITLINE = 48004,
   AcTERMINATELINE = 48005,
   AcCREATEBOX = 48006,
   AcCREATEOBJECTFROMLINE = 48007,
   AcCANCEL = 48008,
   AcACTIVATETOOL = 48009,
   AcROTATEAROUNDPOINT1 = 49002,
   AcROTATEAROUNDPOINT2 = 49003,
   AcMOVEPOINT1 = 49004,
   AcMOVEPOINT2 = 49005,
   AcUPDATEPOINT = 49006,
   AcUPDATERADIUSMOUSEWHEEL = 49007,
   AcDISPLAYOPTIONS = 49009,
   AcCYCLE = 49010,
   AcACCEPT = 49011,
   AcONSPACENAVIGATORMOUSEINPUT = 4001, // On input of 3D Mouse
   AcONPACENAVIGATORKEYDOWN = 4002, // On input of 3D Mouse
   AcONWIIMOTEINPUT = 4003, // used for wiimote to signal IR input
   AcRESETVIEW = 4004, // used for wiimote to reset view
   AcONWIIMOTEBUTTONRELEASED = 4005, // stops the surface interaction
   AcCHECKPOSITION = 5000,
   AcINITIALIZECONTOUR = 5001,
   AcCALCULATENEWSEGMENTATION_SP= 5002,
   AcINTERACTOR = 5003,
   AcCALCULATENEWSEGMENTATION_BB= 5004
 
 };
 
 
 /*
 //!!!!!!!!!!!!!!!!!!!!!!!!
 //!!!!!!!!!!!!!!!!!!!!!!!!
 //EventMechanism:
 //If you change anything from here on, then change in mitkEventMapper.cpp (Array of constants) as well.
 //!!!!!!!!!!!!!!!!!!!!!!!!
 //!!!!!!!!!!!!!!!!!!!!!!!!
 */
 
 //Type of an Event;
 enum EEventType
 {
   Type_None = 0,        // invalid event
   Type_Timer = 1,        // timer event
   Type_MouseButtonPress = 2,  // mouse button pressed
   Type_MouseButtonRelease = 3,  // mouse button released
   Type_MouseButtonDblClick = 4,  // mouse button double click
   Type_MouseMove = 5,      // mouse move
   Type_KeyPress = 6,      // key pressed
   Type_KeyRelease = 7,      // key released
   Type_FocusIn = 8,        // keyboard focus received
   Type_FocusOut = 9,      // keyboard focus lost
   Type_Enter = 10,        // mouse enters widget
   Type_Leave = 11,        // mouse leaves widget
   Type_Paint = 12,        // paint widget
   Type_Move = 13,        // move widget
   Type_Resize = 14,        // resize widget
   Type_Create = 15,        // after object creation
   Type_Destroy = 16,      // during object destruction
   Type_Show = 17,         // widget is shown
   Type_Hide = 18,        // widget is hidden
   Type_Close = 19,        // request to close widget
   Type_Quit = 20,        // request to quit application
   Type_Reparent = 21,      // widget has been reparented
   Type_ShowMinimized = 22,      // widget is shown minimized
   Type_ShowNormal = 23,        // widget is shown normal
   Type_WindowActivate = 24,    // window was activated
   Type_WindowDeactivate = 25,   // window was deactivated
   Type_ShowToParent = 26,      // widget is shown to parent
   Type_HideToParent = 27,      // widget is hidden to parent
   Type_ShowMaximized = 28,      // widget is shown maximized
   Type_ShowFullScreen = 29,   // widget is shown full-screen
   Type_Accel = 30,        // accelerator event
   Type_Wheel = 31,        // wheel event
   Type_AccelAvailable = 32,      // accelerator available event
   Type_CaptionChange = 33,    // caption changed
   Type_IconChange = 34,      // icon changed
   Type_ParentFontChange = 35,  // parent font changed
   Type_ApplicationFontChange = 36,  // application font changed
   Type_ParentPaletteChange = 37,    // parent palette changed
   Type_ApplicationPaletteChange = 38,    // application palette changed
   Type_PaletteChange = 39,    // widget palette changed
   Type_Clipboard = 40,        // internal clipboard event
   Type_Speech = 42,        // reserved for speech input
   Type_SockAct = 50,        // socket activation
   Type_AccelOverride = 51,      // accelerator override event
   Type_DeferredDelete = 52,      // deferred delete event
   Type_DragEnter = 60,        // drag moves into widget
   Type_DragMove = 61,        // drag moves in widget
   Type_DragLeave = 62,        // drag leaves or is cancelled
   Type_Drop = 63,        // actual drop
   Type_DragResponse = 64,      // drag accepted/rejected
   Type_ChildInserted = 70,      // new child widget
   Type_ChildRemoved = 71,      // deleted child widget
   Type_LayoutHint = 72,      // child min/max size changed
   Type_ShowWindowRequest = 73,      // widget's window should be mapped
   Type_ActivateControl = 80,      // ActiveX activation
   Type_DeactivateControl = 81,      // ActiveX deactivation
   Type_ContextMenu = 82,      // context popup menu
   Type_IMStart = 83,        // input method composition start
   Type_IMCompose = 84,        // input method composition
   Type_IMEnd = 85,        // input method composition end
   Type_Accessibility = 86,      // accessibility information is requested
   Type_TabletMove = 87,      // Wacom tablet event
   Type_LocaleChange = 88,      // the system locale changed
   Type_LanguageChange = 89,      // the application language changed
   Type_LayoutDirectionChange = 90,    // the layout direction changed
   Type_Style = 91,        // internal style event
   Type_TabletPress = 92,      // tablet press
   Type_TabletRelease = 93,      // tablet release
   Type_User = 1000,        // first user event id
   Type_SpaceNavigatorInput = 1094,  // 3D mouse input occured
   Type_SpaceNavigatorKeyDown = 1095,  // 3D mouse input occured
   Type_WiiMoteInput = 1096, // WiiMote input occured
   Type_WiiMoteButton= 1097, // WiiMote button pressed
   Type_MaxUser = 65535
 };
 
 
 //##ButtonState
 // mouse/keyboard state values
 //QT combinations if MOUSEBUTTONRelease: left MouseButton + ControlButton: 0x201
 enum EButtonStates
 {
   BS_NoButton        = 0x0000,
   BS_LeftButton      = 0x0001,
   BS_RightButton     = 0x0002,
   BS_MidButton       = 0x0004,
   BS_MouseButtonMask = 0x0007,
   BS_ShiftButton     = 0x0100,
   BS_ControlButton   = 0x0200,
   BS_AltButton       = 0x0400,
   BS_MetaButton     = 0x0800,
   BS_KeyButtonMask   = 0x0f00,
   BS_Keypad          = 0x4000
 };
 //##Key
 enum EKeys
 {
   Key_Escape = 0x1000,           // misc keys
   Key_Tab = 0x1001,
   Key_Backtab = 0x1002,
   Key_BackTab = 0x1002, //= Key_Backtab
   Key_Backspace = 0x1003,
   Key_BackSpace = 0x1003, //= Key_Backspace
   Key_Return = 0x1004,
   Key_Enter = 0x1005,
   Key_Insert = 0x1006,
   Key_Delete = 0x1007,
   Key_Pause = 0x1008,
   Key_Print = 0x1009,
   Key_SysReq = 0x100a,
   Key_Home = 0x1010,   // cursor movement
   Key_End = 0x1011,
   Key_Left = 0x1012,
   Key_Up = 0x1013,
   Key_Right = 0x1014,
   Key_Down = 0x1015,
   Key_Prior = 0x1016,
   Key_PageUp = 0x1016, //=Key_Prior
   Key_Next = 0x1017,
   Key_PageDown = 0x1017, //=Key_Next
   Key_Shift = 0x1020,     // modifiers
   Key_Control = 0x1021,
   Key_Meta = 0x1022,
   Key_Alt = 0x1023,
   Key_CapsLock = 0x1024,
   Key_NumLock = 0x1025,
   Key_ScrollLock = 0x1026,
   Key_F1 = 0x1030,                // function keys
   Key_F2 = 0x1031,
   Key_F3 = 0x1032,
   Key_F4 = 0x1033,
   Key_F5 = 0x1034,
   Key_F6 = 0x1035,
   Key_F7 = 0x1036,
   Key_F8 = 0x1037,
   Key_F9 = 0x1038,
   Key_F10 = 0x1039,
   Key_F11 = 0x103a,
   Key_F12 = 0x103b,
   Key_F13 = 0x103c,
   Key_F14 = 0x103d,
   Key_F15 = 0x103e,
   Key_F16 = 0x103f,
   Key_F17 = 0x1040,
   Key_F18 = 0x1041,
   Key_F19 = 0x1042,
   Key_F20 = 0x1043,
   Key_F21 = 0x1044,
   Key_F22 = 0x1045,
   Key_F23 = 0x1046,
   Key_F24 = 0x1047,
   Key_F25 = 0x1048,              // F25 .. F35 only on X11
   Key_F26 = 0x1049,
   Key_F27 = 0x104a,
   Key_F28 = 0x104b,
   Key_F29 = 0x104c,
   Key_F30 = 0x104d,
   Key_F31 = 0x104e,
   Key_F32 = 0x104f,
   Key_F33 = 0x1050,
   Key_F34 = 0x1051,
   Key_F35 = 0x1052,
   Key_Super_L = 0x1053,           // extra keys
   Key_Super_R = 0x1054,
   Key_Menu = 0x1055,
   Key_Hyper_L = 0x1056,
   Key_Hyper_R = 0x1057,
   Key_Help = 0x1058,
         // International input method support (X keycode - = 0xEE00)
         // Only interesting if you are writing your own input method
   Key_Muhenkan  = 0x1122,  // Cancel Conversion
   Key_Henkan  = 0x1123,  // Start/Stop Conversion
   Key_Hiragana_Katakana = 0x1127,  // Hiragana/Katakana toggle
   Key_Zenkaku_Hankaku = 0x112A,  // Zenkaku/Hankaku toggle
   Key_Space = 0x20,               // 7 bit printable ASCII
   Key_Any  = 0x20, //= Key_Space
   Key_Exclam = 0x21,
   Key_QuoteDbl = 0x22,
   Key_NumberSign = 0x23,
   Key_Dollar = 0x24,
   Key_Percent = 0x25,
   Key_Ampersand = 0x26,
   Key_Apostrophe = 0x27,
   Key_ParenLeft = 0x28,
   Key_ParenRight = 0x29,
   Key_Asterisk = 0x2a,
   Key_Plus = 0x2b,
   Key_Comma = 0x2c,
   Key_Minus = 0x2d,
   Key_Period = 0x2e,
   Key_Slash = 0x2f,
   Key_0 = 0x30,
   Key_1 = 0x31,
   Key_2 = 0x32,
   Key_3 = 0x33,
   Key_4 = 0x34,
   Key_5 = 0x35,
   Key_6 = 0x36,
   Key_7 = 0x37,
   Key_8 = 0x38,
   Key_9 = 0x39,
   Key_Colon = 0x3a,
   Key_Semicolon = 0x3b,
   Key_Less = 0x3c,
   Key_Equal = 0x3d,
   Key_Greater = 0x3e,
   Key_Question = 0x3f,
   Key_At = 0x40,
   Key_A = 0x41,
   Key_B = 0x42,
   Key_C = 0x43,
   Key_D = 0x44,
   Key_E = 0x45,
   Key_F = 0x46,
   Key_G = 0x47,
   Key_H = 0x48,
   Key_I = 0x49,
   Key_J = 0x4a,
   Key_K = 0x4b,
   Key_L = 0x4c,
   Key_M = 0x4d,
   Key_N = 0x4e,
   Key_O = 0x4f,
   Key_P = 0x50,
   Key_Q = 0x51,
   Key_R = 0x52,
   Key_S = 0x53,
   Key_T = 0x54,
   Key_U = 0x55,
   Key_V = 0x56,
   Key_W = 0x57,
   Key_X = 0x58,
   Key_Y = 0x59,
   Key_Z = 0x5a,
   Key_BracketLeft = 0x5b,
   Key_Backslash = 0x5c,
   Key_BracketRight = 0x5d,
   Key_AsciiCircum = 0x5e,
   Key_Underscore = 0x5f,
   Key_QuoteLeft = 0x60,
   Key_BraceLeft = 0x7b,
   Key_Bar = 0x7c,
   Key_BraceRight = 0x7d,
   Key_AsciiTilde = 0x7e,
   Key_nobreakspace = 0x0a0,
   Key_exclamdown = 0x0a1,
   Key_cent = 0x0a2,
   Key_sterling = 0x0a3,
   Key_currency = 0x0a4,
   Key_yen = 0x0a5,
   Key_brokenbar = 0x0a6,
   Key_section = 0x0a7,
   Key_diaeresis = 0x0a8,
   Key_copyright = 0x0a9,
   Key_ordfeminine = 0x0aa,
   Key_guillemotleft = 0x0ab,      // left angle quotation mark
   Key_notsign = 0x0ac,
   Key_hyphen = 0x0ad,
   Key_registered = 0x0ae,
   Key_macron = 0x0af,
   Key_degree = 0x0b0,
   Key_plusminus = 0x0b1,
   Key_twosuperior = 0x0b2,
   Key_threesuperior = 0x0b3,
   Key_acute = 0x0b4,
   Key_mu = 0x0b5,
   Key_paragraph = 0x0b6,
   Key_periodcentered = 0x0b7,
   Key_cedilla = 0x0b8,
   Key_onesuperior = 0x0b9,
   Key_masculine = 0x0ba,
   Key_guillemotright = 0x0bb,     // right angle quotation mark
   Key_onequarter = 0x0bc,
   Key_onehalf = 0x0bd,
   Key_threequarters = 0x0be,
   Key_questiondown = 0x0bf,
   Key_Agrave = 0x0c0,
   Key_Aacute = 0x0c1,
   Key_Acircumflex = 0x0c2,
   Key_Atilde = 0x0c3,
   Key_Adiaeresis = 0x0c4,
   Key_Aring = 0x0c5,
   Key_AE = 0x0c6,
   Key_Ccedilla = 0x0c7,
   Key_Egrave = 0x0c8,
   Key_Eacute = 0x0c9,
   Key_Ecircumflex = 0x0ca,
   Key_Ediaeresis = 0x0cb,
   Key_Igrave = 0x0cc,
   Key_Iacute = 0x0cd,
   Key_Icircumflex = 0x0ce,
   Key_Idiaeresis = 0x0cf,
   Key_ETH = 0x0d0,
   Key_Ntilde = 0x0d1,
   Key_Ograve = 0x0d2,
   Key_Oacute = 0x0d3,
   Key_Ocircumflex = 0x0d4,
   Key_Otilde = 0x0d5,
   Key_Odiaeresis = 0x0d6,
   Key_multiply = 0x0d7,
   Key_Ooblique = 0x0d8,
   Key_Ugrave = 0x0d9,
   Key_Uacute = 0x0da,
   Key_Ucircumflex = 0x0db,
   Key_Udiaeresis = 0x0dc,
   Key_Yacute = 0x0dd,
   Key_THORN = 0x0de,
   Key_ssharp = 0x0df,
   Key_agrave = 0x0e0,
   Key_aacute = 0x0e1,
   Key_acircumflex = 0x0e2,
   Key_atilde = 0x0e3,
   Key_adiaeresis = 0x0e4,
   Key_aring = 0x0e5,
   Key_ae = 0x0e6,
   Key_ccedilla = 0x0e7,
   Key_egrave = 0x0e8,
   Key_eacute = 0x0e9,
   Key_ecircumflex = 0x0ea,
   Key_ediaeresis = 0x0eb,
   Key_igrave = 0x0ec,
   Key_iacute = 0x0ed,
   Key_icircumflex = 0x0ee,
   Key_idiaeresis = 0x0ef,
   Key_eth = 0x0f0,
   Key_ntilde = 0x0f1,
   Key_ograve = 0x0f2,
   Key_oacute = 0x0f3,
   Key_ocircumflex = 0x0f4,
   Key_otilde = 0x0f5,
   Key_odiaeresis = 0x0f6,
   Key_division = 0x0f7,
   Key_oslash = 0x0f8,
   Key_ugrave = 0x0f9,
   Key_uacute = 0x0fa,
   Key_ucircumflex = 0x0fb,
   Key_udiaeresis = 0x0fc,
   Key_yacute = 0x0fd,
   Key_thorn = 0x0fe,
   Key_ydiaeresis = 0x0ff,
   Key_unknown = 0xffff,
   Key_none = 0xffff//= Key_unknown
 };
 
 }//namespace mitk
 #endif //ifndef MITKINTERACTCONST_H
 
diff --git a/Core/Code/files.cmake b/Core/Code/files.cmake
index c097847f05..16e3590afb 100644
--- a/Core/Code/files.cmake
+++ b/Core/Code/files.cmake
@@ -1,314 +1,315 @@
 set(H_FILES
   Algorithms/itkImportMitkImageContainer.h
   Algorithms/itkImportMitkImageContainer.txx
   Algorithms/itkLocalVariationImageFilter.h
   Algorithms/itkLocalVariationImageFilter.txx
   Algorithms/itkMITKScalarImageToHistogramGenerator.h
   Algorithms/itkMITKScalarImageToHistogramGenerator.txx
   Algorithms/itkTotalVariationDenoisingImageFilter.h
   Algorithms/itkTotalVariationDenoisingImageFilter.txx
   Algorithms/itkTotalVariationSingleIterationImageFilter.h
   Algorithms/itkTotalVariationSingleIterationImageFilter.txx
   Algorithms/mitkBilateralFilter.h
   Algorithms/mitkBilateralFilter.cpp
   Algorithms/mitkInstantiateAccessFunctions.h
   Algorithms/mitkPixelTypeList.h
   # Preprocessor macros taken from Boost
   Algorithms/mitkPPArithmeticDec.h
   Algorithms/mitkPPArgCount.h
   Algorithms/mitkPPCat.h
   Algorithms/mitkPPConfig.h
   Algorithms/mitkPPControlExprIIf.h
   Algorithms/mitkPPControlIf.h
   Algorithms/mitkPPControlIIf.h
   Algorithms/mitkPPDebugError.h
   Algorithms/mitkPPDetailAutoRec.h
   Algorithms/mitkPPDetailDMCAutoRec.h
   Algorithms/mitkPPExpand.h
   Algorithms/mitkPPFacilitiesEmpty.h
   Algorithms/mitkPPFacilitiesExpand.h
   Algorithms/mitkPPLogicalBool.h
   Algorithms/mitkPPRepetitionDetailDMCFor.h
   Algorithms/mitkPPRepetitionDetailEDGFor.h
   Algorithms/mitkPPRepetitionDetailFor.h
   Algorithms/mitkPPRepetitionDetailMSVCFor.h
   Algorithms/mitkPPRepetitionFor.h
   Algorithms/mitkPPSeqElem.h
   Algorithms/mitkPPSeqForEach.h
   Algorithms/mitkPPSeqForEachProduct.h
   Algorithms/mitkPPSeq.h
   Algorithms/mitkPPSeqEnum.h
   Algorithms/mitkPPSeqSize.h
   Algorithms/mitkPPSeqToTuple.h
   Algorithms/mitkPPStringize.h
   Algorithms/mitkPPTupleEat.h
   Algorithms/mitkPPTupleElem.h
   Algorithms/mitkPPTupleRem.h
   Algorithms/mitkClippedSurfaceBoundsCalculator.h
   Algorithms/mitkExtractSliceFilter.h
   Algorithms/mitkConvert2Dto3DImageFilter.h
 
   Common/mitkExceptionMacro.h
   Common/mitkServiceBaseObject.h
   Common/mitkTestingMacros.h
 
   DataManagement/mitkImageAccessByItk.h
   DataManagement/mitkImageCast.h
   DataManagement/mitkImagePixelAccessor.h
   DataManagement/mitkImagePixelReadAccessor.h
   DataManagement/mitkImagePixelWriteAccessor.h
   DataManagement/mitkImageReadAccessor.h
   DataManagement/mitkImageWriteAccessor.h
   DataManagement/mitkITKImageImport.h
   DataManagement/mitkITKImageImport.txx
   DataManagement/mitkImageToItk.h
   DataManagement/mitkImageToItk.txx
 
   Interactions/mitkEventMapperAddOn.h
 
   Interfaces/mitkIDataNodeReader.h
 
   IO/mitkPixelTypeTraits.h
 )
 
 set(CPP_FILES
   Algorithms/mitkBaseDataSource.cpp
   Algorithms/mitkBaseProcess.cpp
   Algorithms/mitkDataNodeSource.cpp
   Algorithms/mitkGeometry2DDataToSurfaceFilter.cpp
   Algorithms/mitkHistogramGenerator.cpp
   Algorithms/mitkImageChannelSelector.cpp
   Algorithms/mitkImageSliceSelector.cpp
   Algorithms/mitkImageSource.cpp
   Algorithms/mitkImageTimeSelector.cpp
   Algorithms/mitkImageToImageFilter.cpp
   Algorithms/mitkPointSetSource.cpp
   Algorithms/mitkPointSetToPointSetFilter.cpp
   Algorithms/mitkRGBToRGBACastImageFilter.cpp
   Algorithms/mitkSubImageSelector.cpp
   Algorithms/mitkSurfaceSource.cpp
   Algorithms/mitkSurfaceToSurfaceFilter.cpp
   Algorithms/mitkUIDGenerator.cpp
   Algorithms/mitkVolumeCalculator.cpp
   Algorithms/mitkClippedSurfaceBoundsCalculator.cpp
   Algorithms/mitkExtractSliceFilter.cpp
   Algorithms/mitkConvert2Dto3DImageFilter.cpp
   Controllers/mitkBaseController.cpp
   Controllers/mitkCallbackFromGUIThread.cpp
   Controllers/mitkCameraController.cpp
   Controllers/mitkCameraRotationController.cpp
   Controllers/mitkCoreActivator.cpp
   Controllers/mitkFocusManager.cpp
   Controllers/mitkLimitedLinearUndo.cpp
   Controllers/mitkOperationEvent.cpp
   Controllers/mitkPlanePositionManager.cpp
   Controllers/mitkProgressBar.cpp
   Controllers/mitkRenderingManager.cpp
   Controllers/mitkSliceNavigationController.cpp
   Controllers/mitkSlicesCoordinator.cpp
   Controllers/mitkSlicesRotator.cpp
   Controllers/mitkSlicesSwiveller.cpp
   Controllers/mitkStatusBar.cpp
   Controllers/mitkStepper.cpp
   Controllers/mitkTestManager.cpp
   Controllers/mitkUndoController.cpp
   Controllers/mitkVerboseLimitedLinearUndo.cpp
   Controllers/mitkVtkInteractorCameraController.cpp
   Controllers/mitkVtkLayerController.cpp
   DataManagement/mitkAbstractTransformGeometry.cpp
   DataManagement/mitkAnnotationProperty.cpp
   DataManagement/mitkApplicationCursor.cpp
   DataManagement/mitkBaseData.cpp
   DataManagement/mitkBaseProperty.cpp
   DataManagement/mitkClippingProperty.cpp
   DataManagement/mitkChannelDescriptor.cpp
   DataManagement/mitkColorProperty.cpp
   DataManagement/mitkDataStorage.cpp
   #DataManagement/mitkDataTree.cpp
   DataManagement/mitkDataNode.cpp
   DataManagement/mitkDataNodeFactory.cpp
   #DataManagement/mitkDataTreeStorage.cpp
   DataManagement/mitkDisplayGeometry.cpp
   DataManagement/mitkEnumerationProperty.cpp
   DataManagement/mitkGeometry2D.cpp
   DataManagement/mitkGeometry2DData.cpp
   DataManagement/mitkGeometry3D.cpp
   DataManagement/mitkGeometryData.cpp
   DataManagement/mitkGroupTagProperty.cpp
   DataManagement/mitkImage.cpp
   DataManagement/mitkImageAccessorBase.cpp
   DataManagement/mitkImageCaster.cpp
   DataManagement/mitkImageCastPart1.cpp
   DataManagement/mitkImageCastPart2.cpp
   DataManagement/mitkImageCastPart3.cpp
   DataManagement/mitkImageCastPart4.cpp
   DataManagement/mitkImageDataItem.cpp
   DataManagement/mitkImageDescriptor.cpp
   DataManagement/mitkImageVtkAccessor.cpp
   DataManagement/mitkImageStatisticsHolder.cpp
   DataManagement/mitkLandmarkBasedCurvedGeometry.cpp
   DataManagement/mitkLandmarkProjectorBasedCurvedGeometry.cpp
   DataManagement/mitkLandmarkProjector.cpp
   DataManagement/mitkLevelWindow.cpp
   DataManagement/mitkLevelWindowManager.cpp
   DataManagement/mitkLevelWindowPreset.cpp
   DataManagement/mitkLevelWindowProperty.cpp
   DataManagement/mitkLookupTable.cpp
   DataManagement/mitkLookupTables.cpp # specializations of GenericLookupTable
   DataManagement/mitkMemoryUtilities.cpp
   DataManagement/mitkModalityProperty.cpp
   DataManagement/mitkModeOperation.cpp
   DataManagement/mitkNodePredicateAnd.cpp
   DataManagement/mitkNodePredicateBase.cpp
   DataManagement/mitkNodePredicateCompositeBase.cpp
   DataManagement/mitkNodePredicateData.cpp
   DataManagement/mitkNodePredicateDataType.cpp
   DataManagement/mitkNodePredicateDimension.cpp
   DataManagement/mitkNodePredicateFirstLevel.cpp
   DataManagement/mitkNodePredicateNot.cpp
   DataManagement/mitkNodePredicateOr.cpp
   DataManagement/mitkNodePredicateProperty.cpp
   DataManagement/mitkNodePredicateSource.cpp
   DataManagement/mitkPlaneOrientationProperty.cpp
   DataManagement/mitkPlaneGeometry.cpp
   DataManagement/mitkPlaneOperation.cpp
   DataManagement/mitkPointOperation.cpp
   DataManagement/mitkPointSet.cpp
   DataManagement/mitkProperties.cpp
   DataManagement/mitkPropertyList.cpp
   DataManagement/mitkRestorePlanePositionOperation.cpp
+  DataManagement/mitkApplyTransformMatrixOperation.cpp
   DataManagement/mitkRotationOperation.cpp
   DataManagement/mitkSlicedData.cpp
   DataManagement/mitkSlicedGeometry3D.cpp
   DataManagement/mitkSmartPointerProperty.cpp
   DataManagement/mitkStandaloneDataStorage.cpp
   DataManagement/mitkStateTransitionOperation.cpp
   DataManagement/mitkStringProperty.cpp
   DataManagement/mitkSurface.cpp
   DataManagement/mitkSurfaceOperation.cpp
   DataManagement/mitkThinPlateSplineCurvedGeometry.cpp
   DataManagement/mitkTimeSlicedGeometry.cpp
   DataManagement/mitkTransferFunction.cpp
   DataManagement/mitkTransferFunctionProperty.cpp
   DataManagement/mitkTransferFunctionInitializer.cpp
   DataManagement/mitkVector.cpp
   DataManagement/mitkVtkInterpolationProperty.cpp
   DataManagement/mitkVtkRepresentationProperty.cpp
   DataManagement/mitkVtkResliceInterpolationProperty.cpp
   DataManagement/mitkVtkScalarModeProperty.cpp
   DataManagement/mitkVtkVolumeRenderingProperty.cpp
   DataManagement/mitkWeakPointerProperty.cpp
   DataManagement/mitkShaderProperty.cpp
   DataManagement/mitkResliceMethodProperty.cpp
   DataManagement/mitkMaterial.cpp
   Interactions/mitkAction.cpp
   Interactions/mitkAffineInteractor.cpp
   Interactions/mitkCoordinateSupplier.cpp
   Interactions/mitkDisplayCoordinateOperation.cpp
   Interactions/mitkDisplayInteractor.cpp
   Interactions/mitkDisplayPositionEvent.cpp
   Interactions/mitkDisplayVectorInteractor.cpp
   Interactions/mitkDisplayVectorInteractorLevelWindow.cpp
   Interactions/mitkDisplayVectorInteractorScroll.cpp
   Interactions/mitkEvent.cpp
   Interactions/mitkEventDescription.cpp
   Interactions/mitkEventMapper.cpp
   Interactions/mitkGlobalInteraction.cpp
   Interactions/mitkInteractor.cpp
   Interactions/mitkMouseModeSwitcher.cpp
   Interactions/mitkMouseMovePointSetInteractor.cpp
   Interactions/mitkMoveSurfaceInteractor.cpp
   Interactions/mitkNodeDepententPointSetInteractor.cpp
   Interactions/mitkPointSetInteractor.cpp
   Interactions/mitkPositionEvent.cpp
   Interactions/mitkPositionTracker.cpp
   Interactions/mitkState.cpp
   Interactions/mitkStateEvent.cpp
   Interactions/mitkStateMachine.cpp
   Interactions/mitkStateMachineFactory.cpp
   Interactions/mitkTransition.cpp
   Interactions/mitkWheelEvent.cpp
   Interactions/mitkKeyEvent.cpp
   Interactions/mitkVtkEventAdapter.cpp
   Interactions/mitkVtkInteractorStyle.cxx
   Interactions/mitkCrosshairPositionEvent.cpp
   IO/mitkBaseDataIOFactory.cpp
   IO/mitkCoreDataNodeReader.cpp
   IO/mitkDicomSeriesReader.cpp
   IO/mitkFileReader.cpp
   IO/mitkFileSeriesReader.cpp
   IO/mitkFileWriter.cpp
   #IO/mitkIpPicGet.c
   IO/mitkImageGenerator.cpp
   IO/mitkImageWriter.cpp
   IO/mitkImageWriterFactory.cpp
   IO/mitkItkImageFileIOFactory.cpp
   IO/mitkItkImageFileReader.cpp
   IO/mitkItkLoggingAdapter.cpp
   IO/mitkItkPictureWrite.cpp
   IO/mitkIOUtil.cpp
   IO/mitkLookupTableProperty.cpp
   IO/mitkOperation.cpp
   #IO/mitkPicFileIOFactory.cpp
   #IO/mitkPicFileReader.cpp
   #IO/mitkPicFileWriter.cpp
   #IO/mitkPicHelper.cpp
   #IO/mitkPicVolumeTimeSeriesIOFactory.cpp
   #IO/mitkPicVolumeTimeSeriesReader.cpp
   IO/mitkPixelType.cpp
   IO/mitkPointSetIOFactory.cpp
   IO/mitkPointSetReader.cpp
   IO/mitkPointSetWriter.cpp
   IO/mitkPointSetWriterFactory.cpp
   IO/mitkRawImageFileReader.cpp
   IO/mitkStandardFileLocations.cpp
   IO/mitkSTLFileIOFactory.cpp
   IO/mitkSTLFileReader.cpp
   IO/mitkSurfaceVtkWriter.cpp
   IO/mitkSurfaceVtkWriterFactory.cpp
   IO/mitkVtkLoggingAdapter.cpp
   IO/mitkVtiFileIOFactory.cpp
   IO/mitkVtiFileReader.cpp
   IO/mitkVtkImageIOFactory.cpp
   IO/mitkVtkImageReader.cpp
   IO/mitkVtkSurfaceIOFactory.cpp
   IO/mitkVtkSurfaceReader.cpp
   IO/vtkPointSetXMLParser.cpp
   IO/mitkLog.cpp
   Rendering/mitkBaseRenderer.cpp
   Rendering/mitkVtkMapper2D.cpp
   Rendering/mitkVtkMapper3D.cpp
   Rendering/mitkRenderWindowFrame.cpp
   Rendering/mitkGeometry2DDataMapper2D.cpp
   Rendering/mitkGeometry2DDataVtkMapper3D.cpp
   Rendering/mitkGLMapper2D.cpp
   Rendering/mitkGradientBackground.cpp
   Rendering/mitkManufacturerLogo.cpp
   Rendering/mitkMapper2D.cpp
   Rendering/mitkMapper3D.cpp
   Rendering/mitkMapper.cpp
   Rendering/mitkPointSetGLMapper2D.cpp
   Rendering/mitkPointSetVtkMapper3D.cpp
   Rendering/mitkPolyDataGLMapper2D.cpp
   Rendering/mitkSurfaceGLMapper2D.cpp
   Rendering/mitkSurfaceVtkMapper3D.cpp
   Rendering/mitkVolumeDataVtkMapper3D.cpp
   Rendering/mitkVtkPropRenderer.cpp
   Rendering/mitkVtkWidgetRendering.cpp
   Rendering/vtkMitkRectangleProp.cpp
   Rendering/vtkMitkRenderProp.cpp
   Rendering/mitkVtkEventProvider.cpp
   Rendering/mitkRenderWindow.cpp
   Rendering/mitkRenderWindowBase.cpp
   Rendering/mitkShaderRepository.cpp
   Rendering/mitkImageVtkMapper2D.cpp
   Rendering/vtkMitkThickSlicesFilter.cpp
   Rendering/vtkMitkApplyLevelWindowToRGBFilter.cpp
 
   Common/mitkException.cpp
   Common/mitkCommon.h
   Common/mitkCoreObjectFactoryBase.cpp
   Common/mitkCoreObjectFactory.cpp
 )
 
 list(APPEND CPP_FILES ${CppMicroServices_SOURCES})