fastplotlib · kushalkolar · Dec 11, 2022 · Oct 11, 2022 · Nov 19, 2022 · Nov 19, 2022
diff --git a/examples/gridplot_simple.py b/examples/gridplot_simple.py
@@ -0,0 +1,53 @@
+import numpy as np
+from wgpu.gui.auto import WgpuCanvas
+import pygfx as gfx
+from fastplotlib.layouts import GridPlot
+from fastplotlib.graphics import ImageGraphic, LineGraphic, HistogramGraphic
+from fastplotlib import run
+from math import sin, cos, radians
+
+# GridPlot of shape 2 x 3
+grid_plot = GridPlot(shape=(2, 3))
+
+image_graphics = list()
+
+hist_data1 = np.random.normal(0, 256, 2048)
+hist_data2 = np.random.poisson(0, 256)
+
+# Make a random image graphic for each subplot
+for i, subplot in enumerate(grid_plot):
+    img = np.random.rand(512, 512) * 255
+    ig = ImageGraphic(data=img, vmin=0, vmax=255, cmap='gnuplot2')
+    image_graphics.append(ig)
+
+    # add the graphic to the subplot
+    subplot.add_graphic(ig)
+
+    histogram = HistogramGraphic(data=hist_data1, bins=100)
+    histogram.world_object.rotation.w = cos(radians(45))
+    histogram.world_object.rotation.z = sin(radians(45))
+
+    histogram.world_object.scale.y = 1
+    histogram.world_object.scale.x = 8
+
+    for dv_position in ["right", "top", "bottom", "left"]:
+        h2 = HistogramGraphic(data=hist_data1, bins=100)
+
+        subplot.docked_viewports[dv_position].size = 60
+        subplot.docked_viewports[dv_position].add_graphic(h2)
+#
+
+# Define a function to update the image graphics
+# with new randomly generated data
+def set_random_frame():
+    for ig in image_graphics:
+        new_data = np.random.rand(512, 512) * 255
+        ig.update_data(data=new_data)
+
+
+# add the animation
+# grid_plot.add_animations(set_random_frame)
+
+grid_plot.show()
+
+run()
diff --git a/fastplotlib/__init__.py b/fastplotlib/__init__.py
@@ -1,5 +1,6 @@
 from .plot import Plot
 from pathlib import Path
+from wgpu.gui.auto import run
 
 
 with open(Path(__file__).parent.joinpath("VERSION"), "r") as f:

