diff --git a/Modules/OpenCVVideoSupport/UI/QmitkOpenCVVideoControls.cpp b/Modules/OpenCVVideoSupport/UI/QmitkOpenCVVideoControls.cpp
index 5b2a24593b..2b6c80a529 100644
--- a/Modules/OpenCVVideoSupport/UI/QmitkOpenCVVideoControls.cpp
+++ b/Modules/OpenCVVideoSupport/UI/QmitkOpenCVVideoControls.cpp
@@ -1,428 +1,448 @@
 /*===================================================================
 
 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 "QmitkOpenCVVideoControls.h"
 #include <QmitkVideoBackground.h>
 #include <QmitkRenderWindow.h>
 #include <mitkOpenCVVideoSource.h>
 
 #include <mitkIPersistenceService.h>
 
 class QmitkOpenCVVideoControlsPrivate
 {
 public:
 
   QmitkOpenCVVideoControlsPrivate(QmitkOpenCVVideoControls* q, const std::string& id)
     : q(q)
     , m_Id(id)
   {}
 
   ///
   /// muellerm: persitence service implementation
   ///
   PERSISTENCE_GET_SERVICE_METHOD_MACRO
 
   QmitkOpenCVVideoControls* q;
 
   ///
   /// muellerm: a unique id for the prop list
   ///
   std::string m_Id;
   void ToPropertyList();
   void FromPropertyList();
 };
 
 QmitkOpenCVVideoControls::QmitkOpenCVVideoControls(QmitkVideoBackground* _VideoBackground
   , QmitkRenderWindow* _RenderWindow
   , QWidget * parent, Qt::WindowFlags f)
   : QWidget(parent, f)
   , m_VideoBackground(nullptr)
   , m_RenderWindow(nullptr)
   , m_VideoSource(nullptr)
   , m_Controls(new Ui::QmitkOpenCVVideoControls)
   , m_SliderCurrentlyMoved(false)
   , d(new QmitkOpenCVVideoControlsPrivate(this, "QmitkOpenCVVideoControls"))
 {
   m_Controls->setupUi(this);
   m_Controls->FileChooser->SetFileMustExist(true);
   m_Controls->FileChooser->SetSelectDir(false);
 
   this->SetRenderWindow(_RenderWindow);
   this->SetVideoBackground(_VideoBackground);
   d->FromPropertyList();
 
   mitk::IPersistenceService* persistenceService = d->GetPersistenceService();
 
   if (persistenceService != nullptr)
   {
     persistenceService->AddPropertyListReplacedObserver(this);
   }
   else
   {
     MITK_WARN << "No Persistence Service available in constructor";
   }
 }
 
 QmitkOpenCVVideoControls::~QmitkOpenCVVideoControls()
 {
   if(m_VideoSource != 0 && m_VideoSource->IsCapturingEnabled())
   {
     this->Stop(); // emulate stop
   }
 
   mitk::IPersistenceService* persistenceService = d->GetPersistenceService();
   if (persistenceService != nullptr)
   {
     persistenceService->RemovePropertyListReplacedObserver(this);
   }
   else
   {
     MITK_WARN << "No Persistence Service available in destructor";
   }
 
   d->ToPropertyList();
 }
 
 void QmitkOpenCVVideoControls::on_UseGrabbingDeviceButton_clicked(bool /*checked=false*/)
 {
   m_Controls->GrabbingDevicePanel->setEnabled(true);
   m_Controls->VideoFilePanel->setEnabled(false);
 }
 
 void QmitkOpenCVVideoControls::on_UseVideoFileButton_clicked(bool /*checked=false*/)
 {
   m_Controls->GrabbingDevicePanel->setEnabled(false);
   m_Controls->VideoFilePanel->setEnabled(true);
   m_Controls->FileChooser->setEnabled(true);
 }
 
 //void QmitkOpenCVVideoControls::on_VideoProgressSlider_sliderMoved( int value )
 //{
 //  MITK_DEBUG << "progress bar slider clicked";
 //  double progressRatio = static_cast<double>(value)/static_cast<double>(m_Controls->VideoProgressSlider->maximum());
 //  MITK_DEBUG << "progressRatio" << progressRatio;
 //  m_VideoSource->SetVideoCaptureProperty(CV_CAP_PROP_POS_AVI_RATIO, progressRatio);
 //}
 
 void QmitkOpenCVVideoControls::on_VideoProgressSlider_sliderPressed()
 {
   m_SliderCurrentlyMoved = true;
   // temporary pause the video while sliding
   if (!m_VideoSource->GetCapturePaused())
     m_VideoSource->PauseCapturing();
   MITK_DEBUG << "freezing video with old pos ratio: " << m_VideoSource->GetVideoCaptureProperty(CV_CAP_PROP_POS_AVI_RATIO);
 }
 
 void QmitkOpenCVVideoControls::on_VideoProgressSlider_sliderReleased()
 {
   double progressRatio = static_cast<double>(m_Controls->VideoProgressSlider->value())
     / static_cast<double>(m_Controls->VideoProgressSlider->maximum());
   m_VideoSource->SetVideoCaptureProperty(CV_CAP_PROP_POS_AVI_RATIO, progressRatio);
 
   MITK_DEBUG << "resuming video with new pos ratio: " << progressRatio;
   // resume the video ( if it was not paused by the user)
   if (m_VideoSource->GetCapturePaused() && m_Controls->PlayButton->isChecked())
     m_VideoSource->PauseCapturing();
   m_SliderCurrentlyMoved = false;
 }
 
 void QmitkOpenCVVideoControls::on_RepeatVideoButton_clicked(bool checked)
 {
   MITK_INFO << "repeat video clicked";
   m_VideoSource->SetRepeatVideo(checked);
 }
 
 void QmitkOpenCVVideoControls::on_PlayButton_clicked(bool checked)
 {
   MITK_INFO << "play button clicked";
   if (checked)
   {
-    if (m_VideoSource->GetCapturePaused())
-    {
-      this->SwitchPlayButton(false);
-      m_VideoSource->PauseCapturing();
-    }
-    else
-    {
-      if (m_Controls->UseGrabbingDeviceButton->isChecked())
-      {
-        m_VideoSource->SetVideoCameraInput(m_Controls->GrabbingDeviceNumber->text().toInt(), false);
-        m_Controls->VideoFileControls->setEnabled(false);
-      }
-      else
-      {
-        m_VideoSource->SetVideoFileInput(m_Controls->FileChooser->GetFile().c_str(), m_Controls->RepeatVideoButton->isChecked(), false);
-        m_VideoSource->SetRepeatVideo(m_Controls->RepeatVideoButton->isChecked());
-        m_Controls->VideoProgressSlider->setValue(0);
-      }
-
-      m_VideoSource->StartCapturing();
-      if (!m_VideoSource->IsCapturingEnabled())
-      {
-        MITK_ERROR << "Video could not be initialized!";
-        m_Controls->PlayButton->setChecked(false);
-      }
-
-      else
-      {
-        int hertz = m_Controls->UpdateRate->text().toInt();
-        int updateTime = itk::Math::Round<int, double>(1000.0 / hertz);
-
-        // resets the whole background
-        m_VideoBackground->SetTimerDelay(updateTime);
-        m_VideoBackground->AddRenderWindow(m_RenderWindow->GetVtkRenderWindow());
-        this->connect(m_VideoBackground, SIGNAL(NewFrameAvailable(mitk::VideoSource*))
-          , this, SLOT(NewFrameAvailable(mitk::VideoSource*)));
-
-        m_VideoBackground->Enable();
-        this->m_Controls->StopButton->setEnabled(true);
-        // show video file controls
-        if (m_Controls->UseVideoFileButton->isChecked())
-        {
-          m_Controls->VideoFileControls->setEnabled(true);
-          m_Controls->RepeatVideoButton->setEnabled(true);
-          m_Controls->VideoProgressSlider->setEnabled(true);
-        }
-        // show pause button
-        this->SwitchPlayButton(false);
-        // disable other controls
-        m_Controls->GrabbingDevicePanel->setEnabled(false);
-        m_Controls->VideoFilePanel->setEnabled(false);
-        m_Controls->UseGrabbingDeviceButton->setEnabled(false);
-        m_Controls->UseVideoFileButton->setEnabled(false);
-        m_Controls->UpdateRatePanel->setEnabled(false);
-      }
-    }
+    this->Play();
   }
   else
   {
     // show pause button
     this->SwitchPlayButton(true);
     m_VideoSource->PauseCapturing();
   }
 }
 
 void QmitkOpenCVVideoControls::on_StopButton_clicked(bool /*checked=false*/)
 {
   this->Stop();
 }
 
