blitting still not okay

Author: lionel42

pygame_matplotlib/backend_pygame.py

@@ -7,16 +7,25 @@
     import matplotlib
     matplotlib.use("'module://pygame_matplotlib.backend_pygame'")
 """
+from __future__ import annotations
+import matplotlib
+from matplotlib.pyplot import figure
 import numpy as np
 from matplotlib.transforms import Affine2D
 import pygame
+from pygame import surface
 import pygame.image
 from pygame import gfxdraw
 from matplotlib._pylab_helpers import Gcf
 from matplotlib.backend_bases import (
-     FigureCanvasBase, FigureManagerBase, GraphicsContextBase, RendererBase)
+    FigureCanvasBase,
+    FigureManagerBase,
+    GraphicsContextBase,
+    RendererBase,
+)
 from matplotlib.figure import Figure
 from matplotlib.path import Path
+from matplotlib.transforms import Bbox
 
 
 class FigureSurface(pygame.Surface, Figure):
@@ -26,20 +35,22 @@ class FigureSurface(pygame.Surface, Figure):
     that help handling the figures in pygame.
     """
 
+    canvas: FigureCanvasPygame
+
     def __init__(self, *args, **kwargs):
         """Create a FigureSurface object.
 
         Signature is the same as matplotlib Figure object.
         """
         Figure.__init__(self, *args, **kwargs)
         pygame.Surface.__init__(self, self.bbox.size)
-        self.fill('white')
+        self.fill("white")
 
     def set_bounding_rect(self, rect: pygame.Rect):
         """Set a bounding rectangle around the figure."""
         # First convert inches to pixels for matplotlib
         DPI = self.get_dpi()
-        self.set_size_inches(rect.width/float(DPI), rect.height/float(DPI))
+        self.set_size_inches(rect.width / float(DPI), rect.height / float(DPI))
         # Initialize a new surface for the plot
         pygame.Surface.__init__(self, (rect.width, rect.height))
         # Redraw the figure
