diff --git a/Plugins/org.mitk.gui.qt.regiongrowing/src/internal/QmitkRegionGrowingView.cpp b/Plugins/org.mitk.gui.qt.regiongrowing/src/internal/QmitkRegionGrowingView.cpp
index c17bf491fc..eb4d055aeb 100644
--- a/Plugins/org.mitk.gui.qt.regiongrowing/src/internal/QmitkRegionGrowingView.cpp
+++ b/Plugins/org.mitk.gui.qt.regiongrowing/src/internal/QmitkRegionGrowingView.cpp
@@ -1,363 +1,363 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkRegionGrowingView.h"
 
 //! [cpp-includes]
 // Qmitk
 #include "QmitkPointListWidget.h"
 #include "QmitkRenderWindow.h"
 
 // MITK
 #include "mitkColorProperty.h"
 #include "mitkITKImageImport.h"
 #include "mitkImageAccessByItk.h"
 #include "mitkImageCast.h"
 #include "mitkProperties.h"
 
 // ITK
 #include <itkConnectedThresholdImageFilter.h>
 //! [cpp-includes]
 
 // Qt
 #include <QMessageBox>
 
 #include "MitkRegionIterator.h"
 
 const std::string QmitkRegionGrowingView::VIEW_ID = "org.mitk.views.example.regiongrowing";
 
 QmitkRegionGrowingView::QmitkRegionGrowingView() : m_PointListWidget(NULL), m_ThresholdMethod(ThresholdMethod::easy)
 {
 }
 
 void QmitkRegionGrowingView::SetFocus()
 {
   m_Controls->buttonPerformImageProcessing->setFocus();
 }
 
 void QmitkRegionGrowingView::CreateQtPartControl(QWidget *parent)
 {
   m_Controls = new Ui::QmitkRegionGrowingViewControls;
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls->setupUi(parent);
 
   //add different methods for threshold determination
   m_Controls->comboBoxThresholdMethod->addItem("easy");
   m_Controls->comboBoxThresholdMethod->addItem("mean");
   m_Controls->comboBoxThresholdMethod->addItem("stddiv");
 
   connect(m_Controls->buttonPerformImageProcessing, SIGNAL(clicked()), this, SLOT(DoImageProcessing()));
   connect(m_Controls->checkBoxCustomRange, SIGNAL(clicked(bool)), this, SLOT(UseCustomRange(bool)));
   connect(m_Controls->pushButtonClearPointList, SIGNAL(clicked()), this, SLOT(ClearPointSet()));
   connect(m_Controls->comboBoxThresholdMethod, SIGNAL(currentIndexChanged(int)), this, SLOT(SetThresholdMethod(int)));
   
   //! [cpp-createqtpartcontrol]
   // create a QmitkPointListWidget and add it to the widget created from .ui file
   m_PointListWidget = new QmitkPointListWidget();
   m_Controls->verticalLayout->addWidget(m_PointListWidget, 1);
 
   // retrieve a possibly existing IRenderWindowPart
   if (mitk::IRenderWindowPart *renderWindowPart = GetRenderWindowPart())
   {
     // let the point set widget know about the render window part (crosshair updates)
     RenderWindowPartActivated(renderWindowPart);
   }
 
   mitk::DataNode::Pointer pointSetNode = this->GetDataStorage()->GetNamedNode("seed points for region growing");
   m_PointSet = mitk::PointSet::New();
 
   if (pointSetNode == nullptr)
   {
     // create a new DataNode containing a PointSet with some interaction
     pointSetNode = mitk::DataNode::New();
     pointSetNode->SetData(mitk::PointSet::New());
     pointSetNode->SetName("seed points for region growing");
     //pointSetNode->SetProperty("helper object", mitk::BoolProperty::New(true));
     pointSetNode->SetProperty("layer", mitk::IntProperty::New(1024));
     pointSetNode->SetProperty("globalObject_RWM", mitk::BoolProperty::New(true));
 
     // add the pointset to the data storage (for rendering and access by other modules)
     GetDataStorage()->Add(pointSetNode);
   }
   // tell the GUI widget about the point set
   m_PointListWidget->SetPointSetNode(pointSetNode);
   //! [cpp-createqtpartcontrol]
 
   m_Controls->buttonPerformImageProcessing->setEnabled(false);
 }
 
 void QmitkRegionGrowingView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*source*/,
                                                 const QList<mitk::DataNode::Pointer> &nodes)
 {
   // iterate all selected objects, adjust warning visibility
   foreach (mitk::DataNode::Pointer node, nodes)
   {
     if (node.IsNotNull() && dynamic_cast<mitk::Image *>(node->GetData()))
     {
       m_Controls->labelWarning->setVisible(false);
       m_Controls->buttonPerformImageProcessing->setEnabled(true);
       return;
     }
   }
 
   m_Controls->labelWarning->setVisible(true);
   m_Controls->buttonPerformImageProcessing->setEnabled(false);
 }
 
 void QmitkRegionGrowingView::RenderWindowPartActivated(mitk::IRenderWindowPart *renderWindowPart)
 {
   // let the point set widget know about the slice navigation controllers
   // in the active render window part (crosshair updates)
   foreach (QmitkRenderWindow *renderWindow, renderWindowPart->GetQmitkRenderWindows().values())
   {
     m_PointListWidget->AddSliceNavigationController(renderWindow->GetSliceNavigationController());
   }
 }
 
 void QmitkRegionGrowingView::RenderWindowPartDeactivated(mitk::IRenderWindowPart *renderWindowPart)
 {
   foreach (QmitkRenderWindow *renderWindow, renderWindowPart->GetQmitkRenderWindows().values())
   {
     m_PointListWidget->RemoveSliceNavigationController(renderWindow->GetSliceNavigationController());
   }
 }
 
