diff --git a/Modules/US/USModel/mitkUSVideoDeviceCustomControls.cpp b/Modules/US/USModel/mitkUSVideoDeviceCustomControls.cpp
index bf6ab39efc..72183efc48 100644
--- a/Modules/US/USModel/mitkUSVideoDeviceCustomControls.cpp
+++ b/Modules/US/USModel/mitkUSVideoDeviceCustomControls.cpp
@@ -1,116 +1,139 @@
 /*===================================================================
 
 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 "mitkUSVideoDeviceCustomControls.h"
 
 mitk::USVideoDeviceCustomControls::USVideoDeviceCustomControls(itk::SmartPointer<USVideoDevice> device)
   : mitk::USAbstractControlInterface(device.GetPointer()), m_IsActive(false)
 {
   m_ImageSource = dynamic_cast<mitk::USImageVideoSource*>(m_Device->GetUSImageSource().GetPointer());
 }
 
 mitk::USVideoDeviceCustomControls::~USVideoDeviceCustomControls()
 {
 }
 
 void mitk::USVideoDeviceCustomControls::SetIsActive(bool isActive)
 {
   m_IsActive = isActive;
 }
 
 bool mitk::USVideoDeviceCustomControls::GetIsActive()
 {
   return m_IsActive;
 }
 
 void mitk::USVideoDeviceCustomControls::SetCropArea(mitk::USImageVideoSource::USImageCropping newArea)
 {
   MITK_INFO << "Set Crop Area L:" << newArea.left << " R:" << newArea.right
     << " T:" << newArea.top << " B:" << newArea.bottom;
 
   if (m_ImageSource.IsNotNull())
   {
     // if area is empty, remove region
     if ((newArea.bottom == 0) && (newArea.top == 0) &&
       (newArea.left == 0) && (newArea.right == 0))
     {
       m_ImageSource->RemoveRegionOfInterest();
     }
     else
     {
       m_ImageSource->SetCropping(newArea);
     }
   }
   else
   {
     MITK_WARN << "Cannot set crop are, source is not initialized!";
   }
 }
 
 void mitk::USVideoDeviceCustomControls::SetNewDepth(double depth)
 {
   mitk::USVideoDevice::Pointer device = dynamic_cast<mitk::USVideoDevice*>(m_Device.GetPointer());
   if (device.IsNotNull())
   {
     if( device->GetCurrentProbe().IsNotNull() )
     {
       device->GetCurrentProbe()->SetCurrentDepth(depth);
       MITK_INFO << "SetCurrentDepth of currentProbe: " << depth;
     }
   }
   m_Device->DepthChanged(depth);
 }
 
 void mitk::USVideoDeviceCustomControls::SetNewProbeIdentifier(std::string probename)
 {
   mitk::USVideoDevice::Pointer device = dynamic_cast<mitk::USVideoDevice*>(m_Device.GetPointer());
   if( device.IsNotNull() )
   {
     device->SetCurrentProbe(probename);
   }
   m_Device->ProbeChanged(probename);
 }
 
-mitk::USImageVideoSource::USImageCropping mitk::USVideoDeviceCustomControls::GetCropArea()
+mitk::USProbe::USProbeCropping mitk::USVideoDeviceCustomControls::GetCropArea()
 {
   // just return the crop area set at the image source
-  return m_ImageSource->GetCropping();
+  mitk::USVideoDevice::Pointer device = dynamic_cast<mitk::USVideoDevice*>(m_Device.GetPointer());
+  if (device.IsNotNull())
+  {
+    mitk::USProbe::Pointer probe = device->GetCurrentProbe();
+    if (probe.IsNotNull())
+    {
+      return probe->GetProbeCropping();
+    }
+  }
+  mitk::USProbe::USProbeCropping defaultCropping;
+  return defaultCropping;
+}
+
+void mitk::USVideoDeviceCustomControls::UpdateProbeCropping(mitk::USImageVideoSource::USImageCropping cropping)
+{
+  mitk::USVideoDevice::Pointer device = dynamic_cast<mitk::USVideoDevice*>(m_Device.GetPointer());
+  if (device.IsNotNull())
+  {
+    mitk::USProbe::Pointer probe = device->GetCurrentProbe();
+    if( probe.IsNotNull() )
+    {
+      probe->SetProbeCropping(cropping.top, cropping.bottom, cropping.left, cropping.right);
+    }
+  }
 }
 
 std::vector<mitk::USProbe::Pointer> mitk::USVideoDeviceCustomControls::GetProbes()
 {
   mitk::USVideoDevice::Pointer device = dynamic_cast<mitk::USVideoDevice*>(m_Device.GetPointer());
   return device->GetAllProbes();
 }
 
 std::vector<int> mitk::USVideoDeviceCustomControls::GetDepthsForProbe(std::string name)
 {
   mitk::USVideoDevice::Pointer device = dynamic_cast<mitk::USVideoDevice*>(m_Device.GetPointer());
   mitk::USProbe::Pointer probe = device->GetProbeByName(name);
   std::map<int, mitk::Vector3D> depthsAndSpacings = probe->GetDepthsAndSpacing();
   std::vector<int> depths;
   for (std::map<int, mitk::Vector3D>::iterator it = depthsAndSpacings.begin(); it != depthsAndSpacings.end(); it++)
   {
     depths.push_back((it->first));
   }
   return depths;
 }
 
 void mitk::USVideoDeviceCustomControls::SetDefaultProbeAsCurrentProbe()
 {
   mitk::USVideoDevice::Pointer device = dynamic_cast<mitk::USVideoDevice*>(m_Device.GetPointer());
   device->SetDefaultProbeAsCurrentProbe();
 }
diff --git a/Modules/US/USModel/mitkUSVideoDeviceCustomControls.h b/Modules/US/USModel/mitkUSVideoDeviceCustomControls.h
index ce90da24b1..70b342011e 100644
--- a/Modules/US/USModel/mitkUSVideoDeviceCustomControls.h
+++ b/Modules/US/USModel/mitkUSVideoDeviceCustomControls.h
@@ -1,101 +1,107 @@
 /*===================================================================
 
 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 MITKUSVideoDeviceCustomControls_H_HEADER_INCLUDED_
 #define MITKUSVideoDeviceCustomControls_H_HEADER_INCLUDED_
 
 #include "mitkUSAbstractControlInterface.h"
 #include "mitkUSImageVideoSource.h"
 #include "mitkUSVideoDevice.h"
 
 #include <itkObjectFactory.h>
 
 namespace mitk {
   /**
     * \brief Custom controls for mitk::USVideoDevice.
     * Controls image cropping of the corresponding mitk::USImageVideoSource.
     */
   class MITKUS_EXPORT USVideoDeviceCustomControls : public USAbstractControlInterface
   {
   public:
     mitkClassMacro(USVideoDeviceCustomControls, USAbstractControlInterface);
     mitkNewMacro1Param(Self, itk::SmartPointer<USVideoDevice>);
 
     /**
       * Activate or deactivate the custom controls. This is just for handling
       * widget visibility in a GUI for example. Cropping will not be deactivated
       * if this method is called with false. Use
       * mitk::USVideoDeviceCustomControls::SetCropArea() with an empty are
       * instead.
       */
     void SetIsActive(bool isActive) override;
 
     /**
       * \return if this custom controls are currently activated
       */
     bool GetIsActive() override;
 
     /**
       * \brief Sets the area that will be cropped from the US image.
       * Set [0,0,0,0] to disable it, which is also default.
       */
     void SetCropArea(USImageVideoSource::USImageCropping newArea);
 
     /**
-      * \return area currently set for image cropping
+      * \return area currently set for image cropping defined by the actual current probe.
       */
-    mitk::USImageVideoSource::USImageCropping GetCropArea();
+    mitk::USProbe::USProbeCropping GetCropArea();
+
+    /**
+     * \brief Updates the cropping of the current probe given by the crop area of the
+     * USImageVideoSource.
+     */
+    void UpdateProbeCropping( mitk::USImageVideoSource::USImageCropping cropping );
 
     /**
       * \brief Sets a new depth value to the current probe.
       */
     void SetNewDepth(double depth);
 
     /**
       * \ brief Sets new probe identifier
       */
     void SetNewProbeIdentifier(std::string probename);
 
     /**
     *\brief Get all the probes for the current device
     */
     std::vector<mitk::USProbe::Pointer> GetProbes();
 
     /**
     * \brief Get the scanning dephts of the given probe
     */
     std::vector<int> GetDepthsForProbe(std::string name);
 
     /**
     * \brief Sets the first existing probe or the default probe of a USVideoDevice
     * as the current probe of the USVideoDevice.
     */
     void SetDefaultProbeAsCurrentProbe();
 
   protected:
     /**
       * Class needs an mitk::USImageVideoSource object for beeing constructed.
       * This object will be manipulated by the custom controls methods.
       */
     USVideoDeviceCustomControls(itk::SmartPointer<USVideoDevice> device);
     ~USVideoDeviceCustomControls() override;
 
     bool                          m_IsActive;
     USImageVideoSource::Pointer   m_ImageSource;
   };
 } // namespace mitk
 
 #endif // MITKUSVideoDeviceCustomControls_H_HEADER_INCLUDED_