@@ -52,27 +63,33 @@ class RendererPygame(RendererBase):
     The draw methods convert maptplotlib into pygame.draw .
     """
 
+    surface: pygame.Surface
+
     def __init__(self, dpi):
         super().__init__()
         self.dpi = dpi
 
+    def rect_from_bbox(self, bbox: Bbox) -> pygame.Rect:
+        """Convert a matplotlib bbox to the equivalent pygame Rect."""
+        print(bbox.get_points())
+
     def draw_path(self, gc, path, transform, rgbFace=None):
 
         if rgbFace is not None:
-            color = tuple([
-                int(val*255) for i, val in enumerate(rgbFace) if i < 3
-            ])
+            color = tuple(
+                [int(val * 255) for i, val in enumerate(rgbFace) if i < 3]
+            )
         else:
-            color = tuple([
-                int(val*255) for i, val in enumerate(gc.get_rgb()) if i < 3
-            ])
+            color = tuple(
+                [int(val * 255) for i, val in enumerate(gc.get_rgb()) if i < 3]
+            )
 
         linewidth = int(gc.get_linewidth())
 
         transfrom_to_pygame_axis = Affine2D()
-        transfrom_to_pygame_axis.set_matrix([
-            [1, 0, 0], [0, -1, self.surface.get_height()], [0, 0, 1]
-        ])
+        transfrom_to_pygame_axis.set_matrix(
+            [[1, 0, 0], [0, -1, self.surface.get_height()], [0, 0, 1]]
+        )
 
         transform += transfrom_to_pygame_axis
 
@@ -95,21 +112,17 @@ def draw_path(self, gc, path, transform, rgbFace=None):
                 poly_points.append(point)
             elif code == Path.CURVE3 or code == Path.CURVE4:
                 end_point = point[2:]
-                points_curve = np.concatenate(
-                    (previous_point, point)
-                ).reshape((-1, 2))
+                points_curve = np.concatenate((previous_point, point)).reshape(
+                    (-1, 2)
+                )
                 gfxdraw.bezier(
                     self.surface, points_curve, len(points_curve), color
                 )
                 previous_point = end_point
                 poly_points.append(end_point)
             elif code == Path.CLOSEPOLY:
                 if len(poly_points) > 2:
-                    gfxdraw.filled_polygon(
-                        self.surface,
-                        poly_points,
-                        color
-                    )
+                    gfxdraw.filled_polygon(self.surface, poly_points, color)
             elif code == Path.MOVETO:
                 poly_points.append(point)
                 previous_point = point
@@ -119,37 +132,38 @@ def draw_path(self, gc, path, transform, rgbFace=None):
     # draw_markers is optional, and we get more correct relative
     # timings by leaving it out.  backend implementers concerned with
     # performance will probably want to implement it
-#     def draw_markers(self, gc, marker_path, marker_trans, path, trans,
-#                      rgbFace=None):
-#         pass
+    #     def draw_markers(self, gc, marker_path, marker_trans, path, trans,
+    #                      rgbFace=None):
+    #         pass
 
     # draw_path_collection is optional, and we get more correct
     # relative timings by leaving it out. backend implementers concerned with
     # performance will probably want to implement it
-#     def draw_path_collection(self, gc, master_transform, paths,
-#                              all_transforms, offsets, offsetTrans,
-#                              facecolors, edgecolors, linewidths, linestyles,
-#                              antialiaseds):
-#         pass
+    #     def draw_path_collection(self, gc, master_transform, paths,
+    #                              all_transforms, offsets, offsetTrans,
+    #                              facecolors, edgecolors, linewidths, linestyles,
+    #                              antialiaseds):
+    #         pass
 
     # draw_quad_mesh is optional, and we get more correct
     # relative timings by leaving it out.  backend implementers concerned with
     # performance will probably want to implement it
-#     def draw_quad_mesh(self, gc, master_transform, meshWidth, meshHeight,
-#                        coordinates, offsets, offsetTrans, facecolors,
-#                        antialiased, edgecolors):
-#         pass
+    #     def draw_quad_mesh(self, gc, master_transform, meshWidth, meshHeight,
+    #                        coordinates, offsets, offsetTrans, facecolors,
+    #                        antialiased, edgecolors):
+    #         pass
 
     def draw_image(self, gc, x, y, im):
         img_surf = pygame.image.frombuffer(
             # Need to flip the image as pygame starts top left
             np.ascontiguousarray(np.flip(im, axis=0)),
-            (im.shape[1], im.shape[0]), 'RGBA'
+            (im.shape[1], im.shape[0]),
+            "RGBA",
         )
         self.surface.blit(
             img_surf,
             # Image starts top left
-            (x, self.surface.get_height() - y - im.shape[0])
+            (x, self.surface.get_height() - y - im.shape[0]),
         )
 
     def draw_text(self, gc, x, y, s, prop, angle, ismath=False, mtext=None):
@@ -161,7 +175,7 @@ def draw_text(self, gc, x, y, s, prop, angle, ismath=False, mtext=None):
         myfont = pygame.font.Font(prop.get_file(), int(font_size))
         # apply it to text on a label
         font_surface = myfont.render(
-            s, gc.get_antialiased(), [val*255 for val in gc.get_rgb()]
+            s, gc.get_antialiased(), [val * 255 for val in gc.get_rgb()]
         )
         if mtext is not None:
             # Reads the position of the mtext
@@ -196,6 +210,22 @@ def points_to_pixels(self, points):
         # else
         # return points/72.0 * self.dpi.get()
 
+    def clear(self):
+        self.surface.fill("white")
+
+    def copy_from_bbox(self, bbox):
+        copy = self.surface.copy()
+        copy.bbox = bbox
+        return copy
+
+    def restore_region(self, region: pygame.Surface, bbox: Bbox, xy):
+        rect = (
+            pygame.Rect(0, 0, *self.surface.get_size())
+            if bbox is None
+            else self.rect_from_bbox(bbox)
+        )
+        region.blit(self.surface, rect)
+
 
 class GraphicsContextPygame(GraphicsContextBase):
     """
@@ -243,7 +273,7 @@ def show(*, block=None):
     should do nothing.
     """
     for manager in Gcf.get_all_fig_managers():
-        manager.show()
+        manager.show(block)
 
 
 def new_figure_manager(num, *args, FigureClass=FigureSurface, **kwargs):
@@ -282,25 +312,33 @@ class methods button_press_event, button_release_event,
     figure : `matplotlib.figure.Figure`
         A high-level Figure instance
     """
+
     # File types allowed for saving
     filetypes = {
-        'jpeg': 'Joint Photographic Experts Group',
-        'jpg': 'Joint Photographic Experts Group',
-        'png': 'Portable Network Graphics',
-        'bmp': 'Bitmap Image File',
-        'tga': 'Truevision Graphics Adapter',
+        "jpeg": "Joint Photographic Experts Group",
+        "jpg": "Joint Photographic Experts Group",
+        "png": "Portable Network Graphics",
+        "bmp": "Bitmap Image File",
+        "tga": "Truevision Graphics Adapter",
     }