-void QmitkRegionGrowingView::DoImageProcessing()
+void QmitkRegionGrowingView::OnStartRegionGrowing()
 {
   QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
   if (nodes.empty())
     return;
 
   mitk::DataNode *node = nodes.front();
 
   if (!node)
   {
     // Nothing selected. Inform the user and return
     QMessageBox::information(NULL, "Template", "Please load and select an image before starting image processing.");
     return;
   }
 
   // here we have a valid mitk::DataNode
 
   // a node itself is not very useful, we need its data item (the image)
   mitk::BaseData *data = node->GetData();
   if (data)
   {
     // test if this data item is an image or not (could also be a surface or something totally different)
     mitk::Image *image = dynamic_cast<mitk::Image *>(data);
     if (image)
     {
       //! [cpp-doimageprocessing]
       // So we have an image. Let's see if the user has set some seed points already
       if (m_PointListWidget->GetPointSet()->GetSize() == 0)
       {
         // no points there. Not good for region growing
         QMessageBox::information(NULL,
                                  "Region growing functionality",
                                  "Please set some seed points inside the image first.\n"
                                  "(hold Shift key and click left mouse button inside the image.)");
         return;
       }
 
       // actually perform region growing. Here we have both an image and some seed points
       AccessByItk_1(
         image, ItkImageProcessing, image->GetGeometry()) // some magic to call the correctly templated function
       //! [cpp-doimageprocessing]
     }
   }
 }
 
-void QmitkRegionGrowingView::UseCustomRange(bool useCustomRange)
+void QmitkRegionGrowingView::OnUseCustomRange(bool useCustomRange)
 {
   m_Controls->spinBoxMax->setEnabled(useCustomRange);
   m_Controls->spinBoxMin->setEnabled(useCustomRange);
 }
 
