diff --git a/Modules/ContourModel/Algorithms/mitkContourModelUtils.cpp b/Modules/ContourModel/Algorithms/mitkContourModelUtils.cpp
index ee3ac87ccd..b95705afa1 100755
--- a/Modules/ContourModel/Algorithms/mitkContourModelUtils.cpp
+++ b/Modules/ContourModel/Algorithms/mitkContourModelUtils.cpp
@@ -1,233 +1,231 @@
 /*===================================================================
 
 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 "mitkContourModelUtils.h"
 #include "mitkImageCast.h"
 #include "mitkImageAccessByItk.h"
 
 
 #include "mitkContourModel.h"
 #include "itkCastImageFilter.h"
 #include "mitkImage.h"
 #include "mitkSurface.h"
 #include "vtkPolyData.h"
 #include "mitkContourModelToSurfaceFilter.h"
 #include "vtkPolyDataToImageStencil.h"
 #include "vtkImageStencil.h"
 #include "mitkImageVtkAccessor.h"
 #include "vtkSmartPointer.h"
 #include "vtkImageData.h"
 #include "vtkImageLogic.h"
 #include "vtkPointData.h"
 
 #include "mitkLabelSetImage.h"
 
 mitk::ContourModelUtils::ContourModelUtils()
 {
 }
 
 mitk::ContourModelUtils::~ContourModelUtils()
 {
 }
 
 
 
 mitk::ContourModel::Pointer mitk::ContourModelUtils::ProjectContourTo2DSlice(Image* slice, ContourModel* contourIn3D, bool itkNotUsed( correctionForIpSegmentation ), bool constrainToInside)
 {
   if ( !slice || !contourIn3D ) return NULL;
 
   ContourModel::Pointer projectedContour = ContourModel::New();
   projectedContour->Initialize(*contourIn3D);
 
   const BaseGeometry* sliceGeometry = slice->GetGeometry();
 
   int numberOfTimesteps = contourIn3D->GetTimeGeometry()->CountTimeSteps();
 
   for(int currentTimestep = 0; currentTimestep < numberOfTimesteps; currentTimestep++)
   {
     ContourModel::VertexIterator iter = contourIn3D->Begin(currentTimestep);
     ContourModel::VertexIterator end = contourIn3D->End(currentTimestep);
 
     while( iter != end)
     {
       Point3D currentPointIn3D = (*iter)->Coordinates;
 
       Point3D projectedPointIn2D;
       projectedPointIn2D.Fill(0.0);
       sliceGeometry->WorldToIndex( currentPointIn3D, projectedPointIn2D );
       // MITK_INFO << "world point " << currentPointIn3D << " in index is " << projectedPointIn2D;
 
       if ( !sliceGeometry->IsIndexInside( projectedPointIn2D ) && constrainToInside )
       {
         MITK_INFO << "**" << currentPointIn3D << " is " << projectedPointIn2D << " --> correct it (TODO)" << std::endl;
       }
 
       projectedContour->AddVertex( projectedPointIn2D, currentTimestep );
       iter++;
     }
   }
 
   return projectedContour;
 }
 
 
 
 mitk::ContourModel::Pointer mitk::ContourModelUtils::BackProjectContourFrom2DSlice(const BaseGeometry* sliceGeometry, ContourModel* contourIn2D, bool itkNotUsed( correctionForIpSegmentation ) )
 {
   if ( !sliceGeometry || !contourIn2D ) return NULL;
 
   ContourModel::Pointer worldContour = ContourModel::New();
   worldContour->Initialize(*contourIn2D);
 
   int numberOfTimesteps = contourIn2D->GetTimeGeometry()->CountTimeSteps();
 
   for(int currentTimestep = 0; currentTimestep < numberOfTimesteps; currentTimestep++)
   {
   ContourModel::VertexIterator iter = contourIn2D->Begin(currentTimestep);
   ContourModel::VertexIterator end = contourIn2D->End(currentTimestep);
 
   while( iter != end)
   {
     Point3D currentPointIn2D = (*iter)->Coordinates;
 
     Point3D worldPointIn3D;
     worldPointIn3D.Fill(0.0);
     sliceGeometry->IndexToWorld( currentPointIn2D, worldPointIn3D );
     //MITK_INFO << "index " << currentPointIn2D << " world " << worldPointIn3D << std::endl;
 
     worldContour->AddVertex( worldPointIn3D, currentTimestep );
     iter++;
   }
   }
 
   return worldContour;
 }
 
 
 
 void mitk::ContourModelUtils::FillContourInSlice( ContourModel* projectedContour, Image* sliceImage, mitk::Image::Pointer workingImage, int paintingPixelValue )
 {
   mitk::ContourModelUtils::FillContourInSlice(projectedContour, 0, sliceImage,workingImage, paintingPixelValue);
 }
 
 
 void mitk::ContourModelUtils::FillContourInSlice( ContourModel* projectedContour, unsigned int timeStep, Image* sliceImage, mitk::Image::Pointer workingImage , int eraseMode)
 {
       //create a surface of the input ContourModel
       mitk::Surface::Pointer surface = mitk::Surface::New();
       mitk::ContourModelToSurfaceFilter::Pointer contourModelFilter = mitk::ContourModelToSurfaceFilter::New();
       contourModelFilter->SetInput(projectedContour);
       contourModelFilter->Update();
       surface = contourModelFilter->GetOutput();
 
       // that's our vtkPolyData-Surface
       vtkSmartPointer<vtkPolyData> surface2D = vtkSmartPointer<vtkPolyData>::New();
       if (surface->GetVtkPolyData(timeStep) == NULL)
       {
         MITK_WARN << "No surface has been created from contour model. Add more points to fill contour in slice.";
         return;
       }
       surface2D->SetPoints(surface->GetVtkPolyData(timeStep)->GetPoints());
       surface2D->SetLines(surface->GetVtkPolyData(timeStep)->GetLines());
       surface2D->Modified();
       //surface2D->Update();
 
 
       // prepare the binary image's voxel grid
       vtkSmartPointer<vtkImageData> whiteImage =
           vtkSmartPointer<vtkImageData>::New();
       whiteImage->DeepCopy(sliceImage->GetVtkImageData());
 
       // fill the image with foreground voxels:
       unsigned char inval = 255;
       unsigned char outval = 0;
       vtkIdType count = whiteImage->GetNumberOfPoints();
       for (vtkIdType i = 0; i < count; ++i)
       {
         whiteImage->GetPointData()->GetScalars()->SetTuple1(i, inval);
       }
       // polygonal data --> image stencil:
       vtkSmartPointer<vtkPolyDataToImageStencil> pol2stenc =
         vtkSmartPointer<vtkPolyDataToImageStencil>::New();
       pol2stenc->SetTolerance(0);
       pol2stenc->SetInputData(surface2D);
       pol2stenc->Update();
 
       // cut the corresponding white image and set the background:
       vtkSmartPointer<vtkImageStencil> imgstenc =
         vtkSmartPointer<vtkImageStencil>::New();
 
       imgstenc->SetInputData(whiteImage);
       imgstenc->SetStencilConnection(pol2stenc->GetOutputPort());
       imgstenc->ReverseStencilOff();
       imgstenc->SetBackgroundValue(outval);
       imgstenc->Update();
-      MITK_INFO << "a";
       mitk::LabelSetImage* labelImage; // Todo: Get the working Image
       int activePixelValue = eraseMode;
       labelImage = dynamic_cast<LabelSetImage*>(workingImage.GetPointer());
       if (labelImage)
       {
         activePixelValue = labelImage->GetActiveLabel()->GetValue();
       }
 
       // Fill according to the Color Team
       vtkSmartPointer<vtkImageData> filledImage = imgstenc->GetOutput();
       vtkSmartPointer<vtkImageData> resultImage = sliceImage->GetVtkImageData();
-      MITK_INFO << "a";
       count = filledImage->GetNumberOfPoints();
       if (activePixelValue == 0)
       {
         for (vtkIdType i = 0; i < count; ++i)
         {
           if (filledImage->GetPointData()->GetScalars()->GetTuple1(i) > 1)
           {
             resultImage->GetPointData()->GetScalars()->SetTuple1(i, eraseMode);
           }
         }
       }
       else if (eraseMode != 0) // We are not erasing...
       {
         for (vtkIdType i = 0; i < count; ++i)
         {
           if (filledImage->GetPointData()->GetScalars()->GetTuple1(i) > 1)
           {
             int targetValue = resultImage->GetPointData()->GetScalars()->GetTuple1(i);
             if (labelImage)
             {
               if (!labelImage->GetLabel(targetValue)->GetLocked())
               {
                 resultImage->GetPointData()->GetScalars()->SetTuple1(i, eraseMode);
               }
             } else
             {
               resultImage->GetPointData()->GetScalars()->SetTuple1(i, eraseMode);
             }
           }
         }
       }
       else
       {
         for (vtkIdType i = 0; i < count; ++i)
         {
           if ((resultImage->GetPointData()->GetScalars()->GetTuple1(i) == activePixelValue) & (filledImage->GetPointData()->GetScalars()->GetTuple1(i) > 1))
           {
             resultImage->GetPointData()->GetScalars()->SetTuple1(i, eraseMode);
           }
         }
       }
       sliceImage->SetVolume(resultImage->GetScalarPointer());
 }
diff --git a/Modules/Segmentation/Interactions/mitkSetRegionTool.cpp b/Modules/Segmentation/Interactions/mitkSetRegionTool.cpp
index 7755be5232..6580419d74 100644
--- a/Modules/Segmentation/Interactions/mitkSetRegionTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkSetRegionTool.cpp
@@ -1,323 +1,340 @@
 /*===================================================================
 
 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 "mitkSetRegionTool.h"
 
 #include "mitkToolManager.h"
 #include "mitkOverwriteSliceImageFilter.h"
 #include "mitkAbstractTransformGeometry.h"
 
 #include "ipSegmentation.h"
 
 #include "mitkBaseRenderer.h"
 #include "mitkImageDataItem.h"
 #include "mitkLegacyAdaptors.h"
+#include "mitkLabelSetImage.h"
 
 #include "mitkOverwriteDirectedPlaneImageFilter.h"
 
 mitk::SetRegionTool::SetRegionTool(int paintingPixelValue)
 :FeedbackContourTool("PressMoveReleaseWithCTRLInversion"),
  m_PaintingPixelValue(paintingPixelValue),
  m_FillContour(false),
  m_StatusFillWholeSlice(false)
 {
 }
 
 mitk::SetRegionTool::~SetRegionTool()
 {
 }
 
 void mitk::SetRegionTool::ConnectActionsAndFunctions()
 {
   CONNECT_FUNCTION( "PrimaryButtonPressed", OnMousePressed);
   CONNECT_FUNCTION( "Release", OnMouseReleased);
   CONNECT_FUNCTION( "InvertLogic", OnInvertLogic);
 }
 
 void mitk::SetRegionTool::Activated()
 {
   Superclass::Activated();
 }
 
 void mitk::SetRegionTool::Deactivated()
 {
   Superclass::Deactivated();
 }
 
 bool mitk::SetRegionTool::OnMousePressed ( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   //const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
   if (!positionEvent) return false;
 
   m_LastEventSender = positionEvent->GetSender();
   m_LastEventSlice = m_LastEventSender->GetSlice();
   int timeStep = positionEvent->GetSender()->GetTimeStep();
 
   // 1. Get the working image
   Image::Pointer workingSlice   = FeedbackContourTool::GetAffectedWorkingSlice( positionEvent );
   if ( workingSlice.IsNull() ) return false; // can't do anything without the segmentation
 
   // if click was outside the image, don't continue
   const BaseGeometry* sliceGeometry = workingSlice->GetGeometry();
   itk::Index<2> projectedPointIn2D;
   sliceGeometry->WorldToIndex( positionEvent->GetPositionInWorld(), projectedPointIn2D );
   if ( !sliceGeometry->IsIndexInside( projectedPointIn2D ) )
   {
     MITK_ERROR << "point apparently not inside segmentation slice" << std::endl;
     return false; // can't use that as a seed point
   }
 
     // Convert to ipMITKSegmentationTYPE (because ipMITKSegmentationGetContour8N relys on that data type)
     itk::Image< ipMITKSegmentationTYPE, 2 >::Pointer correctPixelTypeImage;
     CastToItkImage( workingSlice, correctPixelTypeImage );
     assert (correctPixelTypeImage.IsNotNull() );
 
   // possible bug in CastToItkImage ?
   // direction maxtrix is wrong/broken/not working after CastToItkImage, leading to a failed assertion in
   // mitk/Core/DataStructures/mitkSlicedGeometry3D.cpp, 479:
   // virtual void mitk::SlicedGeometry3D::SetSpacing(const mitk::Vector3D&): Assertion `aSpacing[0]>0 && aSpacing[1]>0 && aSpacing[2]>0' failed
   // solution here: we overwrite it with an unity matrix
   itk::Image< ipMITKSegmentationTYPE, 2 >::DirectionType imageDirection;
   imageDirection.SetIdentity();
   correctPixelTypeImage->SetDirection(imageDirection);
 
     Image::Pointer temporarySlice = Image::New();
   //  temporarySlice = ImportItkImage( correctPixelTypeImage );
     CastToMitkImage( correctPixelTypeImage, temporarySlice );
 
 
   // check index positions
   mitkIpPicDescriptor* originalPicSlice = mitkIpPicNew();
   CastToIpPicDescriptor( temporarySlice, originalPicSlice );
 
   int m_SeedPointMemoryOffset = projectedPointIn2D[1] * originalPicSlice->n[0] + projectedPointIn2D[0];
 
   if ( m_SeedPointMemoryOffset >= static_cast<int>( originalPicSlice->n[0] * originalPicSlice->n[1] ) ||
        m_SeedPointMemoryOffset < 0 )
   {
     MITK_ERROR << "Memory offset calculation if mitk::SetRegionTool has some serious flaw! Aborting.." << std::endl;
     return false;
   }
 
+  // Get the current working color
+  DataNode* workingNode( m_ToolManager->GetWorkingData(0) );
+  if (!workingNode) return false;
+
+  Image* image = dynamic_cast<Image*>(workingNode->GetData());
+  LabelSetImage* labelImage = dynamic_cast<LabelSetImage*>(image);
+  int activeColor = 1;
+  if (labelImage != 0)
+  {
+    activeColor = labelImage->GetActiveLabel()->GetValue();
+  }
+
+
   // 2. Determine the contour that surronds the selected "piece of the image"
 
   // find a contour seed point
   unsigned int oneContourOffset = static_cast<unsigned int>( m_SeedPointMemoryOffset ); // safe because of earlier check if m_SeedPointMemoryOffset < 0
 
   /**
     * The logic of finding a starting point for the contour is the following:
     *
     *  - If the initial seed point is 0, we are either inside a hole or outside of every segmentation.
     *    We move to the right until we hit a 1, which must be part of a contour.
     *
     *  - If the initial seed point is 1, then ...
     *    we now do the same (running to the right) until we hit a 1
     *
     *  In both cases the found contour point is used to extract a contour and
     *  then a test is applied to find out if the initial seed point is contained
     *  in the contour. If this is the case, filling should be applied, otherwise
     *  nothing is done.
     */
   unsigned int size = originalPicSlice->n[0] * originalPicSlice->n[1];
 /*
   unsigned int rowSize = originalPicSlice->n[0];
 */
   ipMITKSegmentationTYPE* data = static_cast<ipMITKSegmentationTYPE*>(originalPicSlice->data);
 
   if ( data[oneContourOffset] == 0 ) // initial seed 0
   {
     for ( ; oneContourOffset < size; ++oneContourOffset )
     {
       if ( data[oneContourOffset] > 0 ) break;
     }
   }