+void QmitkOpenCVVideoControls::Play()
+{
+  if (m_VideoSource->GetCapturePaused())
+  {
+    this->SwitchPlayButton(false);
+    m_VideoSource->PauseCapturing();
+  }
+  else
+  {
+    if (m_Controls->UseGrabbingDeviceButton->isChecked())
+    {
+      m_VideoSource->SetVideoCameraInput(m_Controls->GrabbingDeviceNumber->text().toInt(), false);
+      m_Controls->VideoFileControls->setEnabled(false);
+    }
+    else
+    {
+      m_VideoSource->SetVideoFileInput(m_Controls->FileChooser->GetFile().c_str(), m_Controls->RepeatVideoButton->isChecked(), false);
+      m_VideoSource->SetRepeatVideo(m_Controls->RepeatVideoButton->isChecked());
+      m_Controls->VideoProgressSlider->setValue(0);
+    }
+
+    m_VideoSource->StartCapturing();
+
+    if (!m_VideoSource->IsCapturingEnabled())
+    {
+      MITK_ERROR << "Video could not be initialized!";
+      m_Controls->PlayButton->setChecked(false);
+    }
+    else
+    {
+      int hertz = m_Controls->UpdateRate->text().toInt();
+      int updateTime = itk::Math::Round<int, double>(1000.0 / hertz);
+
+      // resets the whole background
+      m_VideoBackground->SetTimerDelay(updateTime);
+      m_VideoBackground->AddRenderWindow(m_RenderWindow->GetVtkRenderWindow());
+      this->connect(m_VideoBackground, SIGNAL(NewFrameAvailable(mitk::VideoSource*))
+        , this, SLOT(NewFrameAvailable(mitk::VideoSource*)));
+      this->connect(m_VideoBackground, SIGNAL(EndOfVideoSourceReached(mitk::VideoSource*))
+        , this, SLOT(EndOfVideoSourceReached(mitk::VideoSource*)));
+
+      m_VideoBackground->Enable();
+      this->m_Controls->StopButton->setEnabled(true);
+      // show video file controls
+      if (m_Controls->UseVideoFileButton->isChecked())
+      {
+        m_Controls->VideoFileControls->setEnabled(true);
+        m_Controls->RepeatVideoButton->setEnabled(true);
+        m_Controls->VideoProgressSlider->setEnabled(true);
+      }
+      // show pause button
+      this->SwitchPlayButton(false);
+      // disable other controls
+      m_Controls->GrabbingDevicePanel->setEnabled(false);
+      m_Controls->VideoFilePanel->setEnabled(false);
+      m_Controls->UseGrabbingDeviceButton->setEnabled(false);
+      m_Controls->UseVideoFileButton->setEnabled(false);
+      m_Controls->UpdateRatePanel->setEnabled(false);
+    }
+  }
+}
+
 void QmitkOpenCVVideoControls::Stop()
 {
   // disable video file controls, stop button and show play button again
   m_Controls->UseGrabbingDeviceButton->setEnabled(true);
   m_Controls->UseVideoFileButton->setEnabled(true);
   if (m_Controls->UseGrabbingDeviceButton->isChecked())
     on_UseGrabbingDeviceButton_clicked(true);
   else
     on_UseVideoFileButton_clicked(true);
 
   m_Controls->UpdateRatePanel->setEnabled(true);
   m_Controls->VideoFileControls->setEnabled(false);
   this->m_Controls->StopButton->setEnabled(false);
   this->SwitchPlayButton(true);
 
   if (m_VideoBackground)
   {
     m_VideoBackground->Disable();
 
     if (m_RenderWindow)
       m_VideoBackground->RemoveRenderWindow(m_RenderWindow->GetVtkRenderWindow());
 
     this->disconnect(m_VideoBackground, SIGNAL(NewFrameAvailable(mitk::VideoSource*))
       , this, SLOT(NewFrameAvailable(mitk::VideoSource*)));
   }
   if (m_VideoSource != 0)
     m_VideoSource->StopCapturing();
 }
 
 void QmitkOpenCVVideoControls::Reset()
 {
   this->Stop();
 }
 
 void QmitkOpenCVVideoControls::SwitchPlayButton(bool paused)
 {
   if (paused)
   {
     m_Controls->PlayButton->setText("Play");
     m_Controls->PlayButton->setIcon(QIcon(":/OpenCVVideoSupportUI/media-playback-start.png"));
     m_Controls->PlayButton->setChecked(false);
   }
   else
   {
     m_Controls->PlayButton->setText("Pause");
     m_Controls->PlayButton->setIcon(QIcon(":/OpenCVVideoSupportUI/media-playback-pause.png"));
     m_Controls->PlayButton->setChecked(true);
   }
 }
 
 void QmitkOpenCVVideoControls::NewFrameAvailable(mitk::VideoSource* /*videoSource*/)
 {
   emit NewOpenCVFrameAvailable(m_VideoSource->GetCurrentFrame());
   if (!m_SliderCurrentlyMoved)
     m_Controls->VideoProgressSlider->setValue(itk::Math::Round<int, double>(m_VideoSource->GetVideoCaptureProperty(CV_CAP_PROP_POS_AVI_RATIO)
     *m_Controls->VideoProgressSlider->maximum()));
 }
 
