diff --git a/Modules/ContourModel/Algorithms/mitkContourModelUtils.cpp b/Modules/ContourModel/Algorithms/mitkContourModelUtils.cpp
index f66952caa9..ee3ac87ccd 100755
--- a/Modules/ContourModel/Algorithms/mitkContourModelUtils.cpp
+++ b/Modules/ContourModel/Algorithms/mitkContourModelUtils.cpp
@@ -1,236 +1,233 @@
 /*===================================================================
 
 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 (workingImage)
+      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/Algorithms/mitkCorrectorAlgorithm.cpp b/Modules/Segmentation/Algorithms/mitkCorrectorAlgorithm.cpp
index 062ac17324..682cea18d9 100644
--- a/Modules/Segmentation/Algorithms/mitkCorrectorAlgorithm.cpp
+++ b/Modules/Segmentation/Algorithms/mitkCorrectorAlgorithm.cpp
@@ -1,447 +1,449 @@
 /*===================================================================
 
 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 "mitkCorrectorAlgorithm.h"
 #include "mitkImageCast.h"
 #include "mitkImageAccessByItk.h"
 #include "mitkImageDataItem.h"
 #include "mitkContourUtils.h"
 #include "mitkLegacyAdaptors.h"
 
 #include <mitkContourModelUtils.h>
 
 #include "itkImageDuplicator.h"
 #include "itkImageRegionIterator.h"
 
 #include <mitkIOUtil.h>
 
 mitk::CorrectorAlgorithm::CorrectorAlgorithm()
 :ImageToImageFilter()
 {
 }
 
 mitk::CorrectorAlgorithm::~CorrectorAlgorithm()
 {
 }
 
 
 void mitk::CorrectorAlgorithm::GenerateData()
 {
   Image::Pointer inputImage = const_cast<Image*>(ImageToImageFilter::GetInput(0));
 
   if (inputImage.IsNull() || inputImage->GetDimension() != 2)
   {
     itkExceptionMacro("CorrectorAlgorithm needs a 2D image as input.");
   }
 
   if (m_Contour.IsNull())
   {
     itkExceptionMacro("CorrectorAlgorithm needs a Contour object as input.");
   }
 
   // copy the input (since m_WorkingImage will be changed later)
   m_WorkingImage = inputImage;
 
   TimeGeometry::Pointer originalGeometry = NULL;
 
   if (inputImage->GetTimeGeometry() )
   {
     originalGeometry = inputImage->GetTimeGeometry()->Clone();
     m_WorkingImage->SetTimeGeometry( originalGeometry );
   }
   else
   {
     itkExceptionMacro("Original image does not have a 'Time sliced geometry'! Cannot copy.");
   }
 
   Image::Pointer temporarySlice;
   // Convert to ipMITKSegmentationTYPE (because TobiasHeimannCorrectionAlgorithm relys on that data type)
   {
     itk::Image< ipMITKSegmentationTYPE, 2 >::Pointer correctPixelTypeImage;
     CastToItkImage( m_WorkingImage, 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);
 
     temporarySlice = this->GetOutput();
     //  temporarySlice = ImportItkImage( correctPixelTypeImage );
     m_FillColor = 1;
     m_EraseColor = 0;
     ImprovedHeimannCorrectionAlgorithm(correctPixelTypeImage);
     CastToMitkImage( correctPixelTypeImage, temporarySlice );
   }
   temporarySlice->SetTimeGeometry(originalGeometry);
 }
 
 bool mitk::CorrectorAlgorithm::ImprovedHeimannCorrectionAlgorithm(itk::Image< ipMITKSegmentationTYPE, 2 >::Pointer pic)
 {
 /*!
 Some documentation (not by the original author)
 
 TobiasHeimannCorrectionAlgorithm will be called, when the user has finished drawing a freehand line.
 
 There should be different results, depending on the line's properties:
 
 1. Without any prior segmentation, the start point and the end point of the drawn line will be
 connected to a contour and the area enclosed by the contour will be marked as segmentation.
 
 2. When the whole line is inside a segmentation, start and end point will be connected to
 a contour and the area of this contour will be subtracted from the segmentation.
 
 3. When the line starts inside a segmentation and ends outside with only a single
 transition from segmentation to no-segmentation, nothing will happen.
 
 4. When there are multiple transitions between inside-segmentation and
 outside-segmentation, the line will be divided in so called segments. Each segment is
 either fully inside or fully outside a segmentation. When it is inside a segmentation, its
 enclosed area will be subtracted from the segmentation. When the segment is outside a
 segmentation, its enclosed area it will be added to the segmentation.
 
 The algorithm is described in full length in Tobias Heimann's diploma thesis
 (MBI Technical Report 145, p. 37 - 40).
 */
 
   ContourModel::Pointer projectedContour = mitk::ContourModelUtils::ProjectContourTo2DSlice( m_WorkingImage, m_Contour, true, false );
 
   bool firstPointIsFillingColor = false;
 
   if (projectedContour.IsNull() ||
     projectedContour->GetNumberOfVertices() < 2 )
   {
     return false;
   }
 
   // Read the first point of the contour
   ContourModel::VertexIterator contourIter = projectedContour->Begin();
   if (contourIter == projectedContour->End())
     return false;
   itk::Index<2> previousIndex;
   previousIndex[0] = (*contourIter)->Coordinates[0];
   previousIndex[1] = (*contourIter)->Coordinates[1];
   ++contourIter;
 
   int currentColor = ( pic->GetPixel(previousIndex) == m_FillColor);
   firstPointIsFillingColor = currentColor;
   TSegData currentSegment;
   int countOfSegments = 1;
 
 
   bool firstSegment = true;
   ContourModel::VertexIterator contourEnd = projectedContour->End();
   for (; contourIter != contourEnd; ++contourIter)
   {
     // Get current point
     itk::Index<2> currentIndex;
     currentIndex[0] = (*contourIter)->Coordinates[0] +0.5;
     currentIndex[1] = (*contourIter)->Coordinates[1] +0.5;
 
     // Calculate length and slope
     double slopeX = currentIndex[0] - previousIndex[0];
     double slopeY = currentIndex[1] - previousIndex[1];
     double length = std::sqrt(slopeX * slopeX + slopeY * slopeY);
     double deltaX = slopeX / length;
     double deltaY = slopeY / length;
 
     for (double i = 0; i <= length && length > 0; i+=1)
     {
       itk::Index<2> temporaryIndex;
       temporaryIndex[0] = previousIndex[0] + deltaX * i;
       temporaryIndex[1] = previousIndex[1] + deltaY * i;
       if ( ! pic->GetLargestPossibleRegion().IsInside(temporaryIndex))
         continue;
       if ( (pic->GetPixel(temporaryIndex) == m_FillColor) != currentColor)
       {
         currentSegment.points.push_back(temporaryIndex);
         if ( ! firstSegment)
         {
           ModifySegment( currentSegment, pic);
         } else
         {
           firstSegment = false;
         }
         currentSegment = TSegData();
         ++countOfSegments;
         currentColor = (pic->GetPixel(temporaryIndex) == m_FillColor);
       }
       currentSegment.points.push_back(temporaryIndex);
     }
     previousIndex = currentIndex;
   }
 
   // Check if only on Segment
   if (firstSegment && currentSegment.points.size() > 0)
   {
       ContourModel::Pointer projectedContour = mitk::ContourModelUtils::ProjectContourTo2DSlice( m_WorkingImage, m_Contour, true, false );
       projectedContour->Close();
+      MITK_INFO << "blub";
       if (firstPointIsFillingColor)
       {
-        ContourModelUtils::FillContourInSlice(projectedContour, 0, m_WorkingImage, m_EraseColor);
+        ContourModelUtils::FillContourInSlice(projectedContour, 0, m_WorkingImage, m_WorkingImage, m_EraseColor);
       } else
       {
-        ContourModelUtils::FillContourInSlice(projectedContour, 0, m_WorkingImage, m_FillColor);
+        ContourModelUtils::FillContourInSlice(projectedContour, 0, m_WorkingImage, m_WorkingImage, m_FillColor);
       }
+      MITK_INFO << "No Blub";
   }
   return true;
 }
 
 static void ColorSegment(const mitk::CorrectorAlgorithm::TSegData &segment, itk::Image< ipMITKSegmentationTYPE, 2 >::Pointer pic, int fillColor, int eraseColor)
 {
   int colorMode = (pic->GetPixel(segment.points[0]) == fillColor);
   int color = 0;
   if (colorMode)
     color = eraseColor;
   else
     color = fillColor;
 
   std::vector< itk::Index<2> >::const_iterator indexIterator;
   std::vector< itk::Index<2> >::const_iterator indexEnd;
 
   indexIterator = segment.points.begin();
   indexEnd = segment.points.end();
 
   for (; indexIterator != indexEnd; ++indexIterator)
   {
     pic->SetPixel(*indexIterator, color);
   }
 }
 static itk::Image< ipMITKSegmentationTYPE, 2 >::Pointer CloneImage(itk::Image< ipMITKSegmentationTYPE, 2 >::Pointer pic)
 {
   typedef itk::Image< ipMITKSegmentationTYPE, 2 > ItkImageType;
 
   typedef itk::ImageDuplicator< ItkImageType > DuplicatorType;
   DuplicatorType::Pointer duplicator = DuplicatorType::New();
   duplicator->SetInputImage(pic);
   duplicator->Update();
 
   return duplicator->GetOutput();
 }
 static itk::Index<2> GetFirstPoint(const mitk::CorrectorAlgorithm::TSegData &segment, itk::Image< ipMITKSegmentationTYPE, 2 >::Pointer pic, int fillColor)
 {
   int colorMode = (pic->GetPixel(segment.points[0]) == fillColor);
 
   std::vector< itk::Index<2> >::const_iterator indexIterator;
   std::vector< itk::Index<2> >::const_iterator indexEnd;
 
   indexIterator = segment.points.begin();
   indexEnd = segment.points.end();
 
   for (; indexIterator != indexEnd; ++indexIterator)
   {
     itk::Index<2> index;
     for (int xOffset = -1 ; xOffset < 2; ++xOffset)
     {
       for (int yOffset = -1 ; yOffset < 2; ++yOffset)
       {
         index[0] = (*indexIterator)[0] - xOffset;
         index[1] = (*indexIterator)[1] - yOffset;
         if ((pic->GetPixel(index) == fillColor) != colorMode)
         {
           return index;
         }
       }
     }
   }
   mitkThrow() << "No Starting point is found next to the curve.";
 }
 
 static std::vector<itk::Index<2> > FindSeedPoints(const mitk::CorrectorAlgorithm::TSegData &segment, itk::Image< ipMITKSegmentationTYPE, 2 >::Pointer pic, int fillColor)
 {
   typedef itk::Image< ipMITKSegmentationTYPE, 2 > ItkImageType;
   typedef itk::Image< ipMITKSegmentationTYPE, 2 >::Pointer ItkImagePointerType;
 
   int colorMode = (pic->GetPixel(segment.points[0]) == fillColor);
   std::vector<itk::Index<2> > seedPoints;
 
   try
   {
     itk::Index<2> firstPoint = GetFirstPoint(segment,  pic, fillColor);
     seedPoints.push_back(firstPoint);
   }
   catch (mitk::Exception e)
   {
     return seedPoints;
   }
 
   if (segment.points.size() < 4)
     return seedPoints;
 
   std::vector< itk::Index<2> >::const_iterator indexIterator;
   std::vector< itk::Index<2> >::const_iterator indexEnd;
 
   indexIterator = segment.points.begin();
   indexEnd = segment.points.end();
 
   ItkImagePointerType listOfPoints = CloneImage(pic);
   listOfPoints->FillBuffer(0);
   listOfPoints->SetPixel(seedPoints[0],1);
   for (; indexIterator != indexEnd; ++indexIterator)
   {
     listOfPoints->SetPixel(*indexIterator, 2);
   }
   indexIterator = segment.points.begin();
   indexIterator++;
   indexIterator++;
   indexEnd--;
   indexEnd--;
   for (; indexIterator != indexEnd; ++indexIterator)
   {
     bool pointFound = true;
     while (pointFound)
     {
       pointFound = false;
       itk::Index<2> index;
       itk::Index<2> index2;
       for (int xOffset = -1 ; xOffset < 2; ++xOffset)
       {
         for (int yOffset = -1 ; yOffset < 2; ++yOffset)
         {
           index[0] = (*indexIterator)[0] - xOffset;
           index[1] = (*indexIterator)[1] - yOffset;
           index2 = index;
 
           if (listOfPoints->GetPixel(index2) > 0)
             continue;
 
           index[0]--;
           if (listOfPoints->GetPixel(index) == 1)
           {
             pointFound = true;
             seedPoints.push_back(index2);
             listOfPoints->SetPixel(index2,1);
             continue;
           }
           index[0]=index[0] + 2;
           if (listOfPoints->GetPixel(index) == 1)
           {
             pointFound = true;
             seedPoints.push_back(index2);
             listOfPoints->SetPixel(index2,1);
             continue;
           }
           index[0]--;
           index[1]--;
           if (listOfPoints->GetPixel(index) == 1)
           {
             pointFound = true;
             seedPoints.push_back(index2);
             listOfPoints->SetPixel(index2,1);
             continue;
           }
           index[1]=index[1] + 2;
           if (listOfPoints->GetPixel(index) == 1)
           {
             pointFound = true;
             seedPoints.push_back(index2);
             listOfPoints->SetPixel(index2,1);
             continue;
           }
         }
       }
     }
   }
   return seedPoints;
 }
 
 static int FillRegion(const std::vector<itk::Index<2> > &seedPoints, itk::Image< ipMITKSegmentationTYPE, 2 >::Pointer pic, int fillColor, int eraseColor)
 {
   int numberOfPixel = 0;
   int mode = (pic->GetPixel(seedPoints[0]) == fillColor);
   int drawColor = fillColor;
   if (mode)
   {
     drawColor = eraseColor;
   }
 
   std::vector<itk::Index<2> > workPoints;
   workPoints = seedPoints;
   //   workPoints.push_back(seedPoints[0]);
   while (workPoints.size() > 0)
   {
     itk::Index<2> currentIndex = workPoints.back();
     workPoints.pop_back();
     if ((pic->GetPixel(currentIndex) == fillColor) == mode)
       ++numberOfPixel;
     pic->SetPixel(currentIndex, drawColor);
 
     currentIndex[0] -= 1;
     if (pic->GetLargestPossibleRegion().IsInside(currentIndex) &&  (pic->GetPixel(currentIndex) == fillColor) == mode)
       workPoints.push_back(currentIndex);
     currentIndex[0] += 2;
     if (pic->GetLargestPossibleRegion().IsInside(currentIndex) &&  (pic->GetPixel(currentIndex) == fillColor) == mode)
       workPoints.push_back(currentIndex);
     currentIndex[0] -= 1;
     currentIndex[1] -= 1;
     if (pic->GetLargestPossibleRegion().IsInside(currentIndex) &&  (pic->GetPixel(currentIndex) == fillColor) == mode)
       workPoints.push_back(currentIndex);
     currentIndex[1] += 2;
     if (pic->GetLargestPossibleRegion().IsInside(currentIndex) &&  (pic->GetPixel(currentIndex) == fillColor) == mode)
       workPoints.push_back(currentIndex);
   }
 
   return numberOfPixel;
 }
 
 
 
 static void OverwriteImage(itk::Image< ipMITKSegmentationTYPE, 2 >::Pointer source, itk::Image< ipMITKSegmentationTYPE, 2 >::Pointer target)
 {
   typedef itk::Image< ipMITKSegmentationTYPE, 2 > ItkImageType;
   typedef itk::ImageRegionIterator<ItkImageType> ImageIteratorType;
 
   ImageIteratorType sourceIter(source, source->GetLargestPossibleRegion());
   ImageIteratorType targetIter(target, target->GetLargestPossibleRegion());
   while ( ! sourceIter.IsAtEnd())
   {
     targetIter.Set(sourceIter.Get());
     ++sourceIter;
     ++targetIter;
   }
 }
 
 bool  mitk::CorrectorAlgorithm::ModifySegment(const TSegData &segment, itk::Image< ipMITKSegmentationTYPE, 2 >::Pointer pic)
 {
     typedef itk::Image< ipMITKSegmentationTYPE, 2 >::Pointer ItkImagePointerType;
 
     ItkImagePointerType firstSideImage = CloneImage(pic);
     ColorSegment(segment, firstSideImage, m_FillColor, m_EraseColor);
     ItkImagePointerType secondSideImage = CloneImage(firstSideImage);
 
     std::vector<itk::Index<2> > seedPoints = FindSeedPoints(segment,firstSideImage,m_FillColor);
     if (seedPoints.size() < 1)
       return false;
     int firstSidePixel = FillRegion(seedPoints, firstSideImage, m_FillColor, m_EraseColor);
 
     std::vector<itk::Index<2> > secondSeedPoints = FindSeedPoints(segment,firstSideImage,m_FillColor);
     if ( secondSeedPoints.size() < 1)
       return false;
     int secondSidePixel = FillRegion(secondSeedPoints, secondSideImage, m_FillColor, m_EraseColor);
 
     if (firstSidePixel < secondSidePixel)
     {
       OverwriteImage(firstSideImage, pic);
     } else
     {
       OverwriteImage(secondSideImage, pic);
     }
     return true;
 }
