ctkVTKAbstractView controls the update rate

It ensures that the DesiredUpdateRate of the render window is respected.
(DesiredUpdateRate is typically set by the interactor style using the
 values from the render window interactor).

Libs/Visualization/VTK/Widgets/ctkVTKAbstractView.cpp

@@ -46,7 +46,7 @@ ctkVTKAbstractViewPrivate::ctkVTKAbstractViewPrivate(ctkVTKAbstractView& object)
 {
   this->RenderWindow = vtkSmartPointer<vtkRenderWindow>::New();
   this->CornerAnnotation = vtkSmartPointer<vtkCornerAnnotation>::New();
-  this->RenderPending = false;
+  this->RequestTimer = 0;
   this->RenderEnabled = true;
 }
 
@@ -63,8 +63,16 @@ void ctkVTKAbstractViewPrivate::init()
   q->layout()->setSpacing(0);
   q->layout()->addWidget(this->VTKWidget);
 
+  this->RequestTimer = new QTimer(q);
+  this->RequestTimer->setSingleShot(true);
+  QObject::connect(this->RequestTimer, SIGNAL(timeout()),
+                   q, SLOT(forceRender()));
+
   this->setupCornerAnnotation();
   this->setupRendering();
+
+  // block renders and observe interactor to enforce framerate
+  q->setInteractor(this->RenderWindow->GetInteractor());
 }
 
 // --------------------------------------------------------------------------
@@ -143,18 +151,44 @@ void ctkVTKAbstractView::scheduleRender()
 {
   Q_D(ctkVTKAbstractView);
 
-  logger.trace(QString("scheduleRender - RenderEnabled: %1 - RenderPending: %2").
+  logger.trace(QString("scheduleRender - RenderEnabled: %1 - Request render elapsed: %2ms").
                arg(d->RenderEnabled ? "true" : "false")
-               .arg(d->RenderPending ? "true:" : "false"));
+               .arg(d->RequestTime.elapsed()));
 
   if (!d->RenderEnabled)
     {
     return;
     }
-  if (!d->RenderPending)
+
+  double msecsBeforeRender = 100. / d->RenderWindow->GetDesiredUpdateRate();
+  if(d->VTKWidget->testAttribute(Qt::WA_WState_InPaintEvent))
+    {
+    // If the request comes from the system (widget exposed, resized...), the
+    // render must be done immediately.
+    this->forceRender();
+    }
+  else if (!d->RequestTime.isValid())
+    {
+    // If the DesiredUpdateRate is in "still mode", the requested framerate
+    // is fake, it is just a way to allocate as much time as possible for the
+    // rendering, it doesn't really mean that rendering must occur only once
+    // every couple seconds. It just means it should be done when there is
+    // time to do it. A timer of 0, kind of mean a rendering is done next time
+    // it is idle.
+    if (msecsBeforeRender > 10000)
+      {
+      msecsBeforeRender = 0;
+      }
+    d->RequestTime.start();
+    d->RequestTimer->start(static_cast<int>(msecsBeforeRender));
+    }
+  else if (d->RequestTime.elapsed() > msecsBeforeRender)
     {
-    d->RenderPending = true;
-    QTimer::singleShot(0, this, SLOT(forceRender()));
+    // The rendering hasn't still be done, but msecsBeforeRender milliseconds
+    // have already been elapsed, it is likely that RequestTimer has already
+    // timed out, but the event queue hasn't been processed yet, rendering is
+    // done now to ensure the desired framerate is respected.
+    this->forceRender();
     }
 }
 
@@ -163,7 +197,19 @@ void ctkVTKAbstractView::forceRender()
 {
   Q_D(ctkVTKAbstractView);
 
-  d->RenderPending = false;
+  if (this->sender() == d->RequestTimer  &&
+      !d->RequestTime.isValid())
+    {
+    // The slot associated to the timeout signal is now called, however the
+    // render has already been executed meanwhile. There is no need to do it
+    // again.
+    return;
+    }
+
+  // The timer can be stopped if it hasn't timed out yet.
+  d->RequestTimer->stop();
+  d->RequestTime = QTime();
+
   logger.trace(QString("forceRender - RenderEnabled: %1")
                .arg(d->RenderEnabled ? "true" : "false"));
 
@@ -185,6 +231,12 @@ void ctkVTKAbstractView::setInteractor(vtkRenderWindowInteractor* newInteractor)
   logger.trace("setInteractor");
 
   d->RenderWindow->SetInteractor(newInteractor);
+  // Prevent the interactor to call Render() on the render window; only
+  // scheduleRender() and forceRender() can Render() the window.
+  // This is done to ensure the desired framerate is respected.
+  newInteractor->SetEnableRender(false);
+  qvtkReconnect(d->RenderWindow->GetInteractor(), newInteractor,
+                vtkCommand::RenderEvent, this, SLOT(scheduleRender()));
 }
 
 //----------------------------------------------------------------------------