+void QmitkOpenCVVideoControls::EndOfVideoSourceReached(mitk::VideoSource* /*videoSource*/)
+{
+  if (m_Controls->RepeatVideoButton->isChecked())
+  {
+    this->Reset();
+    this->Play();
+  }
+  else
+  {
+    this->Stop();
+  }
+}
+
 void QmitkOpenCVVideoControls::SetRenderWindow(QmitkRenderWindow* _RenderWindow)
 {
   if (m_RenderWindow == _RenderWindow)
     return;
 
   // In Reset() m_MultiWidget is used, set it to 0 now for avoiding errors
   if (_RenderWindow == 0)
     m_RenderWindow = 0;
   this->Reset();
 
   m_RenderWindow = _RenderWindow;
 
   if (m_RenderWindow == 0)
   {
     this->setEnabled(false);
   }
   else
   {
     this->setEnabled(true);
   }
 }
 
 QmitkRenderWindow* QmitkOpenCVVideoControls::GetRenderWindow() const
 {
   return m_RenderWindow;
 }
 
 void QmitkOpenCVVideoControls::SetVideoBackground(QmitkVideoBackground* _VideoBackground)
 {
   if (m_VideoBackground == _VideoBackground)
     return;
 
   if (m_VideoBackground != nullptr)
     this->disconnect(m_VideoBackground, SIGNAL(destroyed(QObject*))
     , this, SLOT(QObjectDestroyed(QObject*)));
 
   this->Reset();
 
   m_VideoBackground = _VideoBackground;
 
   if (m_VideoBackground == nullptr)
   {
     m_VideoSource = 0;
     MITK_WARN << "m_MultiWidget is 0";
     this->setEnabled(false);
   }
   else
   {
     this->setEnabled(true);
     m_VideoSource = dynamic_cast<mitk::OpenCVVideoSource*>(m_VideoBackground->GetVideoSource());
     // preset form entries
     if (m_VideoSource != nullptr)
     {
       if (!m_VideoSource->GetVideoFileName().empty())
       {
         m_Controls->FileChooser->SetFile(m_VideoSource->GetVideoFileName());
         on_UseGrabbingDeviceButton_clicked(false);
       }
       else if (m_VideoSource->GetGrabbingDeviceNumber() >= 0)
         m_Controls->GrabbingDeviceNumber->setValue(m_VideoSource->GetGrabbingDeviceNumber());
 
       m_Controls->UpdateRate->setValue(m_VideoBackground->GetTimerDelay());
 
       this->connect(m_VideoBackground, SIGNAL(destroyed(QObject*))
         , this, SLOT(QObjectDestroyed(QObject*)));
     }
     else
     {
       MITK_WARN << "m_VideoSource is 0";
       this->setEnabled(false);
     }
   }
 }
 
 QmitkVideoBackground* QmitkOpenCVVideoControls::GetVideoBackground() const
 {
   return m_VideoBackground;
 }
 
 void QmitkOpenCVVideoControls::QObjectDestroyed(QObject * obj /*= 0 */)
 {
   if (m_VideoBackground == obj)
   {
     m_VideoSource = nullptr;
     this->SetVideoBackground(nullptr);
   }
 }
 
 void QmitkOpenCVVideoControlsPrivate::ToPropertyList()
 {
   mitk::IPersistenceService* persistenceService = this->GetPersistenceService();
 
   if (persistenceService != nullptr)
   {
       mitk::PropertyList::Pointer propList = persistenceService->GetPropertyList(m_Id);
       propList->Set("deviceType", q->m_Controls->UseGrabbingDeviceButton->isChecked() ? 0 : 1);
       propList->Set("grabbingDeviceNumber", q->m_Controls->GrabbingDeviceNumber->value());
       propList->Set("updateRate", q->m_Controls->UpdateRate->value());
       propList->Set("repeatVideo", q->m_Controls->RepeatVideoButton->isChecked());
   }
   else
   {
     MITK_WARN << "Persistence Service not available.";
   }
 }
 
 void QmitkOpenCVVideoControlsPrivate::FromPropertyList()
 {
   mitk::IPersistenceService* persistenceService = this->GetPersistenceService();
 
   if (persistenceService != nullptr)
   {
     mitk::PropertyList::Pointer propList = persistenceService->GetPropertyList(m_Id);
 
     bool repeatVideo = false;
     propList->Get("repeatVideo", repeatVideo);
     q->m_Controls->RepeatVideoButton->setChecked(repeatVideo);
 
     int updateRate = 25;
     propList->Get("updateRate", updateRate);
     q->m_Controls->UpdateRate->setValue(updateRate);
 
     int grabbingDeviceNumber = 0;
     propList->Get("grabbingDeviceNumber", grabbingDeviceNumber);
     q->m_Controls->GrabbingDeviceNumber->setValue(grabbingDeviceNumber);
 
     int deviceType = 0;
     propList->Get("deviceType", deviceType);
     if (deviceType == 0)
     {
       q->m_Controls->UseGrabbingDeviceButton->setChecked(true);
     }
     else
     {
       q->m_Controls->UseVideoFileButton->setChecked(true);
     }
   }
   else
   {
     MITK_WARN << "Persistence Service not available.";
   }
 }
 
 void QmitkOpenCVVideoControls::AfterPropertyListReplaced(const std::string& id, mitk::PropertyList* /*propertyList*/)
 {
   if (id == d->m_Id)
     d->FromPropertyList();
 }
