diff --git a/Plugins/org.mitk.gui.qt.basicimageprocessing/src/internal/QmitkBasicImageProcessingView.cpp b/Plugins/org.mitk.gui.qt.basicimageprocessing/src/internal/QmitkBasicImageProcessingView.cpp
index aec175eaa9..af7f444773 100644
--- a/Plugins/org.mitk.gui.qt.basicimageprocessing/src/internal/QmitkBasicImageProcessingView.cpp
+++ b/Plugins/org.mitk.gui.qt.basicimageprocessing/src/internal/QmitkBasicImageProcessingView.cpp
@@ -1,1343 +1,1346 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkBasicImageProcessingView.h"
 
 // QT includes (GUI)
 #include <qlabel.h>
 #include <qspinbox.h>
 #include <qpushbutton.h>
 #include <qcheckbox.h>
 #include <qgroupbox.h>
 #include <qradiobutton.h>
 #include <qmessagebox.h>
 
-// Berry includes (selection service)
-#include <berryISelectionService.h>
-#include <berryIWorkbenchWindow.h>
-
-// MITK includes (GUI)
-#include "QmitkDataNodeSelectionProvider.h"
-#include "mitkDataNodeObject.h"
-
 // MITK includes (general)
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateDimension.h>
-#include <mitkNodePredicateAnd.h>
+#include <mitkNodePredicateNot.h>
+#include <mitkNodePredicateOr.h>
+#include <mitkNodePredicateProperty.h>
 #include <mitkImageTimeSelector.h>
 #include <mitkVectorImageMapper2D.h>
 #include <mitkProperties.h>
 #include <mitkLevelWindowProperty.h>
 #include <mitkImageStatisticsHolder.h>
 
 // Includes for image casting between ITK and MITK
 #include <mitkImageCast.h>
 #include <mitkITKImageImport.h>
 
 // ITK includes (general)
 #include <itkVectorImage.h>
 #include <itkImageFileWriter.h>
 
 // Morphological Operations
 #include <itkBinaryBallStructuringElement.h>
 #include <itkGrayscaleDilateImageFilter.h>
 #include <itkGrayscaleErodeImageFilter.h>
 #include <itkGrayscaleMorphologicalOpeningImageFilter.h>
 #include <itkGrayscaleMorphologicalClosingImageFilter.h>
 
 // Smoothing
 #include <itkMedianImageFilter.h>
 #include <itkDiscreteGaussianImageFilter.h>
 #include <itkTotalVariationDenoisingImageFilter.h>
 
 // Threshold
 #include <itkBinaryThresholdImageFilter.h>
 
 // Inversion
 #include <itkInvertIntensityImageFilter.h>
 
 // Derivatives
 #include <itkGradientMagnitudeRecursiveGaussianImageFilter.h>
 #include <itkLaplacianImageFilter.h>
 #include <itkSobelEdgeDetectionImageFilter.h>
 
 // Resampling
 #include <itkResampleImageFilter.h>
 #include <itkNearestNeighborInterpolateImageFunction.h>
 #include <itkBSplineInterpolateImageFunction.h>
 #include <itkCastImageFilter.h>
 #include <itkLinearInterpolateImageFunction.h>
 
 // Image Arithmetics
 #include <itkAddImageFilter.h>
 #include <itkSubtractImageFilter.h>
 #include <itkMultiplyImageFilter.h>
 #include <itkDivideImageFilter.h>
 
 // Boolean operations
 #include <itkOrImageFilter.h>
 #include <itkAndImageFilter.h>
 #include <itkXorImageFilter.h>
 
 // Flip Image
 #include <itkFlipImageFilter.h>
 
 #include <itkRescaleIntensityImageFilter.h>
 #include <itkShiftScaleImageFilter.h>
 
-
 // Convenient Definitions
 typedef itk::Image<short, 3>                                                            ImageType;
 typedef itk::Image<unsigned char, 3>                                                    SegmentationImageType;
 typedef itk::Image<double, 3>                                                           DoubleImageType;
 typedef itk::Image<itk::Vector<float,3>, 3>                                             VectorImageType;
 
 typedef itk::BinaryBallStructuringElement<ImageType::PixelType, 3>                      BallType;
 typedef itk::GrayscaleDilateImageFilter<ImageType, ImageType, BallType>                 DilationFilterType;
 typedef itk::GrayscaleErodeImageFilter<ImageType, ImageType, BallType>                  ErosionFilterType;
 typedef itk::GrayscaleMorphologicalOpeningImageFilter<ImageType, ImageType, BallType>   OpeningFilterType;
 typedef itk::GrayscaleMorphologicalClosingImageFilter<ImageType, ImageType, BallType>   ClosingFilterType;
 
 typedef itk::MedianImageFilter< ImageType, ImageType >                                  MedianFilterType;
 typedef itk::DiscreteGaussianImageFilter< ImageType, ImageType>                         GaussianFilterType;
 typedef itk::TotalVariationDenoisingImageFilter<DoubleImageType, DoubleImageType>       TotalVariationFilterType;
 typedef itk::TotalVariationDenoisingImageFilter<VectorImageType, VectorImageType>       VectorTotalVariationFilterType;
 
 typedef itk::BinaryThresholdImageFilter< ImageType, ImageType >                         ThresholdFilterType;
 typedef itk::InvertIntensityImageFilter< ImageType, ImageType >                         InversionFilterType;
 
 typedef itk::GradientMagnitudeRecursiveGaussianImageFilter< ImageType, ImageType >      GradientFilterType;
 typedef itk::LaplacianImageFilter< DoubleImageType, DoubleImageType >                   LaplacianFilterType;
 typedef itk::SobelEdgeDetectionImageFilter< DoubleImageType, DoubleImageType >          SobelFilterType;
 
 typedef itk::ResampleImageFilter< ImageType, ImageType >                                ResampleImageFilterType;
 typedef itk::ResampleImageFilter< ImageType, ImageType >                                ResampleImageFilterType2;
 typedef itk::CastImageFilter< ImageType, DoubleImageType >                              ImagePTypeToFloatPTypeCasterType;
 
 typedef itk::AddImageFilter< ImageType, ImageType, ImageType >                          AddFilterType;
 typedef itk::SubtractImageFilter< ImageType, ImageType, ImageType >                     SubtractFilterType;
 typedef itk::MultiplyImageFilter< ImageType, ImageType, ImageType >                     MultiplyFilterType;
 typedef itk::DivideImageFilter< ImageType, ImageType, DoubleImageType >                 DivideFilterType;
 
 typedef itk::OrImageFilter< ImageType, ImageType >                                      OrImageFilterType;
 typedef itk::AndImageFilter< ImageType, ImageType >                                     AndImageFilterType;
 typedef itk::XorImageFilter< ImageType, ImageType >                                     XorImageFilterType;
 
 typedef itk::FlipImageFilter< ImageType >                                               FlipImageFilterType;
 
 typedef itk::LinearInterpolateImageFunction< ImageType, double >                        LinearInterpolatorType;
 typedef itk::NearestNeighborInterpolateImageFunction< ImageType, double >               NearestInterpolatorType;
 
 const std::string QmitkBasicImageProcessing::VIEW_ID = "org.mitk.views.basicimageprocessing";
 
 QmitkBasicImageProcessing::QmitkBasicImageProcessing()
