diff --git a/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropper.cpp b/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropper.cpp
index c197561f27..e66da61a9b 100644
--- a/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropper.cpp
+++ b/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropper.cpp
@@ -1,510 +1,508 @@
 /*============================================================================
 
 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 "QmitkImageCropper.h"
 
 #include <mitkBoundingShapeCropper.h>
 #include <mitkDisplayInteractor.h>
 #include <mitkImageStatisticsHolder.h>
 #include <mitkInteractionConst.h>
 #include <mitkITKImageImport.h>
 #include <mitkLabelSetImage.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateFunction.h>
 #include <mitkRenderingManager.h>
 
 #include <usModuleRegistry.h>
 
 #include <QMessageBox>
 
 const std::string QmitkImageCropper::VIEW_ID = "org.mitk.views.qmitkimagecropper";
 
 QmitkImageCropper::QmitkImageCropper(QObject *)
   : m_ParentWidget(nullptr),
   m_ImageNode(nullptr),
   m_BoundingBox(nullptr),
   m_BoundingBoxNode(nullptr),
   m_BoundingShapeInteractor(nullptr),
-  m_CropOutsideValue(0),
-  m_Active(0),
-  m_ScrollEnabled(true)
+  m_CropOutsideValue(0)
 {
   CreateBoundingShapeInteractor(false);
 }
 
 QmitkImageCropper::~QmitkImageCropper()
 {
   //delete pointer objects
   m_BoundingBoxNode = nullptr;
   m_BoundingBox = nullptr;
 
   //disable interactor
   if (m_BoundingShapeInteractor != nullptr)
   {
     m_BoundingShapeInteractor->SetDataNode(nullptr);
     m_BoundingShapeInteractor->EnableInteraction(false);
   }
 }
 
 void QmitkImageCropper::CreateQtPartControl(QWidget *parent)
 {
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi(parent);
 
   m_Controls.imageSelectionWidget->SetDataStorage(GetDataStorage());
   m_Controls.imageSelectionWidget->SetNodePredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object")));
   m_Controls.imageSelectionWidget->SetSelectionIsOptional(true);
   m_Controls.imageSelectionWidget->SetEmptyInfo(QString("Please select an image node"));
   m_Controls.imageSelectionWidget->SetPopUpTitel(QString("Select image node"));
 
   connect(m_Controls.imageSelectionWidget, &QmitkSingleNodeSelectionWidget::CurrentSelectionChanged,
     this, &QmitkImageCropper::OnImageSelectionChanged);
 
   m_Controls.boundingBoxSelectionWidget->SetDataStorage(GetDataStorage());
   m_Controls.boundingBoxSelectionWidget->SetNodePredicate(mitk::NodePredicateAnd::New(
     mitk::TNodePredicateDataType<mitk::GeometryData>::New(),
     mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object"))));
   m_Controls.boundingBoxSelectionWidget->SetSelectionIsOptional(true);
   m_Controls.boundingBoxSelectionWidget->SetEmptyInfo(QString("Please select a bounding box"));
   m_Controls.boundingBoxSelectionWidget->SetPopUpTitel(QString("Select bounding box node"));
 
   connect(m_Controls.boundingBoxSelectionWidget, &QmitkSingleNodeSelectionWidget::CurrentSelectionChanged,
     this, &QmitkImageCropper::OnBoundingBoxSelectionChanged);
 
   connect(m_Controls.buttonCreateNewBoundingBox, SIGNAL(clicked()), this, SLOT(DoCreateNewBoundingObject()));
   connect(m_Controls.buttonCropping, SIGNAL(clicked()), this, SLOT(DoCropping()));
   connect(m_Controls.buttonMasking, SIGNAL(clicked()), this, SLOT(DoMasking()));
   connect(m_Controls.buttonAdvancedSettings, &ctkExpandButton::clicked,
     this, [this]()
   {
     m_Controls.groupImageSettings->setVisible(!m_Controls.groupImageSettings->isVisible());
   });
 
   connect(m_Controls.spinBoxOutsidePixelValue, SIGNAL(valueChanged(int)), this, SLOT(OnSliderValueChanged(int)));
 
   SetDefaultGUI();
 
   m_ParentWidget = parent;
 }
 
 void QmitkImageCropper::OnBoundingBoxSelectionChanged(QList<mitk::DataNode::Pointer> nodes)
 {
   if (nodes.empty() || nodes.front().IsNull())
   {
     m_BoundingBoxNode = nullptr;
     m_BoundingBox = nullptr;
     SetDefaultGUI();
 
     m_BoundingShapeInteractor->EnableInteraction(false);
     m_BoundingShapeInteractor->SetDataNode(nullptr);
     return;
   }
 
   auto boundingBoxNode = m_BoundingBoxNode.Lock();
   if (nodes.front() == boundingBoxNode)
   {
     // node already selected, nothing to change
     return;
   }
 
   m_BoundingBox = dynamic_cast<mitk::GeometryData*>(nodes.front()->GetData());
   if (nullptr != m_BoundingBox)
   {
     // node newly selected
     m_BoundingBoxNode = nodes.front();
     boundingBoxNode = m_BoundingBoxNode.Lock();
     boundingBoxNode->SetVisibility(true);
 
     m_BoundingShapeInteractor->EnableInteraction(true);
     m_BoundingShapeInteractor->SetDataNode(boundingBoxNode);
 
     mitk::RenderingManager::GetInstance()->InitializeViews();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
     auto imageNode = m_ImageNode.Lock();
     if (imageNode.IsNotNull())
     {
       m_Controls.buttonCropping->setEnabled(true);
       m_Controls.buttonMasking->setEnabled(true);
       m_Controls.buttonAdvancedSettings->setEnabled(true);
       m_Controls.groupImageSettings->setEnabled(true);
     }
   }
 }
 
 void QmitkImageCropper::CreateBoundingShapeInteractor(bool rotationEnabled)
 {
   if (m_BoundingShapeInteractor.IsNull())
   {
     m_BoundingShapeInteractor = mitk::BoundingShapeInteractor::New();
     m_BoundingShapeInteractor->LoadStateMachine("BoundingShapeInteraction.xml", us::ModuleRegistry::GetModule("MitkBoundingShape"));
     m_BoundingShapeInteractor->SetEventConfig("BoundingShapeMouseConfig.xml", us::ModuleRegistry::GetModule("MitkBoundingShape"));
   }
   m_BoundingShapeInteractor->SetRotationEnabled(rotationEnabled);
 }
 
 mitk::Geometry3D::Pointer QmitkImageCropper::InitializeWithImageGeometry(mitk::BaseGeometry::Pointer geometry)
 {
   // convert a BaseGeometry into a Geometry3D (otherwise IO is not working properly)
   if (geometry == nullptr)
     mitkThrow() << "Geometry is not valid.";
 
   auto boundingGeometry = mitk::Geometry3D::New();
   boundingGeometry->SetBounds(geometry->GetBounds());
   boundingGeometry->SetImageGeometry(geometry->GetImageGeometry());
   boundingGeometry->SetOrigin(geometry->GetOrigin());
   boundingGeometry->SetSpacing(geometry->GetSpacing());
   boundingGeometry->SetIndexToWorldTransform(geometry->GetIndexToWorldTransform());
   boundingGeometry->Modified();
   return boundingGeometry;
 }
 
 void QmitkImageCropper::DoCreateNewBoundingObject()
 {
   if (m_ImageNode.IsExpired())
   {
     return;
   }
 
   auto imageNode = m_ImageNode.Lock();
   QString name = QString::fromStdString(imageNode->GetName() + " Bounding Shape");
 
   auto boundingShape = this->GetDataStorage()->GetNode(mitk::NodePredicateFunction::New([&name](const mitk::DataNode *node)
   {
     return 0 == node->GetName().compare(name.toStdString());
   }));
 
   if (nullptr != boundingShape)
   {
     name = this->AdaptBoundingObjectName(name);
   }
 
   // get current timestep to support 3d+t images
   auto renderWindowPart = this->GetRenderWindowPart(mitk::WorkbenchUtil::IRenderWindowPartStrategy::OPEN);
   int timeStep = renderWindowPart->GetTimeNavigationController()->GetTime()->GetPos();
   auto imageGeometry = static_cast<mitk::BaseGeometry*>(imageNode->GetData()->GetGeometry(timeStep));
 
   auto boundingBox = mitk::GeometryData::New();
   boundingBox->SetGeometry(static_cast<mitk::Geometry3D*>(this->InitializeWithImageGeometry(imageGeometry)));
   auto boundingBoxNode = mitk::DataNode::New();
   boundingBoxNode->SetData(boundingBox);
   boundingBoxNode->SetProperty("name", mitk::StringProperty::New(name.toStdString()));
   boundingBoxNode->SetProperty("color", mitk::ColorProperty::New(1.0, 1.0, 1.0));
   boundingBoxNode->SetProperty("opacity", mitk::FloatProperty::New(0.6));
   boundingBoxNode->SetProperty("layer", mitk::IntProperty::New(99));
   boundingBoxNode->AddProperty("handle size factor", mitk::DoubleProperty::New(1.0 / 40.0));
   boundingBoxNode->SetBoolProperty("pickable", true);
 
   if (!this->GetDataStorage()->Exists(boundingBoxNode))
   {
     GetDataStorage()->Add(boundingBoxNode, imageNode);
   }
 
   m_Controls.boundingBoxSelectionWidget->SetCurrentSelectedNode(boundingBoxNode);
 }
 
 void QmitkImageCropper::OnImageSelectionChanged(QList<mitk::DataNode::Pointer> nodes)
 {
   bool rotationEnabled = false;
   if (nodes.empty() || nodes.front().IsNull())
   {
     m_ImageNode = nullptr;
     SetDefaultGUI();
     return;
   }
 
   auto imageNode = m_ImageNode.Lock();
   if (nodes.front() == imageNode)
   {
     // node already selected, nothing to change
     return;
   }
 
   auto image = dynamic_cast<mitk::Image*>(nodes.front()->GetData());
   if (nullptr != image)
   {
     if (image->GetDimension() < 3)
     {
       QMessageBox::warning(nullptr,
         tr("Invalid image selected"),
         tr("ImageCropper only works with 3 or more dimensions."),
         QMessageBox::Ok, QMessageBox::NoButton, QMessageBox::NoButton);
       SetDefaultGUI();
       return;
     }
 
     // node newly selected
     m_ImageNode = nodes.front();
 
     m_ParentWidget->setEnabled(true);
     m_Controls.buttonCreateNewBoundingBox->setEnabled(true);
 
     vtkSmartPointer<vtkMatrix4x4> imageMat = image->GetGeometry()->GetVtkMatrix();
     // check whether the image geometry is rotated; if so, no pixel aligned cropping or masking can be performed
     if ((imageMat->GetElement(1, 0) == 0.0) && (imageMat->GetElement(0, 1) == 0.0) &&
       (imageMat->GetElement(1, 2) == 0.0) && (imageMat->GetElement(2, 1) == 0.0) &&
       (imageMat->GetElement(2, 0) == 0.0) && (imageMat->GetElement(0, 2) == 0.0))
     {
       rotationEnabled = false;
       m_Controls.labelWarningRotation->setVisible(false);
     }
     else
     {
       rotationEnabled = true;
       m_Controls.labelWarningRotation->setStyleSheet(" QLabel { color: rgb(255, 0, 0) }");
       m_Controls.labelWarningRotation->setVisible(true);
     }
 
     this->CreateBoundingShapeInteractor(rotationEnabled);
 
     if (itk::ImageIOBase::SCALAR == image->GetPixelType().GetPixelType())
     {
       // Might be changed with the upcoming new image statistics plugin
       //(recomputation might be very expensive for large images ;) )
       auto statistics = image->GetStatistics();
       auto minPixelValue = statistics->GetScalarValueMin();
       auto maxPixelValue = statistics->GetScalarValueMax();
 
       if (minPixelValue < std::numeric_limits<int>::min())
       {
         minPixelValue = std::numeric_limits<int>::min();
       }
       if (maxPixelValue > std::numeric_limits<int>::max())
       {
         maxPixelValue = std::numeric_limits<int>::max();
       }
 
       m_Controls.spinBoxOutsidePixelValue->setEnabled(true);
       m_Controls.spinBoxOutsidePixelValue->setMaximum(static_cast<int>(maxPixelValue));
       m_Controls.spinBoxOutsidePixelValue->setMinimum(static_cast<int>(minPixelValue));
       m_Controls.spinBoxOutsidePixelValue->setValue(static_cast<int>(minPixelValue));
     }
     else
     {
       m_Controls.spinBoxOutsidePixelValue->setEnabled(false);
     }
 
     unsigned int dim = image->GetDimension();
     if (dim < 2 || dim > 4)
     {
       m_ParentWidget->setEnabled(false);
     }
 
     auto boundingBoxNode = m_BoundingBoxNode.Lock();
     if (boundingBoxNode.IsNotNull())
     {
       m_Controls.buttonCropping->setEnabled(true);
       m_Controls.buttonMasking->setEnabled(true);
       m_Controls.buttonAdvancedSettings->setEnabled(true);
       m_Controls.groupImageSettings->setEnabled(true);
     }
   }
 }
 
 void QmitkImageCropper::OnSliderValueChanged(int slidervalue)
 {
   m_CropOutsideValue = slidervalue;
 }
 
 void QmitkImageCropper::DoMasking()
 {
   this->ProcessImage(true);
 }
 
 void QmitkImageCropper::DoCropping()
 {
   this->ProcessImage(false);
 }
 
 void QmitkImageCropper::ProcessImage(bool mask)
 {
   auto renderWindowPart = this->GetRenderWindowPart(mitk::WorkbenchUtil::IRenderWindowPartStrategy::OPEN);
   int timeStep = renderWindowPart->GetTimeNavigationController()->GetTime()->GetPos();
 
   auto imageNode = m_ImageNode.Lock();
   if (imageNode.IsNull())
   {
     QMessageBox::information(nullptr, "Warning", "Please load and select an image before starting image processing.");
     return;
   }
 
   auto boundingBoxNode = m_BoundingBoxNode.Lock();
   if (boundingBoxNode.IsNull())
   {
     QMessageBox::information(nullptr, "Warning", "Please load and select a cropping object before starting image processing.");
     return;
   }
 
   mitk::BaseData* image = imageNode->GetData();
   if (nullptr != image)
   {
     QString imageName;
     if (mask)
     {
       imageName = QString::fromStdString(imageNode->GetName() + "_" + boundingBoxNode->GetName() + "_masked");
     }
     else
     {
       imageName = QString::fromStdString(imageNode->GetName() + "_" + boundingBoxNode->GetName() + "_cropped");
     }
 
     if (m_Controls.checkBoxCropTimeStepOnly->isChecked())
     {
       imageName = imageName + "_T" + QString::number(timeStep);
     }
 
     // image and bounding shape ok, set as input
     auto croppedImageNode = mitk::DataNode::New();
     auto cutter = mitk::BoundingShapeCropper::New();
     cutter->SetGeometry(m_BoundingBox);
 
     // adjustable in advanced settings
     cutter->SetUseWholeInputRegion(mask); //either mask (mask=true) or crop (mask=false)
     cutter->SetOutsideValue(m_CropOutsideValue);
     cutter->SetUseCropTimeStepOnly(m_Controls.checkBoxCropTimeStepOnly->isChecked());
     cutter->SetCurrentTimeStep(timeStep);
 
     // TODO: Add support for MultiLayer (right now only Mulitlabel support)
     auto labelsetImageInput = dynamic_cast<mitk::LabelSetImage*>(image);
     if (nullptr != labelsetImageInput)
     {
       cutter->SetInput(labelsetImageInput);
       // do the actual cutting
       try
       {
         cutter->Update();
       }
       catch (const itk::ExceptionObject& e)
       {
         std::string message = std::string("The Cropping filter could not process because of: \n ") + e.GetDescription();
         QMessageBox::warning(nullptr, tr("Cropping not possible!"), tr(message.c_str()),
           QMessageBox::Ok, QMessageBox::NoButton, QMessageBox::NoButton);
         return;
       }
 
       auto labelSetImage = mitk::LabelSetImage::New();
       labelSetImage->InitializeByLabeledImage(cutter->GetOutput());
 
       for (unsigned int i = 0; i < labelsetImageInput->GetNumberOfLayers(); i++)
       {
         labelSetImage->AddLabelSetToLayer(i, labelsetImageInput->GetLabelSet(i));
       }
 
       croppedImageNode->SetData(labelSetImage);
       croppedImageNode->SetProperty("name", mitk::StringProperty::New(imageName.toStdString()));
 
       //add cropping result to the current data storage as child node to the image node
       if (!m_Controls.checkOverwriteImage->isChecked())
       {
         if (!this->GetDataStorage()->Exists(croppedImageNode))
         {
           this->GetDataStorage()->Add(croppedImageNode, m_ImageNode.Lock());
         }
       }
       else // original image will be overwritten by the result image and the bounding box of the result is adjusted
       {
         imageNode->SetData(labelSetImage);
         imageNode->Modified();
         // Adjust coordinate system by doing a reinit on
         auto tempDataStorage = mitk::DataStorage::SetOfObjects::New();
         tempDataStorage->InsertElement(0, imageNode);
 
         // initialize the views to the bounding geometry
         auto bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(tempDataStorage);
         mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
       }
     }
     else
     {
       auto imageInput = dynamic_cast<mitk::Image*>(image);
       if (nullptr != imageInput)
       {
         cutter->SetInput(imageInput);
         // do the actual cutting
         try
         {
           cutter->Update();
         }
         catch (const itk::ExceptionObject& e)
         {
           std::string message = std::string("The Cropping filter could not process because of: \n ") + e.GetDescription();
           QMessageBox::warning(nullptr, tr("Cropping not possible!"), tr(message.c_str()),
             QMessageBox::Ok, QMessageBox::NoButton, QMessageBox::NoButton);
           return;
         }
 
         //add cropping result to the current data storage as child node to the image node
         if (!m_Controls.checkOverwriteImage->isChecked())
         {
           croppedImageNode->SetData(cutter->GetOutput());
           croppedImageNode->SetProperty("name", mitk::StringProperty::New(imageName.toStdString()));
           croppedImageNode->SetProperty("color", mitk::ColorProperty::New(1.0, 1.0, 1.0));
           croppedImageNode->SetProperty("layer", mitk::IntProperty::New(99)); // arbitrary, copied from segmentation functionality
           if (!this->GetDataStorage()->Exists(croppedImageNode))
           {
             this->GetDataStorage()->Add(croppedImageNode, m_ImageNode.Lock());
           }
         }
         else // original image will be overwritten by the result image and the bounding box of the result is adjusted
         {
           imageNode->SetData(cutter->GetOutput());
           imageNode->Modified();
           // Adjust coordinate system by doing a reinit on
           auto tempDataStorage = mitk::DataStorage::SetOfObjects::New();
           tempDataStorage->InsertElement(0, imageNode);
 
           // initialize the views to the bounding geometry
           auto bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(tempDataStorage);
           mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
           mitk::RenderingManager::GetInstance()->RequestUpdateAll();
         }
       }
     }
   }
   else
   {
     QMessageBox::information(nullptr, "Warning", "Please load and select an image before starting image processing.");
   }
 }
 
 void QmitkImageCropper::SetDefaultGUI()
 {
   m_Controls.labelWarningRotation->setVisible(false);
   m_Controls.buttonCreateNewBoundingBox->setEnabled(false);
   m_Controls.buttonCropping->setEnabled(false);
   m_Controls.buttonMasking->setEnabled(false);
   m_Controls.buttonAdvancedSettings->setEnabled(false);
   m_Controls.groupImageSettings->setEnabled(false);
   m_Controls.groupImageSettings->setVisible(false);
   m_Controls.checkOverwriteImage->setChecked(false);
   m_Controls.checkBoxCropTimeStepOnly->setChecked(false);
 }
 
 QString QmitkImageCropper::AdaptBoundingObjectName(const QString& name) const
 {
   unsigned int counter = 2;
   QString newName = QString("%1 %2").arg(name).arg(counter);
 
   while (nullptr != this->GetDataStorage()->GetNode(mitk::NodePredicateFunction::New([&newName](const mitk::DataNode *node)
   {
     return 0 == node->GetName().compare(newName.toStdString());
   })))
   {
     newName = QString("%1 %2").arg(name).arg(++counter);
   }
 
   return newName;
 }
diff --git a/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropper.h b/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropper.h
index 77165871f1..3d815103e0 100644
--- a/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropper.h
+++ b/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropper.h
@@ -1,110 +1,107 @@
 /*============================================================================
 
 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 QmitkImageCropper_h
 #define QmitkImageCropper_h
 
 #include <QmitkAbstractView.h>
 
 #include <mitkBoundingShapeInteractor.h>
 #include <mitkWeakPointer.h>
 
 #include "ui_QmitkImageCropperViewControls.h"
 
 class QmitkImageCropper : public QmitkAbstractView
 {
 
   Q_OBJECT
 
 public:
 
   QmitkImageCropper(QObject *parent = nullptr);
 
   ~QmitkImageCropper() override;
 
   static const std::string VIEW_ID;
 
   void CreateQtPartControl(QWidget *parent) override;
 
   void SetFocus() override { };
 
 protected Q_SLOTS:
   /*!
   * @brief Creates a new bounding object
   */
   virtual void DoCreateNewBoundingObject();
   /*!
   * @brief Whenever Crop button is pressed, issue a cropping action
   */
   void DoCropping();
   /*!
   * @brief Whenever Mask button is pressed, issue a masking action
   */
   void DoMasking();
   /*!
   * @brief Updates current selection of the bounding object
   */
   void OnBoundingBoxSelectionChanged(QList<mitk::DataNode::Pointer> nodes);
   /*!
   * @brief Sets the scalar value for outside pixels in case of masking
   */
   void OnSliderValueChanged(int slidervalue);
 
 protected:
 
   void OnImageSelectionChanged(QList<mitk::DataNode::Pointer> nodes);
   /*!
   * @brief Initializes a new bounding shape using the selected image geometry.
   */
   mitk::Geometry3D::Pointer InitializeWithImageGeometry(mitk::BaseGeometry::Pointer geometry);
 
   void CreateBoundingShapeInteractor(bool rotationEnabled);
 
 private:
 
   QWidget* m_ParentWidget;
   /*!
   * @brief A pointer to the node of the image to be cropped.
   */
   mitk::WeakPointer<mitk::DataNode> m_ImageNode;
   /*!
   * @brief A pointer to the node of the bounding box used for cropping.
   */
   mitk::WeakPointer<mitk::DataNode> m_BoundingBoxNode;
   /*!
   * @brief The cuboid used for cropping.
   */
   mitk::GeometryData::Pointer m_BoundingBox;
   /*!
   * @brief Interactor for moving and scaling the cuboid
   */
   mitk::BoundingShapeInteractor::Pointer m_BoundingShapeInteractor;
 
   void ProcessImage(bool crop);
 
   /*!
   * @brief Resets GUI to default
   */
   void SetDefaultGUI();
 
   QString AdaptBoundingObjectName(const QString& name) const;
 
   // cropping parameter
   mitk::ScalarType m_CropOutsideValue;
-  bool m_Advanced;
-  bool m_Active;
-  bool m_ScrollEnabled;
 
   Ui::QmitkImageCropperViewControls m_Controls;
 };
 
 #endif // QmitkImageCropper_h