diff --git a/Modules/OpenCVVideoSupport/UI/QmitkOpenCVVideoControls.h b/Modules/OpenCVVideoSupport/UI/QmitkOpenCVVideoControls.h
index fca4d0ab50..17fc693eeb 100644
--- a/Modules/OpenCVVideoSupport/UI/QmitkOpenCVVideoControls.h
+++ b/Modules/OpenCVVideoSupport/UI/QmitkOpenCVVideoControls.h
@@ -1,116 +1,119 @@
 /*===================================================================
 
 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 QmitkOpenCVVideoControls_h
 #define QmitkOpenCVVideoControls_h
 
 #include <cv.h>
 #include <ui_QmitkOpenCVVideoControls.h>
 #include <MitkOpenCVVideoSupportUIExports.h>
 #include <mitkPropertyListReplacedObserver.h>
 
 class QmitkRenderWindow;
 class QmitkVideoBackground;
 namespace mitk
 {
   class VideoSource;
   class OpenCVVideoSource;
 }
 
 class QmitkOpenCVVideoControlsPrivate;
 
 ///
 /// \brief Offers widgets to play/pause/stop a video on a certain render window with
 /// the use of an !initialized! QmitkVideoBackground. The QmitkVideoBackground should
 /// contain an OpenCVVideoSource is then owned by this widget (and deleted)
 ///
 class MITKOPENCVVIDEOSUPPORTUI_EXPORT QmitkOpenCVVideoControls : public QWidget,  public mitk::PropertyListReplacedObserver
 {
   Q_OBJECT
 
 public:
   ///
   /// Construct the widget with the given render window and the given preset values
   ///
   QmitkOpenCVVideoControls(QmitkVideoBackground* _VideoBackground, QmitkRenderWindow* _RenderWindow
     , QWidget* parent = 0, Qt::WindowFlags f = 0);
 
   ///
   /// call reset if video playback is enabled here
   ///
   virtual ~QmitkOpenCVVideoControls();
 
   ///
   /// sets the render window for this video player
   ///
   void SetRenderWindow(QmitkRenderWindow* _RenderWindow);
 
   ///
   /// returns the current render window
   ///
   QmitkRenderWindow* GetRenderWindow() const;
 
   ///
   /// sets the qmitkvideobackground for this
   ///
   void SetVideoBackground(QmitkVideoBackground* _VideoBackground);
 
   ///
   /// returns the current QmitkVideoBackground
   ///
   QmitkVideoBackground* GetVideoBackground() const;
 
   ///
   /// calls FromPropertyList
   ///
   void AfterPropertyListReplaced( const std::string& id, mitk::PropertyList* propertyList ) override;
 
 signals:
   ///
   /// When playback is started this informs when a new frame was grabbed
   ///
   void NewOpenCVFrameAvailable(const IplImage*);
 
 protected slots:
   void on_UseGrabbingDeviceButton_clicked(bool checked=false);
   void on_UseVideoFileButton_clicked(bool checked=false);
   void on_VideoProgressSlider_sliderPressed();
   void on_VideoProgressSlider_sliderReleased();
   void on_RepeatVideoButton_clicked( bool checked=false );
   void on_PlayButton_clicked(bool checked=false);
   void on_StopButton_clicked(bool checked=false);
+  void Play();
   void Stop();
   void Reset();
   void SwitchPlayButton(bool paused);
   void QObjectDestroyed( QObject * obj = 0 );
 
   void NewFrameAvailable(mitk::VideoSource* videoSource);
+  void EndOfVideoSourceReached(mitk::VideoSource* videoSource);
+
 protected:
   QmitkVideoBackground* m_VideoBackground;
   QmitkRenderWindow* m_RenderWindow;
   mitk::OpenCVVideoSource* m_VideoSource;
   Ui::QmitkOpenCVVideoControls* m_Controls;
   bool m_SliderCurrentlyMoved;
 
 private:
 
   friend class QmitkOpenCVVideoControlsPrivate;
 
   QScopedPointer<QmitkOpenCVVideoControlsPrivate> d;
 
 };
 
 #endif
diff --git a/Modules/OpenCVVideoSupport/mitkOpenCVVideoSource.cpp b/Modules/OpenCVVideoSupport/mitkOpenCVVideoSource.cpp
index da4f03f135..308f9c8d49 100644
--- a/Modules/OpenCVVideoSupport/mitkOpenCVVideoSource.cpp
+++ b/Modules/OpenCVVideoSupport/mitkOpenCVVideoSource.cpp
@@ -1,426 +1,426 @@
 /*===================================================================
 
 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 "mitkOpenCVVideoSource.h"
 #include <iostream>
 #include <algorithm>
 
 mitk::OpenCVVideoSource::OpenCVVideoSource()
 : m_VideoCapture(nullptr),
   m_CurrentImage(nullptr),
   m_CurrentVideoTexture(nullptr),
   m_PauseImage(nullptr),
   m_GrabbingDeviceNumber(-1),
   m_RepeatVideo(false),
   m_UseCVCAMLib(false),
   m_UndistortImage(false),
   m_FlipXAxisEnabled(false),
   m_FlipYAxisEnabled(false)
 {
 }
 
 mitk::OpenCVVideoSource::~OpenCVVideoSource()
 {
   this->Reset();
 }
 
 void mitk::OpenCVVideoSource::SetVideoFileInput(const char * filename, bool repeatVideo, bool /*useCVCAMLib*/)
 {
   this->Reset();
   m_VideoFileName = filename;
 
   m_VideoCapture = cvCaptureFromFile(filename);
   if(!m_VideoCapture)
     MITK_WARN << "Error in initializing video file input!";
 
   m_RepeatVideo  = repeatVideo;
   //m_CurrentImage        = cvCreateImage(cvSize(m_CaptureWidth,m_CaptureHeight),8,3);
   this->Modified();
 
 }
 void mitk::OpenCVVideoSource::SetVideoCameraInput(int cameraindex, bool /*useCVCAMLib*/)
 {
   this->Reset();
 
   m_GrabbingDeviceNumber = cameraindex;
   m_VideoCapture = cvCaptureFromCAM(m_GrabbingDeviceNumber);
   if(!m_VideoCapture)
     MITK_ERROR << "Error in initializing CVHighGUI video camera!"<< std::endl;
 
   this->Modified();
 }
 
 double mitk::OpenCVVideoSource::GetVideoCaptureProperty(int property_id)
 {
   return cvGetCaptureProperty(m_VideoCapture, property_id);
 }
 
 int mitk::OpenCVVideoSource::SetVideoCaptureProperty(int property_id, double value)
 {
   return cvSetCaptureProperty(m_VideoCapture, property_id, value);
 }
 
 //method extended for "static video feature" if enabled
 unsigned char* mitk::OpenCVVideoSource::GetVideoTexture()
 { // Fetch Frame and return pointer to opengl texture
   FetchFrame();
 
   if (m_FlipXAxisEnabled || m_FlipYAxisEnabled)
   {
     //rotate the image to get a static video
     m_CurrentImage = this->FlipImage(m_CurrentImage);
 
   }
 
   //transfer the image to a texture
   this->UpdateVideoTexture();
   return this->m_CurrentVideoTexture;
   this->Modified();
 }
 
 cv::Mat mitk::OpenCVVideoSource::GetImage()
 {
   if(m_CurrentImage)
   {
     cv::Mat copy( m_CurrentImage, false );
     return copy.clone();
   }
   return cv::Mat();
 }
 
 const IplImage * mitk::OpenCVVideoSource::GetCurrentFrame()
 {
   return m_CurrentImage;
 }
 
 void mitk::OpenCVVideoSource::GetCurrentFrameAsOpenCVImage(IplImage * image)
 { // get last captured frame for processing the image data
   if(m_CurrentImage)
   {
     if(image)
     {
       image->origin = m_CurrentImage->origin;
       memcpy(image->imageData,m_CurrentImage->imageData,m_CurrentImage->width*m_CurrentImage->height*m_CurrentImage->nChannels);
     }
   }
 }
 
 void mitk::OpenCVVideoSource::FetchFrame()
 { // main procedure for updating video data
   if(m_CapturingInProcess)
   {
     if(m_VideoCapture) // we use highgui
     {
       if(!m_CapturePaused)
       {
         // release old image here
         m_CurrentImage = cvQueryFrame(m_VideoCapture);
         ++m_FrameCount;
       }
 
       if(m_CurrentImage == nullptr) // do we need to repeat the video if it is from video file?
       {
         double framePos = this->GetVideoCaptureProperty(CV_CAP_PROP_POS_AVI_RATIO);
         MITK_DEBUG << "End of video file found. framePos: " << framePos;
-        if(m_RepeatVideo &&  framePos >= 0.99)
+        if(m_RepeatVideo && framePos >= 0.99)
         {
           MITK_DEBUG << "Restarting video file playback.";
           this->SetVideoCaptureProperty(CV_CAP_PROP_POS_AVI_RATIO, 0);
           m_FrameCount = 0;
           m_CurrentImage = cvQueryFrame(m_VideoCapture);
         }
         else
         {
           std::ostringstream s;
           s << "End of video file " << m_VideoFileName;
           std::logic_error err( s.str() );
           throw err;
         }
       }
       else
       {
         // only undistort if not paused
         if(m_UndistortImage && m_UndistortCameraImage.IsNotNull())
           m_UndistortCameraImage->UndistortImageFast(m_CurrentImage, nullptr);
       }
 
       if(m_CaptureWidth == 0 || m_CaptureHeight == 0)
       {
         MITK_DEBUG << "Trying to set m_CaptureWidth & m_CaptureHeight.";
         m_CaptureWidth  = m_CurrentImage->width;
         m_CaptureHeight = m_CurrentImage->height;
         MITK_INFO << "frame width: " << m_CaptureWidth << ", height: " << m_CaptureHeight;
         m_CurrentImage->origin = 0;
       }
     }
   }
 }
 
 void mitk::OpenCVVideoSource::UpdateVideoTexture()
 {  //write the grabbed frame into an opengl compatible array, that means flip it and swap channel order
   if(!m_CurrentImage)
     return;
 
   if(m_CurrentVideoTexture == nullptr)
     m_CurrentVideoTexture = new unsigned char[m_CaptureWidth*m_CaptureHeight*3];
 
   int width = m_CurrentImage->width;
   int height = m_CurrentImage->height;
   int widthStep = m_CurrentImage->widthStep;
   int nChannels = m_CurrentImage->nChannels;
   unsigned char* tex = m_CurrentVideoTexture;
   char* data = m_CurrentImage->imageData;
   char* currentData = m_CurrentImage->imageData;
 
   int hIndex=0;
   int wIndex=0;
   int iout,jout;
 
   for(int i=0;i<width*height*3;i+=3,++wIndex)
   {
     if(wIndex >= width)
     {
       wIndex=0;
       hIndex++;
     }
 
     // vertically flip the image
     iout = -hIndex+height-1;
     jout = wIndex;
 
     currentData = data + iout*widthStep;
 
     tex[i+2] = currentData[jout*nChannels + 0]; // B
     tex[i+1] = currentData[jout*nChannels + 1]; // G
     tex[i] = currentData[jout*nChannels + 2]; // R
   }
 
 }
 
 void mitk::OpenCVVideoSource::StartCapturing()
 {
   if(m_VideoCapture != nullptr)
     m_CapturingInProcess = true;
   else
     m_CapturingInProcess = false;
 }
 
 void mitk::OpenCVVideoSource::StopCapturing()
 {
   m_CapturingInProcess = false;
 }
 
 bool mitk::OpenCVVideoSource::OnlineImageUndistortionEnabled() const
 {
   return m_UndistortCameraImage;
 }
 
 void mitk::OpenCVVideoSource::PauseCapturing()
 {
   m_CapturePaused = !m_CapturePaused;
 
   if(m_CapturePaused)
   {
     m_PauseImage = cvCloneImage(m_CurrentImage);
 
     // undistort this pause image if necessary
     if(m_UndistortImage)
       m_UndistortCameraImage->UndistortImageFast(m_PauseImage, nullptr);
     m_CurrentImage = m_PauseImage;
   }
   else
   {
     cvReleaseImage( &m_PauseImage ); // release old pause image if necessary
     m_CurrentImage = nullptr;
     m_PauseImage = nullptr;
   }
 }
 
 void mitk::OpenCVVideoSource::EnableOnlineImageUndistortion(mitk::Point3D focal, mitk::Point3D principal, mitk::Point4D distortion)
 {
   // Initialize Undistortion
   m_UndistortImage = true;
   float kc[4];
   kc[0] = distortion[0]; kc[1] = distortion[1];
   kc[2] = distortion[2]; kc[3] = distortion[3];
   if(m_CaptureWidth == 0 || m_CaptureHeight == 0)
     FetchFrame();
 
   m_UndistortCameraImage = mitk::UndistortCameraImage::New();
   m_UndistortCameraImage->SetUndistortImageFastInfo(focal[0], focal[1], principal[0], principal[1],  kc, (float)m_CaptureWidth, (float)m_CaptureHeight);
 }
 
 void mitk::OpenCVVideoSource::DisableOnlineImageUndistortion()
 {
   m_UndistortImage = false;
 }
 
 // functions for compatibility with ITK segmentation only
 void mitk::OpenCVVideoSource::GetCurrentFrameAsItkHSVPixelImage(HSVPixelImageType::Pointer &Image)
 {
   FetchFrame();
 
   // Prepare iteration
   HSVConstIteratorType itImage( Image, Image->GetLargestPossibleRegion());
   itImage.Begin();
   HSVPixelType pixel;
   int rowsize = 3 * m_CaptureWidth;
 
   char* bufferend;
   char* picture;
   picture = this->m_CurrentImage->imageData;
   bufferend = this->m_CurrentImage->imageData + 3*(m_CaptureHeight*m_CaptureWidth);
 
   float r,g,b,h,s,v;
   try
   {
     // we have to flip the image
     for(char* datapointer = bufferend - rowsize;datapointer >= picture; datapointer -= rowsize)
     {
       for(char* current = datapointer; current < datapointer + rowsize; current++)
       {
           b = *current; current++;
           g = *current; current++;
           r = *current;
           RGBtoHSV(r,g,b,h,s,v);
           pixel[0] = h;
           pixel[1] = s;
           pixel[2] = v;
 
           itImage.Set(pixel);
           ++itImage;
       }
     }
   }
   catch( ... )
   {
     std::cout << "Exception raised mitkOpenCVVideoSource: get hsv itk image conversion error." << std::endl;
   }
 
 }
 
 void mitk::OpenCVVideoSource::RGBtoHSV(float r, float g, float b, float &h, float &s, float &v)
 {
     if(r > 1.0)
       r = r/255;
     if(b > 1.0)
       b = b/255;
     if(g > 1.0)
       g = g/255;
 
     float mn=r,mx=r;
     int maxVal=0;
 
     if (g > mx){ mx=g;maxVal=1;}
     if (b > mx){ mx=b;maxVal=2;}
     if (g < mn) mn=g;
     if (b < mn) mn=b;
 
     float  delta = mx - mn;
 
     v = mx;
     if( mx != 0 )
       s = delta / mx;
     else
     {
       s = 0;
       h = 0;
       return;
     }
     if (s==0.0f)
     {
       h=-1;
       return;
     }
     else
     {
       switch (maxVal)
       {
       case 0:{h = ( g - b ) / delta;break;}         // yel < h < mag
       case 1:{h = 2 + ( b - r ) / delta;break;}     // cyan < h < yel
       case 2:{h = 4 + ( r - g ) / delta;break;}     // mag < h < cyan
       }
     }
 
     h *= 60;
     if( h < 0 ) h += 360;
 }
 
 /*
 * Rotate input image according to rotation angle around the viewing direction.
 * Angle is supposed to be calculated in QmitkARRotationComponet in the update() method.
 */
 IplImage* mitk::OpenCVVideoSource::FlipImage(IplImage* input)
 {
   if(input == nullptr)
   { //warn the user and quit
     std::cout<<"openCVVideoSource: Current video image is null! "<< std::endl;
     return input;
   }
 
   if(m_FlipXAxisEnabled && !m_FlipYAxisEnabled)
   {
   cvFlip(input,nullptr,0);
   }
   if(!m_FlipXAxisEnabled && m_FlipYAxisEnabled)
   {
   cvFlip(input,nullptr,1);
   }
   if(m_FlipXAxisEnabled && m_FlipYAxisEnabled)
   {
   cvFlip(input,nullptr,-1);
   }
 
   return input;
 }
 
 void mitk::OpenCVVideoSource::Reset()
 {
   // set capturing to false
   this->StopCapturing();
   if(m_VideoCapture)
     cvReleaseCapture(&m_VideoCapture);
   m_VideoCapture = nullptr;
   m_CurrentImage = nullptr;
   m_CaptureWidth = 0;
   m_CaptureHeight = 0;
   delete m_CurrentVideoTexture;
   m_CurrentVideoTexture = nullptr;
   if(m_PauseImage)
     cvReleaseImage(&m_PauseImage);
   m_PauseImage = nullptr;
   m_CapturePaused = false;
   m_VideoFileName.clear();
   m_GrabbingDeviceNumber = -1;
   // do not touch repeat video
   //m_RepeatVideo = false;
   m_UseCVCAMLib = false;
   // do not touch undistort settings
   // bool m_UndistortImage;
 }
 
 void mitk::OpenCVVideoSource::SetEnableXAxisFlip(bool enable)
 {
    this->m_FlipXAxisEnabled = enable;
    this->Modified();
 }
 
 void mitk::OpenCVVideoSource::SetEnableYAxisFlip(bool enable)
 {
    this->m_FlipXAxisEnabled = enable;
    this->Modified();
 }
 
