improve pygfx

src/ndv/models/_scene/canvas.py

@@ -76,7 +76,7 @@ def size(self) -> tuple[int, int]:
         return self.width, self.height
 
     @size.setter
-    def size(self, value: tuple[float, float]) -> None:
+    def size(self, value: tuple[int, int]) -> None:
         """Set the size of the canvas."""
         self.width, self.height = value
 

src/ndv/models/_scene/nodes/camera.py

@@ -40,9 +40,8 @@ class Camera(Node["CameraAdaptorProtocol"]):
     )
 
     def _set_range(self, margin: float = 0) -> None:
-        if self.has_backend_adaptor("vispy"):
-            adaptor = self.backend_adaptor()
-            # TODO: this method should probably be pulled off of the backend,
-            # calculated directly in the core, and then applied as a change to the
-            # camera transform
-            adaptor._vis_set_range(margin=margin)
+        adaptor = self.backend_adaptor()
+        # TODO: this method should probably be pulled off of the backend,
+        # calculated directly in the core, and then applied as a change to the
+        # camera transform
+        adaptor._vis_set_range(margin=margin)

src/ndv/models/_scene/nodes/points.py

@@ -52,6 +52,7 @@ def _vis_set_opacity(self, opacity: float) -> None: ...
     "star",
     "cross_lines",
 ]
+ScalingMode = Literal[True, False, "fixed", "scene", "visual"]
 
 
 class Points(Node[PointsBackend]):
@@ -72,7 +73,8 @@ class Points(Node[PointsBackend]):
     symbol: SymbolName = Field(
         default="disc", description="The symbol to use for the points."
     )