-void QmitkRegionGrowingView::ClearPointSet()
+void QmitkRegionGrowingView::OnClearPointSet()
 {
   QMessageBox::StandardButton reply;
   reply = QMessageBox::question(nullptr, "Test", "Are you sure?", QMessageBox::Yes | QMessageBox::No, QMessageBox::No);
   if (reply == QMessageBox::Yes) {
     m_PointListWidget->GetPointSet()->Clear();
   }
   else {
     //Clearing point set canceled
   }
 }
 
 //! [cpp-itkimageaccess]
 template <typename TPixel, unsigned int VImageDimension>
 void QmitkRegionGrowingView::ItkImageProcessing(itk::Image<TPixel, VImageDimension> *itkImage,
   mitk::BaseGeometry *imageGeometry)
 {
   typedef itk::Image<TPixel, VImageDimension> InputImageType;
   typedef typename InputImageType::IndexType IndexType;
 
   // instantiate an ITK region growing filter, set its parameters
   typedef itk::ConnectedThresholdImageFilter<InputImageType, InputImageType> RegionGrowingFilterType;
   typename RegionGrowingFilterType::Pointer regionGrower = RegionGrowingFilterType::New();
   regionGrower->SetInput(itkImage); // don't forget this
 
   // determine a thresholding interval
   IndexType seedIndex;
 
   mitk::PointSet::PointsContainer *points = m_PointListWidget->GetPointSet()->GetPointSet()->GetPoints();
   for (mitk::PointSet::PointsConstIterator pointsIterator = points->Begin(); pointsIterator != points->End();
     ++pointsIterator)
   {
     // first test if this point is inside the image at all
     if (!imageGeometry->IsInside(pointsIterator.Value()))
     {
       continue;
     }
 
     TPixel min(std::numeric_limits<TPixel>::max());
     TPixel max(std::numeric_limits<TPixel>::min());
 
 
     if (m_Controls->checkBoxCustomRange->isChecked())
     {
       max = m_Controls->spinBoxMax->value();
       min = m_Controls->spinBoxMin->value();
     }
 
     // convert world coordinates to image indices
     imageGeometry->WorldToIndex(pointsIterator.Value(), seedIndex);
 
     //=================================================
 
     MitkRegionIterator<InputImageType, IndexType> mitkRegionIterator(itkImage, 1);
     int thresholdRange = 0;
     
     //=================================================
 
     // get the pixel value at this point
     TPixel currentPixelValue = itkImage->GetPixel(seedIndex);
 
     regionGrower->AddSeed(seedIndex);
     MITK_INFO << "Values between " << min << " and " << max;
 
     if (!m_Controls->checkBoxCustomRange->isChecked())
     {
       switch (m_ThresholdMethod)
       {
       case 0:
         // adjust minimum and maximum values
         if (currentPixelValue > max)
           max = currentPixelValue;
 
         if (currentPixelValue < min)
           min = currentPixelValue;
         thresholdRange = 130;
         break;
 
       case 1:
         // adjust minimum and maximum values
         if (currentPixelValue > max)
           max = currentPixelValue;
 
         if (currentPixelValue < min)
           min = currentPixelValue;
         //max = mitkRegionIterator.GetMeanPixelValueForRegion(seedIndex);
         //min = mitkRegionIterator.GetMeanPixelValueForRegion(seedIndex);
 
         mitkRegionIterator.SetRadius(3);
         thresholdRange = mitkRegionIterator.GetThresholdByMeanMethod(seedIndex);
         break;
 
       case 2:
         // adjust minimum and maximum values
         if (currentPixelValue > max)
           max = currentPixelValue;
 
         if (currentPixelValue < min)
           min = currentPixelValue; 
         //max = mitkRegionIterator.GetMeanPixelValueForRegion(seedIndex);
         //min = mitkRegionIterator.GetMeanPixelValueForRegion(seedIndex);
         regionGrower->SetConnectivity(RegionGrowingFilterType::ConnectivityEnumType::FaceConnectivity);
 
         mitkRegionIterator.SetRadius(3);
         thresholdRange = mitkRegionIterator.GetThresholdByStdDivMethod(seedIndex);
         break;
       }
       min -= thresholdRange;
       max += thresholdRange;
     }
 
     m_Controls->spinBoxMin->setValue(min);
     m_Controls->spinBoxMax->setValue(max);
 
     // set thresholds and execute filter
     regionGrower->SetLower(min);
     regionGrower->SetUpper(max);
 
     regionGrower->Update();
 
     mitk::Image::Pointer resultImage;
     mitk::CastToMitkImage(regionGrower->GetOutput(), resultImage);
     mitk::DataNode::Pointer newNode = mitk::DataNode::New();
     newNode->SetData(resultImage);
 
     // set some properties
     newNode->SetProperty("binary", mitk::BoolProperty::New(true));
     newNode->SetProperty("name", mitk::StringProperty::New("dumb segmentation"));
     newNode->SetProperty("color", mitk::ColorProperty::New(1.0, 0.0, 0.0));
     newNode->SetProperty("volumerendering", mitk::BoolProperty::New(true));
     newNode->SetProperty("layer", mitk::IntProperty::New(1));
     newNode->SetProperty("opacity", mitk::FloatProperty::New(0.5));
     newNode->SetProperty("globalObject_RWM", mitk::BoolProperty::New(true));
 
     // add result to data tree
     this->GetDataStorage()->Add(newNode);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
     regionGrower->ClearSeeds();
   }
 
   
 }
 //! [cpp-itkimageaccess]
 