\ No newline at end of file
diff --git a/Modules/Segmentation/Interactions/mitkCorrectorTool2D.cpp b/Modules/Segmentation/Interactions/mitkCorrectorTool2D.cpp
index b52e8d09ac..842d949778 100644
--- a/Modules/Segmentation/Interactions/mitkCorrectorTool2D.cpp
+++ b/Modules/Segmentation/Interactions/mitkCorrectorTool2D.cpp
@@ -1,190 +1,191 @@
 /*===================================================================
 
 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 "mitkCorrectorTool2D.h"
 #include "mitkCorrectorAlgorithm.h"
 
 #include "mitkToolManager.h"
 #include "mitkBaseRenderer.h"
 #include "mitkRenderingManager.h"
 #include "mitkImageReadAccessor.h"
 #include "mitkAbstractTransformGeometry.h"
 
 #include "mitkCorrectorTool2D.xpm"
 
 // us
 #include <usModule.h>
 #include <usModuleResource.h>
 #include <usGetModuleContext.h>
 #include <usModuleContext.h>
 
 namespace mitk {
   MITK_TOOL_MACRO(MitkSegmentation_EXPORT, CorrectorTool2D, "Correction tool");
 }
 
 mitk::CorrectorTool2D::CorrectorTool2D(int paintingPixelValue)
 :FeedbackContourTool("PressMoveRelease"),
  m_PaintingPixelValue(paintingPixelValue)
 {
   GetFeedbackContour()->SetClosed( false ); // don't close the contour to a polygon
 }
 
 mitk::CorrectorTool2D::~CorrectorTool2D()
 {
 }
 
 void mitk::CorrectorTool2D::ConnectActionsAndFunctions()
 {
   CONNECT_FUNCTION( "PrimaryButtonPressed", OnMousePressed);
   CONNECT_FUNCTION( "Move", OnMouseMoved);
   CONNECT_FUNCTION( "Release", OnMouseReleased);
 }
 
 const char** mitk::CorrectorTool2D::GetXPM() const
 {
   return mitkCorrectorTool2D_xpm;
 }
 
 us::ModuleResource mitk::CorrectorTool2D::GetIconResource() const
 {
   us::Module* module = us::GetModuleContext()->GetModule();
   us::ModuleResource resource = module->GetResource("Correction_48x48.png");
   return resource;
 }
 
 us::ModuleResource mitk::CorrectorTool2D::GetCursorIconResource() const
 {
   us::Module* module = us::GetModuleContext()->GetModule();
   us::ModuleResource resource = module->GetResource("Correction_Cursor_32x32.png");
   return resource;
 }
 
 const char* mitk::CorrectorTool2D::GetName() const
 {
   return "Correction";
 }
 
 void mitk::CorrectorTool2D::Activated()
 {
   Superclass::Activated();
 }
 
 void mitk::CorrectorTool2D::Deactivated()
 {
   Superclass::Deactivated();
 }
 
 bool mitk::CorrectorTool2D::OnMousePressed ( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   if (!positionEvent) return false;
 
   m_LastEventSender = positionEvent->GetSender();
   m_LastEventSlice = m_LastEventSender->GetSlice();
 
   int timestep = positionEvent->GetSender()->GetTimeStep();
   ContourModel* contour = FeedbackContourTool::GetFeedbackContour();
   contour->Initialize();
   contour->Expand(timestep + 1);
   contour->SetClosed(false, timestep);
   mitk::Point3D point = positionEvent->GetPositionInWorld();
   contour->AddVertex( point, timestep );
 
   FeedbackContourTool::SetFeedbackContourVisible(true);
 
   return true;
 }
 
 bool mitk::CorrectorTool2D::OnMouseMoved( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   if (!positionEvent) return false;
 
   int timestep = positionEvent->GetSender()->GetTimeStep();
   ContourModel* contour = FeedbackContourTool::GetFeedbackContour();
   mitk::Point3D point = positionEvent->GetPositionInWorld();
   contour->AddVertex( point, timestep );
 
   assert( positionEvent->GetSender()->GetRenderWindow() );
   mitk::RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
 
   return true;
 }
 
 bool mitk::CorrectorTool2D::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 );
   //const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
   if (!positionEvent) return false;
 
   assert( positionEvent->GetSender()->GetRenderWindow() );
   mitk::RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
 
   DataNode* workingNode( m_ToolManager->GetWorkingData(0) );
   if (!workingNode) return false;
 
   Image* image = dynamic_cast<Image*>(workingNode->GetData());
   const PlaneGeometry* planeGeometry( dynamic_cast<const PlaneGeometry*> (positionEvent->GetSender()->GetCurrentWorldPlaneGeometry() ) );
   if ( !image || !planeGeometry ) return false;
 
   const AbstractTransformGeometry* abstractTransformGeometry( dynamic_cast<const AbstractTransformGeometry*> (positionEvent->GetSender()->GetCurrentWorldPlaneGeometry() ) );
   if ( !image || abstractTransformGeometry ) return false;
 
   // 2. Slice is known, now we try to get it as a 2D image and project the contour into index coordinates of this slice
   m_WorkingSlice = FeedbackContourTool::GetAffectedImageSliceAs2DImage( positionEvent, image );
 
   if ( m_WorkingSlice.IsNull() )
   {
       MITK_ERROR << "Unable to extract slice." << std::endl;
       return false;
   }
 
   int timestep = positionEvent->GetSender()->GetTimeStep();
   mitk::ContourModel::Pointer singleTimestepContour = mitk::ContourModel::New();
 
   mitk::ContourModel::VertexIterator it = FeedbackContourTool::GetFeedbackContour()->Begin(timestep);
   mitk::ContourModel::VertexIterator end = FeedbackContourTool::GetFeedbackContour()->End(timestep);
 
   while(it!=end)
   {
     singleTimestepContour->AddVertex((*it)->Coordinates);
     it++;
   }
 
   CorrectorAlgorithm::Pointer algorithm = CorrectorAlgorithm::New();
   algorithm->SetInput( m_WorkingSlice );
   algorithm->SetContour( singleTimestepContour );
   try
   {
       algorithm->UpdateLargestPossibleRegion();
   }
   catch ( std::exception& e )
   {
       MITK_ERROR << "Caught exception '" << e.what() << "'" << std::endl;
   }
 
   mitk::Image::Pointer resultSlice = mitk::Image::New();
   resultSlice->Initialize(algorithm->GetOutput());
+
   mitk::ImageReadAccessor imAccess(algorithm->GetOutput());
   resultSlice->SetVolume(imAccess.GetData());
 
   this->WriteBackSegmentationResult(positionEvent, resultSlice);
 
   return true;
 }
\ No newline at end of file
diff --git a/Modules/Segmentation/Interactions/mitkPaintbrushTool.cpp b/Modules/Segmentation/Interactions/mitkPaintbrushTool.cpp
index e8c21346b5..87aedb6e22 100644
--- a/Modules/Segmentation/Interactions/mitkPaintbrushTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkPaintbrushTool.cpp
@@ -1,519 +1,530 @@
 /*===================================================================
 
 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 "mitkToolManager.h"
 #include "mitkOverwriteSliceImageFilter.h"
 #include "mitkBaseRenderer.h"
 #include "mitkImageDataItem.h"
 #include "ipSegmentation.h"
 #include "mitkAbstractTransformGeometry.h"
 
 #include "mitkLevelWindowProperty.h"
+#include "mitkLabelSetImage.h"
+#include "mitkContourModelUtils.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 = NULL;
 
   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);
   Superclass::Deactivated();
   m_WorkingSlice = NULL;
   m_CurrentPlane = NULL;
   m_ToolManager->WorkingDataChanged -= mitk::MessageDelegate<mitk::PaintbrushTool>( this, &mitk::PaintbrushTool::OnToolManagerWorkingDataModified );
 }
 
 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.
   */
 bool mitk::PaintbrushTool::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();
 
   m_MasterContour->SetClosed(true);
 
   return this->MouseMoved(interactionEvent, true);
 }
 
 bool mitk::PaintbrushTool::OnMouseMoved( StateMachineAction*, InteractionEvent* interactionEvent )
 {
  return MouseMoved(interactionEvent, false);
 }
 
 bool mitk::PaintbrushTool::OnPrimaryButtonPressedMoved( StateMachineAction*, InteractionEvent* interactionEvent )
 {
  return MouseMoved(interactionEvent, true);
 }
 
 /**
   Insert the point to the feedback contour,finish to build the contour and at the same time the painting function
   */
 bool mitk::PaintbrushTool::MouseMoved(mitk::InteractionEvent* interactionEvent, bool leftMouseButtonPressed)
 {
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   //const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
 
   CheckIfCurrentSliceHasChanged( positionEvent );
 
   if ( m_LastContourSize != m_Size )
   {
     UpdateContour( positionEvent );
     m_LastContourSize = m_Size;
   }
 
 //     stateEvent->GetId() == 530
 //     || stateEvent->GetId() == 534
 //     || stateEvent->GetId() == 1
 //     || stateEvent->GetId() == 5
 //     );
 
   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 false;
   }
 
   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)
   {
-    FeedbackContourTool::FillContourInSlice( contour, timestep, m_WorkingSlice, m_PaintingPixelValue );
+    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)
+    {
+      activeColor = labelImage->GetActiveLabel()->GetValue();
+    }
+
+    mitk::ContourModelUtils::FillContourInSlice(contour, timestep, m_WorkingSlice, image, m_PaintingPixelValue*activeColor);
     m_WorkingNode->SetData(m_WorkingSlice);
     m_WorkingNode->Modified();
   }
 
   // visualize contour
   ContourModel::Pointer displayContour = ContourModel::New();
   displayContour->Initialize();
 
   //for (unsigned int index = 0; index < contour->GetNumberOfPoints(); ++index)
   //{
   //  Point3D point = contour->GetPoints()->ElementAt(index);
   //  if ( m_Size % 2 == 0 ) // even
   //  {
   //    point[0] += 0.5;
   //    point[1] += 0.5;
   //  }
   //  displayContour->AddVertex( point );
   //}
 
   displayContour = FeedbackContourTool::BackProjectContourFrom2DSlice( m_WorkingSlice->GetGeometry(), /*displayContour*/contour );
   SetFeedbackContour( *displayContour );
 
   assert( positionEvent->GetSender()->GetRenderWindow() );
 
   RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
 
   return true;
 }
 
 
 bool mitk::PaintbrushTool::OnMouseReleased( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   //When mouse is released write segmentationresult back into image
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   //const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
   if (!positionEvent) return false;
 
   this->WriteBackSegmentationResult(positionEvent, m_WorkingSlice->Clone());
 
   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::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();
     return true;
 }
 
 void mitk::PaintbrushTool::CheckIfCurrentSliceHasChanged(const InteractionPositionEvent *event)
 {
     const PlaneGeometry* planeGeometry( dynamic_cast<const 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 = NULL;
             m_WorkingSlice = NULL;
             m_WorkingNode = NULL;
             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 = 0;
 }