diff --git a/Modules/Segmentation/Algorithms/mitkDiffSliceOperation.cpp b/Modules/Segmentation/Algorithms/mitkDiffSliceOperation.cpp
index 8ef9d07cd7..180e493864 100644
--- a/Modules/Segmentation/Algorithms/mitkDiffSliceOperation.cpp
+++ b/Modules/Segmentation/Algorithms/mitkDiffSliceOperation.cpp
@@ -1,97 +1,97 @@
 /*=========================================================================
  
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date$
 Version:   $Revision: $
  
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
  
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
  
 =========================================================================*/
 
-#include "DiffSliceOperation.h"
+#include "mitkDiffSliceOperation.h"
 
 #include <itkCommand.h>
 
 mitk::DiffSliceOperation::DiffSliceOperation():Operation(1)
 {
   m_TimeStep = 0;
   m_Slice = NULL;
   m_Image = NULL;
   m_WorldGeometry = NULL;
   m_SliceGeometry = NULL;
   m_ImageIsValid = false;
 }
 
 
 mitk::DiffSliceOperation::DiffSliceOperation(mitk::Image* imageVolume,
                                              vtkImageData* slice,
                                              AffineGeometryFrame3D* sliceGeometry,
                                              unsigned int timestep,
                                              AffineGeometryFrame3D* currentWorldGeometry):Operation(1)
 
 {
   m_WorldGeometry = currentWorldGeometry->Clone();
   m_SliceGeometry = sliceGeometry->Clone();
 
   m_TimeStep = timestep;
 
   /*m_zlibSliceContainer = CompressedImageContainer::New();
   m_zlibSliceContainer->SetImage( slice );*/
   m_Slice = vtkSmartPointer<vtkImageData>::New();
   m_Slice->DeepCopy(slice);
 
   m_Image = imageVolume;
 
   if ( m_Image) {
     /*add an observer to listen to the delete event of the image, this is necessary because the operation is then invalid*/
     itk::SimpleMemberCommand< DiffSliceOperation >::Pointer command = itk::SimpleMemberCommand< DiffSliceOperation >::New();
     command->SetCallbackFunction( this, &DiffSliceOperation::OnImageDeleted );
     //get the id of the observer, used to remove it later on
     m_DeleteObserverTag = imageVolume->AddObserver( itk::DeleteEvent(), command );
 
 
     m_ImageIsValid = true;
   }
   else
     m_ImageIsValid = false;
 
 }
 
 mitk::DiffSliceOperation::~DiffSliceOperation()
 {
   
   m_Slice = NULL;
   m_WorldGeometry = NULL;
   //m_zlibSliceContainer = NULL;
 
   if (m_ImageIsValid)
   {
     //if the image is still there, we have to remove the observer from it
     m_Image->RemoveObserver( m_DeleteObserverTag );
   }
   m_Image = NULL;
 }
 
 vtkImageData* mitk::DiffSliceOperation::GetSlice()
 {
   //Image::ConstPointer image = m_zlibSliceContainer->GetImage().GetPointer();
   return m_Slice;
 }
 
 bool mitk::DiffSliceOperation::IsValid()
 {
   return m_ImageIsValid && (m_Slice.GetPointer() != NULL) && (m_WorldGeometry.IsNotNull());//TODO improve
 }
 
 void mitk::DiffSliceOperation::OnImageDeleted()
 {
   //if our imageVolume is removed e.g. from the datastorage the operation is no lnger valid
   m_ImageIsValid = false;
 }
\ No newline at end of file
diff --git a/Modules/Segmentation/Algorithms/mitkDiffSliceOperationApplier.cpp b/Modules/Segmentation/Algorithms/mitkDiffSliceOperationApplier.cpp
index f302b883a6..09e0d21381 100644
--- a/Modules/Segmentation/Algorithms/mitkDiffSliceOperationApplier.cpp
+++ b/Modules/Segmentation/Algorithms/mitkDiffSliceOperationApplier.cpp
@@ -1,77 +1,77 @@
 /*=========================================================================
  
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date$
 Version:   $Revision: $
  
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
  
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
  
 =========================================================================*/
 
