blitting works with the class but not with plt

Author: lionel42

pygame_matplotlib/backend_pygame.py

@@ -56,6 +56,10 @@ def set_bounding_rect(self, rect: pygame.Rect):
         # Redraw the figure
         self.canvas.draw()
 
+    #def draw(self, *args, **kwargs):
+    #    print(*args, **kwargs)
+    #    return super().draw(self, *args, **kwargs)
+
 
 class RendererPygame(RendererBase):
     """The renderer handles drawing/rendering operations.
@@ -71,7 +75,7 @@ def __init__(self, dpi):
 
     def rect_from_bbox(self, bbox: Bbox) -> pygame.Rect:
         """Convert a matplotlib bbox to the equivalent pygame Rect."""
-        print(bbox.get_points())
+        raise NotImplementedError()
 
     def draw_path(self, gc, path, transform, rgbFace=None):
 
@@ -354,10 +358,12 @@ def draw(self):
         self.figure.draw(self.renderer)
 
     def blit(self, bbox=None):
+        # self._png_is_old = True
         self.renderer = self.get_renderer(cleared=False)
         self.renderer.surface = self.figure
         self.figure.draw(self.renderer)
 
+
     def get_renderer(self, cleared=False) -> RendererPygame:
         fig = self.figure
         reuse_renderer = (
@@ -388,6 +394,17 @@ def flush_events(self):
                 pygame.quit()
                 show_fig = False
 
+    def start_event_loop(self, interval: float):
+        FPS = 60
+        FramePerSec = pygame.time.Clock()
+        time_elapsed = 0
+        while time_elapsed < interval:
+            events = pygame.event.get()
+            time_elapsed += FramePerSec.tick(FPS) / 1000. # Convert ms
+            for event in events:
+                if event.type == pygame.QUIT:
+                    pygame.quit()
+
 
 class FigureManagerPygame(FigureManagerBase):
     """

test_blitting.py

@@ -34,18 +34,21 @@
 ax.draw_artist(ln)
 # show the result to the screen, this pushes the updated RGBA buffer from the
 # renderer to the GUI framework so you can see it
-fig.canvas.blit(fig.bbox)
 
 for j in range(1000):
     # reset the background back in the canvas state, screen unchanged
     fig.canvas.restore_region(bg)
     # update the artist, neither the canvas state nor the screen have changed
     ln.set_ydata(np.sin(x + (j / 100) * np.pi))
     # re-render the artist, updating the canvas state, but not the screen
+    print(ax.get_renderer_cache())
+    print('Draw starts')
     ax.draw_artist(ln)
+    print('Draw ends')
     # copy the image to the GUI state, but screen might not be changed yet
     fig.canvas.blit(fig.bbox)
+    print(fig._cachedRenderer)
     # flush any pending GUI events, re-painting the screen if needed
     fig.canvas.flush_events()
     # you can put a pause in if you want to slow things down
-    # plt.pause(.1)
+    plt.pause(1)

test_blitting_class.py

@@ -0,0 +1,104 @@
+import matplotlib.pyplot as plt
+import numpy as np
+import matplotlib
+matplotlib.use('module://pygame_matplotlib.backend_pygame')
+
+class BlitManager:
+    def __init__(self, canvas, animated_artists=()):
+        """
+        Parameters
+        ----------
+        canvas : FigureCanvasAgg
+            The canvas to work with, this only works for sub-classes of the Agg
+            canvas which have the `~FigureCanvasAgg.copy_from_bbox` and
+            `~FigureCanvasAgg.restore_region` methods.
+
+        animated_artists : Iterable[Artist]
+            List of the artists to manage
+        """
+        self.canvas = canvas
+        self._bg = None
+        self._artists = []
+
+        for a in animated_artists:
+            self.add_artist(a)
+        # grab the background on every draw
+        self.cid = canvas.mpl_connect("draw_event", self.on_draw)
+
+    def on_draw(self, event):
+        """Callback to register with 'draw_event'."""
+        cv = self.canvas
+        if event is not None:
+            if event.canvas != cv:
+                raise RuntimeError
+        self._bg = cv.copy_from_bbox(cv.figure.bbox)
+        self._draw_animated()
+
+    def add_artist(self, art):
+        """
+        Add an artist to be managed.
+
+        Parameters
+        ----------
+        art : Artist
+
+            The artist to be added.  Will be set to 'animated' (just
+            to be safe).  *art* must be in the figure associated with
+            the canvas this class is managing.
+
+        """
+        if art.figure != self.canvas.figure:
+            raise RuntimeError
+        art.set_animated(True)
+        self._artists.append(art)
+
+    def _draw_animated(self):
+        """Draw all of the animated artists."""
+        fig = self.canvas.figure
+        for a in self._artists:
+            fig.draw_artist(a)
+
+    def update(self):
+        """Update the screen with animated artists."""
+        cv = self.canvas
+        fig = cv.figure
+        # paranoia in case we missed the draw event,
+        if self._bg is None:
+            self.on_draw(None)
+        else:
+            # restore the background
+            cv.restore_region(self._bg)
+            # draw all of the animated artists
+            self._draw_animated()
+            # update the GUI state
+            cv.blit(fig.bbox)
+        # let the GUI event loop process anything it has to do
+        cv.flush_events()
+
+x = np.linspace(0, 2 * np.pi, 100)
+# make a new figure
+fig, ax = plt.subplots()
+# add a line
+(ln,) = ax.plot(x, np.sin(x), animated=True)
+# add a frame number
+fr_number = ax.annotate(
+    "0",
+    (0, 1),
+    xycoords="axes fraction",
+    xytext=(10, -10),
+    textcoords="offset points",
+    ha="left",
+    va="top",
+    animated=True,
+)
+bm = BlitManager(fig.canvas, [ln, fr_number])
+# make sure our window is on the screen and drawn
+plt.show(block=False)
+plt.pause(.1)
+
+for j in range(1000):
+    # update the artists
+    ln.set_ydata(np.sin(x + (j / 100) * np.pi))
+    fr_number.set_text("frame: {j}".format(j=j))
+    # tell the blitting manager to do its thing
+    bm.update()