-  else if ( data[oneContourOffset] == 1 ) // initial seed 1
+  else if ( data[oneContourOffset] == activeColor ) // initial seed 1
   {
     unsigned int lastValidPixel = size-1; // initialization, will be changed lateron
     bool inSeg = true;    // inside segmentation?
     for ( ; oneContourOffset < size; ++oneContourOffset )
     {
-      if ( ( data[oneContourOffset] == 0 ) && inSeg ) // pixel 0 and inside-flag set: this happens at the first pixel outside a filled region
+      if ( ( data[oneContourOffset] != activeColor ) && inSeg ) // pixel 0 and inside-flag set: this happens at the first pixel outside a filled region
       {
         inSeg = false;
         lastValidPixel = oneContourOffset - 1; // store the last pixel position inside a filled region
         break;
       }
       else // pixel 1, inside-flag doesn't matter: this happens while we are inside a filled region
       {
         inSeg = true; // first iteration lands here
       }
 
     }
     oneContourOffset = lastValidPixel;
   }
-  else
-  {
-    MITK_ERROR << "Fill/Erase was never intended to work with other than binary images." << std::endl;
-    m_FillContour = false;
-    return false;
-  }
 
   if (oneContourOffset == size) // nothing found until end of slice
   {
     m_FillContour = false;
     return false;
   }
 
   int numberOfContourPoints( 0 );
   int newBufferSize( 0 );
   //MITK_INFO << "getting contour from offset " << oneContourOffset << " ("<<oneContourOffset%originalPicSlice->n[0]<<","<<oneContourOffset/originalPicSlice->n[0]<<")"<<std::endl;
   float* contourPoints = ipMITKSegmentationGetContour8N( originalPicSlice, oneContourOffset, numberOfContourPoints, newBufferSize ); // memory allocated with malloc
 
   //MITK_INFO << "contourPoints " << contourPoints << " (N="<<numberOfContourPoints<<")"<<std::endl;
   assert(contourPoints == NULL || numberOfContourPoints > 0);
 
   bool cursorInsideContour = ipMITKSegmentationIsInsideContour( contourPoints, numberOfContourPoints, projectedPointIn2D[0], projectedPointIn2D[1]);
 
   // decide if contour should be filled or not
   m_FillContour = cursorInsideContour;
 
   if (m_FillContour)
   {
     // copy point from float* to mitk::Contour
     ContourModel::Pointer contourInImageIndexCoordinates = ContourModel::New();
     contourInImageIndexCoordinates->Expand(timeStep + 1);
     contourInImageIndexCoordinates->SetClosed(true, timeStep);
     Point3D newPoint;
     for (int index = 0; index < numberOfContourPoints; ++index)
     {
       newPoint[0] = contourPoints[ 2 * index + 0 ] - 0.5;
       newPoint[1] = contourPoints[ 2 * index + 1] - 0.5;
       newPoint[2] = 0;
 
       contourInImageIndexCoordinates->AddVertex(newPoint, timeStep);
     }
 
     m_SegmentationContourInWorldCoordinates = FeedbackContourTool::BackProjectContourFrom2DSlice( workingSlice->GetGeometry(), contourInImageIndexCoordinates, true ); // true, correct the result from ipMITKSegmentationGetContour8N
 
     // 3. Show the contour
     FeedbackContourTool::SetFeedbackContour( *m_SegmentationContourInWorldCoordinates );
 
     FeedbackContourTool::SetFeedbackContourVisible(true);
     mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
   }
 
   // always generate a second contour, containing the whole image (used when CTRL is pressed)
   {
     // copy point from float* to mitk::Contour
     ContourModel::Pointer contourInImageIndexCoordinates = ContourModel::New();
     contourInImageIndexCoordinates->Expand(timeStep + 1);
     contourInImageIndexCoordinates->SetClosed(true, timeStep);
     Point3D newPoint;
     newPoint[0] = 0; newPoint[1] = 0; newPoint[2] = 0.0;
     contourInImageIndexCoordinates->AddVertex( newPoint, timeStep );
     newPoint[0] = originalPicSlice->n[0]; newPoint[1] = 0; newPoint[2] = 0.0;
     contourInImageIndexCoordinates->AddVertex( newPoint, timeStep );
     newPoint[0] = originalPicSlice->n[0]; newPoint[1] = originalPicSlice->n[1]; newPoint[2] = 0.0;
     contourInImageIndexCoordinates->AddVertex( newPoint, timeStep );
     newPoint[0] = 0; newPoint[1] = originalPicSlice->n[1]; newPoint[2] = 0.0;
     contourInImageIndexCoordinates->AddVertex( newPoint, timeStep );
 
     m_WholeImageContourInWorldCoordinates = FeedbackContourTool::BackProjectContourFrom2DSlice( workingSlice->GetGeometry(), contourInImageIndexCoordinates, true ); // true, correct the result from ipMITKSegmentationGetContour8N
 
     // 3. Show the contour
     FeedbackContourTool::SetFeedbackContour( *m_SegmentationContourInWorldCoordinates );
 
     FeedbackContourTool::SetFeedbackContourVisible(true);
     mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
   }
 
 
   free(contourPoints);
 
   return true;
 }
 
 bool mitk::SetRegionTool::OnMouseReleased( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   // 1. Hide the feedback contour, find out which slice the user clicked, find out which slice of the toolmanager's working image corresponds to that
   FeedbackContourTool::SetFeedbackContourVisible(false);
 
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   if (!positionEvent) return false;
 
   assert( positionEvent->GetSender()->GetRenderWindow() );
   mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
 
   int timeStep = positionEvent->GetSender()->GetTimeStep();
 
   if (!m_FillContour && !m_StatusFillWholeSlice) return true;
 
   DataNode* workingNode( m_ToolManager->GetWorkingData(0) );
   if (!workingNode) return false;
 
   Image* image = dynamic_cast<Image*>(workingNode->GetData());
   const AbstractTransformGeometry* abstractTransformGeometry( dynamic_cast<const AbstractTransformGeometry*> (positionEvent->GetSender()->GetCurrentWorldPlaneGeometry() ) );
   const PlaneGeometry* planeGeometry( dynamic_cast<const PlaneGeometry*> (positionEvent->GetSender()->GetCurrentWorldPlaneGeometry() ) );
   if ( !image || !planeGeometry || abstractTransformGeometry ) return false;
 
   Image::Pointer slice = FeedbackContourTool::GetAffectedImageSliceAs2DImage( positionEvent, image );
 
   if ( slice.IsNull() )
   {
       MITK_ERROR << "Unable to extract slice." << std::endl;
       return false;
   }
 
   ContourModel* feedbackContour( FeedbackContourTool::GetFeedbackContour() );
   ContourModel::Pointer projectedContour = FeedbackContourTool::ProjectContourTo2DSlice( slice, feedbackContour, false, false ); // false: don't add 0.5 (done by FillContourInSlice)
   // false: don't constrain the contour to the image's inside
   if (projectedContour.IsNull()) return false;
 
-  FeedbackContourTool::FillContourInSlice( projectedContour, timeStep, slice, m_PaintingPixelValue );
+  LabelSetImage* labelImage = dynamic_cast<LabelSetImage*>(image);
+  int activeColor = 1;
+  if (labelImage != 0)
+  {
+    activeColor = labelImage->GetActiveLabel()->GetValue();
+  }
+
+  mitk::ContourModelUtils::FillContourInSlice(projectedContour, timeStep, slice, image, m_PaintingPixelValue*activeColor);
+
+  //FeedbackContourTool::FillContourInSlice( projectedContour, timeStep, slice, m_PaintingPixelValue );
 
   this->WriteBackSegmentationResult(positionEvent, slice);
 
   m_WholeImageContourInWorldCoordinates = NULL;
   m_SegmentationContourInWorldCoordinates = NULL;
 
   return true;
 }
 
 /**
   Called when the CTRL key is pressed. Will change the painting pixel value from 0 to 1 or from 1 to 0.
 */
 bool mitk::SetRegionTool::OnInvertLogic( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   if (!positionEvent) return false;
 
   if (m_StatusFillWholeSlice)
   {
     // use contour extracted from image data
     if (m_SegmentationContourInWorldCoordinates.IsNotNull())
       FeedbackContourTool::SetFeedbackContour( *m_SegmentationContourInWorldCoordinates );
     mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
   }
   else
   {
     // use some artificial contour
     if (m_WholeImageContourInWorldCoordinates.IsNotNull())
       FeedbackContourTool::SetFeedbackContour( *m_WholeImageContourInWorldCoordinates );
     mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
   }
 
   m_StatusFillWholeSlice = !m_StatusFillWholeSlice;
 
   return true;
 }