diff --git a/Modules/QmitkExt/QmitkBinaryThresholdULToolGUI.cpp b/Modules/QmitkExt/QmitkBinaryThresholdULToolGUI.cpp
index f002bdc4fb..0bb1556c7a 100644
--- a/Modules/QmitkExt/QmitkBinaryThresholdULToolGUI.cpp
+++ b/Modules/QmitkExt/QmitkBinaryThresholdULToolGUI.cpp
@@ -1,167 +1,151 @@
 /*===================================================================
 
 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 "QmitkBinaryThresholdULToolGUI.h"
 #include "QmitkNewSegmentationDialog.h"
 
 #include <qlabel.h>
 #include <qslider.h>
 #include <qpushbutton.h>
 #include <qlayout.h>
 
 MITK_TOOL_GUI_MACRO(QmitkExt_EXPORT, QmitkBinaryThresholdULToolGUI, "")
 
 QmitkBinaryThresholdULToolGUI::QmitkBinaryThresholdULToolGUI()
 :QmitkToolGUI(),
 m_RangeSlider(NULL)
 {
   // create the visible widgets
   QBoxLayout* mainLayout = new QVBoxLayout(this);
 
   QLabel* label = new QLabel( "Threshold :", this );
   QFont f = label->font();
   f.setBold(false);
   label->setFont( f );
   mainLayout->addWidget(label);
 
   QBoxLayout* layout = new QHBoxLayout();
 
   m_LowerSpinner = new QSpinBox();
   m_LowerSpinner->setMinimum(-2048);
   m_LowerSpinner->setMaximum(0);
   m_LowerSpinner->setValue(-2048);
   connect(m_LowerSpinner, SIGNAL(editingFinished()), this, SLOT(OnOneSpinnerChanged()) );
 
   m_RangeSlider = new QxtSpanSlider(Qt::Horizontal, this );
   m_RangeSlider->setMaximum(2048);
   m_RangeSlider->setMinimum(-2048);
   m_RangeSlider->setHandleMovementMode(QxtSpanSlider::NoOverlapping);
 
   m_UpperSpinner = new QSpinBox();
   m_UpperSpinner->setMinimum(0);
   m_UpperSpinner->setMaximum(2048);
   m_UpperSpinner->setValue(2048);
 
   connect(m_UpperSpinner, SIGNAL(editingFinished()), this, SLOT(OnOneSpinnerChanged()) );
   connect(m_RangeSlider, SIGNAL(spanChanged(int, int)  ),this, SLOT( OnSpanChanged(int , int ) ));
 
   layout->addWidget(m_LowerSpinner);
   layout->addWidget(m_RangeSlider);
   layout->addWidget(m_UpperSpinner);
 
   mainLayout->addLayout(layout);
 
   QPushButton* okButton = new QPushButton("Ok", this);
   connect( okButton, SIGNAL(clicked()), this, SLOT(OnAcceptThresholdPreview()));
   okButton->setFont( f );
   mainLayout->addWidget( okButton );
 
   connect( this, SIGNAL(NewToolAssociated(mitk::Tool*)), this, SLOT(OnNewToolAssociated(mitk::Tool*)) );
 }
 
 QmitkBinaryThresholdULToolGUI::~QmitkBinaryThresholdULToolGUI()
 {
   // !!!
   if (m_BinaryThresholdULTool.IsNotNull())
   {
     m_BinaryThresholdULTool->IntervalBordersChanged -= mitk::MessageDelegate2<QmitkBinaryThresholdULToolGUI, int, int>( this, &QmitkBinaryThresholdULToolGUI::OnThresholdingIntervalBordersChanged );
     m_BinaryThresholdULTool->ThresholdingValuesChanged -= mitk::MessageDelegate2<QmitkBinaryThresholdULToolGUI, int, int>( this, &QmitkBinaryThresholdULToolGUI::OnThresholdingValuesChanged );
   }
 
 }
 
 void QmitkBinaryThresholdULToolGUI::OnNewToolAssociated(mitk::Tool* tool)
 {
   if (m_BinaryThresholdULTool.IsNotNull())
   {
     m_BinaryThresholdULTool->IntervalBordersChanged -= mitk::MessageDelegate2<QmitkBinaryThresholdULToolGUI, int, int>( this, &QmitkBinaryThresholdULToolGUI::OnThresholdingIntervalBordersChanged );
     m_BinaryThresholdULTool->ThresholdingValuesChanged -= mitk::MessageDelegate2<QmitkBinaryThresholdULToolGUI, int, int>( this, &QmitkBinaryThresholdULToolGUI::OnThresholdingValuesChanged );
   }
 
   m_BinaryThresholdULTool = dynamic_cast<mitk::BinaryThresholdULTool*>( tool );
 
   if (m_BinaryThresholdULTool.IsNotNull())
   {
     m_BinaryThresholdULTool->IntervalBordersChanged += mitk::MessageDelegate2<QmitkBinaryThresholdULToolGUI, int, int>( this, &QmitkBinaryThresholdULToolGUI::OnThresholdingIntervalBordersChanged );
     m_BinaryThresholdULTool->ThresholdingValuesChanged += mitk::MessageDelegate2<QmitkBinaryThresholdULToolGUI, int, int>( this, &QmitkBinaryThresholdULToolGUI::OnThresholdingValuesChanged );
   }
 }
 
 void QmitkBinaryThresholdULToolGUI::OnAcceptThresholdPreview()
 {
   if (m_BinaryThresholdULTool.IsNotNull())
   {
-    QmitkNewSegmentationDialog* dialog = new QmitkNewSegmentationDialog( this ); // needs a QWidget as parent, "this" is not QWidget
-    dialog->setPrompt("What did you just segment?");
-    int dialogReturnValue = dialog->exec();
-
-    std::string organName = dialog->GetSegmentationName().toLocal8Bit().data();
-    mitk::Color color     = dialog->GetColor();
-
-    delete dialog;
-
-    if ( dialogReturnValue != QDialog::Rejected ) // user clicked cancel or pressed Esc or something similar
-    {
-      m_BinaryThresholdULTool->AcceptCurrentThresholdValue( organName, color );
-    }
-    else
-    {
-      m_BinaryThresholdULTool->CancelThresholding();
-    }
+    m_BinaryThresholdULTool->AcceptCurrentThresholdValue();
   }
 }
 
 void QmitkBinaryThresholdULToolGUI::OnThresholdingIntervalBordersChanged(int lower, int upper)
 {
   m_RangeSlider->setMaximum(upper);
   m_RangeSlider->setMinimum(lower);
   m_LowerSpinner->setMaximum(upper);
   m_LowerSpinner->setMinimum(lower);
   m_UpperSpinner->setMaximum(upper);
   m_UpperSpinner->setMinimum(lower);
 }
 
 void QmitkBinaryThresholdULToolGUI::OnThresholdingValuesChanged(int lower, int upper)
 {
   m_RangeSlider->setSpan(lower, upper);
   m_LowerSpinner->setValue(lower);
   m_UpperSpinner->setValue(upper);
 }
 
 void QmitkBinaryThresholdULToolGUI::OnSpanChanged(int lower, int upper)
 {
   if (upper < lower)
   {
     int tmp = upper;
     upper = lower;
     lower = tmp;
   }
 
   if (m_BinaryThresholdULTool.IsNotNull())
   {
     m_BinaryThresholdULTool->SetThresholdValues(lower, upper);
   }
   if (m_LowerSpinner->value() != lower)
     m_LowerSpinner->setValue(lower);
   if (m_UpperSpinner->value() != upper)
     m_UpperSpinner->setValue(upper);
 }
 
 void QmitkBinaryThresholdULToolGUI::OnOneSpinnerChanged()
 {
   m_RangeSlider->setLowerValue(m_LowerSpinner->value());
   m_RangeSlider->setUpperValue(m_UpperSpinner->value());
 }
diff --git a/Modules/Segmentation/Interactions/mitkBinaryThresholdULTool.cpp b/Modules/Segmentation/Interactions/mitkBinaryThresholdULTool.cpp
index 3e12300986..2c0025bd2e 100644
--- a/Modules/Segmentation/Interactions/mitkBinaryThresholdULTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkBinaryThresholdULTool.cpp
@@ -1,319 +1,314 @@
 /*===================================================================
 
 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 "mitkBinaryThresholdULTool.h"
 #include "mitkBinaryThresholdULTool.xpm"
 
 #include "mitkToolManager.h"
 
 #include "mitkLevelWindowProperty.h"
 #include "mitkColorProperty.h"
 #include "mitkProperties.h"
 
 #include "mitkDataStorage.h"
 #include "mitkRenderingManager.h"
 
 #include "mitkImageCast.h"
 #include "mitkImageAccessByItk.h"
 #include "mitkImageTimeSelector.h"
 #include <itkImageRegionIterator.h>
 #include <itkBinaryThresholdImageFilter.h>
 #include "mitkMaskAndCutRoiImageFilter.h"
 #include "mitkPadImageFilter.h"
 
 namespace mitk {
   MITK_TOOL_MACRO(Segmentation_EXPORT, BinaryThresholdULTool, "ThresholdingUL tool");
 }
 
 mitk::BinaryThresholdULTool::BinaryThresholdULTool()
   :m_SensibleMinimumThresholdValue(-100),
   m_SensibleMaximumThresholdValue(+100),
   m_CurrentLowerThresholdValue(1),
   m_CurrentUpperThresholdValue(1)
 {
   this->SupportRoiOn();
 
   m_ThresholdFeedbackNode = DataNode::New();
   m_ThresholdFeedbackNode->SetProperty( "color", ColorProperty::New(1.0, 0.0, 0.0) );
   m_ThresholdFeedbackNode->SetProperty( "name", StringProperty::New("Thresholding feedback") );
   m_ThresholdFeedbackNode->SetProperty( "opacity", FloatProperty::New(0.3) );
   m_ThresholdFeedbackNode->SetProperty("binary", BoolProperty::New(true));
   m_ThresholdFeedbackNode->SetProperty( "helper object", BoolProperty::New(true) );
 }
 
 mitk::BinaryThresholdULTool::~BinaryThresholdULTool()
 {
 }
 
 const char** mitk::BinaryThresholdULTool::GetXPM() const
 {
   return mitkBinaryThresholdULTool_xpm;
 }
 
 const char* mitk::BinaryThresholdULTool::GetName() const
 {
   return "Two Thresholds";
 }
 
 void mitk::BinaryThresholdULTool::Activated()
 {
   m_ToolManager->RoiDataChanged += mitk::MessageDelegate<mitk::BinaryThresholdULTool>(this, &mitk::BinaryThresholdULTool::OnRoiDataChanged);
 
   m_OriginalImageNode = m_ToolManager->GetReferenceData(0);
   m_NodeForThresholding = m_OriginalImageNode;
 
   if ( m_NodeForThresholding.IsNotNull() )
   {
     SetupPreviewNode();
   }
   else
   {
     m_ToolManager->ActivateTool(-1);
   }
 }
 
 void mitk::BinaryThresholdULTool::Deactivated()
 {
   m_ToolManager->RoiDataChanged -= mitk::MessageDelegate<mitk::BinaryThresholdULTool>(this, &mitk::BinaryThresholdULTool::OnRoiDataChanged);
   m_NodeForThresholding = NULL;
   m_OriginalImageNode = NULL;
   try
   {
     if (DataStorage* storage = m_ToolManager->GetDataStorage())
     {
       storage->Remove( m_ThresholdFeedbackNode );
       RenderingManager::GetInstance()->RequestUpdateAll();
     }
   }
   catch(...)
   {
     // don't care
   }
   m_ThresholdFeedbackNode->SetData(NULL);
 }
 
 void mitk::BinaryThresholdULTool::SetThresholdValues(int lower, int upper)
 {
   if (m_ThresholdFeedbackNode.IsNotNull())
   {
     m_CurrentLowerThresholdValue = lower;
     m_CurrentUpperThresholdValue = upper;
     UpdatePreview();
   }
 }
 
-void mitk::BinaryThresholdULTool::AcceptCurrentThresholdValue(const std::string& organName, const Color& color)
+void mitk::BinaryThresholdULTool::AcceptCurrentThresholdValue()
 {
 
-  CreateNewSegmentationFromThreshold(m_NodeForThresholding, organName, color );
+  CreateNewSegmentationFromThreshold(m_NodeForThresholding);
 
   RenderingManager::GetInstance()->RequestUpdateAll();
   m_ToolManager->ActivateTool(-1);
 }
 
 void mitk::BinaryThresholdULTool::CancelThresholding()
 {
   m_ToolManager->ActivateTool(-1);
 }
 
 void mitk::BinaryThresholdULTool::SetupPreviewNode()
 {
   if (m_NodeForThresholding.IsNotNull())
   {
     Image::Pointer image = dynamic_cast<Image*>( m_NodeForThresholding->GetData() );
     Image::Pointer originalImage = dynamic_cast<Image*> (m_OriginalImageNode->GetData());
 
     if (image.IsNotNull())
     {
       // initialize and a new node with the same image as our reference image
       // use the level window property of this image copy to display the result of a thresholding operation
       m_ThresholdFeedbackNode->SetData( image );
       int layer(50);
       m_NodeForThresholding->GetIntProperty("layer", layer);
       m_ThresholdFeedbackNode->SetIntProperty("layer", layer+1);
 
       if (DataStorage* ds = m_ToolManager->GetDataStorage())
       {
         if (!ds->Exists(m_ThresholdFeedbackNode))
           ds->Add( m_ThresholdFeedbackNode, m_OriginalImageNode );
       }
 
       if (image.GetPointer() == originalImage.GetPointer())
       {
         m_SensibleMinimumThresholdValue = static_cast<int>( originalImage->GetScalarValueMin() );
         m_SensibleMaximumThresholdValue = static_cast<int>( originalImage->GetScalarValueMax() );
       }
 
       m_CurrentLowerThresholdValue = (m_SensibleMaximumThresholdValue + m_SensibleMinimumThresholdValue) / 3;
       m_CurrentUpperThresholdValue = 2*m_CurrentLowerThresholdValue;
 
       IntervalBordersChanged.Send(m_SensibleMinimumThresholdValue, m_SensibleMaximumThresholdValue);
       ThresholdingValuesChanged.Send(m_CurrentLowerThresholdValue, m_CurrentUpperThresholdValue);
     }
   }
 }
 
-void mitk::BinaryThresholdULTool::CreateNewSegmentationFromThreshold(DataNode* node, const std::string& organName, const Color& color)
+void mitk::BinaryThresholdULTool::CreateNewSegmentationFromThreshold(DataNode* node)
 {
   if (node)
   {
     Image::Pointer image = dynamic_cast<Image*>( m_NodeForThresholding->GetData() );
     if (image.IsNotNull())
     {
       // create a new image of the same dimensions and smallest possible pixel type
-      DataNode::Pointer emptySegmentation = Tool::CreateEmptySegmentationNode( image, organName, color );
+      DataNode::Pointer emptySegmentation = m_ToolManager->GetWorkingData(0);
 
       if (emptySegmentation)
       {
         // actually perform a thresholding and ask for an organ type
         for (unsigned int timeStep = 0; timeStep < image->GetTimeSteps(); ++timeStep)
         {
           try
           {
             ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
             timeSelector->SetInput( image );
             timeSelector->SetTimeNr( timeStep );
             timeSelector->UpdateLargestPossibleRegion();
             Image::Pointer image3D = timeSelector->GetOutput();
 
             AccessFixedDimensionByItk_2( image3D, ITKThresholding, 3, dynamic_cast<Image*>(emptySegmentation->GetData()), timeStep );
           }
           catch(...)
           {
             Tool::ErrorMessage("Error accessing single time steps of the original image. Cannot create segmentation.");
           }
         }
 
         //since we are maybe working on a smaller image, pad it to the size of the original image
         if (m_OriginalImageNode.GetPointer() != m_NodeForThresholding.GetPointer())
         {
           mitk::PadImageFilter::Pointer padFilter = mitk::PadImageFilter::New();
 
           padFilter->SetInput(0, dynamic_cast<mitk::Image*> (emptySegmentation->GetData()));
           padFilter->SetInput(1, dynamic_cast<mitk::Image*> (m_OriginalImageNode->GetData()));
           padFilter->SetBinaryFilter(true);
           padFilter->SetUpperThreshold(1);
           padFilter->SetLowerThreshold(1);
           padFilter->Update();
 
           emptySegmentation->SetData(padFilter->GetOutput());
         }
 
-        if (DataStorage* ds = m_ToolManager->GetDataStorage())
-        {
-          ds->Add( emptySegmentation, m_OriginalImageNode );
-        }
-
         m_ToolManager->SetWorkingData( emptySegmentation );
       }
     }
   }
 }
 
 template <typename TPixel, unsigned int VImageDimension>
     void mitk::BinaryThresholdULTool::ITKThresholding( itk::Image<TPixel, VImageDimension>* originalImage, Image* segmentation, unsigned int timeStep )
 {
   ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
   timeSelector->SetInput( segmentation );
   timeSelector->SetTimeNr( timeStep );
   timeSelector->UpdateLargestPossibleRegion();
   Image::Pointer segmentation3D = timeSelector->GetOutput();
 
   typedef itk::Image< Tool::DefaultSegmentationDataType, 3> SegmentationType; // this is sure for new segmentations
   SegmentationType::Pointer itkSegmentation;
   CastToItkImage( segmentation3D, itkSegmentation );
 
   // iterate over original and segmentation
   typedef itk::ImageRegionConstIterator< itk::Image<TPixel, VImageDimension> >     InputIteratorType;
   typedef itk::ImageRegionIterator< SegmentationType >     SegmentationIteratorType;
 
   InputIteratorType inputIterator( originalImage, originalImage->GetLargestPossibleRegion() );
   SegmentationIteratorType outputIterator( itkSegmentation, itkSegmentation->GetLargestPossibleRegion() );
 
   inputIterator.GoToBegin();
   outputIterator.GoToBegin();
 
   while (!outputIterator.IsAtEnd())
   {
     if ( (signed)inputIterator.Get() >= m_CurrentLowerThresholdValue && (signed)inputIterator.Get() <= m_CurrentUpperThresholdValue )
     {
       outputIterator.Set( 1 );
     }
     else
     {
       outputIterator.Set( 0 );
     }
 
     ++inputIterator;
     ++outputIterator;
   }
 }
 
 void mitk::BinaryThresholdULTool::OnRoiDataChanged()
 {
   mitk::DataNode::Pointer node = m_ToolManager->GetRoiData(0);
 
   if (node.IsNotNull())
   {
     mitk::MaskAndCutRoiImageFilter::Pointer roiFilter = mitk::MaskAndCutRoiImageFilter::New();
     mitk::Image::Pointer image = dynamic_cast<mitk::Image*> (m_NodeForThresholding->GetData());
 
     if (image.IsNull())
       return;
 
     roiFilter->SetInput(image);
     roiFilter->SetRegionOfInterest(node->GetData());
     roiFilter->Update();
 
     mitk::DataNode::Pointer tmpNode = mitk::DataNode::New();
     tmpNode->SetData(roiFilter->GetOutput());
 
     m_SensibleMinimumThresholdValue = static_cast<int>( roiFilter->GetMinValue());
     m_SensibleMaximumThresholdValue = static_cast<int>( roiFilter->GetMaxValue());
 
     m_NodeForThresholding = tmpNode;
   }
   else
     m_NodeForThresholding = m_OriginalImageNode;
 
   this->SetupPreviewNode();
   this->UpdatePreview();
 }
 
 void mitk::BinaryThresholdULTool::UpdatePreview()
 {
   typedef itk::Image<int, 3> ImageType;
   typedef itk::Image<unsigned char, 3> SegmentationType;
   typedef itk::BinaryThresholdImageFilter<ImageType, SegmentationType> ThresholdFilterType;
   mitk::Image::Pointer thresholdimage = dynamic_cast<mitk::Image*> (m_NodeForThresholding->GetData());
   if(thresholdimage)
   {
     ImageType::Pointer itkImage = ImageType::New();
     CastToItkImage(thresholdimage, itkImage);
     ThresholdFilterType::Pointer filter = ThresholdFilterType::New();
     filter->SetInput(itkImage);
     filter->SetLowerThreshold(m_CurrentLowerThresholdValue);
     filter->SetUpperThreshold(m_CurrentUpperThresholdValue);
     filter->SetInsideValue(1);
     filter->SetOutsideValue(0);
     filter->Update();
 
     mitk::Image::Pointer new_image = mitk::Image::New();
     CastToMitkImage(filter->GetOutput(), new_image);
     m_ThresholdFeedbackNode->SetData(new_image);
   }
   RenderingManager::GetInstance()->RequestUpdateAll();
 }
diff --git a/Modules/Segmentation/Interactions/mitkBinaryThresholdULTool.h b/Modules/Segmentation/Interactions/mitkBinaryThresholdULTool.h
index 5ce7c115bb..407bd0c448 100644
--- a/Modules/Segmentation/Interactions/mitkBinaryThresholdULTool.h
+++ b/Modules/Segmentation/Interactions/mitkBinaryThresholdULTool.h
@@ -1,95 +1,95 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef mitkBinaryThresholdULTool_h_Included
 #define mitkBinaryThresholdULTool_h_Included
 
 #include "mitkCommon.h"
 #include "SegmentationExports.h"
 #include "mitkAutoSegmentationTool.h"
 #include "mitkDataNode.h"
 
 #include <itkImage.h>
 #include <itkBinaryThresholdImageFilter.h>
 
 namespace mitk
 {
 
   /**
   \brief Calculates the segmented volumes for binary images.
 
   \ingroup ToolManagerEtAl
   \sa mitk::Tool
   \sa QmitkInteractiveSegmentation
 
   Last contributor: $Author$
   */
   class Segmentation_EXPORT BinaryThresholdULTool : public AutoSegmentationTool
   {
   public:
 
     Message2<int,int> IntervalBordersChanged;
     Message2<int, int>     ThresholdingValuesChanged;
 
     mitkClassMacro(BinaryThresholdULTool, AutoSegmentationTool);
     itkNewMacro(BinaryThresholdULTool);
 
     virtual const char** GetXPM() const;
     virtual const char* GetName() const;
 
     virtual void Activated();
     virtual void Deactivated();
 
     virtual void SetThresholdValues(int lower, int upper);
-    virtual void AcceptCurrentThresholdValue(const std::string& organName, const Color& color);
+    virtual void AcceptCurrentThresholdValue();
     virtual void CancelThresholding();
 
 
   protected:
 
     BinaryThresholdULTool(); // purposely hidden
     virtual ~BinaryThresholdULTool();
 
     void SetupPreviewNode();
 
-    void CreateNewSegmentationFromThreshold(DataNode* node, const std::string& organType, const Color& color);
+    void CreateNewSegmentationFromThreshold(DataNode* node);
 
     void OnRoiDataChanged();
     void UpdatePreview();
 
     template <typename TPixel, unsigned int VImageDimension>
     void ITKThresholding( itk::Image<TPixel, VImageDimension>* originalImage, mitk::Image* segmentation, unsigned int timeStep );
 
     DataNode::Pointer m_ThresholdFeedbackNode;
     DataNode::Pointer m_OriginalImageNode;
     DataNode::Pointer m_NodeForThresholding;
 
     int m_SensibleMinimumThresholdValue;
     int m_SensibleMaximumThresholdValue;
     int m_CurrentLowerThresholdValue;
     int m_CurrentUpperThresholdValue;
 
     typedef itk::Image<int, 3> ImageType;
     typedef itk::Image< Tool::DefaultSegmentationDataType, 3> SegmentationType; // this is sure for new segmentations
     typedef itk::BinaryThresholdImageFilter<ImageType, SegmentationType> ThresholdFilterType;
     ThresholdFilterType::Pointer m_ThresholdFilter;
 
   };
 
 } // namespace
 
 #endif