diff --git a/Modules/ContourModel/Algorithms/mitkContourModelUtils.cpp b/Modules/ContourModel/Algorithms/mitkContourModelUtils.cpp
index 34f1cfedb6..bbb4bada72 100755
--- a/Modules/ContourModel/Algorithms/mitkContourModelUtils.cpp
+++ b/Modules/ContourModel/Algorithms/mitkContourModelUtils.cpp
@@ -1,296 +1,247 @@
 /*===================================================================
 
 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 "mitkImageAccessByItk.h"
 #include "mitkImageCast.h"
 
 #include "itkCastImageFilter.h"
 #include "mitkContourModel.h"
 #include "mitkContourModelToSurfaceFilter.h"
 #include "mitkImage.h"
 #include "mitkImageVtkAccessor.h"
 #include "mitkSurface.h"
 #include "vtkImageData.h"
 #include "vtkImageLogic.h"
 #include "vtkImageStencil.h"
 #include "vtkPointData.h"
 #include "vtkPolyData.h"
 #include "vtkPolyDataToImageStencil.h"
 #include "vtkSmartPointer.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 nullptr;
 
   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++)
   {
     auto iter = contourIn3D->Begin(currentTimestep);
     auto 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_DEBUG << "**" << 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 nullptr;
 
   ContourModel::Pointer worldContour = ContourModel::New();
   worldContour->Initialize(*contourIn2D);
 
   int numberOfTimesteps = contourIn2D->GetTimeGeometry()->CountTimeSteps();
 
   for (int currentTimestep = 0; currentTimestep < numberOfTimesteps; currentTimestep++)
   {
     auto iter = contourIn2D->Begin(currentTimestep);
     auto 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 paintingPixelValue)
 {
   // 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) == nullptr)
   {
     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();
 
   // Set a minimal tolerance, so that clipped pixels will be added to contour as well.
   pol2stenc->SetTolerance(mitk::eps);
   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::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();
   FillSliceInSlice(filledImage, resultImage, workingImage, paintingPixelValue);
-  /*
-  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());
 }
 
 void mitk::ContourModelUtils::FillSliceInSlice(vtkSmartPointer<vtkImageData> filledImage,
                                                vtkSmartPointer<vtkImageData> resultImage,
                                                mitk::Image::Pointer image,
                                                int paintingPixelValue)
 {
   mitk::LabelSetImage *labelImage; // Todo: Get the working Image
   labelImage = dynamic_cast<LabelSetImage *>(image.GetPointer());
   int count = filledImage->GetNumberOfPoints();
 
   // if image is not a LabelSetImage just paint or erase
   if (!labelImage)
   {
     for (vtkIdType i = 0; i < count; ++i)
     {
       if (filledImage->GetPointData()->GetScalars()->GetTuple1(i) > 1)
       {
         resultImage->GetPointData()->GetScalars()->SetTuple1(i, paintingPixelValue);
       }
     }
   }
 
   // now for LabelSetImages
   else
   {
     auto backgroundValue = labelImage->GetExteriorLabel()->GetValue();
 
     // paint, but do not overwrite locked pixels
     if (paintingPixelValue != backgroundValue)
     {
       for (vtkIdType i = 0; i < count; ++i)
       {
         if (filledImage->GetPointData()->GetScalars()->GetTuple1(i) > 1)
         {
           auto existingValue = resultImage->GetPointData()->GetScalars()->GetTuple1(i);
           if (!labelImage->GetLabel(existingValue, labelImage->GetActiveLayer())->GetLocked())
           {
             resultImage->GetPointData()->GetScalars()->SetTuple1(i, paintingPixelValue);
           }
         }
       }
     }
 
     // erase, but only active label (regardless of locked state)
     else
     {
       auto activePixelValue = labelImage->GetActiveLabel(labelImage->GetActiveLayer())->GetValue();
 
       for (vtkIdType i = 0; i < count; ++i)
       {
         if (filledImage->GetPointData()->GetScalars()->GetTuple1(i) > 1)
         {
           if (resultImage->GetPointData()->GetScalars()->GetTuple1(i) == activePixelValue)
           {
             resultImage->GetPointData()->GetScalars()->SetTuple1(i, paintingPixelValue);
           }
         }
       }
      }
   }
 }
diff --git a/Modules/Segmentation/Interactions/mitkPaintbrushTool.cpp b/Modules/Segmentation/Interactions/mitkPaintbrushTool.cpp
index 1693a43060..26eddb987c 100644
--- a/Modules/Segmentation/Interactions/mitkPaintbrushTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkPaintbrushTool.cpp
@@ -1,602 +1,604 @@
 /*===================================================================
 
 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 "mitkPaintbrushTool.h"
 
 #include "ipSegmentation.h"
 #include "mitkAbstractTransformGeometry.h"
 #include "mitkBaseRenderer.h"
 #include "mitkImageDataItem.h"
 #include "mitkOverwriteSliceImageFilter.h"
 #include "mitkToolManager.h"
 
 #include "mitkContourModelUtils.h"
 #include "mitkLabelSetImage.h"
 #include "mitkLevelWindowProperty.h"
 
 #define ROUND(a) ((a) > 0 ? (int)((a) + 0.5) : -(int)(0.5 - (a)))
 
 int mitk::PaintbrushTool::m_Size = 1;
 
 mitk::PaintbrushTool::PaintbrushTool(int paintingPixelValue)
   : FeedbackContourTool("PressMoveReleaseWithCTRLInversionAllMouseMoves"),
     m_PaintingPixelValue(paintingPixelValue),
     m_LastContourSize(0) // other than initial mitk::PaintbrushTool::m_Size (around l. 28)
 {
   m_MasterContour = ContourModel::New();
   m_MasterContour->Initialize();
   m_CurrentPlane = nullptr;
 
   m_WorkingNode = DataNode::New();
   m_WorkingNode->SetProperty("levelwindow", mitk::LevelWindowProperty::New(mitk::LevelWindow(0, 1)));
   m_WorkingNode->SetProperty("binary", mitk::BoolProperty::New(true));
 }
 
 mitk::PaintbrushTool::~PaintbrushTool()
 {
 }
 
 void mitk::PaintbrushTool::ConnectActionsAndFunctions()
 {
   CONNECT_FUNCTION("PrimaryButtonPressed", OnMousePressed);
   CONNECT_FUNCTION("Move", OnPrimaryButtonPressedMoved);
   CONNECT_FUNCTION("MouseMove", OnMouseMoved);
   CONNECT_FUNCTION("Release", OnMouseReleased);
   CONNECT_FUNCTION("InvertLogic", OnInvertLogic);
 }
 
 void mitk::PaintbrushTool::Activated()
 {
   Superclass::Activated();
 
   FeedbackContourTool::SetFeedbackContourVisible(true);
   SizeChanged.Send(m_Size);
   m_ToolManager->WorkingDataChanged +=
     mitk::MessageDelegate<mitk::PaintbrushTool>(this, &mitk::PaintbrushTool::OnToolManagerWorkingDataModified);
 }
 
 void mitk::PaintbrushTool::Deactivated()
 {
   FeedbackContourTool::SetFeedbackContourVisible(false);
   if (m_ToolManager->GetDataStorage()->Exists(m_WorkingNode))
     m_ToolManager->GetDataStorage()->Remove(m_WorkingNode);
   m_WorkingSlice = nullptr;
   m_CurrentPlane = nullptr;
   m_ToolManager->WorkingDataChanged -=
     mitk::MessageDelegate<mitk::PaintbrushTool>(this, &mitk::PaintbrushTool::OnToolManagerWorkingDataModified);
 
   Superclass::Deactivated();
 }
 
 void mitk::PaintbrushTool::SetSize(int value)
 {
   m_Size = value;
 }
 
 mitk::Point2D mitk::PaintbrushTool::upperLeft(mitk::Point2D p)
 {
   p[0] -= 0.5;
   p[1] += 0.5;
   return p;
 }
 
 void mitk::PaintbrushTool::UpdateContour(const InteractionPositionEvent *positionEvent)
 {
   // MITK_INFO<<"Update...";
   // examine stateEvent and create a contour that matches the pixel mask that we are going to draw
   // mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   // const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
   if (!positionEvent)
     return;
 
   // Get Spacing of current Slice
   // mitk::Vector3D vSpacing = m_WorkingSlice->GetSlicedGeometry()->GetPlaneGeometry(0)->GetSpacing();
 
   //
   // Draw a contour in Square according to selected brush size
   //
   int radius = (m_Size) / 2;
   float fradius = static_cast<float>(m_Size) / 2.0f;
 
   ContourModel::Pointer contourInImageIndexCoordinates = ContourModel::New();
 
   // estimate center point of the brush ( relative to the pixel the mouse points on )
   // -- left upper corner for even sizes,
   // -- midpoint for uneven sizes
   mitk::Point2D centerCorrection;
   centerCorrection.Fill(0);
 
   // even --> correction of [+0.5, +0.5]
   bool evenSize = ((m_Size % 2) == 0);
   if (evenSize)
   {
     centerCorrection[0] += 0.5;
     centerCorrection[1] += 0.5;
   }
 
   // we will compute the control points for the upper left quarter part of a circle contour
   std::vector<mitk::Point2D> quarterCycleUpperRight;
   std::vector<mitk::Point2D> quarterCycleLowerRight;
   std::vector<mitk::Point2D> quarterCycleLowerLeft;
   std::vector<mitk::Point2D> quarterCycleUpperLeft;
 
   mitk::Point2D curPoint;
   bool curPointIsInside = true;
   curPoint[0] = 0;
   curPoint[1] = radius;
   quarterCycleUpperRight.push_back(upperLeft(curPoint));
 
   // to estimate if a pixel is inside the circle, we need to compare against the 'outer radius'
   // i.e. the distance from the midpoint [0,0] to the border of the pixel [0,radius]
   // const float outer_radius = static_cast<float>(radius) + 0.5;
 
   while (curPoint[1] > 0)
   {
     // Move right until pixel is outside circle
     float curPointX_squared = 0.0f;
     float curPointY_squared = (curPoint[1] - centerCorrection[1]) * (curPoint[1] - centerCorrection[1]);
     while (curPointIsInside)
     {
       // increment posX and chec
       curPoint[0]++;
       curPointX_squared = (curPoint[0] - centerCorrection[0]) * (curPoint[0] - centerCorrection[0]);
       const float len = sqrt(curPointX_squared + curPointY_squared);
       if (len > fradius)
       {
         // found first Pixel in this horizontal line, that is outside the circle
         curPointIsInside = false;
       }
     }
     quarterCycleUpperRight.push_back(upperLeft(curPoint));
 
     // Move down until pixel is inside circle
     while (!curPointIsInside)
     {
       // increment posX and chec
       curPoint[1]--;
       curPointY_squared = (curPoint[1] - centerCorrection[1]) * (curPoint[1] - centerCorrection[1]);
       const float len = sqrt(curPointX_squared + curPointY_squared);
       if (len <= fradius)
       {
         // found first Pixel in this horizontal line, that is outside the circle
         curPointIsInside = true;
         quarterCycleUpperRight.push_back(upperLeft(curPoint));
       }
 
       // Quarter cycle is full, when curPoint y position is 0
       if (curPoint[1] <= 0)
         break;
     }
   }
 
   // QuarterCycle is full! Now copy quarter cycle to other quarters.
 
   if (!evenSize)
   {
     std::vector<mitk::Point2D>::const_iterator it = quarterCycleUpperRight.begin();
     while (it != quarterCycleUpperRight.end())
     {
       mitk::Point2D p;
       p = *it;
 
       // the contour points in the lower right corner have same position but with negative y values
       p[1] *= -1;
       quarterCycleLowerRight.push_back(p);
 
       // the contour points in the lower left corner have same position
       // but with both x,y negative
       p[0] *= -1;
       quarterCycleLowerLeft.push_back(p);
 
       // the contour points in the upper left corner have same position
       // but with x negative
       p[1] *= -1;
       quarterCycleUpperLeft.push_back(p);
 
       it++;
     }
   }
   else
   {
     std::vector<mitk::Point2D>::const_iterator it = quarterCycleUpperRight.begin();
     while (it != quarterCycleUpperRight.end())
     {
       mitk::Point2D p, q;
       p = *it;
 
       q = p;
       // the contour points in the lower right corner have same position but with negative y values
       q[1] *= -1;
       // correct for moved offset if size even = the midpoint is not the midpoint of the current pixel
       // but its upper rigt corner
       q[1] += 1;
       quarterCycleLowerRight.push_back(q);
 
       q = p;
       // the contour points in the lower left corner have same position
       // but with both x,y negative
       q[1] = -1.0f * q[1] + 1;
       q[0] = -1.0f * q[0] + 1;
       quarterCycleLowerLeft.push_back(q);
 
       // the contour points in the upper left corner have same position
       // but with x negative
       q = p;
       q[0] *= -1;
       q[0] += 1;
       quarterCycleUpperLeft.push_back(q);
 
       it++;
     }
   }
 
   // fill contour with poins in right ordering, starting with the upperRight block
   mitk::Point3D tempPoint;
   for (unsigned int i = 0; i < quarterCycleUpperRight.size(); i++)
   {
     tempPoint[0] = quarterCycleUpperRight[i][0];
     tempPoint[1] = quarterCycleUpperRight[i][1];
     tempPoint[2] = 0;
     contourInImageIndexCoordinates->AddVertex(tempPoint);
   }
   // the lower right has to be parsed in reverse order
   for (int i = quarterCycleLowerRight.size() - 1; i >= 0; i--)
   {
     tempPoint[0] = quarterCycleLowerRight[i][0];
     tempPoint[1] = quarterCycleLowerRight[i][1];
     tempPoint[2] = 0;
     contourInImageIndexCoordinates->AddVertex(tempPoint);
   }
   for (unsigned int i = 0; i < quarterCycleLowerLeft.size(); i++)
   {
     tempPoint[0] = quarterCycleLowerLeft[i][0];
     tempPoint[1] = quarterCycleLowerLeft[i][1];
     tempPoint[2] = 0;
     contourInImageIndexCoordinates->AddVertex(tempPoint);
   }
   // the upper left also has to be parsed in reverse order
   for (int i = quarterCycleUpperLeft.size() - 1; i >= 0; i--)
   {
     tempPoint[0] = quarterCycleUpperLeft[i][0];
     tempPoint[1] = quarterCycleUpperLeft[i][1];
     tempPoint[2] = 0;
     contourInImageIndexCoordinates->AddVertex(tempPoint);
   }
 
   m_MasterContour = contourInImageIndexCoordinates;
 }
 
 /**
   Just show the contour, get one point as the central point and add surrounding points to the contour.
   */
 void mitk::PaintbrushTool::OnMousePressed(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   mitk::InteractionPositionEvent *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
   m_WorkingSlice->GetGeometry()->WorldToIndex(positionEvent->GetPositionInWorld(), m_LastPosition);
 
   if (!positionEvent)
     return;
 
   // create new working node
   // a fresh node is needed to only display the actual drawing process for
   // the undo function
   if (m_ToolManager->GetDataStorage()->Exists(m_WorkingNode))
     m_ToolManager->GetDataStorage()->Remove(m_WorkingNode);
   m_WorkingSlice = nullptr;
   m_CurrentPlane = nullptr;
 
   m_WorkingNode = DataNode::New();
   m_WorkingNode->SetProperty("levelwindow", mitk::LevelWindowProperty::New(mitk::LevelWindow(0, 1)));
   m_WorkingNode->SetProperty("binary", mitk::BoolProperty::New(true));
 
   this->m_WorkingNode->SetVisibility(true);
 
   m_LastEventSender = positionEvent->GetSender();
   m_LastEventSlice = m_LastEventSender->GetSlice();
 
   m_MasterContour->SetClosed(true);
   this->MouseMoved(interactionEvent, true);
 }
 
 void mitk::PaintbrushTool::OnMouseMoved(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   MouseMoved(interactionEvent, false);
 }
 
 void mitk::PaintbrushTool::OnPrimaryButtonPressedMoved(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   MouseMoved(interactionEvent, true);
 }
 
 /**
   Insert the point to the feedback contour,finish to build the contour and at the same time the painting function
   */
 void mitk::PaintbrushTool::MouseMoved(mitk::InteractionEvent *interactionEvent, bool leftMouseButtonPressed)
 {
   mitk::InteractionPositionEvent *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
 
   CheckIfCurrentSliceHasChanged(positionEvent);
 
   if (m_LastContourSize != m_Size)
   {
     UpdateContour(positionEvent);
     m_LastContourSize = m_Size;
   }
 
   Point3D worldCoordinates = positionEvent->GetPositionInWorld();
   Point3D indexCoordinates;
 
   m_WorkingSlice->GetGeometry()->WorldToIndex(worldCoordinates, indexCoordinates);
 
   MITK_DEBUG << "Mouse at W " << worldCoordinates << std::endl;
   MITK_DEBUG << "Mouse at I " << indexCoordinates << std::endl;
 
   // round to nearest voxel center (abort if this hasn't changed)
   if (m_Size % 2 == 0) // even
   {
     indexCoordinates[0] = ROUND(indexCoordinates[0]); // /*+ 0.5*/) + 0.5;
     indexCoordinates[1] = ROUND(indexCoordinates[1]); // /*+ 0.5*/ ) + 0.5;
   }
   else // odd
   {
     indexCoordinates[0] = ROUND(indexCoordinates[0]);
     indexCoordinates[1] = ROUND(indexCoordinates[1]);
   }
 
   static Point3D lastPos; // uninitialized: if somebody finds out how this can be initialized in a one-liner, tell me
   if (fabs(indexCoordinates[0] - lastPos[0]) > mitk::eps || fabs(indexCoordinates[1] - lastPos[1]) > mitk::eps ||
       fabs(indexCoordinates[2] - lastPos[2]) > mitk::eps || leftMouseButtonPressed)
   {
     lastPos = indexCoordinates;
   }
   else
   {
     MITK_DEBUG << "." << std::flush;
     return;
   }
 
   MITK_DEBUG << "Mouse at C " << indexCoordinates;
 
   int timestep = positionEvent->GetSender()->GetTimeStep();
 
   ContourModel::Pointer contour = ContourModel::New();
   contour->Expand(timestep + 1);
   contour->SetClosed(true, timestep);
 
   ContourModel::VertexIterator it = m_MasterContour->Begin();
   ContourModel::VertexIterator end = m_MasterContour->End();
 
   while (it != end)
   {
     Point3D point = (*it)->Coordinates;
     point[0] += indexCoordinates[0];
     point[1] += indexCoordinates[1];
 
     contour->AddVertex(point, timestep);
     it++;
   }
 
   if (leftMouseButtonPressed)
   {
     const double dist = indexCoordinates.EuclideanDistanceTo(m_LastPosition);
     const double radius = static_cast<double>(m_Size) / 2.0;
 
     DataNode *workingNode(m_ToolManager->GetWorkingData(0));
     Image::Pointer image = dynamic_cast<Image *>(workingNode->GetData());
     LabelSetImage *labelImage = dynamic_cast<LabelSetImage *>(image.GetPointer());
+
     int activeColor = 1;
-    if (labelImage != 0)
+    if (labelImage)
     {
-      activeColor = labelImage->GetActiveLabel()->GetValue();
+      activeColor = labelImage->GetActiveLabel(labelImage->GetActiveLayer())->GetValue();
     }
 
+    // m_PaintingPixelValue only decides whether to paint or erase
     mitk::ContourModelUtils::FillContourInSlice(
       contour, timestep, m_WorkingSlice, image, m_PaintingPixelValue * activeColor);
 
     m_WorkingNode->SetData(m_WorkingSlice);
     m_WorkingNode->Modified();
 
     // if points are >= radius away draw rectangle to fill empty holes
     // in between the 2 points
     if (dist > radius)
     {
       const mitk::Point3D &currentPos = indexCoordinates;
       mitk::Point3D direction;
       mitk::Point3D vertex;
       mitk::Point3D normal;
 
       direction[0] = indexCoordinates[0] - m_LastPosition[0];
       direction[1] = indexCoordinates[1] - m_LastPosition[1];
       direction[2] = indexCoordinates[2] - m_LastPosition[2];
 
       direction[0] = direction.GetVnlVector().normalize()[0];
       direction[1] = direction.GetVnlVector().normalize()[1];
       direction[2] = direction.GetVnlVector().normalize()[2];
 
       // 90 degrees rotation of direction
       normal[0] = -1.0 * direction[1];
       normal[1] = direction[0];
 
       contour->Clear();
 
       // upper left corner
       vertex[0] = m_LastPosition[0] + (normal[0] * radius);
       vertex[1] = m_LastPosition[1] + (normal[1] * radius);
 
       contour->AddVertex(vertex);
 
       // upper right corner
       vertex[0] = currentPos[0] + (normal[0] * radius);
       vertex[1] = currentPos[1] + (normal[1] * radius);
 
       contour->AddVertex(vertex);
 
       // lower right corner
       vertex[0] = currentPos[0] - (normal[0] * radius);
       vertex[1] = currentPos[1] - (normal[1] * radius);
 
       contour->AddVertex(vertex);
 
       // lower left corner
       vertex[0] = m_LastPosition[0] - (normal[0] * radius);
       vertex[1] = m_LastPosition[1] - (normal[1] * radius);
 
       contour->AddVertex(vertex);
 
-      FeedbackContourTool::FillContourInSlice(contour, timestep, m_WorkingSlice, m_PaintingPixelValue);
+      mitk::ContourModelUtils::FillContourInSlice(contour, timestep, m_WorkingSlice, image, m_PaintingPixelValue * activeColor);
       m_WorkingNode->SetData(m_WorkingSlice);
       m_WorkingNode->Modified();
     }
   }
   else
   {
     // switched from different renderwindow
     // no activate hover highlighting. Otherwise undo / redo wont work
     this->m_WorkingNode->SetVisibility(false);
   }
 
   m_LastPosition = indexCoordinates;
 
   // visualize contour
   ContourModel::Pointer displayContour = FeedbackContourTool::GetFeedbackContour();
   displayContour->Clear();
 
   ContourModel::Pointer tmp =
     FeedbackContourTool::BackProjectContourFrom2DSlice(m_WorkingSlice->GetGeometry(), /*displayContour*/ contour);
 
   // copy transformed contour into display contour
   it = tmp->Begin();
   end = tmp->End();
 
   while (it != end)
   {
     Point3D point = (*it)->Coordinates;
 
     displayContour->AddVertex(point, timestep);
     it++;
   }
 
   m_FeedbackContourNode->GetData()->Modified();
 
   assert(positionEvent->GetSender()->GetRenderWindow());
 
   RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
 }
 
 void mitk::PaintbrushTool::OnMouseReleased(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   // When mouse is released write segmentationresult back into image
   mitk::InteractionPositionEvent *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
   if (!positionEvent)
     return;
 
   this->WriteBackSegmentationResult(positionEvent, m_WorkingSlice->Clone());
 
   // deactivate visibility of helper node
   m_WorkingNode->SetVisibility(false);
 
   RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
 }
 
 /**
   Called when the CTRL key is pressed. Will change the painting pixel value from 0 to 1 or from 1 to 0.
   */
 void mitk::PaintbrushTool::OnInvertLogic(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   // Inversion only for 0 and 1 as painting values
   if (m_PaintingPixelValue == 1)
   {
     m_PaintingPixelValue = 0;
     FeedbackContourTool::SetFeedbackContourColor(1.0, 0.0, 0.0);
   }
   else if (m_PaintingPixelValue == 0)
   {
     m_PaintingPixelValue = 1;
     FeedbackContourTool::SetFeedbackContourColorDefault();
   }
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void mitk::PaintbrushTool::CheckIfCurrentSliceHasChanged(const InteractionPositionEvent *event)
 {
   const PlaneGeometry *planeGeometry((event->GetSender()->GetCurrentWorldPlaneGeometry()));
   const AbstractTransformGeometry *abstractTransformGeometry(
     dynamic_cast<const AbstractTransformGeometry *>(event->GetSender()->GetCurrentWorldPlaneGeometry()));
   DataNode *workingNode(m_ToolManager->GetWorkingData(0));
 
   if (!workingNode)
     return;
 
   Image::Pointer image = dynamic_cast<Image *>(workingNode->GetData());
 
   if (!image || !planeGeometry || abstractTransformGeometry)
     return;
 
   if (m_CurrentPlane.IsNull() || m_WorkingSlice.IsNull())
   {
     m_CurrentPlane = const_cast<PlaneGeometry *>(planeGeometry);
     m_WorkingSlice = SegTool2D::GetAffectedImageSliceAs2DImage(event, image)->Clone();
     m_WorkingNode->ReplaceProperty("color", workingNode->GetProperty("color"));
     m_WorkingNode->SetData(m_WorkingSlice);
   }
   else
   {
     bool isSameSlice(false);
     isSameSlice = mitk::MatrixEqualElementWise(planeGeometry->GetIndexToWorldTransform()->GetMatrix(),
                                                m_CurrentPlane->GetIndexToWorldTransform()->GetMatrix());
     isSameSlice = mitk::Equal(planeGeometry->GetIndexToWorldTransform()->GetOffset(),
                               m_CurrentPlane->GetIndexToWorldTransform()->GetOffset());
     if (!isSameSlice)
     {
       m_ToolManager->GetDataStorage()->Remove(m_WorkingNode);
       m_CurrentPlane = nullptr;
       m_WorkingSlice = nullptr;
       m_WorkingNode = nullptr;
       m_CurrentPlane = const_cast<PlaneGeometry *>(planeGeometry);
       m_WorkingSlice = SegTool2D::GetAffectedImageSliceAs2DImage(event, image)->Clone();
 
       m_WorkingNode = mitk::DataNode::New();
       m_WorkingNode->SetProperty("levelwindow", mitk::LevelWindowProperty::New(mitk::LevelWindow(0, 1)));
       m_WorkingNode->SetProperty("binary", mitk::BoolProperty::New(true));
 
       m_WorkingNode->SetData(m_WorkingSlice);
 
       // So that the paintbrush contour vanished in the previous render window
       RenderingManager::GetInstance()->RequestUpdateAll();
     }
   }
 
   if (!m_ToolManager->GetDataStorage()->Exists(m_WorkingNode))
   {
     m_WorkingNode->SetProperty("outline binary", mitk::BoolProperty::New(true));
     m_WorkingNode->SetProperty("color", workingNode->GetProperty("color"));
     m_WorkingNode->SetProperty("name", mitk::StringProperty::New("Paintbrush_Node"));
     m_WorkingNode->SetProperty("helper object", mitk::BoolProperty::New(true));
     m_WorkingNode->SetProperty("opacity", mitk::FloatProperty::New(0.8));
     m_WorkingNode->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
     m_WorkingNode->SetVisibility(
       false, mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4")));
 
     m_ToolManager->GetDataStorage()->Add(m_WorkingNode);
   }
 }
 
 void mitk::PaintbrushTool::OnToolManagerWorkingDataModified()
 {
   // Here we simply set the current working slice to null. The next time the mouse is moved
   // within a renderwindow a new slice will be extracted from the new working data
   m_WorkingSlice = nullptr;
 }