diff --git a/fastplotlib/layouts/_base.py b/fastplotlib/layouts/_base.py
@@ -0,0 +1,182 @@
+from pygfx import Scene, OrthographicCamera, PerspectiveCamera, PanZoomController, OrbitController, \
+    Viewport, WgpuRenderer
+from wgpu.gui.auto import WgpuCanvas
+from warnings import warn
+from ..graphics._base import Graphic
+from typing import *
+
+
+class PlotArea:
+    def __init__(
+            self,
+            parent,
+            position: Any,
+            camera: Union[OrthographicCamera, PerspectiveCamera],
+            controller: Union[PanZoomController, OrbitController],
+            scene: Scene,
+            canvas: WgpuCanvas,
+            renderer: WgpuRenderer,
+            name: str = None,
+    ):
+        self._parent: PlotArea = parent
+        self._position = position
+
+        self._scene = scene
+        self._canvas = canvas
+        self._renderer = renderer
+        if parent is None:
+            self._viewport: Viewport = Viewport(renderer)
+        else:
+            self._viewport = Viewport(parent.renderer)
+
+        self._camera = camera
+        self._controller = controller
+
+        self.controller.add_default_event_handlers(
+            self.viewport,
+            self.camera
+        )
+
+        self.renderer.add_event_handler(self.set_viewport_rect, "resize")
+
+        self._graphics: List[Graphic] = list()
+
+        self.name = name
+
+        # need to think about how to deal with children better
+        self.children = list()
+
+        self.set_viewport_rect()
+
+    # several read-only properties
+    @property
+    def parent(self):
+        return self._parent
+
+    @property
+    def position(self) -> Union[Tuple[int, int], Any]:
+        """Used by subclass based on its referencing system"""
+        return self._position
+
+    @property
+    def scene(self) -> Scene:
+        return self._scene
+
+    @property
+    def canvas(self) -> WgpuCanvas:
+        return self._canvas
+
+    @property
+    def renderer(self) -> WgpuRenderer:
+        return self._renderer
+
+    @property
+    def viewport(self) -> Viewport:
+        return self._viewport
+
+    @property
+    def camera(self) -> Union[OrthographicCamera, PerspectiveCamera]:
+        return self._camera
+
+    # in the future we can think about how to allow changing the controller
+    @property
+    def controller(self) -> Union[PanZoomController, OrbitController]:
+        return self._controller
+
+    def get_rect(self) -> Tuple[float, float, float, float]:
+        """allows setting the region occupied by the viewport w.r.t. the parent"""
+        raise NotImplementedError("Must be implemented in subclass")
+
+    def set_viewport_rect(self, *args):
+        self.viewport.rect = self.get_rect()
+
+    def render(self):
+        self.controller.update_camera(self.camera)
+        self.viewport.render(self.scene, self.camera)
+
+        for child in self.children:
+            child.render()
+
+    def add_graphic(self, graphic, center: bool = True):
+        if graphic.name is not None:  # skip for those that have no name
+            graphic_names = list()
+
+            for g in self._graphics:
+                graphic_names.append(g.name)
+
+            if graphic.name in graphic_names:
+                raise ValueError(f"graphics must have unique names, current graphic names are:\n {graphic_names}")
+
+        self._graphics.append(graphic)
+        self.scene.add(graphic.world_object)
+
+        if center:
+            self.center_graphic(graphic)
+
+    def _refresh_camera(self):
+        self.controller.update_camera(self.camera)
+        if sum(self.renderer.logical_size) > 0:
+            scene_lsize = self.viewport.rect[2], self.viewport.rect[3]
+        else:
+            scene_lsize = (1, 1)
+
+        self.camera.set_view_size(*scene_lsize)
+        self.camera.update_projection_matrix()
+
+    def center_graphic(self, graphic, zoom: float = 1.3):
+        if not isinstance(self.camera, OrthographicCamera):
+            warn("`center_graphic()` not yet implemented for `PerspectiveCamera`")
+            return
+
+        self._refresh_camera()
+
+        self.controller.show_object(self.camera, graphic.world_object)
+
+        self.controller.zoom(zoom)
+
+    def center_scene(self, zoom: float = 1.3):
+        if not len(self.scene.children) > 0:
+            return
+
+        if not isinstance(self.camera, OrthographicCamera):
+            warn("`center_scene()` not yet implemented for `PerspectiveCamera`")
+            return
+
+        self._refresh_camera()
+
+        self.controller.show_object(self.camera, self.scene)
+
+        self.controller.zoom(zoom)
+
+    def get_graphics(self):
+        return self._graphics
+
+    def remove_graphic(self, graphic):
+        self.scene.remove(graphic.world_object)
+
+    def __getitem__(self, name: str):
+        for graphic in self._graphics:
+            if graphic.name == name:
+                return graphic
+
+        graphic_names = list()
+        for g in self._graphics:
+            graphic_names.append(g.name)
+        raise IndexError(f"no graphic of given name, the current graphics are:\n {graphic_names}")
+
+    def __str__(self):
+        if self.name is None:
+            name = "unnamed"
+        else:
+            name = self.name
+
+        return f"{name}: {self.__class__.__name__} @ {hex(id(self))}"
+
+    def __repr__(self):
+        newline = "\n\t"
+
+        return f"{self}\n" \
+               f"  parent: {self.parent}\n" \
+               f"  Graphics:\n" \
+               f"\t{newline.join(graphic.__repr__() for graphic in self.get_graphics())}" \
+               f"\n"
diff --git a/fastplotlib/layouts/_gridplot.py b/fastplotlib/layouts/_gridplot.py
@@ -154,9 +154,9 @@ def __getitem__(self, index: Union[Tuple[int, int], str]):
         else:
             return self._subplots[index[0], index[1]]
 
-    def animate(self):
+    def render(self):
         for subplot in self:
-            subplot.animate(self.canvas.get_logical_size())
+            subplot.render()
 
         for f in self._animate_funcs:
             f()
@@ -173,7 +173,7 @@ def add_animations(self, *funcs: callable):
             self._animate_funcs += funcs
 
     def show(self):
-        self.canvas.request_draw(self.animate)
+        self.canvas.request_draw(self.render)
 
         for subplot in self:
             subplot.center_scene()
@@ -193,6 +193,3 @@ def __next__(self) -> Subplot:
 
     def __repr__(self):
         return f"fastplotlib.{self.__class__.__name__} @ {hex(id(self))}\n"
-
-
-