-void QmitkRegionGrowingView::SetThresholdMethod(int index)
+void QmitkRegionGrowingView::OnSetThresholdMethod(int index)
 {
   int currentIndex = m_Controls->comboBoxThresholdMethod->currentIndex();
 
   switch (currentIndex)
   {
   case 0:
     m_ThresholdMethod = ThresholdMethod::easy;
     break;
 
   case 1:
     m_ThresholdMethod = ThresholdMethod::mean;
     break;
 
   case 2:
     m_ThresholdMethod = ThresholdMethod::stddiv;
     break;
 
   default:
     m_ThresholdMethod = ThresholdMethod::easy;
     break;
   }
 }
 
 
diff --git a/Plugins/org.mitk.gui.qt.regiongrowing/src/internal/QmitkRegionGrowingView.h b/Plugins/org.mitk.gui.qt.regiongrowing/src/internal/QmitkRegionGrowingView.h
index 531e3bd316..b56cdd45af 100644
--- a/Plugins/org.mitk.gui.qt.regiongrowing/src/internal/QmitkRegionGrowingView.h
+++ b/Plugins/org.mitk.gui.qt.regiongrowing/src/internal/QmitkRegionGrowingView.h
@@ -1,104 +1,104 @@
 /*===================================================================
 
 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 QmitkRegionGrowingView_h
 #define QmitkRegionGrowingView_h
 
 #include <berryISelectionListener.h>
 
 #include <QmitkAbstractView.h>
 
 #include "ui_QmitkRegionGrowingViewControls.h"
 
 //! [includes]
 #include "mitkIRenderWindowPartListener.h"
 #include "mitkPointSet.h"
 #include <itkImage.h>
 
 class QmitkPointListWidget;
 //! [includes]
 
 /**
   \brief QmitkRegionGrowingView
 
   \warning  This class is not yet documented. Use "git blame" and ask the author to provide basic documentation.
 
   \sa QmitkAbstractView
   \ingroup ${plugin_target}_internal
 */
 class QmitkRegionGrowingView : public QmitkAbstractView, public mitk::IRenderWindowPartListener
 {
   // this is needed for all Qt objects that should have a Qt meta-object
   // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
 public:
   static const std::string VIEW_ID;
 
   QmitkRegionGrowingView();
 
 protected slots:
 
   /// \brief Called when the user clicks the GUI button
-  void DoImageProcessing();
+  void OnStartRegionGrowing();
 
-  void UseCustomRange(bool useCustomRange);
+  void OnUseCustomRange(bool useCustomRange);
 
-  void ClearPointSet();
+  void OnClearPointSet();
 
-  void SetThresholdMethod(int index);
+  void OnSetThresholdMethod(int index);
 
 protected:
   virtual void CreateQtPartControl(QWidget *parent) override;
 
   virtual void SetFocus() override;
 
   virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer source,
                                   const QList<mitk::DataNode::Pointer> &nodes) override;
 
   //! [render-window-part-listener]
   void RenderWindowPartActivated(mitk::IRenderWindowPart *renderWindowPart) override;
   void RenderWindowPartDeactivated(mitk::IRenderWindowPart *renderWindowPart) override;
   //! [render-window-part-listener]
 
   Ui::QmitkRegionGrowingViewControls* m_Controls;
 
 private:
   //! [itkimageprocessing]
   /**
     \brief ITK image processing function
     This function is templated like an ITK image. The MITK-Macro AccessByItk determines the actual pixel type and
     dimensionality of
     a given MITK image and calls this function for further processing (in our case region growing)
   */
   template <typename TPixel, unsigned int VImageDimension>
   void ItkImageProcessing(itk::Image<TPixel, VImageDimension> *itkImage, mitk::BaseGeometry *imageGeometry);
   //! [itkimageprocessing]
 
   //template <typename TPixel, unsigned int VImageDimension>
   //void iterateOverNeighborhood(itk::Image<TPixel, VImageDimension> *itkImage, IndexType seedIndex, int radius);
 
   //! [members]
   /// \brief This is the actual seed point data object
   mitk::PointSet::Pointer m_PointSet;
 
   QmitkPointListWidget *m_PointListWidget;
   //! [members]
 
   enum ThresholdMethod { easy, mean, stddiv } m_ThresholdMethod;
 };
 
 #endif // QmitkRegionGrowingView_h