-#include "DiffSliceOperationApplier.h"
+#include "mitkDiffSliceOperationApplier.h"
 #include "mitkRenderingManager.h"
 #include <vtkSmartPointer.h>
 
 mitk::DiffSliceOperationApplier::DiffSliceOperationApplier()
 {
 }
     
 mitk::DiffSliceOperationApplier::~DiffSliceOperationApplier()
 {
 }
 
 void mitk::DiffSliceOperationApplier::ExecuteOperation( Operation* operation )
 {
   DiffSliceOperation* imageOperation = dynamic_cast<DiffSliceOperation*>( operation );
 
   //as we only support DiffSliceOperation return if operation is not type of DiffSliceOperation
   if(!imageOperation)
     return;
 
 
   //chak if the operation is valid
   if(imageOperation->IsValid())
   {
     //the actual overwrite filter (vtk)
     vtkSmartPointer<mitkVtkImageOverwrite> reslice = vtkSmartPointer<mitkVtkImageOverwrite>::New();
 
     //Set the slice as 'input'
     reslice->SetInputSlice(imageOperation->GetSlice());
 
     //set overwrite mode to true to write back to the image volume
     reslice->SetOverwriteMode(true);
     reslice->Modified();
 
     //a wrapper for vtkImageOverwrite
     mitk::ExtractSliceFilter::Pointer extractor =  mitk::ExtractSliceFilter::New(reslice);
     extractor->SetInput( imageOperation->GetImage() );
     extractor->SetTimeStep( imageOperation->GetTimeStep() );
     extractor->SetWorldGeometry( dynamic_cast<Geometry2D*>(imageOperation->GetWorldGeometry()) );
     extractor->SetVtkOutputRequest(true);
     extractor->SetResliceTransformByGeometry( imageOperation->GetImage()->GetTimeSlicedGeometry()->GetGeometry3D( imageOperation->GetTimeStep() ) );
 
     extractor->Modified();
     extractor->Update();
 
     //make sure the modification is rendered
     RenderingManager::GetInstance()->RequestUpdateAll();
     imageOperation->GetImage()->Modified();
   }
 }
 
 //mitk::DiffSliceOperationApplier* mitk::DiffSliceOperationApplier::s_Instance = NULL;
 
 mitk::DiffSliceOperationApplier* mitk::DiffSliceOperationApplier::GetInstance()
 {
   //if(!s_Instance)
   static DiffSliceOperationApplier*  s_Instance = new DiffSliceOperationApplier();
 
   return s_Instance;
 }
\ No newline at end of file
diff --git a/Modules/Segmentation/Algorithms/mitkDiffSliceOperationApplier.h b/Modules/Segmentation/Algorithms/mitkDiffSliceOperationApplier.h
index 7695761c80..675aad602b 100644
--- a/Modules/Segmentation/Algorithms/mitkDiffSliceOperationApplier.h
+++ b/Modules/Segmentation/Algorithms/mitkDiffSliceOperationApplier.h
@@ -1,63 +1,63 @@
 /*===================================================================
 
 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 mitkDiffSliceOpertationApplier_h_Included
 #define mitkDiffSliceOpertationApplier_h_Included
 
 #include "SegmentationExports.h"
 #include "mitkCommon.h"
 #include <mitkOperationActor.h>
 
-#include "DiffSliceOperation.h"
+#include "mitkDiffSliceOperation.h"
 #include <mitkExtractSliceFilter.h>
 #include <mitkVtkImageOverwrite.h>
 
 namespace mitk
 {
   /** \brief Executes a DiffSliceOperation. 
     \sa DiffSliceOperation
   */
   class Segmentation_EXPORT DiffSliceOperationApplier : public OperationActor
   {
 
   public:
 
     mitkClassMacro(DiffSliceOperationApplier, OperationActor);
     
     //itkNewMacro(DiffSliceOperationApplier);
 
     /** \brief Returns an instance of the class */
     static DiffSliceOperationApplier* GetInstance();
 
     /** \brief Executes a DiffSliceOperation. 
       \sa DiffSliceOperation
       Note:
         Only DiffSliceOperation is supported.
     */
     virtual void ExecuteOperation(Operation* op);
 
 
   protected:
   
     DiffSliceOperationApplier();
     
     virtual ~DiffSliceOperationApplier();
 
     //static DiffSliceOperationApplier* s_Instance;
 
   };
 }
 #endif