+    figure: FigureSurface
+    renderer: RendererPygame
 
     def __init__(self, figure=None):
         super().__init__(figure)
 
         # You should provide a print_xxx function for every file format
         # you can write.
         for file_extension in self.filetypes.keys():
-            setattr(
-                self, 'print_{}'.format(file_extension),
-                self._print_any
-            )
+            setattr(self, "print_{}".format(file_extension), self._print_any)
+
+    def copy_from_bbox(self, bbox):
+        renderer = self.get_renderer()
+        return renderer.copy_from_bbox(bbox)
+
+    def restore_region(self, region, bbox=None, xy=None):
+        renderer = self.get_renderer()
+        return renderer.restore_region(region, bbox, xy)
 
     def draw(self):
         """
@@ -311,17 +349,44 @@ def draw(self):
         deferred work (like computing limits auto-limits and tick
         values) that users may want access to before saving to disk.
         """
-        renderer = RendererPygame(self.figure.dpi)
-        renderer.surface = self.figure
-        self.figure.draw(renderer)
+        self.renderer = self.get_renderer(cleared=True)
+        self.renderer.surface = self.figure
+        self.figure.draw(self.renderer)
+
+    def blit(self, bbox=None):
+        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 = (
+            hasattr(self, "renderer")
+            and getattr(self, "_last_fig", None) == fig
+        )
+        if not reuse_renderer:
+            self.renderer = RendererPygame(self.figure.dpi)
+            self._last_fig = fig
+        elif cleared:
+            self.renderer.clear()
+        return self.renderer
 
     def _print_any(self, filename, *args, **kwargs):
         """Call the pygame image saving method for the correct extenstion."""
         self.draw()
         pygame.image.save(self.figure, filename)
 
     def get_default_filetype(self):
-        return 'jpg'
+        return "jpg"
+
+    def flush_events(self):
+        self.main_display.blit(self.figure, (0, 0))
+        pygame.display.update()
+        events = pygame.event.get()
+        for event in events:
+            if event.type == pygame.QUIT:
+                pygame.quit()
+                show_fig = False
 
 
 class FigureManagerPygame(FigureManagerBase):
@@ -331,20 +396,23 @@ class FigureManagerPygame(FigureManagerBase):
     For non-interactive backends, the base class is sufficient.
     """
 
-    def show(self):
+    def show(self, block):
         # do something to display the GUI
         pygame.init()
         main_display = pygame.display.set_mode(
             self.canvas.figure.get_size(),  # Size matches figure size
         )
 
+        self.canvas.main_display = main_display
+
         FPS = 60
         FramePerSec = pygame.time.Clock()
 
         self.canvas.figure.canvas.draw()
         main_display.blit(self.canvas.figure, (0, 0))
+        pygame.display.update()
 
-        show_fig = True
+        show_fig = True if block is None else False
         while show_fig:
             events = pygame.event.get()
             pygame.display.update()

test_blitting.py

@@ -0,0 +1,51 @@
+import matplotlib
+import matplotlib.pyplot as plt
+
+matplotlib.use('module://pygame_matplotlib.backend_pygame')
+import numpy as np
+
+x = np.linspace(0, 2 * np.pi, 100)
+
+fig, ax = plt.subplots()
+
+# animated=True tells matplotlib to only draw the artist when we
+# explicitly request it
+(ln,) = ax.plot(x, np.sin(x), animated=True)
+
+# make sure the window is raised, but the script keeps going
+plt.show(block=False)
+
+# stop to admire our empty window axes and ensure it is rendered at
+# least once.
+#
+# We need to fully draw the figure at its final size on the screen
+# before we continue on so that :
+#  a) we have the correctly sized and drawn background to grab
+#  b) we have a cached renderer so that ``ax.draw_artist`` works
+# so we spin the event loop to let the backend process any pending operations
+plt.pause(0.1)
+
+# get copy of entire figure (everything inside fig.bbox) sans animated artist
+print(fig.bbox)
+bg = fig.canvas.copy_from_bbox(fig.bbox)
+print(bg)
+
+# draw the animated artist, this uses a cached renderer
+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
+    ax.draw_artist(ln)
+    # copy the image to the GUI state, but screen might not be changed yet
+    fig.canvas.blit(fig.bbox)
+    # 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)

test_plt.py

@@ -16,4 +16,4 @@
 plt.xlabel('swag')
 
 
-plt.show()
+plt.show()