diff --git a/Modules/BoundingShape/src/DataManagement/mitkBoundingShapeCropper.cpp b/Modules/BoundingShape/src/DataManagement/mitkBoundingShapeCropper.cpp
index 852efff158..b69e42537e 100644
--- a/Modules/BoundingShape/src/DataManagement/mitkBoundingShapeCropper.cpp
+++ b/Modules/BoundingShape/src/DataManagement/mitkBoundingShapeCropper.cpp
@@ -1,317 +1,337 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkBoundingShapeCropper.h"
 #include "mitkGeometry3D.h"
 #include "mitkImageAccessByItk.h"
 #include "mitkImageCast.h"
 #include "mitkImageToItk.h"
 #include "mitkStatusBar.h"
 #include "mitkTimeHelper.h"
 
 #include <math.h>
 
 #include "vtkMatrix4x4.h"
 #include "vtkSmartPointer.h"
 #include "vtkTransform.h"
 
 #include "itkImageRegionIteratorWithIndex.h"
 #include <itkImageIOBase.h>
 #include <itkImageRegionConstIterator.h>
 #include <itkRGBAPixel.h>
 #include <itkRGBPixel.h>
 
 namespace mitk
 {
   BoundingShapeCropper::BoundingShapeCropper()
     : m_Geometry(nullptr),
       m_OutsideValue(0),
       m_UseCropTimeStepOnly(false),
       m_CurrentTimeStep(0),
       m_UseWholeInputRegion(false),
       m_InputTimeSelector(mitk::ImageTimeSelector::New()),
       m_OutputTimeSelector(mitk::ImageTimeSelector::New())
   {
     this->SetNumberOfIndexedInputs(2);
     this->SetNumberOfRequiredInputs(2);
   }
 
   BoundingShapeCropper::~BoundingShapeCropper() {}
+
   template <typename TPixel, unsigned int VImageDimension>
   void BoundingShapeCropper::CutImage(itk::Image<TPixel, VImageDimension> *inputItkImage, int timeStep)
   {
     MITK_INFO << "Scalar Pixeltype" << std::endl;
 
     typedef TPixel TOutputPixel;
     typedef itk::Image<TPixel, VImageDimension> ItkInputImageType;
     typedef itk::Image<TOutputPixel, VImageDimension> ItkOutputImageType;
     typedef typename itk::ImageBase<VImageDimension>::RegionType ItkRegionType;
     typedef itk::ImageRegionIteratorWithIndex<ItkInputImageType> ItkInputImageIteratorType;
     typedef itk::ImageRegionIteratorWithIndex<ItkOutputImageType> ItkOutputImageIteratorType;
 
     TOutputPixel outsideValue = this->GetOutsideValue();
     // currently 0 if not set in advance
     // TODO: change default value to itk::NumericTraits<TOutputPixel>::min();
 
     if (this->m_Geometry.IsNull())
       return;
 
     if (inputItkImage == nullptr)
     {
       mitk::StatusBar::GetInstance()->DisplayErrorText(
         "An internal error occurred. Can't convert Image. Please report to bugs@mitk.org");
       std::cout << " image is NULL...returning" << std::endl;
       return;
     }
 
     // first convert the index
     typename ItkRegionType::IndexType::IndexValueType tmpIndex[3];
     itk2vtk(this->m_InputRequestedRegion.GetIndex(), tmpIndex);
     typename ItkRegionType::IndexType index;
     index.SetIndex(tmpIndex);
 
     // then convert the size
     typename ItkRegionType::SizeType::SizeValueType tmpSize[3];
     itk2vtk(this->m_InputRequestedRegion.GetSize(), tmpSize);
     typename ItkRegionType::SizeType size;
     size.SetSize(tmpSize);
 
     // create the ITK-image-region out of index and size
     ItkRegionType inputRegionOfInterest(index, size);
 
     // Get access to the MITK output image via an ITK image
     typename mitk::ImageToItk<ItkOutputImageType>::Pointer outputimagetoitk =
       mitk::ImageToItk<ItkOutputImageType>::New();
     outputimagetoitk->SetInput(this->m_OutputTimeSelector->GetOutput());
     outputimagetoitk->Update();
     typename ItkOutputImageType::Pointer outputItkImage = outputimagetoitk->GetOutput();
 
     // create the iterators
     ItkInputImageIteratorType inputIt(inputItkImage, inputRegionOfInterest);
     ItkOutputImageIteratorType outputIt(outputItkImage, outputItkImage->GetLargestPossibleRegion());
 
     // Cut the boundingbox out of the image by iterating through all images
     // TODO: use more efficient method by using the contour instead off all single pixels
     mitk::Point3D p;
     mitk::BaseGeometry *inputGeometry = this->GetInput()->GetGeometry(timeStep);
 
     // calculates translation based on offset+extent not on the transformation matrix
     // NOTE: center of the box is
     vtkSmartPointer<vtkMatrix4x4> imageTransform = this->m_Geometry->GetGeometry()->GetVtkTransform()->GetMatrix();
     Point3D center = this->m_Geometry->GetGeometry()->GetCenter();
     auto translation = vtkSmartPointer<vtkTransform>::New();
     translation->Translate(center[0] - imageTransform->GetElement(0, 3),
                            center[1] - imageTransform->GetElement(1, 3),
                            center[2] - imageTransform->GetElement(2, 3));
     auto transform = vtkSmartPointer<vtkTransform>::New();
     transform->SetMatrix(imageTransform);
     transform->PostMultiply();
     transform->Concatenate(translation);
     transform->Update();
 
     mitk::Vector3D extent;
     for (unsigned int i = 0; i < 3; ++i)
       extent[i] = (this->m_Geometry->GetGeometry()->GetExtent(i));
 
     for (inputIt.GoToBegin(), outputIt.GoToBegin(); !inputIt.IsAtEnd(); ++inputIt, ++outputIt)
     {
       vtk2itk(inputIt.GetIndex(), p);
       inputGeometry->IndexToWorld(p, p);
       ScalarType p2[4];
       p2[0] = p[0];
       p2[1] = p[1];
       p2[2] = p[2];
       p2[3] = 1;
       // transform point from world to object coordinates
       transform->GetInverse()->TransformPoint(p2, p2);
       // check if the world point is within bounds
       bool isInside = (p2[0] >= (-extent[0] / 2.0)) && (p2[0] <= (extent[0] / 2.0)) && (p2[1] >= (-extent[1] / 2.0)) &&
                       (p2[1] <= (extent[1] / 2.0)) && (p2[2] >= (-extent[2] / 2.0)) && (p2[2] <= (extent[2] / 2.0));
 
       if ((!this->m_UseCropTimeStepOnly && isInside) ||
-          (this->m_UseCropTimeStepOnly && timeStep != this->m_CurrentTimeStep) ||
           (this->m_UseCropTimeStepOnly && timeStep == this->m_CurrentTimeStep && isInside))
       {
         outputIt.Set((TOutputPixel)inputIt.Value());
       }
       else
       {
         outputIt.Set(outsideValue);
       }
     }
   }
 
   void BoundingShapeCropper::SetGeometry(const mitk::GeometryData *geometry)
   {
     m_Geometry = const_cast<mitk::GeometryData *>(geometry);
     // Process object is not const-correct so the const_cast is required here
     this->ProcessObject::SetNthInput(1, const_cast<mitk::GeometryData *>(geometry));
   }
 
   // const mitk::GeometryData* BoundingShapeCropper::GetGeometryData() const
   //{
   // return m_Geometry.GetPointer();
   //}
 
   const mitk::PixelType BoundingShapeCropper::GetOutputPixelType() { return this->GetInput()->GetPixelType(); }
   void BoundingShapeCropper::GenerateInputRequestedRegion()
   {
     mitk::Image *output = this->GetOutput();
     if ((output->IsInitialized() == false) || (m_Geometry.IsNull()) ||
         (m_Geometry->GetTimeGeometry()->CountTimeSteps() == 0))
       return;
 
     GenerateTimeInInputRegion(output, const_cast<mitk::Image *>(this->GetInput()));
   }
 
   void BoundingShapeCropper::GenerateOutputInformation()
   {
     // Set Cropping region
     mitk::Image::Pointer output = this->GetOutput();
     if ((output->IsInitialized()) && (output->GetPipelineMTime() <= m_TimeOfHeaderInitialization.GetMTime()))
       return;
 
     mitk::Image::Pointer input = const_cast<mitk::Image *>(this->GetInput());
 
     if (input.IsNull())
     {
       mitkThrow() << "Input is not a mitk::Image";
     }
     itkDebugMacro(<< "GenerateOutputInformation()");
 
     unsigned int dimension = input->GetDimension();
     if (dimension < 3)
     {
       mitkThrow() << "ImageCropper cannot handle 1D or 2D Objects.";
     }
 
     if ((m_Geometry.IsNull()) || (m_Geometry->GetTimeGeometry()->CountTimeSteps() == 0))
       return;
 
     mitk::BaseGeometry *bsGeometry = m_Geometry->GetGeometry();
     mitk::BaseGeometry *inputImageGeometry = input->GetSlicedGeometry();
 
     // calculate bounding box
     mitk::BoundingBox::Pointer bsBoxRelativeToImage =
       bsGeometry->CalculateBoundingBoxRelativeToTransform(inputImageGeometry->GetIndexToWorldTransform());
 
     // pre-initialize input-requested-region to largest-possible-region
     m_InputRequestedRegion = input->GetLargestPossibleRegion();
     // build region out of bounding-box of index and size of the bounding box
     mitk::SlicedData::IndexType index = m_InputRequestedRegion.GetIndex(); // init times and channels
     mitk::BoundingBox::PointType min = bsBoxRelativeToImage->GetMinimum();
     mitk::SlicedData::SizeType size = m_InputRequestedRegion.GetSize(); // init times and channels
     mitk::BoundingBox::PointType max = bsBoxRelativeToImage->GetMaximum();
 
     for (unsigned int i = 0; i < dimension; i++)
     {
       index[i] = (mitk::SlicedData::IndexType::IndexValueType)(std::ceil(min[i]));
       size[i] = (mitk::SlicedData::SizeType::SizeValueType)(std::ceil(max[i]) - index[i]);
     }
     mitk::SlicedData::RegionType bsRegion(index, size);
 
     if (m_UseWholeInputRegion == false)
     {
       // crop input-requested-region with region of bounding-object
       if (m_InputRequestedRegion.Crop(bsRegion) == false)
       {
         // crop not possible => do nothing: set time size to 0.
         size.Fill(0);
         m_InputRequestedRegion.SetSize(size);
         bsRegion.SetSize(size);
         mitkThrow() << "No overlap of the image and the cropping object.";
       }
     }
 
     // initialize output image
     auto dimensions = new unsigned int[dimension];
     if (dimension > 3 && !this->GetUseCropTimeStepOnly())
       memcpy(dimensions + 3, input->GetDimensions() + 3, (dimension - 3) * sizeof(unsigned int));
     else
       dimension = 3; // set timeStep to zero if GetUseCropTimeStepOnly is true
 
     itk2vtk(m_InputRequestedRegion.GetSize(), dimensions);
 
     output->Initialize(mitk::PixelType(GetOutputPixelType()), dimension, dimensions);
     delete[] dimensions;
 
     // Apply transform of the input image to the new generated output image
     mitk::BoundingShapeCropper::RegionType outputRegion = output->GetRequestedRegion();
 
     m_TimeOfHeaderInitialization.Modified();
   }
 
   void BoundingShapeCropper::ComputeData(mitk::Image *image, int boTimeStep)
   {
     // examine dimension and pixeltype
     if ((image == nullptr) || (image->GetDimension() > 4) || (image->GetDimension() <= 2))
     {
       MITK_ERROR << "Filter cannot handle dimensions less than 2 and greater than 4" << std::endl;
       itkExceptionMacro("Filter cannot handle dimensions less than 2 and greater than 4");
       return;
     }
 
     AccessByItk_1(image, CutImage, boTimeStep);
   }
 
   void BoundingShapeCropper::GenerateData()
   {
     MITK_INFO << "Generate Data" << std::endl;
     mitk::Image::ConstPointer input = this->GetInput();
     mitk::Image::Pointer output = this->GetOutput();
 
     if (input.IsNull())
       return;
 
     if ((output->IsInitialized() == false) || (m_Geometry.IsNull()) ||
         (m_Geometry->GetTimeGeometry()->CountTimeSteps() == 0))
       return;
 
     m_InputTimeSelector->SetInput(input);
     m_OutputTimeSelector->SetInput(this->GetOutput());
 
     mitk::BoundingShapeCropper::RegionType outputRegion = output->GetRequestedRegion();
     mitk::BaseGeometry *inputImageGeometry = input->GetSlicedGeometry();
 
     // iterate over all time steps and perform cropping or masking on all or a specific timestep (perviously specified
     // by UseCurrentTimeStepOnly)
     int tstart = outputRegion.GetIndex(3);
     int tmax = tstart + outputRegion.GetSize(3);
-    int t;
-    for (t = tstart; t < tmax; ++t)
+
+    if (this->m_UseCropTimeStepOnly)
     {
-      mitk::SlicedGeometry3D *slicedGeometry = output->GetSlicedGeometry(t);
+      mitk::SlicedGeometry3D *slicedGeometry = output->GetSlicedGeometry(tstart);
       auto indexToWorldTransform = AffineTransform3D::New();
-      indexToWorldTransform->SetParameters(input->GetSlicedGeometry(t)->GetIndexToWorldTransform()->GetParameters());
+      indexToWorldTransform->SetParameters(input->GetSlicedGeometry(tstart)->GetIndexToWorldTransform()->GetParameters());
       slicedGeometry->SetIndexToWorldTransform(indexToWorldTransform);
-
       const mitk::SlicedData::IndexType &start = m_InputRequestedRegion.GetIndex();
       mitk::Point3D origin;
       vtk2itk(start, origin);
       inputImageGeometry->IndexToWorld(origin, origin);
       slicedGeometry->SetOrigin(origin);
-      m_InputTimeSelector->SetTimeNr(t);
+      m_InputTimeSelector->SetTimeNr(m_CurrentTimeStep);
       m_InputTimeSelector->UpdateLargestPossibleRegion();
-      m_OutputTimeSelector->SetTimeNr(t);
+      m_OutputTimeSelector->SetTimeNr(tstart);
       m_OutputTimeSelector->UpdateLargestPossibleRegion();
-      ComputeData(m_InputTimeSelector->GetOutput(), t);
+      ComputeData(m_InputTimeSelector->GetOutput(), m_CurrentTimeStep);
+    }
+    else
+    {
+      int t;
+      for (t = tstart; t < tmax; ++t)
+      {
+        mitk::SlicedGeometry3D *slicedGeometry = output->GetSlicedGeometry(t);
+        auto indexToWorldTransform = AffineTransform3D::New();
+        indexToWorldTransform->SetParameters(input->GetSlicedGeometry(t)->GetIndexToWorldTransform()->GetParameters());
+        slicedGeometry->SetIndexToWorldTransform(indexToWorldTransform);
+        const mitk::SlicedData::IndexType &start = m_InputRequestedRegion.GetIndex();
+        mitk::Point3D origin;
+        vtk2itk(start, origin);
+        inputImageGeometry->IndexToWorld(origin, origin);
+        slicedGeometry->SetOrigin(origin);
+        m_InputTimeSelector->SetTimeNr(t);
+        m_InputTimeSelector->UpdateLargestPossibleRegion();
+        m_OutputTimeSelector->SetTimeNr(t);
+        m_OutputTimeSelector->UpdateLargestPossibleRegion();
+        ComputeData(m_InputTimeSelector->GetOutput(), t);
+      }
     }
     m_InputTimeSelector->SetInput(nullptr);
     m_OutputTimeSelector->SetInput(nullptr);
     m_TimeOfHeaderInitialization.Modified();
   }
 
 } // of namespace mitk
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 a1b1fa8797..fe224fcf22 100644
--- a/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropper.cpp
+++ b/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropper.cpp
@@ -1,528 +1,532 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date$
 Version:   $Revision$
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include "QmitkImageCropper.h"
 
 #include <QAction>
 #include <QCheckBox>
 #include <QColorDialog>
 #include <QInputDialog>
 #include <QMessageBox>
 #include <QSpinBox>
 #include <QSlider>
 
 #include <vtkCommand.h>
 #include <vtkCubeSource.h>
 #include <vtkObjectFactory.h>
 #include <vtkRenderWindow.h>
 #include <vtkPlaneWidget.h>
 #include <vtkProperty.h>
 #include <vtkSmartPointer.h>
 #include <vtkTransform.h>
 #include <vtkTransformFilter.h>
 
 #include <mitkBoundingShapeInteractor.h>
 #include <mitkBoundingShapeCropper.h>
 #include <mitkDisplayInteractor.h>
 #include <mitkIDataStorageService.h>
 #include <mitkImageCast.h> // Includes for image casting between ITK and MITK: added after using Plugin Generator
 #include <mitkImageAccessByItk.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 <mitkRenderingManager.h>
 #include <mitkProperties.h>
 
 #include <itkBoundingBox.h>
 #include <itkCommand.h>
 
 #include <usModuleRegistry.h>
 #include <usGetModuleContext.h>
 
 const std::string QmitkImageCropper::VIEW_ID = "org.mitk.views.qmitkimagecropper";
 
 QmitkImageCropper::QmitkImageCropper(QObject *parent)
   : m_ParentWidget(0),
   m_ImageNode(nullptr),
   m_CroppingObject(nullptr),
   m_CroppingObjectNode(nullptr),
   m_BoundingShapeInteractor(nullptr),
   m_CropOutsideValue(0),
   m_Advanced(0),
   m_Active(0),
   m_ScrollEnabled(true)
 {
   CreateBoundingShapeInteractor(false);
 }
 
 QmitkImageCropper::~QmitkImageCropper()
 {
   //delete pointer objects
   m_CroppingObjectNode = nullptr;
   m_CroppingObject = nullptr;
 
   //disable interactor
   if (m_BoundingShapeInteractor != nullptr)
   {
     m_BoundingShapeInteractor->SetDataNode(nullptr);
     m_BoundingShapeInteractor->EnableInteraction(false);
   }
 }
 
 void QmitkImageCropper::SetFocus()
 {
   m_Controls.buttonCreateNewBoundingBox->setFocus();
 }
 
 void QmitkImageCropper::CreateQtPartControl(QWidget *parent)
 {
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi(parent);
 
   m_Controls.boundingShapeSelector->SetDataStorage(this->GetDataStorage());
   m_Controls.boundingShapeSelector->SetPredicate(mitk::NodePredicateAnd::New(
     mitk::TNodePredicateDataType<mitk::GeometryData>::New(),
     mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object"))));
   m_CroppingObjectNode = m_Controls.boundingShapeSelector->GetSelectedNode();
 
   connect(m_Controls.buttonCropping, SIGNAL(clicked()), this, SLOT(DoCropping()));
   connect(m_Controls.buttonMasking, SIGNAL(clicked()), this, SLOT(DoMasking()));
   connect(m_Controls.boundingShapeSelector, SIGNAL(OnSelectionChanged(const mitk::DataNode*)),
     this, SLOT(OnDataSelectionChanged(const mitk::DataNode*)));
   connect(m_Controls.buttonCreateNewBoundingBox, SIGNAL(clicked()), this, SLOT(DoCreateNewBoundingObject()));
   connect(m_Controls.buttonAdvancedSettings, SIGNAL(clicked()), this, SLOT(OnAdvancedSettingsButtonToggled()));
   connect(m_Controls.spinBox, SIGNAL(valueChanged(int)), this, SLOT(OnSliderValueChanged(int)));
 
   m_Controls.spinBox->setValue(-1000);
   m_Controls.spinBox->setEnabled(false);
   m_Controls.buttonCreateNewBoundingBox->setEnabled(false);
   m_Controls.buttonCropping->setEnabled(false);
   m_Controls.boundingShapeSelector->setEnabled(false);
   m_Controls.labelWarningRotation->setVisible(false);
   m_Controls.buttonAdvancedSettings->setEnabled(false);
 
   m_Advanced = false;
   this->OnAdvancedSettingsButtonToggled();
   m_ParentWidget = parent;
 
 }
 
 void QmitkImageCropper::OnDataSelectionChanged(const mitk::DataNode* node)
 {
   m_Controls.boundingShapeSelector->setEnabled(true);
   m_CroppingObjectNode = m_Controls.boundingShapeSelector->GetSelectedNode();
 
   if (m_CroppingObjectNode.IsNotNull() && dynamic_cast<mitk::GeometryData*>(this->m_CroppingObjectNode->GetData()))
   {
     m_Controls.buttonAdvancedSettings->setEnabled(true);
     m_Controls.labelWarningBB->setText(QString::fromStdString(""));
     m_CroppingObject = dynamic_cast<mitk::GeometryData*>(m_CroppingObjectNode->GetData());
     m_Advanced = true;
 
     mitk::RenderingManager::GetInstance()->InitializeViews();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
   else
   {
     m_Controls.buttonAdvancedSettings->setEnabled(false);
     m_CroppingObject = nullptr;
     m_BoundingShapeInteractor->EnableInteraction(false);
     m_BoundingShapeInteractor->SetDataNode(nullptr);
     m_Advanced = false;
     this->OnAdvancedSettingsButtonToggled();
   }
 
 }
 
 void QmitkImageCropper::OnAdvancedSettingsButtonToggled()
 {
   m_Controls.groupImageSettings->setVisible(m_Advanced);
   m_Advanced = !m_Advanced;
 }
 
 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.IsNotNull())
   {
     bool ok = false;
     QString name = QInputDialog::getText(QApplication::activeWindow()
       , "Add cropping shape...", "Enter name for the new cropping shape", QLineEdit::Normal, "BoundingShape", &ok);
     if (!ok)
       return;
 
     m_Controls.buttonCropping->setEnabled(true);
     m_Controls.buttonMasking->setEnabled(true);
     m_Controls.boundingShapeSelector->setEnabled(true);
 
     // to do: check whether stdmulti.widget is valid
     // get current timestep to support 3d+t images //to do: check if stdmultiwidget is valid
     int timeStep = mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1"))->GetTimeStep();
     mitk::BaseGeometry::Pointer imageGeometry = static_cast<mitk::BaseGeometry*>(m_ImageNode->GetData()->GetGeometry(timeStep));
 
     m_CroppingObject = mitk::GeometryData::New();
     m_CroppingObject->SetGeometry(static_cast<mitk::Geometry3D*>(this->InitializeWithImageGeometry(imageGeometry)));
     m_CroppingObjectNode = mitk::DataNode::New();
     m_CroppingObjectNode->SetData(m_CroppingObject);
     m_CroppingObjectNode->SetProperty("name", mitk::StringProperty::New(name.toStdString()));
     m_CroppingObjectNode->SetProperty("color", mitk::ColorProperty::New(1.0, 1.0, 1.0));
     m_CroppingObjectNode->SetProperty("opacity", mitk::FloatProperty::New(0.6));
     m_CroppingObjectNode->SetProperty("layer", mitk::IntProperty::New(99));
     m_CroppingObjectNode->AddProperty("handle size factor", mitk::DoubleProperty::New(1.0 / 40.0));
     m_CroppingObjectNode->SetBoolProperty("pickable", true);
 
     if (!this->GetDataStorage()->Exists(m_CroppingObjectNode))
     {
       GetDataStorage()->Add(m_CroppingObjectNode, m_ImageNode);
       m_Controls.boundingShapeSelector->SetSelectedNode(m_CroppingObjectNode);
       m_CroppingObjectNode->SetVisibility(true);
       m_BoundingShapeInteractor->EnableInteraction(true);
       m_BoundingShapeInteractor->SetDataNode(this->m_CroppingObjectNode);
       this->OnDataSelectionChanged(m_CroppingObjectNode);
     }
   }
   // Adjust coordinate system by doing a reinit on
   auto tempDataStorage = mitk::DataStorage::SetOfObjects::New();
   tempDataStorage->InsertElement(0, m_CroppingObjectNode);
 
-  // initialize the views to the bounding geometry
-  mitk::TimeGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(tempDataStorage);
-  mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
-  mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+  //// initialize the views to the bounding geometry
+  //mitk::TimeGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(tempDataStorage);
+  //mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
+  //mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkImageCropper::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/,
   const QList<mitk::DataNode::Pointer>& nodes)
 {
   bool rotationEnabled = false;
   if (nodes.empty())
   {
     m_Controls.labelWarningImage->setStyleSheet(" QLabel { color: rgb(255, 0, 0) }");
     m_Controls.labelWarningImage->setText(QString::fromStdString("Select an image."));
     m_Controls.labelWarningBB->setStyleSheet(" QLabel { color: rgb(255, 0, 0) }");
     m_Controls.labelWarningBB->setText(QString::fromStdString("Create a bounding shape below."));
     m_Controls.buttonCreateNewBoundingBox->setEnabled(false);
     m_Controls.buttonCropping->setEnabled(false);
     m_Controls.buttonMasking->setEnabled(false);
     m_Controls.labelWarningRotation->setVisible(false);
     return;
   }
   m_ParentWidget->setEnabled(true);
 
   foreach(mitk::DataNode::Pointer node, nodes)
   {
     if (node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()))
     {
       m_ImageNode = nodes[0];
       m_Controls.groupBoundingObject->setEnabled(true);
       m_Controls.labelWarningImage->setStyleSheet(" QLabel { color: rgb(0, 0, 0) }");
       m_Controls.labelWarningImage->setText(QString::fromStdString("File name: " + m_ImageNode->GetName()));
       m_Controls.buttonCreateNewBoundingBox->setEnabled(true);
 
       mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(m_ImageNode->GetData());
       if (image != nullptr)
       {
         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);
         m_CroppingObjectNode = m_Controls.boundingShapeSelector->GetSelectedNode();
         if (m_CroppingObjectNode != nullptr)
         {
           this->OnDataSelectionChanged(m_CroppingObjectNode);
           m_BoundingShapeInteractor->EnableInteraction(true);
           m_BoundingShapeInteractor->SetDataNode(this->m_CroppingObjectNode);
           m_Controls.boundingShapeSelector->setEnabled(true);
         }
 
         if (image->GetPixelType().GetPixelType() == itk::ImageIOBase::SCALAR)
         {
           // Might be changed with the upcoming new image statistics plugin
           int minPixelValue = static_cast<int>(image->GetScalarValueMinNoRecompute());
           //static_cast<int>image->GetStatistics()->GetScalarValueMinNoRecompute();
           int maxPixelValue = static_cast<int>(image->GetScalarValueMaxNoRecompute());
           //static_cast<int>image->GetStatistics()->GetScalarValueMaxNoRecompute();
           m_Controls.spinBox->setEnabled(true);
           m_Controls.spinBox->setMaximum(maxPixelValue);
           m_Controls.spinBox->setMinimum(minPixelValue);
           m_Controls.spinBox->setValue(minPixelValue);
         }
         else
           m_Controls.spinBox->setEnabled(false);
 
         unsigned int dim = image->GetDimension();
         if (dim < 2 || dim > 4)
         {
           m_Controls.labelWarningImage->setStyleSheet(" QLabel { color: rgb(255, 0, 0) }");
           m_Controls.labelWarningImage->setText(QString::fromStdString("Select an image."));
           m_ParentWidget->setEnabled(false);
         }
         if (m_CroppingObjectNode != nullptr)
         {
           m_Controls.buttonCropping->setEnabled(true);
           m_Controls.buttonMasking->setEnabled(true);
           m_Controls.boundingShapeSelector->setEnabled(true);
           m_Controls.labelWarningBB->setVisible(false);
         }
         else
         {
           m_Controls.buttonCropping->setEnabled(false);
           m_Controls.buttonMasking->setEnabled(false);
           m_Controls.boundingShapeSelector->setEnabled(false);
           m_Controls.labelWarningBB->setStyleSheet(" QLabel { color: rgb(255, 0, 0) }");
           m_Controls.labelWarningBB->setText(QString::fromStdString("Create a bounding shape below."));
         }
         return;
       }
       //  iterate all selected objects, adjust warning visibility
       m_Controls.labelWarningImage->setStyleSheet(" QLabel { color: rgb(255, 0, 0) }");
       m_Controls.labelWarningImage->setText(QString::fromStdString("Select an image."));
       m_Controls.buttonCropping->setEnabled(false);
       m_Controls.buttonMasking->setEnabled(false);
       m_Controls.buttonCreateNewBoundingBox->setEnabled(false);
       m_Controls.boundingShapeSelector->setEnabled(false);
       m_ParentWidget->setEnabled(true);
       m_Controls.labelWarningRotation->setVisible(false);
     }
   }
 }
 
 void QmitkImageCropper::OnComboBoxSelectionChanged(const mitk::DataNode* node)
 {
   mitk::DataNode* selectedNode = const_cast<mitk::DataNode*>(node);
   if (selectedNode != nullptr)
   {
     if (m_ImageNode.IsNotNull())
       selectedNode->SetDataInteractor(m_ImageNode->GetDataInteractor());
     // m_ImageNode->GetDataInteractor()->SetDataNode(selectedNode);
     m_ImageNode = selectedNode;
   }
 }
 
 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)
 {
   // cropping only possible if valid bounding shape as well as a valid image are loaded
   QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
 
   // to do: check whether stdmultiwidget is valid
   int timeStep = mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1"))->GetTimeStep();
 
+ 
   if (nodes.empty()) return;
 
   mitk::DataNode* node = nodes[0];
 
   if (node == nullptr)
   {
     QMessageBox::information(nullptr, "Warning", "Please load and select an image before starting image processing.");
     return;
   }
   if (m_CroppingObject == nullptr)
   {
     QMessageBox::information(nullptr, "Warning", "Please load and select a cropping object before starting image processing.");
     return;
   }
 
   mitk::BaseData* data = node->GetData(); //get data from node
   if (data != nullptr)
   {
     QString imageName;
     if (mask)
       imageName = QString::fromStdString(node->GetName() + "_masked");
     else
       imageName = QString::fromStdString(node->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_CroppingObject);
 
     // 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)
     mitk::LabelSetImage* labelsetImageInput = dynamic_cast<mitk::LabelSetImage*>(data);
     if (labelsetImageInput != nullptr)
     {
         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 (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);
           }
         }
         else // original image will be overwritten by the result image and the bounding box of the result is adjusted
         {
           node->SetData(labelSetImage);
           node->Modified();
           // Adjust coordinate system by doing a reinit on
           auto tempDataStorage = mitk::DataStorage::SetOfObjects::New();
           tempDataStorage->InsertElement(0, node);
 
           // initialize the views to the bounding geometry
           mitk::TimeGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(tempDataStorage);
           mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
           mitk::RenderingManager::GetInstance()->RequestUpdateAll();
         }
     }
     else
     {
       mitk::Image::Pointer imageInput = dynamic_cast<mitk::Image*>(data);
       if (imageInput != nullptr)
       {
         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);
           }
         }
         else // original image will be overwritten by the result image and the bounding box of the result is adjusted
         {
           node->SetData(cutter->GetOutput());
           node->Modified();
           // Adjust coordinate system by doing a reinit on
           auto tempDataStorage = mitk::DataStorage::SetOfObjects::New();
           tempDataStorage->InsertElement(0, node);
 
           // initialize the views to the bounding geometry
           mitk::TimeGeometry::Pointer 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.");
   }
 }