diff --git a/Modules/QtWidgetsExt/include/QmitkVideoBackground.h b/Modules/QtWidgetsExt/include/QmitkVideoBackground.h
index 9e5682353d..5c4d43ecc3 100644
--- a/Modules/QtWidgetsExt/include/QmitkVideoBackground.h
+++ b/Modules/QtWidgetsExt/include/QmitkVideoBackground.h
@@ -1,207 +1,209 @@
 /*===================================================================
 
 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 _Qmitk_Video_Background_h_
 #define _Qmitk_Video_Background_h_
 
 // MITK
 #include "mitkVideoSource.h"
 #include "MitkQtWidgetsExtExports.h"
 
 // Qt
 #include <QObject>
 class QTimer;
 
 // vtk
 class vtkRenderer;
 class vtkRenderWindow;
 class vtkImageActor;
 class vtkImageImport;
 class vtkActor2D;
 class vtkVideoSizeCallback;
 class vtkObject;
 
 /**
  * Displays a 3-channel (!) video data in the background
  * of one or more vtkRenderWindow(s).
  * The video is provided by a mitkVideoSource / GetVideoTexture().
  * Caution: As the texture data is not being copied, the user is responsible for a valid
  * pointer to the data. Also the image dimensions needs to be set correctly before enabling the
  * background.
  */
 class MITKQTWIDGETSEXT_EXPORT QmitkVideoBackground : public QObject
 {
   Q_OBJECT
 
 public:
   ///
   /// default ctor, TimerDelay is 40 by default
   /// you must SetVideoSource() and AddRenderWindow() afterwards
   ///
   explicit QmitkVideoBackground(QObject* parent = nullptr);
   ///
   /// constructs a video background with the given video source
   /// no parent is set here, dont forget to delete the object or
   /// call setParent()
   /// TimerDelay = refresh rate of video in ms (25 ms = 40 Hz).
   /// you must call AddRenderWindow() afterwards
   ///
   explicit QmitkVideoBackground(mitk::VideoSource* v, int TimerDelay = 25);
   ///
   /// disables all video backgrounds
   ///
   virtual ~QmitkVideoBackground();
 
   ///
   /// \brief add a RenderWindow in which the video is displayed.
   /// -> must be initialized before enabling the background.
   /// if the renderwindow was previously inserted it will get
   /// re-inserted (restarted videobackground)
   /// *ATTENTION*: to size the renderwindow correctly GetImageWidth() of the video
   /// source will be called and if *no size is returned: FetchFrame()
   /// on the video source will be called to get the first frame and
   /// the corresponding size*
   ///
   void AddRenderWindow(vtkRenderWindow* renderWindow);
   ///
   /// \brief removes a renderwindow = disables video background there
   ///
   void RemoveRenderWindow(vtkRenderWindow* renderWindow);
   ///
   /// \return true if "renderWindow" is currently connected to the video
   /// background or not
   ///
   bool IsRenderWindowIncluded(vtkRenderWindow* renderWindow);
 
   ///
   /// \brief sets the update rate of the video in milli seconds, by default 25.
   ///
   void SetTimerDelay(int ms);
   ///
   /// visualizes the video. Requires image dimensions and an active videosource to be set.
   ///
   void Enable();
   ///
   /// \brief disables visualization of the video.
   ///
   void Disable();
   ///
   /// \brief Checks, if the Video background is currently enabled (visible).
   ///
   bool IsEnabled();
 
   ///
   /// Returns the videosource attached to this background
   ///
   mitk::VideoSource* GetVideoSource();
   ///
   /// Returns the timer delay
   ///
   int GetTimerDelay();
   ///
   /// pauses the playback (stops the update timer)
   ///
   void Pause();
   ///
   /// resumes the playback (restarts the update timer)
   ///
   void Resume();
 
   ///
   /// sets a *new* video source (if previously enabled, this will stop
   /// the video background if it was previously enabled
   ///
   void SetVideoSource(mitk::VideoSource* videoSource);
 
   ///
   /// receive renderwindow delete events
   ///
   static void OnRenderWindowDelete(vtkObject*, unsigned long eid , void* clientdata, void* /*calldata*/);
 
   ///
   /// receive VideoSource delete event
   ///
   void OnVideoSourceDelete(const itk::Object* caller
     , const itk::EventObject &event);
   public slots:
     ///
     /// update all video backgrounds. (called by the timer or manually
     /// by the user)
     ///
     void UpdateVideo();
   signals:
     ///
     /// emitted after all video backgrounds are filled with the new
     /// video frame
     ///
     void NewFrameAvailable(mitk::VideoSource*);
 
+    void EndOfVideoSourceReached(mitk::VideoSource*);
+
 protected:
   ///
   /// class for holding all vtk dependencies
   /// needed to do background image rendering
   ///
   struct VideoBackgroundVectorInfo
   {
     vtkRenderWindow*  renWin;
     vtkRenderer*      videoRenderer;
     vtkImageActor*    videoActor;
     vtkImageImport*   videoImport;
     unsigned long renderWindowObserverTag;
   };
 
   ///
   /// removes the renderwindow and also removes the observer if the flag is set
   ///
   void RemoveRenderWindow(vtkRenderWindow* renderWindow, bool removeObserver);
   ///
   /// reset all video backgrounds
   ///
   void ResetVideoBackground();
 
   ///
   /// inits all renderwindows with default values, called before video rendering is started
   ///
   void Modified();
   ///
   /// the class has to store a list of renderwindows
   ///
   typedef std::vector<VideoBackgroundVectorInfo> RenderWindowVectorInfoType;
 
 protected:
   ///
   /// a list of renderwindows and associated renderers and actors and imageimporters
   ///
   RenderWindowVectorInfoType m_renderWindowVectorInfo;
 
   ///
   /// calls updatevideo repeateadly for framegrabbing
   ///
   QTimer* m_QTimer;
 
   ///
   /// must implement GetVideoTexture() correctly (must return an OpenGL texture)
   ///
   mitk::VideoSource* m_VideoSource;
 
   ///
   /// the observer tag for the video source
   ///
   unsigned long m_VideoSourceObserverTag;
 };
 
 #endif
 