-    scaling: Literal[True, False, "fixed", "scene", "visual"] = Field(
+    # TODO: these are vispy-specific names.  Determine more general names
+    scaling: ScalingMode = Field(
         default=True, description="Determines how points scale when zooming."
     )
 

src/ndv/models/_scene/nodes/scene.py

@@ -1,9 +1,9 @@
 from typing import Literal
 
-from .node import Node
+from .node import Node, NodeAdaptorProtocol
 
 
-class Scene(Node):
+class Scene(Node[NodeAdaptorProtocol]):
     """A Root node for a scene graph.
 
     This really isn't anything more than a regular Node, but it's an explicit

src/ndv/models/_scene/view.py

@@ -5,7 +5,7 @@
 from typing import TYPE_CHECKING, Any, Protocol, TypeVar
 
 from cmap import Color
-from pydantic import ConfigDict, Field
+from pydantic import ConfigDict, Field, PrivateAttr, computed_field
 
 from ._vis_model import ModelBase, SupportsVisibility, VisModel
 from .nodes import Camera, Scene
@@ -121,10 +121,31 @@ class View(VisModel[ViewAdaptorProtocol]):
 
     model_config = ConfigDict(repr_exclude_defaults=False)  # type: ignore
 
+    _canvas: Canvas | None = PrivateAttr(None)
+
     def model_post_init(self, __context: Any) -> None:
         super().model_post_init(__context)
+        self.camera.parent = self.scene
         self.layout.events.connect(self._on_layout_event)
 
+    @computed_field  # type: ignore
+    @property
+    def canvas(self) -> Canvas:
+        """The canvas that the view is on.
+
+        If one hasn't been created/assigned, a new one is created.
+        """
+        if (canvas := self._canvas) is None:
+            from .canvas import Canvas
+
+            self.canvas = canvas = Canvas()
+        return canvas
+
+    @canvas.setter
+    def canvas(self, value: Canvas) -> None:
+        self._canvas = value
+        self._canvas.add_view(self)
+
     def _on_layout_event(self, info: EmissionInfo) -> None:
         _signal_name = info.signal.name
         ...
@@ -135,15 +156,9 @@ def show(self) -> Canvas:
         Convenience method for showing the canvas that the view is on.
         If no canvas exists, a new one is created.
         """
-        if not hasattr(self, "_canvas"):
-            from .canvas import Canvas
-
-            # TODO: we need to know/check somehow if the view is already on a canvas
-            # This just creates a new canvas every time
-            self._canvas = Canvas()
-            self._canvas.add_view(self)
-        self._canvas.show()
-        return self._canvas
+        canvas = self.canvas
+        canvas.show()
+        return self.canvas
 
     def add_node(self, node: NodeType) -> NodeType:
         """Add any node to the scene."""

src/ndv/views/_scene/pygfx/__init__.py

@@ -2,7 +2,8 @@
 from ._canvas import Canvas
 from ._image import Image
 from ._node import Node
+from ._points import Points
 from ._scene import Scene
 from ._view import View
 
-__all__ = ["Camera", "Canvas", "Image", "Node", "Scene", "View"]
+__all__ = ["Camera", "Canvas", "Image", "Node", "Points", "Scene", "View"]

src/ndv/views/_scene/pygfx/_camera.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
-import warnings
-from typing import Any
+from typing import Any, cast
 
+import numpy as np
 import pygfx
 
 from ndv._types import CameraType
@@ -14,18 +14,19 @@
 class Camera(Node, camera.CameraAdaptorProtocol):
     """Adaptor for pygfx camera."""
 
-    _pygfx_node: pygfx.Camera
+    _pygfx_node: pygfx.PerspectiveCamera
+    pygfx_controller: pygfx.Controller
 
     def __init__(self, camera: camera.Camera, **backend_kwargs: Any) -> None:
+        self._camera_model = camera
         if camera.type == CameraType.PANZOOM:
-            self._pygfx_node = pygfx.OrthographicCamera(**backend_kwargs)
-            self.controller = pygfx.PanZoomController(self._pygfx_node)
+            self._pygfx_node = pygfx.OrthographicCamera()
+            self.pygfx_controller = pygfx.PanZoomController(self._pygfx_node)
         elif camera.type == CameraType.ARCBALL:
-            self._pygfx_node = pygfx.PerspectiveCamera(**backend_kwargs)
-            self.controller = pygfx.OrbitOrthoController(self._pygfx_node)
+            self._pygfx_node = pygfx.PerspectiveCamera(70, 4 / 3)
+            self.pygfx_controller = pygfx.OrbitController(self._pygfx_node)
 
-        # FIXME: hardcoded
-        # self._pygfx_cam.scale.y = -1
+        self._pygfx_node.local.scale_y = -1  # don't think this is working...
 
     def _vis_set_zoom(self, zoom: float) -> None:
         raise NotImplementedError
@@ -44,14 +45,29 @@ def update_controller(self) -> None:
         # This is called by the View Adaptor in the `_visit` method
         # ... which is in turn called by the Canvas backend adaptor's `_animate` method
         # i.e. the main render loop.
-        self.controller.update_camera(self._pygfx_node)
+        self.pygfx_controller.update_camera(self._pygfx_node)
 
     def set_viewport(self, viewport: pygfx.Viewport) -> None:
         # This is used by the Canvas backend adaptor...
         # and should perhaps be moved to the View Adaptor
-        self.controller.add_default_event_handlers(viewport, self._pygfx_node)
+        self.pygfx_controller.add_default_event_handlers(viewport, self._pygfx_node)
 
     def _vis_set_range(self, margin: float) -> None:
-        warnings.warn(
-            "set_range not implemented for pygfx", RuntimeWarning, stacklevel=2
-        )
+        # reset camera to fit all objects
+        if not (scene := self._camera_model.parent):
+            print("No scene found for camera")
+            return
+
+        py_scene = cast("pygfx.Scene", scene.backend_adaptor("pygfx")._vis_get_native())
+        cam = self._pygfx_node
+        cam.show_object(py_scene)
+
+        if (bb := py_scene.get_world_bounding_box()) is not None:
+            width, height, _depth = np.ptp(bb, axis=0)
+            if width < 0.01:
+                width = 1
+            if height < 0.01:
+                height = 1
+            cam.width = width
+            cam.height = height
+        cam.zoom = 1 - margin

src/ndv/views/_scene/pygfx/_canvas.py

@@ -1,84 +1,51 @@
 from __future__ import annotations
 
-from contextlib import suppress
-from typing import TYPE_CHECKING, Any, Union, cast
-
-import pygfx
+from typing import TYPE_CHECKING, Any, cast
 
 from ndv.models import _scene as core
 
 if TYPE_CHECKING:
     import numpy as np
     from cmap import Color
-    from typing_extensions import TypeAlias
-    from wgpu.gui import glfw, jupyter, offscreen, qt
+    from rendercanvas.auto import RenderCanvas
 
     from ._view import View
 
-    # from wgpu.gui.auto import WgpuCanvas
-    # ... will result in one of the following canvas classes
-    TypeWgpuCanvasType: TypeAlias = Union[
-        type[offscreen.WgpuCanvas],  # if WGPU_FORCE_OFFSCREEN=1
-        type[jupyter.WgpuCanvas],  # if is_jupyter()
-        type[glfw.WgpuCanvas],  # if glfw is installed
-        type[qt.WgpuCanvas],  # if any pyqt backend is installed
-    ]
-    # TODO: lol... there's probably a better way to do this :)
-    WgpuCanvasType: TypeAlias = Union[
-        offscreen.WgpuCanvas,  # if WGPU_FORCE_OFFSCREEN=1
-        jupyter.WgpuCanvas,  # if is_jupyter()
-        glfw.WgpuCanvas,  # if glfw is installed
-        qt.WgpuCanvas,  # if any pyqt backend is installed
-    ]
-
 
 class Canvas(core.canvas.CanvasAdaptorProtocol):
     """Canvas interface for pygfx Backend."""
 
     def __init__(self, canvas: core.Canvas, **backend_kwargs: Any) -> None:
-        # wgpu.gui.auto.WgpuCanvas is a "magic" import that itself is context sensitive
-        # see TYPE_CHECKING section above for details
-        from wgpu.gui.auto import WgpuCanvas
-
-        WgpuCanvas = cast("TypeWgpuCanvasType", WgpuCanvas)
+        from rendercanvas.auto import RenderCanvas
 
-        canvas = WgpuCanvas(size=canvas.size, title=canvas.title, **backend_kwargs)
-        self._wgpu_canvas = cast("WgpuCanvasType", canvas)
-        # TODO: background_color
-        # the qt backend, this shows by default...
-        # if we need to prevent it, we could potentially monkeypatch during init.
+        self._wgpu_canvas = RenderCanvas()
+        # Qt RenderCanvas calls show() in its __init__ method, so we need to hide it
         if hasattr(self._wgpu_canvas, "hide"):
             self._wgpu_canvas.hide()
 
-        self._renderer = pygfx.renderers.WgpuRenderer(self._wgpu_canvas)
-        self._viewport: pygfx.Viewport = pygfx.Viewport(self._renderer)
-        self._views: list[View] = []
-        # self._grid: dict[tuple[int, int], View] = {}
+        self._wgpu_canvas.set_logical_size(canvas.width, canvas.height)
+        self._wgpu_canvas.set_title(canvas.title)
+        self._views = canvas.views
 
-    def _vis_get_native(self) -> WgpuCanvasType:
+    def _vis_get_native(self) -> RenderCanvas:
         return self._wgpu_canvas
 
     def _vis_set_visible(self, arg: bool) -> None:
+        # show the qt canvas we patched earlier in __init__
         if hasattr(self._wgpu_canvas, "show"):
             self._wgpu_canvas.show()
-        self._wgpu_canvas.request_draw(self._animate)
+        self._wgpu_canvas.request_draw(self._draw)
 
-    def _animate(self, viewport: pygfx.Viewport | None = None) -> None:
-        vp = viewport or self._viewport
+    def _draw(self) -> None:
         for view in self._views:
-            view._visit(vp)
-        if hasattr(vp.renderer, "flush"):
-            # an attribute error can occur if flush() is called before render()
-            # https://github.com/pygfx/pygfx/issues/946
-            with suppress(AttributeError):
-                vp.renderer.flush()
-        if viewport is None:
-            self._wgpu_canvas.request_draw()
+            adaptor = cast("View", view.backend_adaptor("pygfx"))
+            adaptor._draw()
 
     def _vis_add_view(self, view: core.View) -> None:
-        adaptor = cast("View", view.backend_adaptor())
+        pass
+        # adaptor = cast("View", view.backend_adaptor())
         # adaptor._pygfx_cam.set_viewport(self._viewport)
-        self._views.append(adaptor)
+        # self._views.append(adaptor)
 
     def _vis_set_width(self, arg: int) -> None:
         _, height = self._wgpu_canvas.get_logical_size()
@@ -88,11 +55,12 @@ def _vis_set_height(self, arg: int) -> None:
         width, _ = self._wgpu_canvas.get_logical_size()
         self._wgpu_canvas.set_logical_size(width, arg)
 
-    def _vis_set_background_color(self, arg: Color | None) -> None:
-        raise NotImplementedError()
+    def _vis_set_background_color(self, arg: Color) -> None:
+        # not sure if pygfx has both a canavs and view background color...
+        pass
 
     def _vis_set_title(self, arg: str) -> None:
-        raise NotImplementedError()
+        self._wgpu_canvas.set_title(arg)
 
     def _vis_close(self) -> None:
         """Close canvas."""
@@ -107,11 +75,10 @@ def _vis_render(
         alpha: bool = True,
     ) -> np.ndarray:
         """Render to screenshot."""
-        from wgpu.gui.offscreen import WgpuCanvas
+        from rendercanvas.offscreen import OffscreenRenderCanvas
 
+        # not sure about this...
         w, h = self._wgpu_canvas.get_logical_size()
-        canvas = WgpuCanvas(width=w, height=h, pixel_ratio=1)
-        renderer = pygfx.renderers.WgpuRenderer(canvas)
-        viewport = pygfx.Viewport(renderer)
-        canvas.request_draw(lambda: self._animate(viewport))
+        canvas = OffscreenRenderCanvas(width=w, height=h, pixel_ratio=1)
+        canvas.request_draw(self._draw)
         return cast("np.ndarray", canvas.draw())