\ No newline at end of file
diff --git a/Modules/USUI/Qmitk/QmitkUSControlsCustomVideoDeviceWidget.cpp b/Modules/USUI/Qmitk/QmitkUSControlsCustomVideoDeviceWidget.cpp
index 6785955e4a..132923bbc3 100644
--- a/Modules/USUI/Qmitk/QmitkUSControlsCustomVideoDeviceWidget.cpp
+++ b/Modules/USUI/Qmitk/QmitkUSControlsCustomVideoDeviceWidget.cpp
@@ -1,172 +1,181 @@
 /*===================================================================
 
 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 "QmitkUSControlsCustomVideoDeviceWidget.h"
 #include "ui_QmitkUSControlsCustomVideoDeviceWidget.h"
 #include <QMessageBox>
 
 #include <mitkException.h>
 
 
 QmitkUSControlsCustomVideoDeviceWidget::QmitkUSControlsCustomVideoDeviceWidget()
   : ui(new Ui::QmitkUSControlsCustomVideoDeviceWidget)
 {
 }
 
 
 QmitkUSControlsCustomVideoDeviceWidget::QmitkUSControlsCustomVideoDeviceWidget(QWidget *parent)
   : QmitkUSAbstractCustomWidget(parent), ui(new Ui::QmitkUSControlsCustomVideoDeviceWidget)
 {
   m_Cropping.left = 0;
   m_Cropping.top = 0;
   m_Cropping.right = 0;
   m_Cropping.bottom = 0;
 }
 
 QmitkUSControlsCustomVideoDeviceWidget::~QmitkUSControlsCustomVideoDeviceWidget()
 {
   delete ui;
 }
 
 std::string QmitkUSControlsCustomVideoDeviceWidget::GetDeviceClass() const
 {
   return mitk::USVideoDevice::GetDeviceClassStatic();
 }
 
 QmitkUSAbstractCustomWidget* QmitkUSControlsCustomVideoDeviceWidget::Clone(QWidget* parent) const
 {
   QmitkUSAbstractCustomWidget* clonedWidget = new QmitkUSControlsCustomVideoDeviceWidget(parent);
   clonedWidget->SetDevice(this->GetDevice());
   return clonedWidget;
 }
 
 void QmitkUSControlsCustomVideoDeviceWidget::OnDeviceSet()
 {
   m_ControlInterface = dynamic_cast<mitk::USVideoDeviceCustomControls*>
     (this->GetDevice()->GetControlInterfaceCustom().GetPointer());
 
   if (m_ControlInterface.IsNotNull())
   {
-    mitk::USImageVideoSource::USImageCropping cropping = m_ControlInterface->GetCropArea();
-    ui->crop_left->setValue(cropping.left);
-    ui->crop_right->setValue(cropping.right);
-    ui->crop_bot->setValue(cropping.bottom);
-    ui->crop_top->setValue(cropping.top);
-
     //get all probes and put their names into a combobox
     std::vector<mitk::USProbe::Pointer> probes = m_ControlInterface->GetProbes();
     for (std::vector<mitk::USProbe::Pointer>::iterator it = probes.begin(); it != probes.end(); it++)
     {
       std::string probeName = (*it)->GetName();
       ui->m_ProbeIdentifier->addItem(QString::fromUtf8(probeName.data(), probeName.size()));
     }
 
     m_ControlInterface->SetDefaultProbeAsCurrentProbe();
 
     SetDepthsForProbe( ui->m_ProbeIdentifier->currentText().toStdString() );
     m_ControlInterface->SetNewDepth( ui->m_UsDepth->currentText().toDouble() );
 
     connect(ui->m_UsDepth, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnDepthChanged()));
     connect(ui->m_ProbeIdentifier, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnProbeChanged()));
 
+    // Call GetCropArea after the current ultrasound probe was set as default probe:
+    mitk::USProbe::USProbeCropping cropping = m_ControlInterface->GetCropArea();
+    ui->crop_left->setValue(cropping.left);
+    ui->crop_right->setValue(cropping.right);
+    ui->crop_bot->setValue(cropping.bottom);
+    ui->crop_top->setValue(cropping.top);
+
   }
   else
   {
     MITK_WARN("QmitkUSAbstractCustomWidget")("QmitkUSControlsCustomVideoDeviceWidget")
       << "Did not get a custom video device control interface.";
   }
 
   ui->crop_left->setEnabled(m_ControlInterface.IsNotNull());
   ui->crop_right->setEnabled(m_ControlInterface.IsNotNull());
   ui->crop_bot->setEnabled(m_ControlInterface.IsNotNull());
   ui->crop_top->setEnabled(m_ControlInterface.IsNotNull());
 }
 
 void QmitkUSControlsCustomVideoDeviceWidget::Initialize()
 {
   ui->setupUi(this);
 
   connect(ui->crop_left, SIGNAL(valueChanged(int)), this, SLOT(OnCropAreaChanged()));
   connect(ui->crop_right, SIGNAL(valueChanged(int)), this, SLOT(OnCropAreaChanged()));
   connect(ui->crop_top, SIGNAL(valueChanged(int)), this, SLOT(OnCropAreaChanged()));
   connect(ui->crop_bot, SIGNAL(valueChanged(int)), this, SLOT(OnCropAreaChanged()));
 
 }
 
 void QmitkUSControlsCustomVideoDeviceWidget::OnCropAreaChanged()
 {
   if (m_ControlInterface.IsNull()) { return; }
 
   mitk::USImageVideoSource::USImageCropping cropping;
   cropping.left = ui->crop_left->value();
   cropping.top = ui->crop_top->value();
   cropping.right = ui->crop_right->value();
   cropping.bottom = ui->crop_bot->value();
 
   try
   {
     m_ControlInterface->SetCropArea(cropping);
+    m_ControlInterface->UpdateProbeCropping(cropping);
     m_Cropping = cropping;
   }
   catch (mitk::Exception e)
   {
     m_ControlInterface->SetCropArea(m_Cropping); // reset to last valid crop
+    m_ControlInterface->UpdateProbeCropping(m_Cropping);
 
     //reset values
     BlockSignalAndSetValue(ui->crop_left, m_Cropping.left);
     BlockSignalAndSetValue(ui->crop_right, m_Cropping.right);
     BlockSignalAndSetValue(ui->crop_top, m_Cropping.top);
     BlockSignalAndSetValue(ui->crop_bot, m_Cropping.bottom);
 
     // inform user
     QMessageBox msgBox;
     msgBox.setInformativeText("The crop area you specified is invalid.\nPlease make sure that no more pixels are cropped than are available.");
     msgBox.setStandardButtons(QMessageBox::Ok);
     msgBox.exec();
     MITK_WARN << "User tried to crop beyond limits of the image";
   }
 }
 
 void QmitkUSControlsCustomVideoDeviceWidget::OnDepthChanged()
 {
   double depth = ui->m_UsDepth->currentText().toDouble();
   MITK_INFO << "OnDepthChanged() " << depth;
   m_ControlInterface->SetNewDepth(depth);
 }
 
 void QmitkUSControlsCustomVideoDeviceWidget::OnProbeChanged()
 {
   std::string probename = ui->m_ProbeIdentifier->currentText().toStdString();
   m_ControlInterface->SetNewProbeIdentifier(probename);
   SetDepthsForProbe(probename);
+
+  mitk::USProbe::USProbeCropping cropping = m_ControlInterface->GetCropArea();
+  ui->crop_left->setValue(cropping.left);
+  ui->crop_right->setValue(cropping.right);
+  ui->crop_bot->setValue(cropping.bottom);
+  ui->crop_top->setValue(cropping.top);
 }
 
 void QmitkUSControlsCustomVideoDeviceWidget::BlockSignalAndSetValue(QSpinBox* target, int value)
 {
   bool oldState = target->blockSignals(true);
   target->setValue(value);
   target->blockSignals(oldState);
 }
 
 void QmitkUSControlsCustomVideoDeviceWidget::SetDepthsForProbe(std::string probename)
 {
   ui->m_UsDepth->clear();
   std::vector<int> depths = m_ControlInterface->GetDepthsForProbe(probename);
   for (std::vector<int>::iterator it = depths.begin(); it != depths.end(); it++)
   {
     ui->m_UsDepth->addItem(QString::number(*it));
   }
 }