Qt embedding example: Separate drawing and data retrieval timers

doronbehar · doronbehar · commit 0f92e8cc51dc · 2024-07-22T15:33:24.000+03:00
In the previous version of this example, if the timer interval would
have been simply decreased to 1ms, the GUI could have appeared as
stuck on some platforms / (slow) machines, because the event loop didn't
find the time to respond to external events such as the user dragging
the window etc. This change does 3 things:

- Puts the data to plot in the self.{x,y}data attributes.
- Separates the timer that updates the self.{x,y}data from the timer
  that updates the canvas
- Explains much better the reasoning for the timers' intervals choices
  in comments, as well as explaining why the timers are attributed to
  self, although they are not used by other methods of the class.
- Use the asynchronous draw_idle() function to further guarantee that
  the drawing won't be blocking.
diff --git a/galleries/examples/user_interfaces/embedding_in_qt_sgskip.py b/galleries/examples/user_interfaces/embedding_in_qt_sgskip.py
@@ -44,18 +44,34 @@ def __init__(self):
         self._static_ax.plot(t, np.tan(t), ".")
 
         self._dynamic_ax = dynamic_canvas.figure.subplots()
-        t = np.linspace(0, 10, 101)
         # Set up a Line2D.
-        self._line, = self._dynamic_ax.plot(t, np.sin(t + time.time()))
-        self._timer = dynamic_canvas.new_timer(50)
-        self._timer.add_callback(self._update_canvas)
-        self._timer.start()
+        self._update_data()
+        self._line, = self._dynamic_ax.plot(self.xdata, self.ydata)
+        # The below two timers must be attributes of self, so that the garbage
+        # collector won't clean them after we finish with __init__...
 
-    def _update_canvas(self):
-        t = np.linspace(0, 10, 101)
+        # The data retrieval should be fast as possible (Using QRunnable should
+        # be even faster)
+        self.dataTimer = dynamic_canvas.new_timer(1)
+        self.dataTimer.add_callback(self._update_data)
+        self.dataTimer.start()
+        # Drawing at 50Hz should be fast enough for the GUI to feel smooth, and
+        # not too fast for the GUI to be overloaded with events that need to be
+        # processed while the GUI element is changed.
+        self.drawingTimer = dynamic_canvas.new_timer(50)
+        self.drawingTimer.add_callback(self._update_canvas)
+        self.drawingTimer.start()
+
+    def _update_data(self):
+        self.xdata = np.linspace(0, 10, 101)
         # Shift the sinusoid as a function of time.
-        self._line.set_data(t, np.sin(t + time.time()))
-        self._line.figure.canvas.draw()
+        self.ydata = np.sin(self.xdata + time.time())
+
+    def _update_canvas(self):
+        self._line.set_data(self.xdata, self.ydata)
+        # It should be safe to use the synchronous draw() method as well for
+        # most drawing frequencies, but it should be safer to use draw_idle().
+        self._line.figure.canvas.draw_idle()
 
 
 if __name__ == "__main__":
