adding tests

Author: lionel42

tests/test_blitting.py

@@ -0,0 +1,50 @@
+import matplotlib
+import matplotlib.pyplot as plt
+
+matplotlib.use('pygame')
+import numpy as np
+
+
+def test_blitting():
+
+    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
+    bg = fig.canvas.copy_from_bbox(fig.bbox)
+
+    # 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
+
+    for j in range(2):
+        # 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()
+    

tests/test_blitting_class.py

@@ -0,0 +1,112 @@
+import matplotlib.pyplot as plt
+import numpy as np
+import matplotlib
+matplotlib.use('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()
+
+
+def test_blitting_class():
+    """
+    Test the BlitManager class by creating a simple animated plot.
+    """
+    # create some data
+    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(0.1)
+
+    for j in range(3):
+        # 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()
+        # plt.pause(1)
+    plt.close(fig)  # Close the figure after testing

tests/test_gui_window.py

@@ -0,0 +1,78 @@
+"""Simple script to test from https://pygame-gui.readthedocs.io/en/latest/quick_start.html"""
+
+
+import pygame
+import pygame_gui
+
+import matplotlib.pyplot as plt
+
+from pygame_matplotlib.gui_window import UIPlotWindow
+
+
+def test_gui_window():
+
+    pygame.init()
+
+    pygame.display.set_caption('Test')
+    window_surface = pygame.display.set_mode((800, 600))
+
+    background = pygame.Surface((800, 600))
+    background.fill(pygame.Color('#000000'))
+
+    manager = pygame_gui.UIManager((800, 600))
+
+    fig, axes = plt.subplots(1, 1,)
+    axes.plot([1,2], [1,2], color='green', label='test')
+    fig.canvas.draw()
+
+
+    fig2, axes2 = plt.subplots(1, 1,)
+    axes2.plot([1,2], [1,2], color='blue', label='test')
+    fig2.canvas.draw()
+
+
+    plot_window = UIPlotWindow(
+        rect=pygame.Rect((350, 275), (300, 200)),
+        manager=manager,
+        figuresurface=fig,
+        resizable=True
+    )
+
+
+
+
+    plot_window2 = UIPlotWindow(
+        rect=pygame.Rect((350, 275), (200, 200)),
+        manager=manager,
+        figuresurface=fig2,
+        resizable=False
+    )
+
+
+    clock = pygame.time.Clock()
+
+    is_running = True
+    i = 0
+
+    while is_running:
+        if i > 2:
+            is_running = False
+        time_delta = clock.tick(60)/1000.0
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+                is_running = False
+
+
+            manager.process_events(event)
+
+        manager.update(time_delta)
+
+        # Blitts and draw
+        window_surface.blit(background, (0, 0))
+        manager.draw_ui(window_surface)
+
+
+        # print(plot_window2.get_container().get_size())
+
+        pygame.display.update()
+        i += 1

tests/test_save_to_file.py

@@ -0,0 +1,33 @@
+import sys
+import os
+from numpy.ma.core import size
+import pygame
+
+import matplotlib
+matplotlib.use('pygame')
+#matplotlib.use('Qt4Agg')
+
+import matplotlib.pyplot as plt
+import matplotlib.figure as fg
+
+import matplotlib.pyplot as plt
+
+
+
+def test_save_jpg():
+    plt.figure()
+
+
+    plt.plot([1,2], [1,2], color='green')
+    plt.text(1.5, 1.5, '2', size=50)
+    plt.xlabel('swag')
+
+    plt.savefig('images' + os.sep + 'test.jpg')
+
+
+def test_save_bmp():
+    plt.figure()
+    plt.plot([1,2], [1,2], color='green')
+    plt.text(1.5, 1.5, '2', size=50)
+    plt.xlabel('swag')
+    plt.savefig('images' + os.sep + 'test.bmp')