diff --git a/Modules/Segmentation/Interactions/mitkFastMarchingTool.cpp b/Modules/Segmentation/Interactions/mitkFastMarchingTool.cpp
index 2dc45ea3c4..74b82b4248 100644
--- a/Modules/Segmentation/Interactions/mitkFastMarchingTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkFastMarchingTool.cpp
@@ -1,478 +1,481 @@
 /*===================================================================
 
 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 "mitkFastMarchingTool.h"
 #include "mitkToolManager.h"
 
 #include "mitkBaseRenderer.h"
 #include "mitkRenderingManager.h"
 #include "mitkInteractionConst.h"
 
 #include "itkOrImageFilter.h"
 #include "mitkImageTimeSelector.h"
 
 // us
 #include <usModule.h>
 #include <usModuleResource.h>
 #include <usGetModuleContext.h>
 #include <usModuleContext.h>
 
 namespace mitk {
   MITK_TOOL_MACRO(Segmentation_EXPORT, FastMarchingTool, "FastMarching2D tool");
 }
 
 
 mitk::FastMarchingTool::FastMarchingTool()
 :FeedbackContourTool("PressMoveReleaseAndPointSetting"),
 m_NeedUpdate(true),
 m_CurrentTimeStep(0),
 m_LowerThreshold(0),
 m_UpperThreshold(200),
 m_StoppingValue(100),
 m_Sigma(1.0),
 m_Alpha(-0.5),
 m_Beta(3.0),
 m_PositionEvent(0)
 {
   CONNECT_ACTION( AcADDPOINTRMB, OnAddPoint );
   CONNECT_ACTION( AcADDPOINT, OnAddPoint );
   CONNECT_ACTION( AcREMOVEPOINT, OnDelete );
 }
 
 mitk::FastMarchingTool::~FastMarchingTool()
 {
   if (this->m_SmoothFilter.IsNotNull())
       this->m_SmoothFilter->RemoveAllObservers();
 
   if (this->m_SigmoidFilter.IsNotNull())
       this->m_SigmoidFilter->RemoveAllObservers();
 
   if (this->m_GradientMagnitudeFilter.IsNotNull())
       this->m_GradientMagnitudeFilter->RemoveAllObservers();
 
   if (this->m_FastMarchingFilter.IsNotNull())
       this->m_FastMarchingFilter->RemoveAllObservers();
 }
 
 
 float mitk::FastMarchingTool::CanHandleEvent( StateEvent const *stateEvent) const
 {
   float returnValue = Superclass::CanHandleEvent(stateEvent);
 
   //we can handle delete
   if(stateEvent->GetId() == 12 )
   {
     returnValue = 1.0;
   }
 
   return returnValue;
 }
 
 
 const char** mitk::FastMarchingTool::GetXPM() const
 {
   return NULL;//mitkFastMarchingTool_xpm;
 }
 
 us::ModuleResource mitk::FastMarchingTool::GetIconResource() const
 {
   us::Module* module = us::GetModuleContext()->GetModule();
   us::ModuleResource resource = module->GetResource("FastMarching_48x48.png");
   return resource;
 }
 
 us::ModuleResource mitk::FastMarchingTool::GetCursorIconResource() const
 {
   us::Module* module = us::GetModuleContext()->GetModule();
   us::ModuleResource resource = module->GetResource("FastMarching_Cursor_32x32.png");
   return resource;
 }
 
 const char* mitk::FastMarchingTool::GetName() const
 {
   return "FastMarching2D";
 }
 
 void mitk::FastMarchingTool::BuildITKPipeline()
 {
   m_ReferenceImageSliceAsITK = InternalImageType::New();
 
   m_ReferenceImageSlice = GetAffectedReferenceSlice( m_PositionEvent );
   CastToItkImage(m_ReferenceImageSlice, m_ReferenceImageSliceAsITK);
 
   m_ProgressCommand = mitk::ToolCommand::New();
 
   m_SmoothFilter = SmoothingFilterType::New();
   m_SmoothFilter->SetInput( m_ReferenceImageSliceAsITK );
   m_SmoothFilter->SetTimeStep( 0.05 );
   m_SmoothFilter->SetNumberOfIterations( 2 );
   m_SmoothFilter->SetConductanceParameter( 9.0 );
 
   m_GradientMagnitudeFilter = GradientFilterType::New();
   m_GradientMagnitudeFilter->SetSigma( m_Sigma );
 
   m_SigmoidFilter = SigmoidFilterType::New();
   m_SigmoidFilter->SetAlpha( m_Alpha );
   m_SigmoidFilter->SetBeta( m_Beta );
   m_SigmoidFilter->SetOutputMinimum( 0.0 );
   m_SigmoidFilter->SetOutputMaximum( 1.0 );
 
   m_FastMarchingFilter = FastMarchingFilterType::New();
   m_FastMarchingFilter->SetStoppingValue( m_StoppingValue );
 
   m_ThresholdFilter = ThresholdingFilterType::New();
   m_ThresholdFilter->SetLowerThreshold( m_LowerThreshold );
   m_ThresholdFilter->SetUpperThreshold( m_UpperThreshold );
   m_ThresholdFilter->SetOutsideValue( 0 );
   m_ThresholdFilter->SetInsideValue( 1.0 );
 
   m_SeedContainer = NodeContainer::New();
   m_SeedContainer->Initialize();
   m_FastMarchingFilter->SetTrialPoints( m_SeedContainer );
 
   if (this->m_SmoothFilter.IsNotNull())
       this->m_SmoothFilter->RemoveAllObservers();
 
   if (this->m_SigmoidFilter.IsNotNull())
       this->m_SigmoidFilter->RemoveAllObservers();
 
   if (this->m_GradientMagnitudeFilter.IsNotNull())
       this->m_GradientMagnitudeFilter->RemoveAllObservers();
 
   if (this->m_FastMarchingFilter.IsNotNull())
       this->m_FastMarchingFilter->RemoveAllObservers();
 
   m_SmoothFilter->AddObserver( itk::ProgressEvent(), m_ProgressCommand);
   m_GradientMagnitudeFilter->AddObserver( itk::ProgressEvent(), m_ProgressCommand);
   m_SigmoidFilter->AddObserver( itk::ProgressEvent(), m_ProgressCommand);
   m_FastMarchingFilter->AddObserver( itk::ProgressEvent(), m_ProgressCommand);
 
   m_SmoothFilter->SetInput( m_ReferenceImageSliceAsITK );
   m_GradientMagnitudeFilter->SetInput( m_SmoothFilter->GetOutput() );
   m_SigmoidFilter->SetInput( m_GradientMagnitudeFilter->GetOutput() );
   m_FastMarchingFilter->SetInput( m_SigmoidFilter->GetOutput() );
   m_ThresholdFilter->SetInput( m_FastMarchingFilter->GetOutput() );
   m_ReferenceImageSliceAsITK = InternalImageType::New();
 }
 
 void mitk::FastMarchingTool::SetUpperThreshold(double value)
 {
  if (m_UpperThreshold != value)
  {
     m_UpperThreshold = value / 10.0;
     m_ThresholdFilter->SetUpperThreshold( m_UpperThreshold );
     m_NeedUpdate = true;
  }
 }
 
 void mitk::FastMarchingTool::SetLowerThreshold(double value)
 {
   if (m_LowerThreshold != value)
   {
     m_LowerThreshold = value / 10.0;
     m_ThresholdFilter->SetLowerThreshold( m_LowerThreshold );
     m_NeedUpdate = true;
   }
 }
 
 void mitk::FastMarchingTool::SetBeta(double value)
 {
   if (m_Beta != value)
   {
     m_Beta = value;
     m_SigmoidFilter->SetBeta( m_Beta );
     m_NeedUpdate = true;
   }
 }
 
 void mitk::FastMarchingTool::SetSigma(double value)
 {
   if (m_Sigma != value)
   {
     m_Sigma = value;
     m_GradientMagnitudeFilter->SetSigma( m_Sigma );
     m_NeedUpdate = true;
   }
 }
 
 void mitk::FastMarchingTool::SetAlpha(double value)
 {
   if (m_Alpha != value)
   {
       m_Alpha = value;
       m_SigmoidFilter->SetAlpha( m_Alpha );
       m_NeedUpdate = true;
   }
 }
 
 void mitk::FastMarchingTool::SetStoppingValue(double value)
 {
   if (m_StoppingValue != value)
   {
       m_StoppingValue = value;
       m_FastMarchingFilter->SetStoppingValue( m_StoppingValue );
       m_NeedUpdate = true;
   }
 }
 
 void mitk::FastMarchingTool::Activated()
 {
   Superclass::Activated();
 
   m_ResultImageNode = mitk::DataNode::New();
   m_ResultImageNode->SetName("FastMarching_Preview");
   m_ResultImageNode->SetBoolProperty("helper object", true);
   m_ResultImageNode->SetColor(0.0, 1.0, 0.0);
   m_ResultImageNode->SetVisibility(true);
   m_ToolManager->GetDataStorage()->Add( this->m_ResultImageNode, m_ToolManager->GetReferenceData(0));
 
   m_SeedsAsPointSet = mitk::PointSet::New();
   m_SeedsAsPointSetNode = mitk::DataNode::New();
   m_SeedsAsPointSetNode->SetData(m_SeedsAsPointSet);
   m_SeedsAsPointSetNode->SetName("Seeds_Preview");
   m_SeedsAsPointSetNode->SetBoolProperty("helper object", true);
   m_SeedsAsPointSetNode->SetColor(0.0, 1.0, 0.0);
   m_SeedsAsPointSetNode->SetVisibility(true);
   m_ToolManager->GetDataStorage()->Add( this->m_SeedsAsPointSetNode, m_ToolManager->GetReferenceData(0));
 
   this->Initialize();
 }
 
 void mitk::FastMarchingTool::Deactivated()
 {
   Superclass::Deactivated();
   m_ToolManager->GetDataStorage()->Remove( this->m_ResultImageNode );
   m_ToolManager->GetDataStorage()->Remove( this->m_SeedsAsPointSetNode );
   this->ClearSeeds();
   m_ResultImageNode = NULL;
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void mitk::FastMarchingTool::Initialize()
 {
   m_ReferenceImage = dynamic_cast<mitk::Image*>(m_ToolManager->GetReferenceData(0)->GetData());
   if(m_ReferenceImage->GetTimeSlicedGeometry()->GetTimeSteps() > 1)
   {
     mitk::ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
     timeSelector->SetInput( m_ReferenceImage );
     timeSelector->SetTimeNr( m_CurrentTimeStep );
     timeSelector->UpdateLargestPossibleRegion();
     m_ReferenceImage = timeSelector->GetOutput();
   }
   m_NeedUpdate = true;
 }
 
 void mitk::FastMarchingTool::ConfirmSegmentation()
 {
   // combine preview image with current working segmentation
   if (dynamic_cast<mitk::Image*>(m_ResultImageNode->GetData()))
   {
     //logical or combination of preview and segmentation slice
     OutputImageType::Pointer workingImageSliceInITK = OutputImageType::New();
 
     mitk::Image::Pointer workingImageSlice;
     mitk::Image::Pointer workingImage = dynamic_cast<mitk::Image*>(this->m_ToolManager->GetWorkingData(0)->GetData());
     if(workingImage->GetTimeSlicedGeometry()->GetTimeSteps() > 1)
     {
       mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
       timeSelector->SetInput( workingImage );
       timeSelector->SetTimeNr( m_CurrentTimeStep );
       timeSelector->UpdateLargestPossibleRegion();
       // todo: make GetAffectedWorkingSlice dependant of current time step
       workingImageSlice = GetAffectedWorkingSlice( m_PositionEvent );
       CastToItkImage( workingImageSlice, workingImageSliceInITK );
     }
     else
     {
       workingImageSlice = GetAffectedWorkingSlice( m_PositionEvent );
       CastToItkImage( workingImageSlice, workingImageSliceInITK );
     }
 
     typedef itk::OrImageFilter<OutputImageType, OutputImageType> OrImageFilterType;
     OrImageFilterType::Pointer orFilter = OrImageFilterType::New();
 
     orFilter->SetInput(0, m_ThresholdFilter->GetOutput());
     orFilter->SetInput(1, workingImageSliceInITK);
     orFilter->Update();
 
     mitk::Image::Pointer segmentationResult = mitk::Image::New();
 
     mitk::CastToMitkImage(orFilter->GetOutput(), segmentationResult);
     segmentationResult->GetGeometry()->SetOrigin(workingImageSlice->GetGeometry()->GetOrigin());
     segmentationResult->GetGeometry()->SetIndexToWorldTransform(workingImageSlice->GetGeometry()->GetIndexToWorldTransform());
 
     //write to segmentation volume and hide preview image
     // again, current time step is not considered
     this->WriteBackSegmentationResult(m_PositionEvent, segmentationResult );
     this->m_ResultImageNode->SetVisibility(false);
 
     this->ClearSeeds();
   }
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 
 bool mitk::FastMarchingTool::OnAddPoint(Action* action, const StateEvent* stateEvent)
 {
   // Add a new seed point for FastMarching algorithm
   const PositionEvent* p = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
   if (!p) return false;
 
   if (m_PositionEvent != NULL)
       delete m_PositionEvent;
   m_PositionEvent = new PositionEvent(p->GetSender(), p->GetType(), p->GetButton(), p->GetButtonState(), p->GetKey(), p->GetDisplayPosition(), p->GetWorldPosition() );
 
   //if click was on another renderwindow or slice then reset pipeline and preview
   if( (m_LastEventSender != m_PositionEvent->GetSender()) || (m_LastEventSlice != m_PositionEvent->GetSender()->GetSlice()) )
   {
       this->BuildITKPipeline();
       this->ClearSeeds();
   }
 
   m_LastEventSender = m_PositionEvent->GetSender();
   m_LastEventSlice = m_LastEventSender->GetSlice();
 
   mitk::Point3D clickInIndex;
 
   m_ReferenceImageSlice->GetGeometry()->WorldToIndex(m_PositionEvent->GetWorldPosition(), clickInIndex);
   itk::Index<2> seedPosition;
   seedPosition[0] = clickInIndex[0];
   seedPosition[1] = clickInIndex[1];
 
   NodeType node;
   const double seedValue = 0.0;
   node.SetValue( seedValue );
   node.SetIndex( seedPosition );
   this->m_SeedContainer->InsertElement(this->m_SeedContainer->Size(), node);
   m_FastMarchingFilter->Modified();
 
   m_SeedsAsPointSet->InsertPoint(m_SeedsAsPointSet->GetSize(), m_PositionEvent->GetWorldPosition());
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   m_NeedUpdate = true;
 
   m_ReadyMessage.Send();
 
   this->Update();
 
   return true;
 }
 
 
 bool mitk::FastMarchingTool::OnDelete(Action* action, const StateEvent* stateEvent)
 {
   // delete last seed point
   if(!(this->m_SeedContainer->empty()))
   {
     //delete last element of seeds container
     this->m_SeedContainer->pop_back();
     m_FastMarchingFilter->Modified();
 
     //delete last point in pointset - somehow ugly
     m_SeedsAsPointSet->GetPointSet()->GetPoints()->DeleteIndex(m_SeedsAsPointSet->GetSize() - 1);
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
     m_NeedUpdate = true;
 
     this->Update();
   }
   return true;
 }
 
 
 void mitk::FastMarchingTool::Update()
 {
+  const unsigned int progress_steps = 20;
+
   // update FastMarching pipeline and show result
   if (m_NeedUpdate)
   {
-    m_ProgressCommand->AddStepsToDo(20);
+    m_ProgressCommand->AddStepsToDo(progress_steps);
     CurrentlyBusy.Send(true);
     try
     {
       m_ThresholdFilter->Update();
     }
     catch( itk::ExceptionObject & excep )
     {
      MITK_ERROR << "Exception caught: " << excep.GetDescription();
 
-     m_ProgressCommand->SetRemainingProgress(100);
+     // progress by max step count, will force
+     m_ProgressCommand->SetRemainingProgress(progress_steps);
      CurrentlyBusy.Send(false);
 
      std::string msg = excep.GetDescription();
      ErrorMessage.Send(msg);
 
      return;
     }
-    m_ProgressCommand->SetRemainingProgress(100);
+    m_ProgressCommand->SetRemainingProgress(progress_steps);
     CurrentlyBusy.Send(false);
 
     //make output visible
     mitk::Image::Pointer result = mitk::Image::New();
     CastToMitkImage( m_ThresholdFilter->GetOutput(), result);
     result->GetGeometry()->SetOrigin(m_ReferenceImageSlice->GetGeometry()->GetOrigin() );
     result->GetGeometry()->SetIndexToWorldTransform(m_ReferenceImageSlice->GetGeometry()->GetIndexToWorldTransform() );
     m_ResultImageNode->SetData(result);
     m_ResultImageNode->SetVisibility(true);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 
 void mitk::FastMarchingTool::ClearSeeds()
 {
   // clear seeds for FastMarching as well as the PointSet for visualization
   if(this->m_SeedContainer.IsNotNull())
     this->m_SeedContainer->Initialize();
 
   if(this->m_SeedsAsPointSet.IsNotNull())
   {
     this->m_SeedsAsPointSet = mitk::PointSet::New();
     this->m_SeedsAsPointSetNode->SetData(this->m_SeedsAsPointSet);
     m_SeedsAsPointSetNode->SetName("Seeds_Preview");
     m_SeedsAsPointSetNode->SetBoolProperty("helper object", true);
     m_SeedsAsPointSetNode->SetColor(0.0, 1.0, 0.0);
     m_SeedsAsPointSetNode->SetVisibility(true);
   }
 
   if(this->m_FastMarchingFilter.IsNotNull())
     m_FastMarchingFilter->Modified();
 
   this->m_NeedUpdate = true;
 }
 
 
 void mitk::FastMarchingTool::Reset()
 {
   //clear all seeds and preview empty result
   this->ClearSeeds();
 
   m_ResultImageNode->SetVisibility(false);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void mitk::FastMarchingTool::SetCurrentTimeStep(int t)
 {
   if( m_CurrentTimeStep != t )
   {
     m_CurrentTimeStep = t;
 
     this->Initialize();
   }
 }
diff --git a/Modules/Segmentation/Interactions/mitkFastMarchingTool3D.cpp b/Modules/Segmentation/Interactions/mitkFastMarchingTool3D.cpp
index 47b82e907f..ef18da63be 100644
--- a/Modules/Segmentation/Interactions/mitkFastMarchingTool3D.cpp
+++ b/Modules/Segmentation/Interactions/mitkFastMarchingTool3D.cpp
@@ -1,412 +1,414 @@
 /*===================================================================
 
 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 "mitkFastMarchingTool3D.h"
 #include "mitkToolManager.h"
 
 
 #include "mitkBaseRenderer.h"
 #include "mitkRenderingManager.h"
 #include "mitkInteractionConst.h"
 #include "mitkGlobalInteraction.h"
 
 #include "itkOrImageFilter.h"
 #include "mitkImageTimeSelector.h"
 #include "mitkImageCast.h"
 
 // us
 #include <usModule.h>
 #include <usModuleResource.h>
 #include <usGetModuleContext.h>
 #include <usModuleContext.h>
 
 namespace mitk {
   MITK_TOOL_MACRO(Segmentation_EXPORT, FastMarchingTool3D, "FastMarching3D tool");
 }
 
 
 mitk::FastMarchingTool3D::FastMarchingTool3D()
 :/*FeedbackContourTool*/AutoSegmentationTool(),
 m_NeedUpdate(true),
 m_CurrentTimeStep(0),
 m_LowerThreshold(0),
 m_UpperThreshold(200),
 m_StoppingValue(100),
 m_Sigma(1.0),
 m_Alpha(-0.5),
 m_Beta(3.0)
 {
 }
 
 mitk::FastMarchingTool3D::~FastMarchingTool3D()
 {
 }
 
 const char** mitk::FastMarchingTool3D::GetXPM() const
 {
   return NULL;//mitkFastMarchingTool3D_xpm;
 }
 
 us::ModuleResource mitk::FastMarchingTool3D::GetIconResource() const
 {
   us::Module* module = us::GetModuleContext()->GetModule();
   us::ModuleResource resource = module->GetResource("FastMarching_48x48.png");
   return resource;
 }
 
 const char* mitk::FastMarchingTool3D::GetName() const
 {
   return "FastMarching3D";
 }
 
 void mitk::FastMarchingTool3D::SetUpperThreshold(double value)
 {
   m_UpperThreshold = value / 10.0;
   m_ThresholdFilter->SetUpperThreshold( m_UpperThreshold );
   m_NeedUpdate = true;
 }
 
 void mitk::FastMarchingTool3D::SetLowerThreshold(double value)
 {
   m_LowerThreshold = value / 10.0;
   m_ThresholdFilter->SetLowerThreshold( m_LowerThreshold );
   m_NeedUpdate = true;
 }
 
 void mitk::FastMarchingTool3D::SetBeta(double value)
 {
   if (m_Beta != value)
   {
       m_Beta = value;
       m_SigmoidFilter->SetBeta( m_Beta );
       m_NeedUpdate = true;
   }
 }
 
 void mitk::FastMarchingTool3D::SetSigma(double value)
 {
   if (m_Sigma != value)
   {
       m_Sigma = value;
       m_GradientMagnitudeFilter->SetSigma( m_Sigma );
       m_NeedUpdate = true;
   }
 }
 
 void mitk::FastMarchingTool3D::SetAlpha(double value)
 {
   if (m_Alpha != value)
   {
       m_Alpha = value;
       m_SigmoidFilter->SetAlpha( m_Alpha );
       m_NeedUpdate = true;
   }
 }
 
 void mitk::FastMarchingTool3D::SetStoppingValue(double value)
 {
   if (m_StoppingValue != value)
   {
       m_StoppingValue = value;
       m_FastMarchingFilter->SetStoppingValue( m_StoppingValue );
       m_NeedUpdate = true;
   }
 }
 
 void mitk::FastMarchingTool3D::Activated()
 {
   Superclass::Activated();
 
   m_ResultImageNode = mitk::DataNode::New();
   m_ResultImageNode->SetName("FastMarching_Preview");
   m_ResultImageNode->SetBoolProperty("helper object", true);
   m_ResultImageNode->SetColor(0.0, 1.0, 0.0);
   m_ResultImageNode->SetVisibility(true);
   m_ToolManager->GetDataStorage()->Add( this->m_ResultImageNode, m_ToolManager->GetReferenceData(0));
 
   m_SeedsAsPointSet = mitk::PointSet::New();
   m_SeedsAsPointSetNode = mitk::DataNode::New();
   m_SeedsAsPointSetNode->SetData(m_SeedsAsPointSet);
   m_SeedsAsPointSetNode->SetName("3D_FastMarching_PointSet");
   m_SeedsAsPointSetNode->SetBoolProperty("helper object", true);
   m_SeedsAsPointSetNode->SetColor(0.0, 1.0, 0.0);
   m_SeedsAsPointSetNode->SetVisibility(true);
   m_SeedPointInteractor = mitk::PointSetInteractor::New("PressMoveReleaseAndPointSetting", m_SeedsAsPointSetNode);
 
   m_ReferenceImageAsITK = InternalImageType::New();
 
   m_ProgressCommand = mitk::ToolCommand::New();
 
   m_ThresholdFilter = ThresholdingFilterType::New();
   m_ThresholdFilter->SetLowerThreshold( m_LowerThreshold );
   m_ThresholdFilter->SetUpperThreshold( m_UpperThreshold );
   m_ThresholdFilter->SetOutsideValue( 0 );
   m_ThresholdFilter->SetInsideValue( 1.0 );
 
   m_SmoothFilter = SmoothingFilterType::New();
   m_SmoothFilter->AddObserver( itk::ProgressEvent(), m_ProgressCommand);
   m_SmoothFilter->SetTimeStep( 0.05 );
   m_SmoothFilter->SetNumberOfIterations( 2 );
   m_SmoothFilter->SetConductanceParameter( 9.0 );
 
   m_GradientMagnitudeFilter = GradientFilterType::New();
   m_GradientMagnitudeFilter->AddObserver( itk::ProgressEvent(), m_ProgressCommand);
   m_GradientMagnitudeFilter->SetSigma( m_Sigma );
 
   m_SigmoidFilter = SigmoidFilterType::New();
   m_SigmoidFilter->AddObserver( itk::ProgressEvent(), m_ProgressCommand);
   m_SigmoidFilter->SetAlpha( m_Alpha );
   m_SigmoidFilter->SetBeta( m_Beta );
   m_SigmoidFilter->SetOutputMinimum( 0.0 );
   m_SigmoidFilter->SetOutputMaximum( 1.0 );
 
   m_FastMarchingFilter = FastMarchingFilterType::New();
   m_FastMarchingFilter->AddObserver( itk::ProgressEvent(), m_ProgressCommand);
   m_FastMarchingFilter->SetStoppingValue( m_StoppingValue );
 
   m_SeedContainer = NodeContainer::New();
   m_SeedContainer->Initialize();
   m_FastMarchingFilter->SetTrialPoints( m_SeedContainer );
 
   //set up pipeline
   m_SmoothFilter->SetInput( m_ReferenceImageAsITK );
   m_GradientMagnitudeFilter->SetInput( m_SmoothFilter->GetOutput() );
   m_SigmoidFilter->SetInput( m_GradientMagnitudeFilter->GetOutput() );
   m_FastMarchingFilter->SetInput( m_SigmoidFilter->GetOutput() );
   m_ThresholdFilter->SetInput( m_FastMarchingFilter->GetOutput() );
 
   m_ToolManager->GetDataStorage()->Add(m_SeedsAsPointSetNode, m_ToolManager->GetWorkingData(0));
   mitk::GlobalInteraction::GetInstance()->AddInteractor(m_SeedPointInteractor);
 
   itk::SimpleMemberCommand<mitk::FastMarchingTool3D>::Pointer pointAddedCommand = itk::SimpleMemberCommand<mitk::FastMarchingTool3D>::New();
   pointAddedCommand->SetCallbackFunction(this, &mitk::FastMarchingTool3D::OnAddPoint);
   m_PointSetAddObserverTag = m_SeedsAsPointSet->AddObserver( mitk::PointSetAddEvent(), pointAddedCommand);
 
   itk::SimpleMemberCommand<mitk::FastMarchingTool3D>::Pointer pointRemovedCommand = itk::SimpleMemberCommand<mitk::FastMarchingTool3D>::New();
   pointRemovedCommand->SetCallbackFunction(this, &mitk::FastMarchingTool3D::OnDelete);
   m_PointSetRemoveObserverTag = m_SeedsAsPointSet->AddObserver( mitk::PointSetRemoveEvent(), pointRemovedCommand);
 
   this->Initialize();
 }
 
 void mitk::FastMarchingTool3D::Deactivated()
 {
   Superclass::Deactivated();
   m_ToolManager->GetDataStorage()->Remove( this->m_ResultImageNode );
   m_ToolManager->GetDataStorage()->Remove( this->m_SeedsAsPointSetNode );
   this->ClearSeeds();
   this->m_SmoothFilter->RemoveAllObservers();
   this->m_SigmoidFilter->RemoveAllObservers();
   this->m_GradientMagnitudeFilter->RemoveAllObservers();
   this->m_FastMarchingFilter->RemoveAllObservers();
   m_ResultImageNode = NULL;
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   unsigned int numberOfPoints = m_SeedsAsPointSet->GetSize();
   for (unsigned int i = 0; i < numberOfPoints; ++i)
   {
     mitk::Point3D point = m_SeedsAsPointSet->GetPoint(i);
     mitk::PointOperation* doOp = new mitk::PointOperation(mitk::OpREMOVE, point, 0);
     m_SeedsAsPointSet->ExecuteOperation(doOp);
   }
   mitk::GlobalInteraction::GetInstance()->RemoveInteractor(m_SeedPointInteractor);
   m_ToolManager->GetDataStorage()->Remove(m_SeedsAsPointSetNode);
   m_SeedsAsPointSet->RemoveObserver(m_PointSetAddObserverTag);
   m_SeedsAsPointSet->RemoveObserver(m_PointSetRemoveObserverTag);
 }
 
 void mitk::FastMarchingTool3D::Initialize()
 {
   m_ReferenceImage = dynamic_cast<mitk::Image*>(m_ToolManager->GetReferenceData(0)->GetData());
   if(m_ReferenceImage->GetTimeSlicedGeometry()->GetTimeSteps() > 1)
   {
     mitk::ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
     timeSelector->SetInput( m_ReferenceImage );
     timeSelector->SetTimeNr( m_CurrentTimeStep );
     timeSelector->UpdateLargestPossibleRegion();
     m_ReferenceImage = timeSelector->GetOutput();
   }
   CastToItkImage(m_ReferenceImage, m_ReferenceImageAsITK);
   m_SmoothFilter->SetInput( m_ReferenceImageAsITK );
   m_NeedUpdate = true;
 }
 
 void mitk::FastMarchingTool3D::ConfirmSegmentation()
 {
   // combine preview image with current working segmentation
   if (dynamic_cast<mitk::Image*>(m_ResultImageNode->GetData()))
   {
     //logical or combination of preview and segmentation slice
     OutputImageType::Pointer segmentationImageInITK = OutputImageType::New();
 
     mitk::Image::Pointer workingImage = dynamic_cast<mitk::Image*>(GetTargetSegmentationNode()->GetData());
     if(workingImage->GetTimeSlicedGeometry()->GetTimeSteps() > 1)
     {
       mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
       timeSelector->SetInput( workingImage );
       timeSelector->SetTimeNr( m_CurrentTimeStep );
       timeSelector->UpdateLargestPossibleRegion();
       CastToItkImage( timeSelector->GetOutput(), segmentationImageInITK );
     }
     else
     {
       CastToItkImage( workingImage, segmentationImageInITK );
     }
 
     typedef itk::OrImageFilter<OutputImageType, OutputImageType> OrImageFilterType;
     OrImageFilterType::Pointer orFilter = OrImageFilterType::New();
 
     orFilter->SetInput(0, m_ThresholdFilter->GetOutput());
     orFilter->SetInput(1, segmentationImageInITK);
     orFilter->Update();
 
     //set image volume in current time step from itk image
     workingImage->SetVolume( (void*)(m_ThresholdFilter->GetOutput()->GetPixelContainer()->GetBufferPointer()), m_CurrentTimeStep);
     this->m_ResultImageNode->SetVisibility(false);
     this->ClearSeeds();
     workingImage->Modified();
   }
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 
 void mitk::FastMarchingTool3D::OnAddPoint()
 {
   // Add a new seed point for FastMarching algorithm
   mitk::Point3D clickInIndex;
 
   m_ReferenceImage->GetGeometry()->WorldToIndex(m_SeedsAsPointSet->GetPoint(m_SeedsAsPointSet->GetSize()-1),
                                                 clickInIndex);
   itk::Index<3> seedPosition;
   seedPosition[0] = clickInIndex[0];
   seedPosition[1] = clickInIndex[1];
   seedPosition[2] = clickInIndex[2];
 
   NodeType node;
   const double seedValue = 0.0;
   node.SetValue( seedValue );
   node.SetIndex( seedPosition );
   this->m_SeedContainer->InsertElement(this->m_SeedContainer->Size(), node);
   m_FastMarchingFilter->Modified();
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   m_NeedUpdate = true;
 
   m_ReadyMessage.Send();
 
   this->Update();
 }
 
 
 void mitk::FastMarchingTool3D::OnDelete()
 {
   // delete last seed point
   if(!(this->m_SeedContainer->empty()))
   {
     //delete last element of seeds container
     this->m_SeedContainer->pop_back();
     m_FastMarchingFilter->Modified();
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
     m_NeedUpdate = true;
 
     this->Update();
   }
 }
 
 
 void mitk::FastMarchingTool3D::Update()
 {
+  const unsigned int progress_steps = 200;
+
   if (m_NeedUpdate)
   {
-    m_ProgressCommand->AddStepsToDo(200);
+    m_ProgressCommand->AddStepsToDo(progress_steps);
     CurrentlyBusy.Send(true);
     try
     {
       m_ThresholdFilter->Update();
     }
     catch( itk::ExceptionObject & excep )
     {
      MITK_ERROR << "Exception caught: " << excep.GetDescription();
 
-     m_ProgressCommand->SetRemainingProgress(100);
+     m_ProgressCommand->SetRemainingProgress(progress_steps);
      CurrentlyBusy.Send(false);
 
      std::string msg = excep.GetDescription();
      ErrorMessage.Send(msg);
 
      return;
     }
-    m_ProgressCommand->SetRemainingProgress(100);
+    m_ProgressCommand->SetRemainingProgress(progress_steps);
     CurrentlyBusy.Send(false);
 
     //make output visible
     mitk::Image::Pointer result = mitk::Image::New();
     CastToMitkImage( m_ThresholdFilter->GetOutput(), result);
     result->GetGeometry()->SetOrigin(m_ReferenceImage->GetGeometry()->GetOrigin() );
     result->GetGeometry()->SetIndexToWorldTransform(m_ReferenceImage->GetGeometry()->GetIndexToWorldTransform() );
     m_ResultImageNode->SetData(result);
     m_ResultImageNode->SetVisibility(true);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 
 void mitk::FastMarchingTool3D::ClearSeeds()
 {
   // clear seeds for FastMarching as well as the PointSet for visualization
   if(this->m_SeedContainer.IsNotNull())
     this->m_SeedContainer->Initialize();
 
   if(this->m_SeedsAsPointSet.IsNotNull())
   {
     this->m_SeedsAsPointSet = mitk::PointSet::New();
     this->m_SeedsAsPointSetNode->SetData(this->m_SeedsAsPointSet);
     m_SeedsAsPointSetNode->SetName("Seeds_Preview");
     m_SeedsAsPointSetNode->SetBoolProperty("helper object", true);
     m_SeedsAsPointSetNode->SetColor(0.0, 1.0, 0.0);
     m_SeedsAsPointSetNode->SetVisibility(true);
   }
 
   if(this->m_FastMarchingFilter.IsNotNull())
     m_FastMarchingFilter->Modified();
 
   this->m_NeedUpdate = true;
 }
 
 
 void mitk::FastMarchingTool3D::Reset()
 {
   //clear all seeds and preview empty result
   this->ClearSeeds();
 
   m_ResultImageNode->SetVisibility(false);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void mitk::FastMarchingTool3D::SetCurrentTimeStep(int t)
 {
   if( m_CurrentTimeStep != t )
   {
     m_CurrentTimeStep = t;
 
     this->Initialize();
   }
 }
diff --git a/Modules/Segmentation/Interactions/mitkWatershedTool.cpp b/Modules/Segmentation/Interactions/mitkWatershedTool.cpp
index e82b9394a2..904493e33c 100644
--- a/Modules/Segmentation/Interactions/mitkWatershedTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkWatershedTool.cpp
@@ -1,207 +1,210 @@
 /*===================================================================
 
 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 "mitkWatershedTool.h"
 
 #include "mitkBinaryThresholdTool.xpm"
 #include "mitkToolManager.h"
 #include "mitkImageAccessByItk.h"
 #include "mitkImageCast.h"
 #include "mitkITKImageImport.h"
 #include "mitkRenderingManager.h"
 #include "mitkRenderingModeProperty.h"
 #include "mitkLookupTable.h"
 #include "mitkLookupTableProperty.h"
 #include "mitkIOUtil.h"
 #include "mitkLevelWindowManager.h"
 #include "mitkImageStatisticsHolder.h"
 #include "mitkToolCommand.h"
 #include "mitkProgressBar.h"
 
 #include <usModule.h>
 #include <usModuleResource.h>
 #include <usGetModuleContext.h>
 #include <usModuleContext.h>
 
 #include <vtkLookupTable.h>
 
 #include <itkWatershedImageFilter.h>
 #include <itkGradientMagnitudeRecursiveGaussianImageFilter.h>
 #include <itkExceptionObject.h>
 
 namespace mitk {
   MITK_TOOL_MACRO(Segmentation_EXPORT, WatershedTool, "Watershed tool");
 }
 
 
 mitk::WatershedTool::WatershedTool() :
   m_Level(0.),
   m_Threshold(0.)
 {
 }
 
 mitk::WatershedTool::~WatershedTool()
 {
 }
 
 void mitk::WatershedTool::Activated()
 {
   Superclass::Activated();
 }
 
 void mitk::WatershedTool::Deactivated()
 {
   Superclass::Deactivated();
 }
 
 us::ModuleResource mitk::WatershedTool::GetIconResource() const
 {
   us::Module* module = us::GetModuleContext()->GetModule();
   us::ModuleResource resource = module->GetResource("Watershed_48x48.png");
   return resource;
 }
 
 us::ModuleResource mitk::WatershedTool::GetCursorIconResource() const
 {
   us::Module* module = us::GetModuleContext()->GetModule();
   us::ModuleResource resource = module->GetResource("Watershed_Cursor_32x32.png");
   return resource;
 }
 
 const char** mitk::WatershedTool::GetXPM() const
 {
   return NULL;
 }
 
 const char* mitk::WatershedTool::GetName() const
 {
   return "Watershed";
 }
 
 void mitk::WatershedTool::DoIt()
 {
 
   // get image from tool manager
   mitk::DataNode::Pointer referenceData = m_ToolManager->GetReferenceData(0);
   mitk::Image::Pointer input = dynamic_cast<mitk::Image*>(referenceData->GetData());
 
   mitk::Image::Pointer output;
 
   try {
     // create and run itk filter pipeline
     AccessFixedDimensionByItk_1(input.GetPointer(),ITKWatershed,3,output);
 
     // create a new datanode for output
     mitk::DataNode::Pointer dataNode = mitk::DataNode::New();
     dataNode->SetData(output);
 
     // set properties of datanode
     dataNode->SetProperty("binary", mitk::BoolProperty::New(false));
     dataNode->SetProperty("name", mitk::StringProperty::New("Watershed Result"));
     mitk::RenderingModeProperty::Pointer renderingMode = mitk::RenderingModeProperty::New();
     renderingMode->SetValue( mitk::RenderingModeProperty::LOOKUPTABLE_LEVELWINDOW_COLOR );
     dataNode->SetProperty("Image Rendering.Mode", renderingMode);
 
     // since we create a multi label image, define a vtk lookup table
     mitk::LookupTable::Pointer lut = mitk::LookupTable::New();
     mitk::LookupTableProperty::Pointer prop = mitk::LookupTableProperty::New(lut);
     vtkLookupTable *lookupTable = vtkLookupTable::New();
     lookupTable->SetHueRange(1.0, 0.0);
     lookupTable->SetSaturationRange(1.0, 1.0);
     lookupTable->SetValueRange(1.0, 1.0);
     lookupTable->SetTableRange(-1.0, 1.0);
     lookupTable->Build();
     lookupTable->SetTableValue(1,0,0,0);
     lut->SetVtkLookupTable(lookupTable);
     prop->SetLookupTable(lut);
     dataNode->SetProperty("LookupTable",prop);
 
     // make the levelwindow fit to right values
     mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
     mitk::LevelWindow levelwindow;
     levelwindow.SetRangeMinMax(0, output->GetStatistics()->GetScalarValueMax());
     levWinProp->SetLevelWindow( levelwindow );
     dataNode->SetProperty( "levelwindow", levWinProp );
     dataNode->SetProperty( "opacity", mitk::FloatProperty::New(0.5));
 
     // set name of data node
     std::string name = referenceData->GetName() + "_Watershed";
     dataNode->SetName( name );
 
     // look, if there is already a node with this name
     mitk::DataStorage::SetOfObjects::ConstPointer children = m_ToolManager->GetDataStorage()->GetDerivations(referenceData);
     mitk::DataStorage::SetOfObjects::ConstIterator currentNode = children->Begin();
     mitk::DataNode::Pointer removeNode;
     while(currentNode != children->End())
     {
       if(dataNode->GetName().compare(currentNode->Value()->GetName()) == 0)
       {
         removeNode = currentNode->Value();
       }
       currentNode++;
     }
     // remove node with same name
     if(removeNode.IsNotNull())
       m_ToolManager->GetDataStorage()->Remove(removeNode);
 
     // add output to the data storage
     m_ToolManager->GetDataStorage()->Add(dataNode,referenceData);
   }
   catch(itk::ExceptionObject& e)
   {
     MITK_ERROR<<"Watershed Filter Error: " << e.GetDescription();
   }
 
   RenderingManager::GetInstance()->RequestUpdateAll();
 
 }
 
 template <typename TPixel, unsigned int VImageDimension>
 void mitk::WatershedTool::ITKWatershed( itk::Image<TPixel, VImageDimension>* originalImage, mitk::Image::Pointer& segmentation )
 {
   typedef itk::WatershedImageFilter< itk::Image<float, VImageDimension> > WatershedFilter;
   typedef itk::GradientMagnitudeRecursiveGaussianImageFilter< itk::Image<TPixel, VImageDimension >, itk::Image<float, VImageDimension> > MagnitudeFilter;
 
   // at first add a gradient magnitude filter
   typename MagnitudeFilter::Pointer magnitude = MagnitudeFilter::New();
   magnitude->SetInput(originalImage);
   magnitude->SetSigma(1.0);
 
   // use the progress bar
   mitk::ToolCommand::Pointer command = mitk::ToolCommand::New();
   command->AddStepsToDo(10);
 
   // then add the watershed filter to the pipeline
   typename WatershedFilter::Pointer watershed = WatershedFilter::New();
   watershed->SetInput(magnitude->GetOutput());
   watershed->SetThreshold(m_Threshold);
   watershed->SetLevel(m_Level);
   watershed->AddObserver(itk::ProgressEvent(),command);
   watershed->Update();
 
   // then make sure, that the output has the desired pixel type
   typedef itk::CastImageFilter<typename WatershedFilter::OutputImageType, itk::Image<Tool::DefaultSegmentationDataType,3> > CastFilter;
   typename CastFilter::Pointer cast = CastFilter::New();
   cast->SetInput(watershed->GetOutput());
 
   // start the whole pipeline
   cast->Update();
 
+  // reset the progress bar by setting progress
+  command->SetRemainingProgress(10);
+
   // since we obtain a new image from our pipeline, we have to make sure, that our mitk::Image::Pointer
   // is responsible for the memory management of the output image
   segmentation = mitk::GrabItkImageMemory(cast->GetOutput());
 
 }