\ No newline at end of file
diff --git a/Modules/Segmentation/Interactions/mitkSegTool2D.cpp b/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
index 89bfd57bb1..8e5433a2c5 100644
--- a/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
+++ b/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
@@ -1,393 +1,393 @@
 /*===================================================================
 
 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 "mitkSegTool2D.h"
 #include "mitkToolManager.h"
 
 #include "mitkDataStorage.h"
 #include "mitkBaseRenderer.h"
 
 #include "mitkPlaneGeometry.h"
 
 #include "mitkExtractImageFilter.h"
 #include "mitkExtractDirectedPlaneImageFilter.h"
 
 //Include of the new ImageExtractor
 #include "mitkExtractDirectedPlaneImageFilterNew.h"
 #include "mitkPlanarCircle.h"
 #include "mitkOverwriteSliceImageFilter.h"
 #include "mitkOverwriteDirectedPlaneImageFilter.h"
 
 #include "mitkGetModuleContext.h"
 
 //Includes for 3DSurfaceInterpolation
 #include "mitkImageToContourFilter.h"
 #include "mitkSurfaceInterpolationController.h"
 
 //includes for resling and overwriting
 #include <mitkExtractSliceFilter.h>
 #include <mitkVtkImageOverwrite.h>
 #include <vtkSmartPointer.h>
 #include <vtkImageData.h>
 
-#include <DiffSliceOperationApplier.h>
+#include <mitkDiffSliceOperationApplier.h>
 #include "mitkOperationEvent.h"
 #include "mitkUndoController.h"
 
 #define ROUND(a)     ((a)>0 ? (int)((a)+0.5) : -(int)(0.5-(a)))
 
 mitk::SegTool2D::SegTool2D(const char* type)
 :Tool(type),
  m_LastEventSender(NULL),
  m_LastEventSlice(0),
  m_Contourmarkername ("Position"),
  m_ShowMarkerNodes (true),
  m_3DInterpolationEnabled (true)
 {
   // great magic numbers
   CONNECT_ACTION( 80, OnMousePressed );
   CONNECT_ACTION( 90, OnMouseMoved );
   CONNECT_ACTION( 42, OnMouseReleased );
   CONNECT_ACTION( 49014, OnInvertLogic );
 
 
 }
 
 mitk::SegTool2D::~SegTool2D()
 {
 }
 
 bool mitk::SegTool2D::OnMousePressed (Action*, const StateEvent* stateEvent)
 {
   const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
   if (!positionEvent) return false;
 
   if ( positionEvent->GetSender()->GetMapperID() != BaseRenderer::Standard2D ) return false; // we don't want anything but 2D
 
   m_LastEventSender = positionEvent->GetSender();
   m_LastEventSlice = m_LastEventSender->GetSlice();
 
   return true;
 }
 
 bool mitk::SegTool2D::OnMouseMoved   (Action*, const StateEvent* stateEvent)
 {
   const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
   if (!positionEvent) return false;
 
   if ( m_LastEventSender != positionEvent->GetSender() ) return false;
   if ( m_LastEventSlice  != m_LastEventSender->GetSlice() ) return false;
 
   return true;
 }
 
 bool mitk::SegTool2D::OnMouseReleased(Action*, const StateEvent* stateEvent)
 {
   const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
   if (!positionEvent) return false;
 
   if ( m_LastEventSender != positionEvent->GetSender() ) return false;
   if ( m_LastEventSlice  != m_LastEventSender->GetSlice() ) return false;
 
   return true;
 }
 
 bool mitk::SegTool2D::OnInvertLogic(Action*, const StateEvent* stateEvent)
 {
   const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
   if (!positionEvent) return false;
 
   if ( m_LastEventSender != positionEvent->GetSender() ) return false;
   if ( m_LastEventSlice  != m_LastEventSender->GetSlice() ) return false;
 
   return true;
 }
 
 bool mitk::SegTool2D::DetermineAffectedImageSlice( const Image* image, const PlaneGeometry* plane, int& affectedDimension, int& affectedSlice )
 {
   assert(image);
   assert(plane);
 
   // compare normal of plane to the three axis vectors of the image
   Vector3D normal       = plane->GetNormal();
   Vector3D imageNormal0 = image->GetSlicedGeometry()->GetAxisVector(0);
   Vector3D imageNormal1 = image->GetSlicedGeometry()->GetAxisVector(1);
   Vector3D imageNormal2 = image->GetSlicedGeometry()->GetAxisVector(2);
 
   normal.Normalize();
   imageNormal0.Normalize();
   imageNormal1.Normalize();
   imageNormal2.Normalize();
 
   imageNormal0.Set_vnl_vector( vnl_cross_3d<ScalarType>(normal.Get_vnl_vector(),imageNormal0.Get_vnl_vector()) );
   imageNormal1.Set_vnl_vector( vnl_cross_3d<ScalarType>(normal.Get_vnl_vector(),imageNormal1.Get_vnl_vector()) );
   imageNormal2.Set_vnl_vector( vnl_cross_3d<ScalarType>(normal.Get_vnl_vector(),imageNormal2.Get_vnl_vector()) );
 
   double eps( 0.00001 );
   // transversal
   if ( imageNormal2.GetNorm() <= eps )
   {
     affectedDimension = 2;
   }
   // sagittal
   else if ( imageNormal1.GetNorm() <= eps )
   {
     affectedDimension = 1;
   }
   // frontal
   else if ( imageNormal0.GetNorm() <= eps )
   {
     affectedDimension = 0;
   }
   else
   {
     affectedDimension = -1; // no idea
     return false;
   }
 
   // determine slice number in image
   Geometry3D* imageGeometry = image->GetGeometry(0);
   Point3D testPoint = imageGeometry->GetCenter();
   Point3D projectedPoint;
   plane->Project( testPoint, projectedPoint );
 
   Point3D indexPoint;
 
   imageGeometry->WorldToIndex( projectedPoint, indexPoint );
   affectedSlice = ROUND( indexPoint[affectedDimension] );
   MITK_DEBUG << "indexPoint " << indexPoint << " affectedDimension " << affectedDimension << " affectedSlice " << affectedSlice;
 
   // check if this index is still within the image
   if ( affectedSlice < 0 || affectedSlice >= static_cast<int>(image->GetDimension(affectedDimension)) ) return false;
 
   return true;
 }
 
 mitk::Image::Pointer mitk::SegTool2D::GetAffectedImageSliceAs2DImage(const PositionEvent* positionEvent, const Image* image)
 {
   if (!positionEvent) return NULL;
 
   assert( positionEvent->GetSender() ); // sure, right?
   unsigned int timeStep = positionEvent->GetSender()->GetTimeStep( image ); // get the timestep of the visible part (time-wise) of the image
 
   // first, we determine, which slice is affected
   const PlaneGeometry* planeGeometry( dynamic_cast<const PlaneGeometry*> (positionEvent->GetSender()->GetCurrentWorldGeometry2D() ) );
 
   if ( !image || !planeGeometry ) return NULL;
 
   //Make sure that for reslicing and overwriting the same alogrithm is used. We can specify the mode of the vtk reslicer
   vtkSmartPointer<mitkVtkImageOverwrite> reslice = vtkSmartPointer<mitkVtkImageOverwrite>::New();
   //set to false to extract a slice
   reslice->SetOverwriteMode(false);
   reslice->Modified();
 
   //use ExtractSliceFilter with our specific vtkImageReslice for overwriting and extracting
   mitk::ExtractSliceFilter::Pointer extractor =  mitk::ExtractSliceFilter::New(reslice);
   extractor->SetInput( image );
   extractor->SetTimeStep( timeStep );
   extractor->SetWorldGeometry( planeGeometry );
   extractor->SetVtkOutputRequest(false);
   extractor->SetResliceTransformByGeometry( image->GetTimeSlicedGeometry()->GetGeometry3D( timeStep ) );
 
   extractor->Modified();
   extractor->Update();
 
   Image::Pointer slice = extractor->GetOutput();
 
   /*============= BEGIN undo feature block ========================*/
   //specify the undo operation with the non edited slice
   m_undoOperation = new DiffSliceOperation(const_cast<mitk::Image*>(image), extractor->GetVtkOutput(), slice->GetGeometry(), timeStep, const_cast<mitk::PlaneGeometry*>(planeGeometry));
   /*============= END undo feature block ========================*/
 
   return slice;
 }
 
 mitk::Image::Pointer mitk::SegTool2D::GetAffectedWorkingSlice(const PositionEvent* positionEvent)
 {
   DataNode* workingNode( m_ToolManager->GetWorkingData(0) );
   if ( !workingNode ) return NULL;
 
   Image* workingImage = dynamic_cast<Image*>(workingNode->GetData());
   if ( !workingImage ) return NULL;
 
   return GetAffectedImageSliceAs2DImage( positionEvent, workingImage );
 }
 
 mitk::Image::Pointer mitk::SegTool2D::GetAffectedReferenceSlice(const PositionEvent* positionEvent)
 {
   DataNode* referenceNode( m_ToolManager->GetReferenceData(0) );
   if ( !referenceNode ) return NULL;
 
   Image* referenceImage = dynamic_cast<Image*>(referenceNode->GetData());
   if ( !referenceImage ) return NULL;
 
   return GetAffectedImageSliceAs2DImage( positionEvent, referenceImage );
 }
 
 void mitk::SegTool2D::WriteBackSegmentationResult (const PositionEvent* positionEvent, Image* slice)
 {
   const PlaneGeometry* planeGeometry( dynamic_cast<const PlaneGeometry*> (positionEvent->GetSender()->GetCurrentWorldGeometry2D() ) );
 
   DataNode* workingNode( m_ToolManager->GetWorkingData(0) );
   Image* image = dynamic_cast<Image*>(workingNode->GetData());
 
   //Make sure that for reslicing and overwriting the same alogrithm is used. We can specify the mode of the vtk reslicer
   vtkSmartPointer<mitkVtkImageOverwrite> reslice = vtkSmartPointer<mitkVtkImageOverwrite>::New();
 
   //Set the slice as 'input'
   reslice->SetInputSlice(slice->GetVtkImageData(this->m_TimeStep));
 
   //set overwrite mode to true to write back to the image volume
   reslice->SetOverwriteMode(true);
   reslice->Modified();
 
   mitk::ExtractSliceFilter::Pointer extractor =  mitk::ExtractSliceFilter::New(reslice);
   extractor->SetInput( image );
   extractor->SetTimeStep( this->m_TimeStep );
   extractor->SetWorldGeometry( planeGeometry );
   extractor->SetVtkOutputRequest(true);
   extractor->SetResliceTransformByGeometry( image->GetTimeSlicedGeometry()->GetGeometry3D( this->m_TimeStep ) );
 
   extractor->Modified();
   extractor->Update();
 
   //the image was modified within the pipeline, but not marked so
   image->Modified();
 
   /*============= BEGIN undo feature block ========================*/
   //specify the undo operation with the edited slice
   m_doOperation = new DiffSliceOperation(image, extractor->GetVtkOutput(),slice->GetGeometry(), this->m_TimeStep, const_cast<mitk::PlaneGeometry*>(planeGeometry));
   
   //create an operation event for the undo stack
   OperationEvent* undoStackItem = new OperationEvent( DiffSliceOperationApplier::GetInstance(), m_doOperation, m_undoOperation, "Segmentation" );
   
   //add it to the undo controller
   UndoController::GetCurrentUndoModel()->SetOperationEvent( undoStackItem );
 
   //clear the pointers as the operation are stored in the undocontroller and also deleted from there
   m_undoOperation = NULL;
   m_doOperation = NULL;
   /*============= END undo feature block ========================*/
   
   if ( m_3DInterpolationEnabled )
   {
     slice->DisconnectPipeline();
     ImageToContourFilter::Pointer contourExtractor = ImageToContourFilter::New();
     contourExtractor->SetInput(slice);
     contourExtractor->Update();
     mitk::Surface::Pointer contour = contourExtractor->GetOutput();
 
     if (contour->GetVtkPolyData()->GetNumberOfPoints() > 0 )
     {
       unsigned int pos = this->AddContourmarker(positionEvent);
       mitk::ServiceReference serviceRef = mitk::GetModuleContext()->GetServiceReference<PlanePositionManagerService>();
       PlanePositionManagerService* service = dynamic_cast<PlanePositionManagerService*>(mitk::GetModuleContext()->GetService(serviceRef));
       mitk::SurfaceInterpolationController::GetInstance()->AddNewContour( contour, service->GetPlanePosition(pos));
       contour->DisconnectPipeline();
     }
 
   }
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void mitk::SegTool2D::SetShowMarkerNodes(bool status)
 {
     m_ShowMarkerNodes = status;
 }
 
 void mitk::SegTool2D::Enable3DInterpolation(bool status)
 {
     m_3DInterpolationEnabled = status;
 }
 
 unsigned int mitk::SegTool2D::AddContourmarker ( const PositionEvent* positionEvent )
 {
   const mitk::Geometry2D* plane = dynamic_cast<const Geometry2D*> (dynamic_cast< const mitk::SlicedGeometry3D*>(
     positionEvent->GetSender()->GetSliceNavigationController()->GetCurrentGeometry3D())->GetGeometry2D(0));
 
   mitk::ServiceReference serviceRef = mitk::GetModuleContext()->GetServiceReference<PlanePositionManagerService>();
   PlanePositionManagerService* service = dynamic_cast<PlanePositionManagerService*>(mitk::GetModuleContext()->GetService(serviceRef));
   unsigned int size = service->GetNumberOfPlanePositions();
   unsigned int id = service->AddNewPlanePosition(plane, positionEvent->GetSender()->GetSliceNavigationController()->GetSlice()->GetPos());
 
   mitk::PlanarCircle::Pointer contourMarker = mitk::PlanarCircle::New();
   contourMarker->SetGeometry2D( const_cast<Geometry2D*>(plane));
 
   std::stringstream markerStream;
   mitk::DataNode* workingNode (m_ToolManager->GetWorkingData(0));
 
   markerStream << m_Contourmarkername ;
   markerStream << " ";
   markerStream << id+1;
 
   DataNode::Pointer rotatedContourNode = DataNode::New();
 
   rotatedContourNode->SetData(contourMarker);
   rotatedContourNode->SetProperty( "name", StringProperty::New(markerStream.str()) );
   rotatedContourNode->SetProperty( "isContourMarker", BoolProperty::New(true));
   rotatedContourNode->SetBoolProperty( "PlanarFigureInitializedWindow", true, positionEvent->GetSender() );
   rotatedContourNode->SetProperty( "includeInBoundingBox", BoolProperty::New(false));
   rotatedContourNode->SetProperty( "helper object", mitk::BoolProperty::New(!m_ShowMarkerNodes));
 
   if (plane)
   {
 
     if ( id ==  size )
     {
       m_ToolManager->GetDataStorage()->Add(rotatedContourNode, workingNode);
     }
     else
     {
         mitk::NodePredicateProperty::Pointer isMarker = mitk::NodePredicateProperty::New("isContourMarker", mitk::BoolProperty::New(true));
 
         mitk::DataStorage::SetOfObjects::ConstPointer markers = m_ToolManager->GetDataStorage()->GetDerivations(workingNode,isMarker);
 
         for ( mitk::DataStorage::SetOfObjects::const_iterator iter = markers->begin();
           iter != markers->end();
           ++iter)
         {
             std::string nodeName = (*iter)->GetName();
             unsigned int t = nodeName.find_last_of(" ");
             unsigned int markerId = atof(nodeName.substr(t+1).c_str())-1;
             if(id == markerId)
             {
                 return id;
             }
         }
         m_ToolManager->GetDataStorage()->Add(rotatedContourNode, workingNode);
     }
   }
   return id;
 }
 
 void mitk::SegTool2D::InteractiveSegmentationBugMessage( const std::string& message )
 {
   MITK_ERROR << "********************************************************************************" << std::endl
     << " " << message << std::endl
     << "********************************************************************************" << std::endl
     << "  " << std::endl
     << " If your image is rotated or the 2D views don't really contain the patient image, try to press the button next to the image selection. " << std::endl
     << "  " << std::endl
     << " Please file a BUG REPORT: " << std::endl
     << " http://bugs.mitk.org" << std::endl
     << " Contain the following information:" << std::endl
     << "  - What image were you working on?" << std::endl
     << "  - Which region of the image?" << std::endl
     << "  - Which tool did you use?" << std::endl
     << "  - What did you do?" << std::endl
     << "  - What happened (not)? What did you expect?" << std::endl;
 }
 
diff --git a/Modules/Segmentation/Interactions/mitkSegTool2D.h b/Modules/Segmentation/Interactions/mitkSegTool2D.h
index 87de98d12c..1a21d36089 100644
--- a/Modules/Segmentation/Interactions/mitkSegTool2D.h
+++ b/Modules/Segmentation/Interactions/mitkSegTool2D.h
@@ -1,140 +1,140 @@
 /*===================================================================
 
 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 mitkSegTool2D_h_Included
 #define mitkSegTool2D_h_Included
 
 #include "mitkCommon.h"
 #include "SegmentationExports.h"
 #include "mitkTool.h"
 #include "mitkImage.h"
 
 #include "mitkStateEvent.h"
 #include "mitkPositionEvent.h"
 
 #include "mitkPlanePositionManager.h"
 #include "mitkRestorePlanePositionOperation.h"
 #include "mitkInteractionConst.h"
 
-#include <DiffSliceOperation.h>
+#include <mitkDiffSliceOperation.h>
 
 
 namespace mitk
 {
 
 class BaseRenderer;
 
 /**
   \brief Abstract base class for segmentation tools.
 
   \sa Tool
 
   \ingroup Interaction
   \ingroup ToolManagerEtAl
 
   Implements 2D segmentation specific helper methods, that might be of use to
   all kind of 2D segmentation tools. At the moment these are:
    - Determination of the slice where the user paints upon (DetermineAffectedImageSlice)
    - Projection of a 3D contour onto a 2D plane/slice
 
    SegTool2D tries to structure the interaction a bit. If you pass "PressMoveRelease" as the interaction type
    of your derived tool, you might implement the methods OnMousePressed, OnMouseMoved, and OnMouseReleased. 
    Yes, your guess about when they are called is correct.
 
   \warning Only to be instantiated by mitk::ToolManager.
 
   $Author$
 */
 class Segmentation_EXPORT SegTool2D : public Tool
 {
   public:
     
     mitkClassMacro(SegTool2D, Tool);
 
     /**
       \brief Calculates for a given Image and PlaneGeometry, which slice of the image (in index corrdinates) is meant by the plane.
 
       \return false, if no slice direction seems right (e.g. rotated planes)
       \param affectedDimension The image dimension, which is constant for all points in the plane, e.g. Transversal --> 2
       \param affectedSlice The index of the image slice
     */
     static bool DetermineAffectedImageSlice( const Image* image, const PlaneGeometry* plane, int& affectedDimension, int& affectedSlice );
 
     void SetShowMarkerNodes(bool);
 
     void Enable3DInterpolation(bool);
 
   protected:
 
     SegTool2D(); // purposely hidden
     SegTool2D(const char*); // purposely hidden
     virtual ~SegTool2D();
 
     virtual bool OnMousePressed (Action*, const StateEvent*);
     virtual bool OnMouseMoved   (Action*, const StateEvent*);
     virtual bool OnMouseReleased(Action*, const StateEvent*);
     virtual bool OnInvertLogic  (Action*, const StateEvent*);
 
     /**
       \brief Extract the slice of an image that the user just scribbles on.
       \return NULL if SegTool2D is either unable to determine which slice was affected, or if there was some problem getting the image data at that position.
     */
     Image::Pointer GetAffectedImageSliceAs2DImage(const PositionEvent*, const Image* image);
 
     /**
       \brief Extract the slice of the currently selected working image that the user just scribbles on.
       \return NULL if SegTool2D is either unable to determine which slice was affected, or if there was some problem getting the image data at that position,
                    or just no working image is selected.
     */
     Image::Pointer GetAffectedWorkingSlice(const PositionEvent*);
 
     /**
       \brief Extract the slice of the currently selected reference image that the user just scribbles on.
       \return NULL if SegTool2D is either unable to determine which slice was affected, or if there was some problem getting the image data at that position,
                    or just no reference image is selected.
     */
     Image::Pointer GetAffectedReferenceSlice(const PositionEvent*);
 
     void WriteBackSegmentationResult (const PositionEvent*, Image*);
 
     /**
       \brief Adds a new node called Contourmarker to the datastorage which holds a mitk::PlanarFigure. 
              By selecting this node the slicestack will be reoriented according to the PlanarFigure's Geometry
     */
 
     unsigned int AddContourmarker ( const PositionEvent* );
 
     void InteractiveSegmentationBugMessage( const std::string& message );
  
   private:
 
     BaseRenderer*         m_LastEventSender;
     unsigned int          m_LastEventSlice;
     //The prefix of the contourmarkername. Suffix is a consecutive number
     const std::string     m_Contourmarkername;
 
     bool m_ShowMarkerNodes;
     bool m_3DInterpolationEnabled;
 
-		DiffSliceOperation* m_doOperation;
-		DiffSliceOperation* m_undoOperation;
+    DiffSliceOperation* m_doOperation;
+    DiffSliceOperation* m_undoOperation;
 };
 
 } // namespace
 
 #endif