diff --git a/Modules/QtWidgetsExt/src/QmitkVideoBackground.cpp b/Modules/QtWidgetsExt/src/QmitkVideoBackground.cpp
index 386b8acdf4..3a305549b6 100644
--- a/Modules/QtWidgetsExt/src/QmitkVideoBackground.cpp
+++ b/Modules/QtWidgetsExt/src/QmitkVideoBackground.cpp
@@ -1,303 +1,314 @@
 /*===================================================================
 
 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 "QmitkVideoBackground.h"
 
 // MITK includes
 #include "mitkVtkLayerController.h"
 #include "mitkRenderingManager.h"
 
 // QT includes
 #include <QTimer>
 
 // itk includes
 #include <itkCommand.h>
 
 // VTK includes
 #include <vtkSystemIncludes.h>
 #include <vtkRenderer.h>
 #include <vtkMapper.h>
 #include <vtkObjectFactory.h>
 #include <vtkImageActor.h>
 #include <vtkRenderWindow.h>
 #include <vtkImageImport.h>
 #include <vtkCommand.h>
 #include <vtkCamera.h>
 #include <vtkCommand.h>
 #include <vtkSmartPointer.h>
 #include <vtkCallbackCommand.h>
 
 QmitkVideoBackground::QmitkVideoBackground( QObject *parent )
 : QObject(parent)
 , m_QTimer(new QTimer(this))
 , m_VideoSource(nullptr)
 , m_VideoSourceObserverTag(0)
 {
   this->ResetVideoBackground();
 }
 
 QmitkVideoBackground::QmitkVideoBackground(mitk::VideoSource* v, int)
 : QObject(nullptr)
 , m_QTimer(new QTimer(this))
 , m_VideoSource(nullptr)
 , m_VideoSourceObserverTag(0)
 {
   this->SetVideoSource( v );
   this->ResetVideoBackground();
 }
 
 void QmitkVideoBackground::ResetVideoBackground()
 {
   m_QTimer->setInterval(25);
   connect( m_QTimer, SIGNAL(timeout()), SLOT(UpdateVideo()) );
   m_renderWindowVectorInfo.clear();
 }
 
 QmitkVideoBackground::~QmitkVideoBackground()
 {
   this->Disable();
 }
 
 void QmitkVideoBackground::AddRenderWindow(vtkRenderWindow* renderWindow )
 {
   if(!renderWindow || !m_VideoSource)
   {
     MITK_WARN << "No Renderwindow or VideoSource set!";
     return;
   }
 
   this->RemoveRenderWindow(renderWindow);
 
   vtkRenderer*    videoRenderer   = vtkRenderer::New();
   vtkImageActor*  videoActor      = vtkImageActor::New();
   vtkImageImport* videoImport     = vtkImageImport::New();
 
   videoImport->SetDataScalarTypeToUnsignedChar();
   videoImport->SetNumberOfScalarComponents(3);
 
   if(m_VideoSource->GetImageWidth() == 0)
     m_VideoSource->FetchFrame();
 
   videoImport->SetWholeExtent(0, m_VideoSource->GetImageWidth()-1,
     0, m_VideoSource->GetImageHeight()-1, 0, 1-1);
   videoImport->SetDataExtentToWholeExtent();
 
   VideoBackgroundVectorInfo v;
   v.renWin        = renderWindow;
   v.videoRenderer = videoRenderer;
   v.videoActor    = videoActor;
   v.videoImport   = videoImport;
 
   // callback for the deletion of the renderwindow
   vtkSmartPointer<vtkCallbackCommand> deleteCallback =
     vtkSmartPointer<vtkCallbackCommand>::New();
   deleteCallback->SetCallback ( QmitkVideoBackground::OnRenderWindowDelete );
   deleteCallback->SetClientData(this);
 
   v.renderWindowObserverTag = renderWindow->AddObserver( vtkCommand::DeleteEvent, deleteCallback );
 
   m_renderWindowVectorInfo.push_back(v);
 
   // completes the initialization
   this->Modified();
 }
 
 void QmitkVideoBackground::RemoveRenderWindow( vtkRenderWindow* renderWindow )
 {
   this->RemoveRenderWindow(renderWindow, true);
 }
 
 void QmitkVideoBackground::RemoveRenderWindow( vtkRenderWindow* renderWindow, bool removeObserver )
 {
   // search for renderwindow and remove it
   for(auto it = m_renderWindowVectorInfo.begin();
     it != m_renderWindowVectorInfo.end(); it++)
   {
     if((*it).renWin == renderWindow)
     {
       mitk::VtkLayerController* layerController =
         mitk::VtkLayerController::GetInstance((*it).renWin);
       // unregister video backround renderer from renderwindow
       if( layerController )
         layerController->RemoveRenderer((*it).videoRenderer);
 
       (*it).videoRenderer->Delete();
       (*it).videoActor->Delete();
       (*it).videoImport->Delete();
       // remove listener
       if(removeObserver)
         renderWindow->RemoveObserver( (*it).renderWindowObserverTag );
       m_renderWindowVectorInfo.erase(it);
       break;
     }
   }
 }
 
 bool QmitkVideoBackground::IsRenderWindowIncluded(vtkRenderWindow* renderWindow )
 {
   for(auto it = m_renderWindowVectorInfo.begin();
     it != m_renderWindowVectorInfo.end(); it++)
   {
     if((*it).renWin == renderWindow)
       return true;
   }
   return false;
 }
 
 void QmitkVideoBackground::Pause()
 {
   m_QTimer->stop();
 }
 
 void QmitkVideoBackground::Resume()
 {
   m_QTimer->start();
 }
 
 /**
  * Enables drawing of the color Video background.
  * If you want to disable it, call the Disable() function.
  */
 void QmitkVideoBackground::Enable()
 {
   UpdateVideo();
   Modified();
 
   m_QTimer->start();
 }
 
 /**
  * Disables drawing of the color Video background.
  * If you want to enable it, call the Enable() function.
  */
 void QmitkVideoBackground::Disable()
 {
   if ( this->IsEnabled() )
   {
     mitk::VtkLayerController* layerController = nullptr;
     for(auto it = m_renderWindowVectorInfo.begin();
       it != m_renderWindowVectorInfo.end(); it++)
     {
       layerController = mitk::VtkLayerController::GetInstance((*it).renWin);
       if(layerController)
         layerController->RemoveRenderer((*it).videoRenderer);
     }
     m_QTimer->stop();
   }
 }
 
 bool QmitkVideoBackground::IsEnabled()
 {
   return m_QTimer->isActive();
 }
 
 void QmitkVideoBackground::UpdateVideo()
 {
   if( m_renderWindowVectorInfo.size() > 0 )
   {
     unsigned char *src = nullptr;
-    src = m_VideoSource->GetVideoTexture();
+
+    try
+    {
+      src = m_VideoSource->GetVideoTexture();
+    }
+    catch (const std::logic_error& error)
+    {
+        MITK_DEBUG << error.what();
+        emit EndOfVideoSourceReached(m_VideoSource);
+        return;
+    }
+
     if(src)
     {
       for(auto it = m_renderWindowVectorInfo.begin();
         it != m_renderWindowVectorInfo.end(); it++)
       {
         (*it).videoImport->SetImportVoidPointer(src);
         (*it).videoImport->Modified();
         (*it).videoImport->Update();
         mitk::RenderingManager::GetInstance()->RequestUpdate((*it).renWin);
       }
       emit NewFrameAvailable ( m_VideoSource );
     }
     else
       MITK_WARN << "No video texture available";
   }
 }
 
 void QmitkVideoBackground::Modified()
 {
   // ensures registration of video backrounds in each renderwindow
   for(auto it = m_renderWindowVectorInfo.begin();
     it != m_renderWindowVectorInfo.end(); it++)
   {
     (*it).videoImport->Update();
     (*it).videoActor->SetInputData((*it).videoImport->GetOutput());
     (*it).videoRenderer->AddActor2D((*it).videoActor);
     (*it).videoRenderer->ResetCamera();
     (*it).videoRenderer->InteractiveOff();
     (*it).videoRenderer->GetActiveCamera()->ParallelProjectionOn();
     (*it).videoRenderer->GetActiveCamera()->SetParallelScale(m_VideoSource->GetImageHeight()/2);
 
     mitk::VtkLayerController* layerController =
       mitk::VtkLayerController::GetInstance((*it).renWin);
 
     if( layerController && !layerController->IsRendererInserted((*it).videoRenderer) )
       layerController->InsertBackgroundRenderer((*it).videoRenderer,true);
   }
 }
 
 void QmitkVideoBackground::SetVideoSource( mitk::VideoSource* videoSource )
 {
   if( m_VideoSource == videoSource )
     return;
 
   if( m_VideoSource )
     m_VideoSource->RemoveObserver( m_VideoSourceObserverTag );
 
   m_VideoSource = videoSource;
 
   if( m_VideoSource )
   {
     itk::MemberCommand<QmitkVideoBackground>::Pointer _ModifiedCommand =
       itk::MemberCommand<QmitkVideoBackground>::New();
     _ModifiedCommand->SetCallbackFunction(this, &QmitkVideoBackground::OnVideoSourceDelete);
     m_VideoSourceObserverTag
       = m_VideoSource->AddObserver(itk::DeleteEvent(), _ModifiedCommand);
   }
 
 }
 
 void QmitkVideoBackground::SetTimerDelay( int ms )
 {
   m_QTimer->setInterval( ms );
 }
 
 mitk::VideoSource* QmitkVideoBackground::GetVideoSource()
 {
   return m_VideoSource;
 }
 
 int QmitkVideoBackground::GetTimerDelay()
 {
   return m_QTimer->interval();
 }
 
 void QmitkVideoBackground::OnVideoSourceDelete(const itk::Object*,
                                                const itk::EventObject&)
 {
   this->Disable(); // will only disable if enabled
   m_VideoSource = nullptr;
 }
 
 void QmitkVideoBackground::OnRenderWindowDelete( vtkObject * object,
                                                  unsigned long,
                                                  void* clientdata,
                                                  void*)
 {
   QmitkVideoBackground* instance = static_cast<QmitkVideoBackground*>( clientdata );
   instance->RemoveRenderWindow( static_cast<vtkRenderWindow*>(object), false );
 }