-: QmitkAbstractView(),
-  m_Controls(nullptr),
-  m_SelectedImageNode(nullptr),
-  m_TimeStepperAdapter(nullptr)
+  : QmitkAbstractView()
+  , m_Controls(new Ui::QmitkBasicImageProcessingViewControls)
+  , m_TimeStepperAdapter(nullptr)
 {
   auto isImage = mitk::TNodePredicateDataType<mitk::Image>::New();
   auto isNotHelperObject = mitk::NodePredicateNot::New(
     mitk::NodePredicateProperty::New("helper object", mitk::BoolProperty::New(true)));
   auto dimensionPredicate = mitk::NodePredicateOr::New(
     mitk::NodePredicateDimension::New(3), mitk::NodePredicateDimension::New(4));
 
   m_IsImagePredicate = mitk::NodePredicateAnd::New(
     isImage, isNotHelperObject, dimensionPredicate);
 }
 
 QmitkBasicImageProcessing::~QmitkBasicImageProcessing()
 {
 
 }
 
 void QmitkBasicImageProcessing::CreateQtPartControl(QWidget *parent)
 {
-    m_Controls = new Ui::QmitkBasicImageProcessingViewControls;
-    m_Controls->setupUi(parent);
-    this->CreateConnections();
+  m_Controls->setupUi(parent);
+
+  m_Controls->selectedImageWidget->SetDataStorage(this->GetDataStorage());
+  m_Controls->selectedImageWidget->SetNodePredicate(m_IsImagePredicate);
+  m_Controls->selectedImageWidget->SetSelectionIsOptional(true);
+  m_Controls->selectedImageWidget->SetAutoSelectNewNodes(true);
+  m_Controls->selectedImageWidget->SetEmptyInfo(QString("Please select a 3D / 4D image"));
+  m_Controls->selectedImageWidget->SetPopUpTitel(QString("Select an image"));
+
+  m_Controls->selectedImageWidget_2->SetDataStorage(this->GetDataStorage());
+  m_Controls->selectedImageWidget_2->SetNodePredicate(m_IsImagePredicate);
+  m_Controls->selectedImageWidget_2->SetSelectionIsOptional(true);
+  m_Controls->selectedImageWidget_2->SetAutoSelectNewNodes(true);
+  m_Controls->selectedImageWidget_2->SetEmptyInfo(QString("Please select a 3D / 4D image"));
+  m_Controls->selectedImageWidget_2->SetPopUpTitel(QString("Select an image"));
 
-
-    mitk::NodePredicateDimension::Pointer dimensionPredicate = mitk::NodePredicateDimension::New(3);
-    mitk::NodePredicateDataType::Pointer imagePredicate = mitk::NodePredicateDataType::New("Image");
-    m_Controls->m_ImageSelector2->SetDataStorage(this->GetDataStorage());
-    m_Controls->m_ImageSelector2->SetPredicate(mitk::NodePredicateAnd::New(dimensionPredicate, imagePredicate));
   m_Controls->gbTwoImageOps->hide();
 
   m_Controls->cbWhat1->clear();
   m_Controls->cbWhat1->insertItem(NOACTIONSELECTED, "Please select operation");
   m_Controls->cbWhat1->insertItem(CATEGORY_DENOISING, "--- Denoising ---");
   m_Controls->cbWhat1->insertItem(GAUSSIAN, "Gaussian");
   m_Controls->cbWhat1->insertItem(MEDIAN, "Median");
   m_Controls->cbWhat1->insertItem(TOTALVARIATION, "Total Variation");
   m_Controls->cbWhat1->insertItem(CATEGORY_MORPHOLOGICAL, "--- Morphological ---");
   m_Controls->cbWhat1->insertItem(DILATION, "Dilation");
   m_Controls->cbWhat1->insertItem(EROSION, "Erosion");
   m_Controls->cbWhat1->insertItem(OPENING, "Opening");
   m_Controls->cbWhat1->insertItem(CLOSING, "Closing");
   m_Controls->cbWhat1->insertItem(CATEGORY_EDGE_DETECTION, "--- Edge Detection ---");
   m_Controls->cbWhat1->insertItem(GRADIENT, "Gradient");
   m_Controls->cbWhat1->insertItem(LAPLACIAN, "Laplacian (2nd Derivative)");
   m_Controls->cbWhat1->insertItem(SOBEL, "Sobel Operator");
   m_Controls->cbWhat1->insertItem(CATEGORY_MISC, "--- Misc ---");
   m_Controls->cbWhat1->insertItem(THRESHOLD, "Threshold");
   m_Controls->cbWhat1->insertItem(INVERSION, "Image Inversion");
   m_Controls->cbWhat1->insertItem(DOWNSAMPLING, "Downsampling");
   m_Controls->cbWhat1->insertItem(FLIPPING, "Flipping");
   m_Controls->cbWhat1->insertItem(RESAMPLING, "Resample to");
   m_Controls->cbWhat1->insertItem(RESCALE, "Rescale values to interval");
   m_Controls->cbWhat1->insertItem(RESCALE2, "Rescale values by scalar");
 
   m_Controls->cbWhat2->clear();
   m_Controls->cbWhat2->insertItem(TWOIMAGESNOACTIONSELECTED, "Please select on operation");
   m_Controls->cbWhat2->insertItem(CATEGORY_ARITHMETIC, "--- Arithmetric operations ---");
   m_Controls->cbWhat2->insertItem(ADD, "Add to Image 1:");
   m_Controls->cbWhat2->insertItem(SUBTRACT, "Subtract from Image 1:");
   m_Controls->cbWhat2->insertItem(MULTIPLY, "Multiply with Image 1:");
   m_Controls->cbWhat2->insertItem(RESAMPLE_TO, "Resample Image 1 to fit geometry:");
   m_Controls->cbWhat2->insertItem(DIVIDE, "Divide Image 1 by:");
   m_Controls->cbWhat2->insertItem(CATEGORY_BOOLEAN, "--- Boolean operations ---");
   m_Controls->cbWhat2->insertItem(AND, "AND");
   m_Controls->cbWhat2->insertItem(OR, "OR");
   m_Controls->cbWhat2->insertItem(XOR, "XOR");
 
   m_Controls->cbParam4->clear();
   m_Controls->cbParam4->insertItem(LINEAR, "Linear");
   m_Controls->cbParam4->insertItem(NEAREST, "Nearest neighbor");
 
   m_Controls->dsbParam1->hide();
   m_Controls->dsbParam2->hide();
   m_Controls->dsbParam3->hide();
   m_Controls->tlParam3->hide();
   m_Controls->tlParam4->hide();
   m_Controls->cbParam4->hide();
 
   this->CreateConnections();
 }
 
 void QmitkBasicImageProcessing::CreateConnections()
 {
-  if ( m_Controls )
-  {
-    connect( (QObject*)(m_Controls->cbWhat1), SIGNAL( activated(int) ), this, SLOT( SelectAction(int) ) );
-    connect( (QObject*)(m_Controls->btnDoIt), SIGNAL(clicked()),(QObject*) this, SLOT(StartButtonClicked()));
-    connect( (QObject*)(m_Controls->cbWhat2), SIGNAL( activated(int) ), this, SLOT( SelectAction2(int) ) );
-    connect( (QObject*)(m_Controls->btnDoIt2), SIGNAL(clicked()),(QObject*) this, SLOT(StartButton2Clicked()));
-    connect( (QObject*)(m_Controls->rBOneImOp), SIGNAL( clicked() ), this, SLOT( ChangeGUI() ) );
-    connect( (QObject*)(m_Controls->rBTwoImOp), SIGNAL( clicked() ), this, SLOT( ChangeGUI() ) );
-    connect( (QObject*)(m_Controls->cbParam4), SIGNAL( activated(int) ), this, SLOT( SelectInterpolator(int) ) );
-  }
+  connect((QObject *)(m_Controls->cbWhat1), SIGNAL(activated(int)), this, SLOT(SelectAction(int)));
+  connect((QObject *)(m_Controls->btnDoIt), SIGNAL(clicked()), (QObject *)this, SLOT(StartButtonClicked()));
+  connect((QObject *)(m_Controls->cbWhat2), SIGNAL(activated(int)), this, SLOT(SelectAction2(int)));
+  connect((QObject *)(m_Controls->btnDoIt2), SIGNAL(clicked()), (QObject *)this, SLOT(StartButton2Clicked()));
+  connect((QObject *)(m_Controls->rBOneImOp), SIGNAL(clicked()), this, SLOT(ChangeGUI()));
+  connect((QObject *)(m_Controls->rBTwoImOp), SIGNAL(clicked()), this, SLOT(ChangeGUI()));
+  connect((QObject *)(m_Controls->cbParam4), SIGNAL(activated(int)), this, SLOT(SelectInterpolator(int)));
+  connect(m_Controls->selectedImageWidget, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged,
+    this, &QmitkBasicImageProcessing::OnCurrentSelectionChanged);
+  connect(m_Controls->selectedImageWidget_2, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged,
+    this, &QmitkBasicImageProcessing::OnCurrentSelectionChanged);
 }
 
 void QmitkBasicImageProcessing::InternalGetTimeNavigationController()
 {
   auto renwin_part = GetRenderWindowPart();
   if( renwin_part != nullptr )
   {
     auto tnc = renwin_part->GetTimeNavigationController();
     if( tnc != nullptr )
     {
       m_TimeStepperAdapter = new QmitkStepperAdapter((QObject*) m_Controls->sliceNavigatorTime, tnc->GetTime(), "sliceNavigatorTimeFromBIP");
     }
   }
 }
 
 void QmitkBasicImageProcessing::SetFocus()
 {
   m_Controls->rBOneImOp->setFocus();
 }
 