Libs/Visualization/VTK/Widgets/ctkVTKAbstractView.h

@@ -28,6 +28,7 @@
 #include <QVTKWidget.h>
 
 // CTK includes
+#include "ctkVTKObject.h"
 #include "ctkVisualizationVTKWidgetsExport.h"
 class ctkVTKAbstractViewPrivate;
 
@@ -39,6 +40,7 @@ class vtkRenderWindow;
 class CTK_VISUALIZATION_VTK_WIDGETS_EXPORT ctkVTKAbstractView : public QWidget
 {
   Q_OBJECT
+  QVTK_OBJECT
   Q_PROPERTY(QString cornerAnnotationText READ cornerAnnotationText WRITE setCornerAnnotationText)
   Q_PROPERTY(QColor backgroundColor READ backgroundColor WRITE setBackgroundColor)
   Q_PROPERTY(QColor backgroundColor2 READ backgroundColor2 WRITE setBackgroundColor)
@@ -51,11 +53,15 @@ public:
   virtual ~ctkVTKAbstractView();
 
 public slots:
-
-  /// If a render has already been scheduled, this called is a no-op
+  /// Notify QVTKWidget that the view needs to be rendered.
+  /// scheduleRender() respects the desired framerate of the render window,
+  /// it won't render the window more than what the current render window
+  /// framerate is.
   void scheduleRender();
 
   /// Force a render even if a render is already ocurring
+  /// Be careful when calling forceRender() as it can slow down your
+  /// application. It is preferable to use scheduleRender() instead.
   void forceRender();
 
   /// Set the background color of the rendering screen.
@@ -81,6 +87,10 @@ public:
 
   /// Set/Get window interactor
   Q_INVOKABLE vtkRenderWindowInteractor* interactor()const;
+  /// QVTKWidget catches all render requests, and ensure the desired framerate
+  /// is respected.
+  /// The interactor never calls Render() on the render window.
+  /// TBD: can we only set a QVTKRenderWindowInteractor ?
   virtual void setInteractor(vtkRenderWindowInteractor* interactor);
 
   /// Get current interactor style

Libs/Visualization/VTK/Widgets/ctkVTKAbstractView_p.h

@@ -23,6 +23,8 @@
 
 // Qt includes
 #include <QObject>
+#include <QTime>
+class QTimer;
 
 // CTK includes
 #include "ctkVTKAbstractView.h"
@@ -56,7 +58,8 @@ public:
 
   QVTKWidget*                                   VTKWidget;
   vtkSmartPointer<vtkRenderWindow>              RenderWindow;
-  bool                                          RenderPending;
+  QTimer*                                       RequestTimer;
+  QTime                                         RequestTime;
   bool                                          RenderEnabled;
 
   vtkSmartPointer<vtkCornerAnnotation>          CornerAnnotation;

Libs/Visualization/VTK/Widgets/ctkVTKRenderView.cpp

@@ -147,6 +147,7 @@ void ctkVTKRenderViewPrivate::yaw(int rotateDegrees,
 //---------------------------------------------------------------------------
 void ctkVTKRenderViewPrivate::doSpin()
 {
+  Q_Q(ctkVTKRenderView);
   if (!this->SpinEnabled)
     {
     return;
@@ -168,12 +169,14 @@ void ctkVTKRenderViewPrivate::doSpin()
       break;
     }
 
+  q->forceRender();
   QTimer::singleShot(this->AnimationIntervalMs, this, SLOT(doSpin()));
 }
 
 //---------------------------------------------------------------------------
 void ctkVTKRenderViewPrivate::doRock()
 {
+  Q_Q(ctkVTKRenderView);
   Q_ASSERT(this->Renderer->IsActiveCameraCreated());
 
   if (!this->RockEnabled)
@@ -195,6 +198,7 @@ void ctkVTKRenderViewPrivate::doRock()
   //Make the lighting follow the camera to avoid illumination changes
   this->Renderer->UpdateLightsGeometryToFollowCamera();
 
+  q->forceRender();
   QTimer::singleShot(this->AnimationIntervalMs, this, SLOT(doRock()));
 }