-//datamanager selection changed
-void QmitkBasicImageProcessing::OnSelectionChanged(berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>& nodes)
+void QmitkBasicImageProcessing::OnCurrentSelectionChanged(const QList<mitk::DataNode::Pointer>& nodes)
 {
-  //any nodes there?
-  if (!nodes.empty())
+  if (nodes.empty() || nodes.front().IsNull())
   {
-  // reset GUI
-//  this->ResetOneImageOpPanel();
-  m_Controls->sliceNavigatorTime->setEnabled(false);
-  m_Controls->leImage1->setText(tr("Select an Image in Data Manager"));
-  m_Controls->tlWhat1->setEnabled(false);
-  m_Controls->cbWhat1->setEnabled(false);
-  m_Controls->tlWhat2->setEnabled(false);
-  m_Controls->cbWhat2->setEnabled(false);
-
-  m_SelectedImageNode->RemoveAllNodes();
-  //get the selected Node
-  mitk::DataNode* _DataNode = nodes.front();
-  *m_SelectedImageNode = _DataNode;
-  //try to cast to image
-  mitk::Image::Pointer tempImage = dynamic_cast<mitk::Image*>(m_SelectedImageNode->GetNode()->GetData());
-
-    //no image
-    if( tempImage.IsNull() || (tempImage->IsInitialized() == false) )
-    {
-      m_Controls->leImage1->setText(tr("Not an image."));
-      return;
-    }
-
-    //2D image
-    if( tempImage->GetDimension() < 3)
-    {
-      m_Controls->leImage1->setText(tr("2D images are not supported."));
-      return;
-    }
+    m_Controls->sliceNavigatorTime->setEnabled(false);
+    m_Controls->tlTime->setEnabled(false);
+    m_Controls->tlWhat1->setEnabled(false);
+    m_Controls->cbWhat1->setEnabled(false);
+    m_Controls->tlWhat2->setEnabled(false);
+    m_Controls->cbWhat2->setEnabled(false);
+    return;
+  }
 
-    //image
-    m_Controls->leImage1->setText(QString(m_SelectedImageNode->GetNode()->GetName().c_str()));
+  auto selectedImage = dynamic_cast<mitk::Image*>(nodes.front()->GetData());
+  if (nullptr == selectedImage)
+  {
+    return;
+  }
 
-    // button coding
-    if ( tempImage->GetDimension() > 3 )
-    {
-      // try to retrieve the TNC (for 4-D Processing )
-      this->InternalGetTimeNavigationController();
+  if (selectedImage->GetDimension() > 3)
+  {
+    // try to retrieve the TNC (for 4-D Processing )
+    this->InternalGetTimeNavigationController();
 
-      m_Controls->sliceNavigatorTime->setEnabled(true);
-      m_Controls->tlTime->setEnabled(true);
-    }
-    m_Controls->tlWhat1->setEnabled(true);
-    m_Controls->cbWhat1->setEnabled(true);
-    m_Controls->tlWhat2->setEnabled(true);
-    m_Controls->cbWhat2->setEnabled(true);
+    m_Controls->sliceNavigatorTime->setEnabled(true);
+    m_Controls->tlTime->setEnabled(true);
   }
+
+  m_Controls->tlWhat1->setEnabled(true);
+  m_Controls->cbWhat1->setEnabled(true);
+  m_Controls->tlWhat2->setEnabled(true);
+  m_Controls->cbWhat2->setEnabled(true);
 }
 
 void QmitkBasicImageProcessing::ChangeGUI()
 {
   if(m_Controls->rBOneImOp->isChecked())
   {
     m_Controls->gbTwoImageOps->hide();
     m_Controls->gbOneImageOps->show();
   }
   else if(m_Controls->rBTwoImOp->isChecked())
   {
     m_Controls->gbOneImageOps->hide();
     m_Controls->gbTwoImageOps->show();
   }
 }
 
 void QmitkBasicImageProcessing::ResetParameterPanel()
 {
   m_Controls->tlParam->setEnabled(false);
   m_Controls->tlParam1->setEnabled(false);
   m_Controls->tlParam2->setEnabled(false);
   m_Controls->tlParam3->setEnabled(false);
   m_Controls->tlParam4->setEnabled(false);
 
   m_Controls->sbParam1->setEnabled(false);
   m_Controls->sbParam2->setEnabled(false);
   m_Controls->dsbParam1->setEnabled(false);
   m_Controls->dsbParam2->setEnabled(false);
   m_Controls->dsbParam3->setEnabled(false);
   m_Controls->cbParam4->setEnabled(false);
   m_Controls->sbParam1->setValue(0);
   m_Controls->sbParam2->setValue(0);
   m_Controls->dsbParam1->setValue(0);
   m_Controls->dsbParam2->setValue(0);
   m_Controls->dsbParam3->setValue(0);
 
   m_Controls->sbParam1->show();
   m_Controls->sbParam2->show();
   m_Controls->dsbParam1->hide();
   m_Controls->dsbParam2->hide();
   m_Controls->dsbParam3->hide();
   m_Controls->cbParam4->hide();
   m_Controls->tlParam3->hide();
   m_Controls->tlParam4->hide();
 }
 
 void QmitkBasicImageProcessing::SelectAction(int action)
 {
-  if ( ! m_SelectedImageNode->GetNode() ) return;
+  auto selectedImage = m_Controls->selectedImageWidget->GetSelectedNode();
+  if (selectedImage.IsNull())
+  {
+    return;
+  }
 
   // Prepare GUI
   this->ResetParameterPanel();
   m_Controls->btnDoIt->setEnabled(false);
   m_Controls->cbHideOrig->setEnabled(false);
 
   QString text1 = tr("No Parameters");
   QString text2 = text1;
   QString text3 = text1;
   QString text4 = text1;
 
   if (action != 19)
   {
     m_Controls->dsbParam1->hide();
     m_Controls->dsbParam2->hide();
     m_Controls->dsbParam3->hide();
     m_Controls->tlParam1->show();
     m_Controls->tlParam2->show();
     m_Controls->tlParam3->hide();
     m_Controls->tlParam4->hide();
     m_Controls->sbParam1->show();
     m_Controls->sbParam2->show();
     m_Controls->cbParam4->hide();
   }
 
   switch (action)
   {
   case 2:
     {
       m_SelectedAction = GAUSSIAN;
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->sbParam1->hide();
       m_Controls->dsbParam1->show();
       m_Controls->dsbParam1->setEnabled(true);
       text1 = tr("&Variance:");
       m_Controls->tlParam2->hide();
       m_Controls->sbParam2->hide();
 
       m_Controls->dsbParam1->setMinimum( 0 );
       m_Controls->dsbParam1->setMaximum( 200 );
       m_Controls->dsbParam1->setValue( 2 );
       break;
     }
   case 3:
     {
       m_SelectedAction = MEDIAN;
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->sbParam1->setEnabled(true);
       text1 = tr("&Radius:");
       m_Controls->sbParam1->setMinimum( 0 );
       m_Controls->sbParam1->setMaximum( 200 );
       m_Controls->sbParam1->setValue( 3 );
       break;
     }
   case 4:
     {
       m_SelectedAction = TOTALVARIATION;
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->sbParam1->setEnabled(true);
       m_Controls->tlParam2->setEnabled(true);
       m_Controls->sbParam2->setEnabled(true);
       text1 = tr("Number Iterations:");
       text2 = tr("Regularization\n(Lambda/1000):");
       m_Controls->sbParam1->setMinimum( 1 );
       m_Controls->sbParam1->setMaximum( 1000 );
       m_Controls->sbParam1->setValue( 40 );
       m_Controls->sbParam2->setMinimum( 0 );
       m_Controls->sbParam2->setMaximum( 100000 );
       m_Controls->sbParam2->setValue( 1 );
       break;
     }
   case 6:
     {
       m_SelectedAction = DILATION;
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->sbParam1->setEnabled(true);
       text1 = tr("&Radius:");
       m_Controls->sbParam1->setMinimum( 0 );
       m_Controls->sbParam1->setMaximum( 200 );
       m_Controls->sbParam1->setValue( 3 );
       break;
     }
   case 7:
     {
       m_SelectedAction = EROSION;
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->sbParam1->setEnabled(true);
       text1 = tr("&Radius:");
       m_Controls->sbParam1->setMinimum( 0 );
       m_Controls->sbParam1->setMaximum( 200 );
       m_Controls->sbParam1->setValue( 3 );
       break;
     }
   case 8:
     {
       m_SelectedAction = OPENING;
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->sbParam1->setEnabled(true);
       text1 = tr("&Radius:");
       m_Controls->sbParam1->setMinimum( 0 );
       m_Controls->sbParam1->setMaximum( 200 );
       m_Controls->sbParam1->setValue( 3 );
       break;
     }
   case 9:
     {
       m_SelectedAction = CLOSING;
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->sbParam1->setEnabled(true);
       text1 = tr("&Radius:");
       m_Controls->sbParam1->setMinimum( 0 );
       m_Controls->sbParam1->setMaximum( 200 );
       m_Controls->sbParam1->setValue( 3 );
       break;
     }
   case 11:
     {
       m_SelectedAction = GRADIENT;
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->sbParam1->hide();
       m_Controls->dsbParam1->show();
       m_Controls->dsbParam1->setEnabled(true);
       text1 = tr("Sigma of Gaussian Kernel:\n(in Image Spacing Units)");
       m_Controls->tlParam2->hide();
       m_Controls->sbParam2->hide();
 
       m_Controls->dsbParam1->setMinimum( 0 );
       m_Controls->dsbParam1->setMaximum( 200 );
       m_Controls->dsbParam1->setValue( 2 );
       break;
     }
   case 12:
     {
       m_SelectedAction = LAPLACIAN;
       break;
     }
   case 13:
     {
       m_SelectedAction = SOBEL;
       break;
     }
   case 15:
     {
       m_SelectedAction = THRESHOLD;
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->sbParam1->setEnabled(true);
       m_Controls->tlParam2->setEnabled(true);
       m_Controls->sbParam2->setEnabled(true);
       text1 = tr("Lower threshold:");
       text2 = tr("Upper threshold:");
       m_Controls->sbParam1->setMinimum( -100000 );
       m_Controls->sbParam1->setMaximum( 100000 );
       m_Controls->sbParam1->setValue( 0 );
       m_Controls->sbParam2->setMinimum( -100000 );
       m_Controls->sbParam2->setMaximum( 100000 );
       m_Controls->sbParam2->setValue( 300 );
       break;
     }
   case 16:
     {
       m_SelectedAction = INVERSION;
       break;
     }
   case 17:
     {
       m_SelectedAction = DOWNSAMPLING;
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->sbParam1->setEnabled(true);
       text1 = tr("Downsampling by Factor:");
       m_Controls->sbParam1->setMinimum( 1 );
       m_Controls->sbParam1->setMaximum( 100 );
       m_Controls->sbParam1->setValue( 2 );
       break;
     }
   case 18:
     {
       m_SelectedAction = FLIPPING;
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->sbParam1->setEnabled(true);
       text1 = tr("Flip across axis:");
       m_Controls->sbParam1->setMinimum( 0 );
       m_Controls->sbParam1->setMaximum( 2 );
       m_Controls->sbParam1->setValue( 1 );
       break;
     }
   case 19:
     {
       m_SelectedAction = RESAMPLING;
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->sbParam1->setEnabled(false);
       m_Controls->sbParam1->hide();
       m_Controls->dsbParam1->show();
       m_Controls->dsbParam1->setEnabled(true);
       m_Controls->tlParam2->setEnabled(true);
       m_Controls->sbParam2->setEnabled(false);
       m_Controls->sbParam2->hide();
       m_Controls->dsbParam2->show();
       m_Controls->dsbParam2->setEnabled(true);
       m_Controls->tlParam3->show();
       m_Controls->tlParam3->setEnabled(true);
       m_Controls->dsbParam3->show();
       m_Controls->dsbParam3->setEnabled(true);
       m_Controls->tlParam4->show();
       m_Controls->tlParam4->setEnabled(true);
       m_Controls->cbParam4->show();
       m_Controls->cbParam4->setEnabled(true);
 
       m_Controls->dsbParam1->setMinimum(0.01);
       m_Controls->dsbParam1->setMaximum(10.0);
       m_Controls->dsbParam1->setSingleStep(0.1);
       m_Controls->dsbParam1->setValue(0.3);
       m_Controls->dsbParam2->setMinimum(0.01);
       m_Controls->dsbParam2->setMaximum(10.0);
       m_Controls->dsbParam2->setSingleStep(0.1);
       m_Controls->dsbParam2->setValue(0.3);
       m_Controls->dsbParam3->setMinimum(0.01);
       m_Controls->dsbParam3->setMaximum(10.0);
       m_Controls->dsbParam3->setSingleStep(0.1);
       m_Controls->dsbParam3->setValue(1.5);
 
       text1 = tr("x-spacing:");
       text2 = tr("y-spacing:");
       text3 = tr("z-spacing:");
       text4 = tr("Interplation:");
       break;
     }
   case 20:
     {
       m_SelectedAction = RESCALE;
       m_Controls->dsbParam1->show();
       m_Controls->tlParam1->show();
       m_Controls->dsbParam1->setEnabled(true);
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->dsbParam2->show();
       m_Controls->tlParam2->show();
       m_Controls->dsbParam2->setEnabled(true);
       m_Controls->tlParam2->setEnabled(true);
       text1 = tr("Output minimum:");
       text2 = tr("Output maximum:");
       break;
     }
   case 21:
   {
       m_SelectedAction = RESCALE2;
       m_Controls->dsbParam1->show();
       m_Controls->tlParam1->show();
       m_Controls->dsbParam1->setEnabled(true);
       m_Controls->tlParam1->setEnabled(true);
       text1 = tr("Scaling value:");
       break;
   }
   default:
     return;
   }
 
   m_Controls->tlParam->setEnabled(true);
   m_Controls->tlParam1->setText(text1);
   m_Controls->tlParam2->setText(text2);
   m_Controls->tlParam3->setText(text3);
   m_Controls->tlParam4->setText(text4);
 
   m_Controls->btnDoIt->setEnabled(true);
   m_Controls->cbHideOrig->setEnabled(true);
 }
 
 void QmitkBasicImageProcessing::StartButtonClicked()
 {
-  if(!m_SelectedImageNode->GetNode()) return;
+  auto selectedNode = m_Controls->selectedImageWidget->GetSelectedNode();
+  if (selectedNode.IsNull())
+  {
+    return;
+  }
 
   this->BusyCursorOn();
 
   mitk::Image::Pointer newImage;
   try
   {
-    newImage = dynamic_cast<mitk::Image*>(m_SelectedImageNode->GetNode()->GetData());
+    newImage = dynamic_cast<mitk::Image*>(selectedNode->GetData());
   }
   catch ( std::exception &e )
   {
   QString exceptionString = tr("An error occured during image loading:\n");
   exceptionString.append( e.what() );
     QMessageBox::warning( nullptr, "Basic Image Processing", exceptionString , QMessageBox::Ok, QMessageBox::NoButton );
     this->BusyCursorOff();
     return;
   }
 
   // check if input image is valid, casting does not throw exception when casting from 'nullptr-Object'
   if ( (! newImage) || (newImage->IsInitialized() == false) )
   {
     this->BusyCursorOff();
 
     QMessageBox::warning( nullptr, "Basic Image Processing", tr("Input image is broken or not initialized. Returning."), QMessageBox::Ok, QMessageBox::NoButton );
     return;
   }
 
   // check if operation is done on 4D a image time step
   if(newImage->GetDimension() > 3)
   {
     auto timeSelector = mitk::ImageTimeSelector::New();
     timeSelector->SetInput(newImage);
     timeSelector->SetTimeNr( ((QmitkSliderNavigatorWidget*)m_Controls->sliceNavigatorTime)->GetPos() );
     timeSelector->Update();
     newImage = timeSelector->GetOutput();
   }
 
   // check if image or vector image
   auto itkImage = ImageType::New();
   auto itkVecImage = VectorImageType::New();
 
   int isVectorImage = newImage->GetPixelType().GetNumberOfComponents();
 
   if(isVectorImage > 1)
   {
     CastToItkImage( newImage, itkVecImage );
   }
   else
   {
     CastToItkImage( newImage, itkImage );
   }
 
   std::stringstream nameAddition("");
 
   int param1 = m_Controls->sbParam1->value();
   int param2 = m_Controls->sbParam2->value();
   double dparam1 = m_Controls->dsbParam1->value();
   double dparam2 = m_Controls->dsbParam2->value();
   double dparam3 = m_Controls->dsbParam3->value();
 
   try
   {
   switch (m_SelectedAction)
   {
   case GAUSSIAN:
     {
       GaussianFilterType::Pointer gaussianFilter = GaussianFilterType::New();
       gaussianFilter->SetInput( itkImage );
       gaussianFilter->SetVariance( dparam1 );
       gaussianFilter->UpdateLargestPossibleRegion();
       newImage = mitk::ImportItkImage(gaussianFilter->GetOutput())->Clone();
       nameAddition << "_Gaussian_var_" << dparam1;
       std::cout << "Gaussian filtering successful." << std::endl;
       break;
     }
   case MEDIAN:
     {
       MedianFilterType::Pointer medianFilter = MedianFilterType::New();
       MedianFilterType::InputSizeType size;
       size.Fill(param1);
       medianFilter->SetRadius( size );
       medianFilter->SetInput(itkImage);
       medianFilter->UpdateLargestPossibleRegion();
       newImage = mitk::ImportItkImage(medianFilter->GetOutput())->Clone();
       nameAddition << "_Median_radius_" << param1;
       std::cout << "Median Filtering successful." << std::endl;
       break;
     }
   case TOTALVARIATION:
     {
       if(isVectorImage > 1)
       {
         VectorTotalVariationFilterType::Pointer TVFilter
           = VectorTotalVariationFilterType::New();
         TVFilter->SetInput( itkVecImage.GetPointer() );
         TVFilter->SetNumberIterations(param1);
         TVFilter->SetLambda(double(param2)/1000.);
         TVFilter->UpdateLargestPossibleRegion();
 
         newImage = mitk::ImportItkImage(TVFilter->GetOutput())->Clone();
       }
       else
       {
         ImagePTypeToFloatPTypeCasterType::Pointer floatCaster = ImagePTypeToFloatPTypeCasterType::New();
         floatCaster->SetInput( itkImage );
         floatCaster->Update();
         DoubleImageType::Pointer fImage = floatCaster->GetOutput();
 
         TotalVariationFilterType::Pointer TVFilter
           = TotalVariationFilterType::New();
         TVFilter->SetInput( fImage.GetPointer() );
         TVFilter->SetNumberIterations(param1);
         TVFilter->SetLambda(double(param2)/1000.);
         TVFilter->UpdateLargestPossibleRegion();
 
         newImage = mitk::ImportItkImage(TVFilter->GetOutput())->Clone();
       }
 
       nameAddition << "_TV_Iter_" << param1 << "_L_" << param2;
       std::cout << "Total Variation Filtering successful." << std::endl;
       break;
     }
   case DILATION:
     {
       BallType binaryBall;
       binaryBall.SetRadius( param1 );
       binaryBall.CreateStructuringElement();
 
       DilationFilterType::Pointer dilationFilter = DilationFilterType::New();
       dilationFilter->SetInput( itkImage );
       dilationFilter->SetKernel( binaryBall );
       dilationFilter->UpdateLargestPossibleRegion();
       newImage = mitk::ImportItkImage(dilationFilter->GetOutput())->Clone();
       nameAddition << "_Dilated_by_" << param1;
       std::cout << "Dilation successful." << std::endl;
       break;
     }
   case EROSION:
     {
       BallType binaryBall;
       binaryBall.SetRadius( param1 );
       binaryBall.CreateStructuringElement();
 
       ErosionFilterType::Pointer erosionFilter = ErosionFilterType::New();
       erosionFilter->SetInput( itkImage );
       erosionFilter->SetKernel( binaryBall );
       erosionFilter->UpdateLargestPossibleRegion();
       newImage = mitk::ImportItkImage(erosionFilter->GetOutput())->Clone();
       nameAddition << "_Eroded_by_" << param1;
       std::cout << "Erosion successful." << std::endl;
       break;
     }
   case OPENING:
     {
       BallType binaryBall;
       binaryBall.SetRadius( param1 );
       binaryBall.CreateStructuringElement();
 
       OpeningFilterType::Pointer openFilter = OpeningFilterType::New();
       openFilter->SetInput( itkImage );
       openFilter->SetKernel( binaryBall );
       openFilter->UpdateLargestPossibleRegion();
       newImage = mitk::ImportItkImage(openFilter->GetOutput())->Clone();
       nameAddition << "_Opened_by_" << param1;
       std::cout << "Opening successful." << std::endl;
       break;
     }
   case CLOSING:
     {
       BallType binaryBall;
       binaryBall.SetRadius( param1 );
       binaryBall.CreateStructuringElement();
 
       ClosingFilterType::Pointer closeFilter = ClosingFilterType::New();
       closeFilter->SetInput( itkImage );
       closeFilter->SetKernel( binaryBall );
       closeFilter->UpdateLargestPossibleRegion();
       newImage = mitk::ImportItkImage(closeFilter->GetOutput())->Clone();
       nameAddition << "_Closed_by_" << param1;
       std::cout << "Closing successful." << std::endl;
       break;
     }
   case GRADIENT:
     {
       GradientFilterType::Pointer gradientFilter = GradientFilterType::New();
       gradientFilter->SetInput( itkImage );
       gradientFilter->SetSigma( dparam1 );
       gradientFilter->UpdateLargestPossibleRegion();
       newImage = mitk::ImportItkImage(gradientFilter->GetOutput())->Clone();
       nameAddition << "_Gradient_sigma_" << dparam1;
       std::cout << "Gradient calculation successful." << std::endl;
       break;
     }
   case LAPLACIAN:
     {
       // the laplace filter requires a float type image as input, we need to cast the itkImage
       // to correct type
       ImagePTypeToFloatPTypeCasterType::Pointer caster = ImagePTypeToFloatPTypeCasterType::New();
       caster->SetInput( itkImage );
       caster->Update();
       DoubleImageType::Pointer fImage = caster->GetOutput();
 
       LaplacianFilterType::Pointer laplacianFilter = LaplacianFilterType::New();
       laplacianFilter->SetInput( fImage );
       laplacianFilter->UpdateLargestPossibleRegion();
       newImage = mitk::ImportItkImage(laplacianFilter->GetOutput())->Clone();
       nameAddition << "_Second_Derivative";
       std::cout << "Laplacian filtering successful." << std::endl;
       break;
     }
   case SOBEL:
     {
       // the sobel filter requires a float type image as input, we need to cast the itkImage
       // to correct type
       ImagePTypeToFloatPTypeCasterType::Pointer caster = ImagePTypeToFloatPTypeCasterType::New();
       caster->SetInput( itkImage );
       caster->Update();
       DoubleImageType::Pointer fImage = caster->GetOutput();
 
       SobelFilterType::Pointer sobelFilter = SobelFilterType::New();
       sobelFilter->SetInput( fImage );
       sobelFilter->UpdateLargestPossibleRegion();
       newImage = mitk::ImportItkImage(sobelFilter->GetOutput())->Clone();
       nameAddition << "_Sobel";
       std::cout << "Edge Detection successful." << std::endl;
       break;
     }
   case THRESHOLD:
     {
       ThresholdFilterType::Pointer thFilter = ThresholdFilterType::New();
       thFilter->SetLowerThreshold(param1 < param2 ? param1 : param2);
       thFilter->SetUpperThreshold(param2 > param1 ? param2 : param1);
       thFilter->SetInsideValue(1);
       thFilter->SetOutsideValue(0);
       thFilter->SetInput(itkImage);
       thFilter->UpdateLargestPossibleRegion();
       newImage = mitk::ImportItkImage(thFilter->GetOutput())->Clone();
       nameAddition << "_Threshold";
       std::cout << "Thresholding successful." << std::endl;
       break;
     }
   case INVERSION:
     {
       InversionFilterType::Pointer invFilter = InversionFilterType::New();
       mitk::ScalarType min = newImage->GetStatistics()->GetScalarValueMin();
       mitk::ScalarType max = newImage->GetStatistics()->GetScalarValueMax();
       invFilter->SetMaximum( max + min );
       invFilter->SetInput(itkImage);
       invFilter->UpdateLargestPossibleRegion();
       newImage = mitk::ImportItkImage(invFilter->GetOutput())->Clone();
       nameAddition << "_Inverted";
       std::cout << "Image inversion successful." << std::endl;
       break;
     }
   case DOWNSAMPLING:
     {
       ResampleImageFilterType::Pointer downsampler = ResampleImageFilterType::New();
       downsampler->SetInput( itkImage );
 
       NearestInterpolatorType::Pointer interpolator = NearestInterpolatorType::New();
       downsampler->SetInterpolator( interpolator );
 
       downsampler->SetDefaultPixelValue( 0 );
 
       ResampleImageFilterType::SpacingType spacing = itkImage->GetSpacing();
       spacing *= (double) param1;
       downsampler->SetOutputSpacing( spacing );
 
       downsampler->SetOutputOrigin( itkImage->GetOrigin() );
       downsampler->SetOutputDirection( itkImage->GetDirection() );
 
       ResampleImageFilterType::SizeType size = itkImage->GetLargestPossibleRegion().GetSize();
       for ( int i = 0; i < 3; ++i )
       {
         size[i] /= param1;
       }
       downsampler->SetSize( size );
       downsampler->UpdateLargestPossibleRegion();
 
       newImage = mitk::ImportItkImage(downsampler->GetOutput())->Clone();
       nameAddition << "_Downsampled_by_" << param1;
       std::cout << "Downsampling successful." << std::endl;
       break;
     }
   case FLIPPING:
     {
       FlipImageFilterType::Pointer flipper = FlipImageFilterType::New();
       flipper->SetInput( itkImage );
       itk::FixedArray<bool, 3> flipAxes;
       for(int i=0; i<3; ++i)
       {
         if(i == param1)
         {
           flipAxes[i] = true;
         }
         else
         {
           flipAxes[i] = false;
         }
       }
       flipper->SetFlipAxes(flipAxes);
       flipper->UpdateLargestPossibleRegion();
       newImage = mitk::ImportItkImage(flipper->GetOutput())->Clone();
       std::cout << "Image flipping successful." << std::endl;
       break;
     }
   case RESAMPLING:
     {
       std::string selectedInterpolator;
       ResampleImageFilterType::Pointer resampler = ResampleImageFilterType::New();
       switch (m_SelectedInterpolation)
       {
       case LINEAR:
         {
           LinearInterpolatorType::Pointer interpolator = LinearInterpolatorType::New();
           resampler->SetInterpolator(interpolator);
           selectedInterpolator = "Linear";
           break;
         }
       case NEAREST:
         {
           NearestInterpolatorType::Pointer interpolator = NearestInterpolatorType::New();
           resampler->SetInterpolator(interpolator);
           selectedInterpolator = "Nearest";
           break;
         }
       default:
         {
           LinearInterpolatorType::Pointer interpolator = LinearInterpolatorType::New();
           resampler->SetInterpolator(interpolator);
           selectedInterpolator = "Linear";
           break;
         }
       }
       resampler->SetInput( itkImage );
       resampler->SetOutputOrigin( itkImage->GetOrigin() );
 
       ImageType::SizeType input_size = itkImage->GetLargestPossibleRegion().GetSize();
       ImageType::SpacingType input_spacing = itkImage->GetSpacing();
 
       ImageType::SizeType output_size;
       ImageType::SpacingType output_spacing;
 
       output_size[0] = input_size[0] * (input_spacing[0] / dparam1);
       output_size[1] = input_size[1] * (input_spacing[1] / dparam2);
       output_size[2] = input_size[2] * (input_spacing[2] / dparam3);
       output_spacing [0] = dparam1;
       output_spacing [1] = dparam2;
       output_spacing [2] = dparam3;
 
       resampler->SetSize( output_size );
       resampler->SetOutputSpacing( output_spacing );
       resampler->SetOutputDirection( itkImage->GetDirection() );
 
       resampler->UpdateLargestPossibleRegion();
 
       ImageType::Pointer resampledImage = resampler->GetOutput();
 
       newImage = mitk::ImportItkImage( resampledImage )->Clone();
       nameAddition << "_Resampled_" << selectedInterpolator;
       std::cout << "Resampling successful." << std::endl;
       break;
     }
   case RESCALE:
     {
       DoubleImageType::Pointer floatImage = DoubleImageType::New();
       CastToItkImage( newImage, floatImage );
       itk::RescaleIntensityImageFilter<DoubleImageType,DoubleImageType>::Pointer filter = itk::RescaleIntensityImageFilter<DoubleImageType,DoubleImageType>::New();
       filter->SetInput(0, floatImage);
       filter->SetOutputMinimum(dparam1);
       filter->SetOutputMaximum(dparam2);
       filter->Update();
       floatImage = filter->GetOutput();
 
       newImage = mitk::Image::New();
       newImage->InitializeByItk(floatImage.GetPointer());
       newImage->SetVolume(floatImage->GetBufferPointer());
       nameAddition << "_Rescaled";
       std::cout << "Rescaling successful." << std::endl;
 
       break;
     }
   case RESCALE2:
   {
       DoubleImageType::Pointer floatImage = DoubleImageType::New();
       CastToItkImage( newImage, floatImage );
       itk::ShiftScaleImageFilter<DoubleImageType,DoubleImageType>::Pointer filter = itk::ShiftScaleImageFilter<DoubleImageType,DoubleImageType>::New();
       filter->SetInput(0, floatImage);
       filter->SetScale(dparam1);
 
       filter->Update();
       floatImage = filter->GetOutput();
 
       newImage = mitk::Image::New();
       newImage->InitializeByItk(floatImage.GetPointer());
       newImage->SetVolume(floatImage->GetBufferPointer());
       nameAddition << "_Rescaled";
       std::cout << "Rescaling successful." << std::endl;
       break;
   }
 
   default:
     this->BusyCursorOff();
     return;
   }
   }
   catch (...)
   {
     this->BusyCursorOff();
     QMessageBox::warning(nullptr, "Warning", "Problem when applying filter operation. Check your input...");
     return;
   }
 
   newImage->DisconnectPipeline();
 
   // adjust level/window to new image
   mitk::LevelWindow levelwindow;
   levelwindow.SetAuto( newImage );
   auto levWinProp = mitk::LevelWindowProperty::New();
   levWinProp->SetLevelWindow( levelwindow );
 
   // compose new image name
-  std::string name = m_SelectedImageNode->GetNode()->GetName();
+  std::string name = selectedNode->GetName();
   if (name.find(".pic.gz") == name.size() -7 )
   {
     name = name.substr(0,name.size() -7);
   }
   name.append( nameAddition.str() );
 
   // create final result MITK data storage node
   auto result = mitk::DataNode::New();
   result->SetProperty( "levelwindow", levWinProp );
   result->SetProperty( "name", mitk::StringProperty::New( name.c_str() ) );
   result->SetData( newImage );
 
   // for vector images, a different mapper is needed
   if(isVectorImage > 1)
   {
     auto mapper = mitk::VectorImageMapper2D::New();
     result->SetMapper(1,mapper);
   }
 
   // add new image to data storage and set as active to ease further processing
-  GetDataStorage()->Add( result, m_SelectedImageNode->GetNode() );
-  if ( m_Controls->cbHideOrig->isChecked() == true )
-    m_SelectedImageNode->GetNode()->SetProperty( "visible", mitk::BoolProperty::New(false) );
+  GetDataStorage()->Add(result, selectedNode);
+  if (m_Controls->cbHideOrig->isChecked() == true)
+  {
+    selectedNode->SetProperty("visible", mitk::BoolProperty::New(false));
+  }
 
   // show the results
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   this->BusyCursorOff();
 }
 
 void QmitkBasicImageProcessing::SelectAction2(int operation)
 {
   switch (operation)
   {
   case 2:
     m_SelectedOperation = ADD;
     break;
   case 3:
     m_SelectedOperation = SUBTRACT;
     break;
   case 4:
     m_SelectedOperation = MULTIPLY;
     break;
   case 5:
     m_SelectedOperation = DIVIDE;
     break;
   case 6:
     m_SelectedOperation = RESAMPLE_TO;
     break;
   case 8:
     m_SelectedOperation = AND;
     break;
   case 9:
     m_SelectedOperation = OR;
     break;
   case 10:
     m_SelectedOperation = XOR;
     break;
   default:
     return;
   }
-  m_Controls->tlImage2->setEnabled(true);
-  m_Controls->m_ImageSelector2->setEnabled(true);
+
+  m_Controls->selectedImageLabel_2->setEnabled(true);
+  m_Controls->selectedImageWidget_2->setEnabled(true);
   m_Controls->btnDoIt2->setEnabled(true);
 }
 
 void QmitkBasicImageProcessing::StartButton2Clicked()
 {
-  mitk::Image::Pointer newImage1 = dynamic_cast<mitk::Image*>
-    (m_SelectedImageNode->GetNode()->GetData());
-  mitk::Image::Pointer newImage2 = dynamic_cast<mitk::Image*>
-    (m_Controls->m_ImageSelector2->GetSelectedNode()->GetData());
+  auto selectedNode = m_Controls->selectedImageWidget->GetSelectedNode();
+  if (selectedNode.IsNull())
+  {
+    return;
+  }
+
+  auto selectedNode2 = m_Controls->selectedImageWidget_2->GetSelectedNode();
+  if (selectedNode2.IsNull())
+  {
+    return;
+  }
+
+  auto newImage1 = dynamic_cast<mitk::Image*>(selectedNode->GetData());
+  auto newImage2 = dynamic_cast<mitk::Image*>(selectedNode2->GetData());
 
   // check if images are valid
   if(nullptr == newImage1 || nullptr == newImage2
  || false == newImage1->IsInitialized() || false == newImage2->IsInitialized())
   {
     itkGenericExceptionMacro(<< "At least one of the input images is broken or not initialized.");
     return;
   }
 
   this->BusyCursorOn();
 
   // check if 4D image and use filter on correct time step
   if(newImage1->GetDimension() > 3)
   {
     auto timeSelector = mitk::ImageTimeSelector::New();
 
     auto sn_widget = static_cast<QmitkSliderNavigatorWidget*>( m_Controls->sliceNavigatorTime );
     int time = 0;
 
     if( sn_widget != nullptr )
         time = sn_widget->GetPos();
 
     timeSelector->SetInput(newImage1);
     timeSelector->SetTimeNr( time );
     timeSelector->UpdateLargestPossibleRegion();
     newImage1 = timeSelector->GetOutput();
     newImage1->DisconnectPipeline();
 
     timeSelector->SetInput(newImage2);
     timeSelector->SetTimeNr( time );
     timeSelector->UpdateLargestPossibleRegion();
     newImage2 = timeSelector->GetOutput();
     newImage2->DisconnectPipeline();
   }
 
   auto itkImage1 = ImageType::New();
   auto itkImage2 = ImageType::New();
 
   CastToItkImage( newImage1, itkImage1 );
   CastToItkImage( newImage2, itkImage2 );
 
   std::string nameAddition = "";
   try
   {
   switch (m_SelectedOperation)
   {
   case ADD:
     {
       AddFilterType::Pointer addFilter = AddFilterType::New();
       addFilter->SetInput1( itkImage1 );
       addFilter->SetInput2( itkImage2 );
       addFilter->UpdateLargestPossibleRegion();
       newImage1 = mitk::ImportItkImage(addFilter->GetOutput())->Clone();
       nameAddition = "_Added";
     }
     break;
   case SUBTRACT:
     {
       SubtractFilterType::Pointer subFilter = SubtractFilterType::New();
       subFilter->SetInput1( itkImage1 );
       subFilter->SetInput2( itkImage2 );
       subFilter->UpdateLargestPossibleRegion();
       newImage1 = mitk::ImportItkImage(subFilter->GetOutput())->Clone();
       nameAddition = "_Subtracted";
     }
     break;
   case MULTIPLY:
     {
       MultiplyFilterType::Pointer multFilter = MultiplyFilterType::New();
       multFilter->SetInput1( itkImage1 );
       multFilter->SetInput2( itkImage2 );
       multFilter->UpdateLargestPossibleRegion();
       newImage1 = mitk::ImportItkImage(multFilter->GetOutput())->Clone();
       nameAddition = "_Multiplied";
     }
     break;
   case DIVIDE:
     {
       DivideFilterType::Pointer divFilter = DivideFilterType::New();
       divFilter->SetInput1( itkImage1 );
       divFilter->SetInput2( itkImage2 );
       divFilter->UpdateLargestPossibleRegion();
       newImage1 = mitk::ImportItkImage<DoubleImageType>(divFilter->GetOutput())->Clone();
       nameAddition = "_Divided";
     }
     break;
   case AND:
     {
       AndImageFilterType::Pointer andFilter = AndImageFilterType::New();
       andFilter->SetInput1( itkImage1 );
       andFilter->SetInput2( itkImage2 );
       andFilter->UpdateLargestPossibleRegion();
       newImage1 = mitk::ImportItkImage(andFilter->GetOutput())->Clone();
       nameAddition = "_AND";
       break;
     }
   case OR:
     {
       OrImageFilterType::Pointer orFilter = OrImageFilterType::New();
       orFilter->SetInput1( itkImage1 );
       orFilter->SetInput2( itkImage2 );
       orFilter->UpdateLargestPossibleRegion();
       newImage1 = mitk::ImportItkImage(orFilter->GetOutput())->Clone();
       nameAddition = "_OR";
       break;
     }
   case XOR:
     {
       XorImageFilterType::Pointer xorFilter = XorImageFilterType::New();
       xorFilter->SetInput1( itkImage1 );
       xorFilter->SetInput2( itkImage2 );
       xorFilter->UpdateLargestPossibleRegion();
       newImage1 = mitk::ImportItkImage(xorFilter->GetOutput())->Clone();
       nameAddition = "_XOR";
       break;
     }
   case RESAMPLE_TO:
     {
       itk::BSplineInterpolateImageFunction<DoubleImageType, double>::Pointer bspl_interpolator
         = itk::BSplineInterpolateImageFunction<DoubleImageType, double>::New();
       bspl_interpolator->SetSplineOrder( 3 );
 
       itk::NearestNeighborInterpolateImageFunction< DoubleImageType >::Pointer nn_interpolator
           = itk::NearestNeighborInterpolateImageFunction< DoubleImageType>::New();
 
       DoubleImageType::Pointer itkImage1 = DoubleImageType::New();
       DoubleImageType::Pointer itkImage2 = DoubleImageType::New();
 
       CastToItkImage( newImage1, itkImage1 );
       CastToItkImage( newImage2, itkImage2 );
 
       itk::ResampleImageFilter< DoubleImageType, DoubleImageType >::Pointer resampleFilter = itk::ResampleImageFilter< DoubleImageType, DoubleImageType >::New();
       resampleFilter->SetInput( itkImage1 );
       resampleFilter->SetReferenceImage( itkImage2 );
       resampleFilter->SetUseReferenceImage( true );
 
       // use NN interp with binary images
-      if( m_SelectedImageNode->GetNode()->GetProperty("binary") )
+      if(selectedNode->GetProperty("binary") )
         resampleFilter->SetInterpolator( nn_interpolator );
       else
         resampleFilter->SetInterpolator( bspl_interpolator );
 
       resampleFilter->SetDefaultPixelValue( 0 );
 
       try
       {
         resampleFilter->UpdateLargestPossibleRegion();
       }
       catch( const itk::ExceptionObject &e)
       {
         MITK_WARN << "Updating resampling filter failed. ";
         MITK_WARN << "REASON: " << e.what();
       }
 
       DoubleImageType::Pointer resampledImage = resampleFilter->GetOutput();
 
       newImage1 = mitk::ImportItkImage( resampledImage )->Clone();
       nameAddition = "_Resampled";
       break;
     }
 
   default:
     std::cout << "Something went wrong..." << std::endl;
     this->BusyCursorOff();
     return;
   }
   }
   catch (const itk::ExceptionObject& e )
   {
     this->BusyCursorOff();
     QMessageBox::warning(nullptr, "ITK Exception", e.what() );
     QMessageBox::warning(nullptr, "Warning", tr("Problem when applying arithmetic operation to two images. Check dimensions of input images."));
     return;
   }
 
   // disconnect pipeline; images will not be reused
   newImage1->DisconnectPipeline();
   itkImage1 = nullptr;
   itkImage2 = nullptr;
 
   // adjust level/window to new image and compose new image name
   mitk::LevelWindow levelwindow;
   levelwindow.SetAuto( newImage1 );
   auto levWinProp = mitk::LevelWindowProperty::New();
   levWinProp->SetLevelWindow( levelwindow );
-  std::string name = m_SelectedImageNode->GetNode()->GetName();
+  std::string name = selectedNode->GetName();
   if (name.find(".pic.gz") == name.size() -7 )
   {
     name = name.substr(0,name.size() -7);
   }
 
   // create final result MITK data storage node
   auto result = mitk::DataNode::New();
   result->SetProperty( "levelwindow", levWinProp );
   result->SetProperty( "name", mitk::StringProperty::New( (name + nameAddition ).c_str() ));
   result->SetData( newImage1 );
-  GetDataStorage()->Add( result, m_SelectedImageNode->GetNode() );
+  this->GetDataStorage()->Add(result, selectedNode);
 
-  m_SelectedImageNode->GetNode()->SetProperty( "visible", mitk::BoolProperty::New(false) );
-  m_Controls->m_ImageSelector2->GetSelectedNode()->SetProperty( "visible", mitk::BoolProperty::New(false) );
+  if (m_Controls->cbHideOrig->isChecked() == true)
+  {
+    selectedNode->SetProperty("visible", mitk::BoolProperty::New(false));
+    selectedNode2->SetProperty("visible", mitk::BoolProperty::New(false));
+  }
 
   // show the newly created image
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   this->BusyCursorOff();
 }
 
 void QmitkBasicImageProcessing::SelectInterpolator(int interpolator)
 {
   switch (interpolator)
   {
   case 0:
     {
       m_SelectedInterpolation = LINEAR;
       break;
     }
   case 1:
     {
       m_SelectedInterpolation = NEAREST;
       break;
     }
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.basicimageprocessing/src/internal/QmitkBasicImageProcessingView.h b/Plugins/org.mitk.gui.qt.basicimageprocessing/src/internal/QmitkBasicImageProcessingView.h
index 14781257aa..a750463193 100644
--- a/Plugins/org.mitk.gui.qt.basicimageprocessing/src/internal/QmitkBasicImageProcessingView.h
+++ b/Plugins/org.mitk.gui.qt.basicimageprocessing/src/internal/QmitkBasicImageProcessingView.h
@@ -1,158 +1,154 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QMITKBASICIMAGEPROCESSINGVIEW_H
 #define QMITKBASICIMAGEPROCESSINGVIEW_H
 
-#include <QmitkAbstractView.h>
-#include <org_mitk_gui_qt_basicimageprocessing_Export.h>
-#include "ui_QmitkBasicImageProcessingViewControls.h"
+#include <ui_QmitkBasicImageProcessingViewControls.h>
 
-#include "QmitkStepperAdapter.h"
+#include <org_mitk_gui_qt_basicimageprocessing_Export.h>
 
-#include <mitkDataStorageSelection.h>
+#include <mitkNodePredicateAnd.h>
+#include <QmitkStepperAdapter.h>
+#include <QmitkAbstractView.h>
 
 /*!
 \brief This module allows to use some basic image processing filters for preprocessing, image enhancement and testing purposes
 
 Several basic ITK image processing filters, like denoising, morphological and edge detection
 are encapsulated in this module and can be selected via a list and an intuitive parameter input.
 The selected filter will be applied on the image, and a new image showing the output is displayed
 as result.
 Also, some image arithmetic operations are available.
 
 Images can be 3D or 4D.
 In the 4D case, the filters work on the 3D image selected via the
 time slider. The result is also a 3D image.
 
 \class QmitkBasicImageProcessing
 \author Tobias Schwarz
 \version 1.0 (3M3)
 \date 2009-05-10
 \ingroup Bundles
 */
 
 class BASICIMAGEPROCESSING_EXPORT QmitkBasicImageProcessing : public QmitkAbstractView
 {
   Q_OBJECT
 
 public:
   static const std::string VIEW_ID;
 
   QmitkBasicImageProcessing();
   ~QmitkBasicImageProcessing() override;
 
   void SetFocus() override;
 
 private Q_SLOTS:
 
-  /*!
-  \brief Invoked when the DataManager selection changed
-  */
-  void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer>& nodes) override;
-
-
+  void OnCurrentSelectionChanged(const QList<mitk::DataNode::Pointer>& nodes);
 
     /*
    * When an action is selected in the "one image ops" list box
    */
   void SelectAction(int action);
 
   /*
    * When an action is selected in the "two image ops" list box
    */
   void SelectAction2(int operation);
 
   /*
    * The "Execute" button in the "one image ops" box was triggered
    */
   void StartButtonClicked();
 
   /*
    * The "Execute" button in the "two image ops" box was triggered
    */
   void StartButton2Clicked();
 
   /*
    *  Switch between the one and the two image operations GUI
    */
   void ChangeGUI();
 
   void SelectInterpolator(int interpolator);
 
 private:
 
   void CreateQtPartControl(QWidget *parent) override;
   virtual void CreateConnections();
 
   /*
   * Helper method to reset the parameter set panel
   */
   void ResetParameterPanel();
 
   /** retrieve the tnc from renderwindow part */
   void InternalGetTimeNavigationController();
 
   Ui::QmitkBasicImageProcessingViewControls* m_Controls;
 
-  mitk::DataStorageSelection::Pointer m_SelectedImageNode;
   QmitkStepperAdapter* m_TimeStepperAdapter;
 
+  mitk::NodePredicateAnd::Pointer m_IsImagePredicate;
+
   enum ActionType
   {
     NOACTIONSELECTED,
     CATEGORY_DENOISING,
     GAUSSIAN,
     MEDIAN,
     TOTALVARIATION,
     CATEGORY_MORPHOLOGICAL,
     DILATION,
     EROSION,
     OPENING,
     CLOSING,
     CATEGORY_EDGE_DETECTION,
     GRADIENT,
     LAPLACIAN,
     SOBEL,
     CATEGORY_MISC,
     THRESHOLD,
     INVERSION,
     DOWNSAMPLING,
     FLIPPING,
     RESAMPLING,
     RESCALE,
     RESCALE2
   } m_SelectedAction;
 
   enum OperationType
   {
     TWOIMAGESNOACTIONSELECTED,
     CATEGORY_ARITHMETIC,
     ADD,
     SUBTRACT,
     MULTIPLY,
     DIVIDE,
     RESAMPLE_TO,
     CATEGORY_BOOLEAN,
     AND,
     OR,
     XOR
   } m_SelectedOperation;
 
   enum InterpolationType
   {
     LINEAR,
     NEAREST
   } m_SelectedInterpolation;
 };
 
 #endif // !defined(QmitkBasicImageProcessing_H__INCLUDED)QMITKBASICIMAGEPROCESSINGVIEW_H
diff --git a/Plugins/org.mitk.gui.qt.basicimageprocessing/src/internal/QmitkBasicImageProcessingViewControls.ui b/Plugins/org.mitk.gui.qt.basicimageprocessing/src/internal/QmitkBasicImageProcessingViewControls.ui
index b6a6c4dd2b..abb43d9246 100644
--- a/Plugins/org.mitk.gui.qt.basicimageprocessing/src/internal/QmitkBasicImageProcessingViewControls.ui
+++ b/Plugins/org.mitk.gui.qt.basicimageprocessing/src/internal/QmitkBasicImageProcessingViewControls.ui
@@ -1,428 +1,447 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkBasicImageProcessingViewControls</class>
  <widget class="QWidget" name="QmitkBasicImageProcessingViewControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>448</width>
-    <height>980</height>
+    <width>370</width>
+    <height>620</height>
    </rect>
   </property>
   <property name="windowTitle">
-   <string>Form</string>
+   <string>Basic Image Processing</string>
   </property>
   <layout class="QGridLayout" name="gridLayout_4">
    <item row="0" column="0">
     <widget class="QGroupBox" name="groupBox">
-     <property name="title">
-      <string/>
-     </property>
-     <property name="flat">
-      <bool>false</bool>
-     </property>
      <layout class="QGridLayout" name="gridLayout_3">
       <item row="0" column="0">
        <widget class="QRadioButton" name="rBOneImOp">
         <property name="text">
          <string>Filters
 (One Image)</string>
         </property>
         <property name="checked">
          <bool>true</bool>
         </property>
        </widget>
       </item>
       <item row="0" column="1">
        <widget class="QRadioButton" name="rBTwoImOp">
         <property name="text">
          <string>Arithmetic
 (Two Images)</string>
         </property>
        </widget>
       </item>
-      <item row="1" column="0" colspan="2">
-       <widget class="QLineEdit" name="leImage1">
+      <item row="1" column="0">
+       <widget class="QLabel" name="selectedImageLabel">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
         <property name="text">
-         <string>Select an image in the Data Manager</string>
+         <string>Selected image</string>
         </property>
-        <property name="readOnly">
-         <bool>true</bool>
+       </widget>
+      </item>
+      <item row="1" column="1">
+       <widget class="QmitkSingleNodeSelectionWidget" name="selectedImageWidget" native="true">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="minimumSize">
+         <size>
+          <width>0</width>
+          <height>40</height>
+         </size>
         </property>
        </widget>
       </item>
       <item row="2" column="0">
        <widget class="QLabel" name="tlTime">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="toolTip">
          <string>Output image will be 3D</string>
         </property>
         <property name="text">
          <string>Choose time step if 4D
 (Slider for both images)</string>
         </property>
         <property name="wordWrap">
          <bool>false</bool>
         </property>
        </widget>
       </item>
       <item row="2" column="1">
        <widget class="QmitkSliderNavigatorWidget" name="sliceNavigatorTime" native="true">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="toolTip">
          <string>Output image will be 3D</string>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
-   <item row="2" column="0">
-    <widget class="QGroupBox" name="gbTwoImageOps">
-     <property name="enabled">
-      <bool>true</bool>
-     </property>
-     <property name="title">
-      <string/>
-     </property>
-     <property name="checked">
-      <bool>false</bool>
-     </property>
-     <layout class="QGridLayout" name="gridLayout_2">
-      <item row="2" column="0" colspan="2">
-       <widget class="QLabel" name="tlImage2">
-        <property name="enabled">
-         <bool>false</bool>
-        </property>
-        <property name="text">
-         <string>Select second image:</string>
-        </property>
-        <property name="wordWrap">
-         <bool>false</bool>
-        </property>
-        <property name="buddy">
-         <cstring>m_ImageSelector2</cstring>
-        </property>
-       </widget>
-      </item>
-      <item row="3" column="0" colspan="3">
-       <widget class="QmitkDataStorageComboBox" name="m_ImageSelector2">
-        <property name="enabled">
-         <bool>false</bool>
-        </property>
-       </widget>
-      </item>
-      <item row="6" column="0" colspan="3">
-       <widget class="QPushButton" name="btnDoIt2">
-        <property name="enabled">
-         <bool>false</bool>
-        </property>
-        <property name="text">
-         <string>E&amp;xecute</string>
-        </property>
-       </widget>
-      </item>
-      <item row="0" column="0">
-       <widget class="QLabel" name="tlWhat2">
-        <property name="enabled">
-         <bool>false</bool>
-        </property>
-        <property name="text">
-         <string>Select an operation:</string>
-        </property>
-        <property name="wordWrap">
-         <bool>false</bool>
-        </property>
-        <property name="buddy">
-         <cstring>cbWhat2</cstring>
-        </property>
-       </widget>
-      </item>
-      <item row="1" column="0" colspan="3">
-       <widget class="QComboBox" name="cbWhat2">
-        <property name="enabled">
-         <bool>false</bool>
-        </property>
-       </widget>
-      </item>
-     </layout>
-    </widget>
-   </item>
-   <item row="3" column="0">
-    <spacer name="verticalSpacer">
-     <property name="orientation">
-      <enum>Qt::Vertical</enum>
-     </property>
-     <property name="sizeHint" stdset="0">
-      <size>
-       <width>254</width>
-       <height>403</height>
-      </size>
-     </property>
-    </spacer>
-   </item>
    <item row="1" column="0">
     <widget class="QGroupBox" name="gbOneImageOps">
-     <property name="title">
-      <string/>
-     </property>
      <layout class="QGridLayout" name="gridLayout">
       <item row="0" column="0" colspan="3">
        <widget class="QLabel" name="tlWhat1">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="text">
          <string>Select an operation:</string>
         </property>
         <property name="wordWrap">
          <bool>false</bool>
         </property>
         <property name="buddy">
          <cstring>cbWhat1</cstring>
         </property>
        </widget>
       </item>
       <item row="1" column="0" colspan="3">
        <widget class="QComboBox" name="cbWhat1">
         <property name="enabled">
          <bool>false</bool>
         </property>
        </widget>
       </item>
       <item row="2" column="0" colspan="3">
        <widget class="QLabel" name="tlParam">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="text">
          <string>... and parameters:</string>
         </property>
         <property name="wordWrap">
          <bool>false</bool>
         </property>
        </widget>
       </item>
       <item row="3" column="0">
        <widget class="QLabel" name="tlParam1">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="text">
          <string>Parameter 1:</string>
         </property>
         <property name="wordWrap">
          <bool>false</bool>
         </property>
         <property name="buddy">
          <cstring>sbParam1</cstring>
         </property>
        </widget>
       </item>
-      <item row="4" column="0">
-       <widget class="QLabel" name="tlParam2">
+      <item row="3" column="1">
+       <widget class="QSpinBox" name="sbParam1">
         <property name="enabled">
          <bool>false</bool>
         </property>
-        <property name="text">
-         <string>Parameter 2:</string>
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
         </property>
-        <property name="wordWrap">
-         <bool>false</bool>
+        <property name="minimum">
+         <number>-999999999</number>
         </property>
-        <property name="buddy">
-         <cstring>sbParam2</cstring>
+        <property name="maximum">
+         <number>999999999</number>
         </property>
        </widget>
       </item>
-      <item row="8" column="0" colspan="3">
-       <widget class="QPushButton" name="btnDoIt">
+      <item row="3" column="2">
+       <widget class="QDoubleSpinBox" name="dsbParam1">
         <property name="enabled">
          <bool>false</bool>
         </property>
-        <property name="text">
-         <string>&amp;Execute</string>
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
         </property>
-       </widget>
-      </item>
-      <item row="7" column="0">
-       <widget class="QCheckBox" name="cbHideOrig">
-        <property name="enabled">
-         <bool>false</bool>
+        <property name="decimals">
+         <number>4</number>
         </property>
-        <property name="text">
-         <string>Hide Original Image</string>
+        <property name="minimum">
+         <double>-999999999.000000000000000</double>
         </property>
-        <property name="checked">
-         <bool>true</bool>
+        <property name="maximum">
+         <double>999999999.000000000000000</double>
         </property>
        </widget>
       </item>
-      <item row="5" column="0">
-       <widget class="QLabel" name="tlParam3">
+      <item row="4" column="0">
+       <widget class="QLabel" name="tlParam2">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="text">
-         <string>Parameter 3:</string>
+         <string>Parameter 2:</string>
         </property>
-       </widget>
-      </item>
-      <item row="6" column="0">
-       <widget class="QLabel" name="tlParam4">
-        <property name="enabled">
+        <property name="wordWrap">
          <bool>false</bool>
         </property>
-        <property name="text">
-         <string>Parameter 4:</string>
+        <property name="buddy">
+         <cstring>sbParam2</cstring>
         </property>
        </widget>
       </item>
-      <item row="6" column="2">
-       <widget class="QComboBox" name="cbParam4">
+      <item row="4" column="1">
+       <widget class="QSpinBox" name="sbParam2">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="sizePolicy">
          <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
+        <property name="minimum">
+         <number>-999999999</number>
+        </property>
+        <property name="maximum">
+         <number>999999999</number>
+        </property>
        </widget>
       </item>
-      <item row="5" column="2">
-       <widget class="QDoubleSpinBox" name="dsbParam3">
+      <item row="4" column="2">
+       <widget class="QDoubleSpinBox" name="dsbParam2">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="sizePolicy">
          <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
-        <property name="layoutDirection">
-         <enum>Qt::LeftToRight</enum>
-        </property>
-        <property name="alignment">
-         <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter</set>
-        </property>
         <property name="decimals">
          <number>4</number>
         </property>
         <property name="minimum">
          <double>-999999999.000000000000000</double>
         </property>
         <property name="maximum">
          <double>999999999.000000000000000</double>
         </property>
        </widget>
       </item>
-      <item row="4" column="2">
-       <widget class="QDoubleSpinBox" name="dsbParam2">
+      <item row="5" column="0">
+       <widget class="QLabel" name="tlParam3">
+        <property name="enabled">
+         <bool>false</bool>
+        </property>
+        <property name="text">
+         <string>Parameter 3:</string>
+        </property>
+       </widget>
+      </item>
+      <item row="5" column="2">
+       <widget class="QDoubleSpinBox" name="dsbParam3">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="sizePolicy">
          <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
+        <property name="layoutDirection">
+         <enum>Qt::LeftToRight</enum>
+        </property>
+        <property name="alignment">
+         <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter</set>
+        </property>
         <property name="decimals">
          <number>4</number>
         </property>
         <property name="minimum">
          <double>-999999999.000000000000000</double>
         </property>
         <property name="maximum">
          <double>999999999.000000000000000</double>
         </property>
        </widget>
       </item>
-      <item row="3" column="2">
-       <widget class="QDoubleSpinBox" name="dsbParam1">
+      <item row="6" column="0">
+       <widget class="QLabel" name="tlParam4">
+        <property name="enabled">
+         <bool>false</bool>
+        </property>
+        <property name="text">
+         <string>Parameter 4:</string>
+        </property>
+       </widget>
+      </item>
+      <item row="6" column="2">
+       <widget class="QComboBox" name="cbParam4">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="sizePolicy">
          <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
-        <property name="decimals">
-         <number>4</number>
+       </widget>
+      </item>
+      <item row="7" column="0">
+       <widget class="QCheckBox" name="cbHideOrig">
+        <property name="enabled">
+         <bool>false</bool>
         </property>
-        <property name="minimum">
-         <double>-999999999.000000000000000</double>
+        <property name="text">
+         <string>Hide Original Image</string>
         </property>
-        <property name="maximum">
-         <double>999999999.000000000000000</double>
+        <property name="checked">
+         <bool>true</bool>
         </property>
        </widget>
       </item>
-      <item row="3" column="1">
-       <widget class="QSpinBox" name="sbParam1">
+      <item row="8" column="0" colspan="3">
+       <widget class="QPushButton" name="btnDoIt">
         <property name="enabled">
          <bool>false</bool>
         </property>
-        <property name="sizePolicy">
-         <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
-          <horstretch>0</horstretch>
-          <verstretch>0</verstretch>
-         </sizepolicy>
+        <property name="text">
+         <string>&amp;Execute</string>
         </property>
-        <property name="minimum">
-         <number>-999999999</number>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item row="2" column="0">
+    <widget class="QGroupBox" name="gbTwoImageOps">
+     <property name="enabled">
+      <bool>true</bool>
+     </property>
+     <property name="checked">
+      <bool>false</bool>
+     </property>
+     <layout class="QGridLayout" name="gridLayout_2">
+      <item row="0" column="0">
+       <widget class="QLabel" name="tlWhat2">
+        <property name="enabled">
+         <bool>false</bool>
         </property>
-        <property name="maximum">
-         <number>999999999</number>
+        <property name="text">
+         <string>Select an operation:</string>
+        </property>
+        <property name="wordWrap">
+         <bool>false</bool>
+        </property>
+        <property name="buddy">
+         <cstring>cbWhat2</cstring>
         </property>
        </widget>
       </item>
-      <item row="4" column="1">
-       <widget class="QSpinBox" name="sbParam2">
+      <item row="1" column="0" colspan="2">
+       <widget class="QComboBox" name="cbWhat2">
         <property name="enabled">
          <bool>false</bool>
         </property>
-        <property name="sizePolicy">
-         <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
+       </widget>
+      </item>
+      <item row="2" column="0">
+       <widget class="QLabel" name="selectedImageLabel_2">
+	    <property name="sizePolicy">
+         <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
-        <property name="minimum">
-         <number>-999999999</number>
+        <property name="enabled">
+         <bool>false</bool>
         </property>
-        <property name="maximum">
-         <number>999999999</number>
+        <property name="text">
+         <string>Selected second image</string>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="1">
+       <widget class="QmitkSingleNodeSelectionWidget" name="selectedImageWidget_2" native="true">
+	    <property name="sizePolicy">
+         <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="enabled">
+         <bool>false</bool>
+        </property>
+        <property name="minimumSize">
+         <size>
+          <width>0</width>
+          <height>40</height>
+         </size>
+        </property>
+       </widget>
+      </item>
+      <item row="3" column="0" colspan="2">
+       <widget class="QPushButton" name="btnDoIt2">
+        <property name="enabled">
+         <bool>false</bool>
+        </property>
+        <property name="text">
+         <string>E&amp;xecute</string>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
+   <item row="3" column="0">
+    <spacer name="verticalSpacer">
+     <property name="orientation">
+      <enum>Qt::Vertical</enum>
+     </property>
+     <property name="sizeHint" stdset="0">
+      <size>
+       <width>254</width>
+       <height>403</height>
+      </size>
+     </property>
+    </spacer>
+   </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
-   <class>QmitkDataStorageComboBox</class>
-   <extends>QComboBox</extends>
-   <header location="global">QmitkDataStorageComboBox.h</header>
+   <class>QmitkSingleNodeSelectionWidget</class>
+   <extends>QWidget</extends>
+   <header location="global">QmitkSingleNodeSelectionWidget.h</header>
   </customwidget>
   <customwidget>
    <class>QmitkSliderNavigatorWidget</class>
    <extends>QWidget</extends>
    <header location="global">QmitkSliderNavigatorWidget.h</header>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>