glplot 0.1.10__tar.gz → 0.1.11__tar.gz

{glplot-0.1.10 → glplot-0.1.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: glplot
-Version: 0.1.10
+Version: 0.1.11
 Summary: High-performance OpenGL plotting library for Python
 Project-URL: Homepage, https://github.com/AkarisDimitry/GLPlot
 Project-URL: Repository, https://github.com/AkarisDimitry/GLPlot
@@ -486,7 +486,7 @@ plt.show()
 ```
 </details>
 
-**All of the above render at 60+ FPS** with interactive panning, zooming, and rotation, regardless of point count. Discover more in the [example gallery](examples/gallery/README.md) (28 static scripts) and the [animated gallery](examples/gallery/animations/README.md) (15 animated scripts).
+**All of the above render at 60+ FPS** with interactive panning, zooming, and rotation, regardless of point count. Discover more in the [example gallery](examples/gallery/README.md) (28 static scripts) and the [animated gallery](examples/gallery/animations/README.md) (16 animated scripts).
 
 ## Features
 

{glplot-0.1.10 → glplot-0.1.11}/README.md

@@ -442,7 +442,7 @@ plt.show()
 ```
 </details>
 
-**All of the above render at 60+ FPS** with interactive panning, zooming, and rotation, regardless of point count. Discover more in the [example gallery](examples/gallery/README.md) (28 static scripts) and the [animated gallery](examples/gallery/animations/README.md) (15 animated scripts).
+**All of the above render at 60+ FPS** with interactive panning, zooming, and rotation, regardless of point count. Discover more in the [example gallery](examples/gallery/README.md) (28 static scripts) and the [animated gallery](examples/gallery/animations/README.md) (16 animated scripts).
 
 ## Features
 

{glplot-0.1.10 → glplot-0.1.11}/glplot/__init__.py

@@ -38,7 +38,7 @@ except Exception:  # pragma: no cover - imgui_bundle is optional at import time
 from .engine import GPULinePlot
 from .options import BlendMode, EngineOptions, RenderMode
 
-__version__ = "0.1.6"
+__version__ = "0.1.10"
 __author__ = "Juan Manuel Lombardi"
 __license__ = "MIT"
 

{glplot-0.1.10 → glplot-0.1.11}/glplot/animation.py

@@ -32,13 +32,10 @@ How a frame is produced
 -----------------------
 :func:`figure_to_rgb` is the whole bridge, and it has two modes:
 
-* **Live GL** — when ``fig.window`` exists, ``fig.export.savefig()`` renders the scene
-  offscreen through the real pipeline at full quality, to a temporary PNG that is read back
-  immediately after. That round trip is a deliberate trade: reimplementing
-  ``ExportManager.savefig``'s ``glReadPixels`` here to skip the file would duplicate the
-  panel/scissor/projection logic and go stale the first time the render pipeline changed —
-  there is no "give me the pixels" entry point to call instead, and this is the one GL render
-  mode this module has, so paying that cost once here beats maintaining a second copy.
+* **OpenGL** — when ``fig.window`` exists, or ``Animation.save`` is explicitly given
+  ``savefig_kwargs={"renderer": "opengl"}``, the scene is rendered offscreen through the
+  real GPU pipeline at full quality. ``ExportManager.render_rgb`` returns the framebuffer
+  directly, so animation frames do not make a temporary PNG round trip.
 * **Headless** — when it does not,
   :func:`glplot.utils.preview.render_preview_array` draws the same scene through
   matplotlib's Agg backend and hands back the rendered pixels directly, with no file
@@ -52,11 +49,12 @@ How a frame is produced
   ``savefig()`` call uses) is unchanged; :func:`render_preview_array` is a second entry
   point onto the same figure-building code, not a rewrite of it — see its docstring.
 
-**The headless path is not pixel-identical to the GL path.** ``render_preview`` is a
+**The matplotlib path is not pixel-identical to the GL path.** ``render_preview`` is a
 matplotlib re-drawing of the scene, not the GPU renderer; it approximates. An animation
-saved without a window looks like a matplotlib plot of the same data, which is usually
-what a user wants from CI and never quite what they want from a demo reel. Call
-``fig.run()`` first if the GPU look matters.
+saved without a window uses this backwards-compatible path unless a renderer is requested.
+Pass ``savefig_kwargs={"renderer": "opengl"}`` when the GPU look matters, ``"matplotlib"``
+to force the portable preview, or ``"auto"`` to try an invisible GL context and warn before
+falling back to matplotlib when no context can be created.
 
 Limitations, stated plainly
 ---------------------------
@@ -95,7 +93,9 @@ import itertools
 import json
 import os
 import shutil
+import sys
 import tempfile
+import threading
 import uuid
 import warnings
 from pathlib import Path
@@ -309,12 +309,104 @@ def figure_to_rgb(fig: Any, dpi: Optional[float] = None) -> np.ndarray:
     )
 
 
-def _render_glplot_frame(fig: Any, scale: float) -> np.ndarray:
-    """Render one frame of a GLPlot engine, through GL if there is a context and Agg if not.
+def _normalize_frame_renderer(renderer: Any) -> Optional[str]:
+    """Validate the GLPlot-only renderer option carried inside ``savefig_kwargs``."""
+    if renderer is None:
+        return None
+    value = str(renderer).strip().lower()
+    if value not in {"auto", "opengl", "matplotlib"}:
+        raise ValueError(
+            "animation renderer must be 'auto', 'opengl', or 'matplotlib'; "
+            f"got {renderer!r}"
+        )
+    return value
 
-    **Live GL** still round-trips through a temporary PNG — see the module docstring's
-    "Rejected: reimplementing ExportManager.savefig's glReadPixels here", unchanged reasoning
-    so this stays unchanged.
+
+@contextlib.contextmanager
+def _frame_renderer_override(fig: Any, renderer: str) -> Iterator[None]:
+    """Temporarily select the route used by :func:`figure_to_rgb`."""
+    missing = object()
+    previous = getattr(fig, "_animation_renderer_override", missing)
+    fig._animation_renderer_override = renderer
+    try:
+        yield
+    finally:
+        if previous is missing:
+            with contextlib.suppress(AttributeError):
+                del fig._animation_renderer_override
+        else:
+            fig._animation_renderer_override = previous
+
+
+@contextlib.contextmanager
+def _animation_render_context(fig: Any, renderer: Optional[str]) -> Iterator[None]:
+    """Keep the selected animation renderer ready for one complete save operation.
+
+    ``None`` preserves the historical behaviour: use GL only if the caller already opened
+    a context, otherwise use matplotlib. Explicit ``auto`` is opt-in and tries to create an
+    invisible context once before falling back. Explicit ``opengl`` reports setup failure
+    instead of silently producing a visually different animation.
+    """
+    renderer = _normalize_frame_renderer(renderer)
+
+    if not hasattr(fig, "scene"):
+        if renderer == "opengl":
+            raise ValueError("renderer='opengl' requires a GLPlot figure")
+        yield
+        return
+
+    if renderer is None:
+        with _frame_renderer_override(fig, "auto"):
+            yield
+        return
+
+    if renderer == "matplotlib":
+        with _frame_renderer_override(fig, "matplotlib"):
+            yield
+        return
+
+    setup_error: Optional[BaseException] = None
+    stack = contextlib.ExitStack()
+    try:
+        if (
+            getattr(fig, "window", None) is None
+            and sys.platform == "darwin"
+            and threading.current_thread() is not threading.main_thread()
+        ):
+            raise RuntimeError(
+                "macOS requires creation of the GLFW/OpenGL context on the main thread"
+            )
+
+        context_factory = getattr(fig, "_offscreen_export_context", None)
+        if not callable(context_factory):
+            raise RuntimeError("this GLPlot figure cannot create an offscreen OpenGL context")
+        stack.enter_context(context_factory())
+    except Exception as exc:
+        setup_error = exc
+        stack.close()
+
+    if setup_error is not None:
+        if renderer == "opengl":
+            raise RuntimeError(
+                "Could not create the OpenGL context requested for animation export"
+            ) from setup_error
+        warnings.warn(
+            "OpenGL animation export is unavailable; falling back to the matplotlib "
+            f"renderer ({setup_error}).",
+            RuntimeWarning,
+            stacklevel=3,
+        )
+        with _frame_renderer_override(fig, "matplotlib"):
+            yield
+        return
+
+    with stack:
+        with _frame_renderer_override(fig, "opengl"):
+            yield
+
+
+def _render_glplot_frame(fig: Any, scale: float) -> np.ndarray:
+    """Render one GLPlot frame through the selected OpenGL or matplotlib route.
 
     **Headless** does not: :func:`glplot.utils.preview.render_preview_array` hands back the
     rendered pixels directly from matplotlib's Agg canvas, skipping the PNG encode and the
@@ -323,17 +415,18 @@ def _render_glplot_frame(fig: Any, scale: float) -> np.ndarray:
     common case, since a saved animation is usually built without ever calling ``fig.run()``
     — this removes roughly a third of each frame's cost with no change in what gets drawn.
 
-    ``ExportManager.savefig`` prints a "Exported high-res image to ..." line on every call.
-    That is fine for one interactive export and intolerable at 300 frames, so stdout is
-    swallowed for the duration of the GL branch — this is the only place that print reaches,
-    and suppressing it here beats every alternative that would require editing the engine.
+    The OpenGL branch calls ``ExportManager.render_rgb`` so it shares the export pipeline's
+    panel, scissor, projection, depth and shader logic without touching the filesystem.
     """
-    if getattr(fig, "window", None) is not None and hasattr(fig, "export"):
-        with tempfile.TemporaryDirectory(prefix="glplot-anim-") as tmpdir:
-            target = os.path.join(tmpdir, "frame.png")
-            with contextlib.redirect_stdout(io.StringIO()):
-                fig.export.savefig(target, scale=scale)
-            return _read_png(target)
+    renderer = getattr(fig, "_animation_renderer_override", "auto")
+    if renderer != "matplotlib" and getattr(fig, "window", None) is not None:
+        export = getattr(fig, "export", None)
+        render_rgb = getattr(export, "render_rgb", None)
+        if callable(render_rgb):
+            return render_rgb(scale=scale)
+
+    if renderer == "opengl":
+        raise RuntimeError("OpenGL animation rendering was requested, but no context is active")
 
     from .utils.preview import render_preview_array
 
@@ -1340,8 +1433,10 @@ class Animation:
         twice the default size. See :func:`figure_pixel_size` for what that works out to.
 
         ``extra_anim`` is honoured: the animations are stepped together, one saved frame per
-        tick, as in matplotlib. ``savefig_kwargs`` is accepted and ignored except for
-        ``dpi``; see :meth:`AbstractMovieWriter.grab_frame`.
+        tick, as in matplotlib. Most ``savefig_kwargs`` are accepted for compatibility and
+        ignored; GLPlot additionally consumes ``renderer`` with values ``"opengl"``,
+        ``"matplotlib"`` or ``"auto"``. Omitting it preserves the historical behaviour:
+        an already-live GL context is used, otherwise rendering stays headless through Agg.
         """
         all_anim: List[Animation] = [self]
         if extra_anim is not None:
@@ -1371,6 +1466,7 @@ class Animation:
         else:
             savefig_kwargs = dict(savefig_kwargs)
         savefig_kwargs.pop("bbox_inches", None)
+        renderer = _normalize_frame_renderer(savefig_kwargs.pop("renderer", None))
 
         if fps is None and hasattr(self, "_interval"):
             fps = MS_PER_SECOND / float(self._interval)
@@ -1390,17 +1486,18 @@ class Animation:
             writer = writer_cls(fps if fps is not None else 5, **writer_kwargs)
 
         total_frames = _total_frames(all_anim)
-        with writer.saving(self._fig, str(filename), dpi):
-            for anim in all_anim:
-                anim._init_draw()
-            frame_number = 0
-            for data in zip(*[anim.new_saved_frame_seq() for anim in all_anim]):
-                for anim, datum in zip(all_anim, data):
-                    anim._draw_next_frame(datum, blit=False)
-                    if progress_callback is not None:
-                        progress_callback(frame_number, total_frames)
-                        frame_number += 1
-                writer.grab_frame(**savefig_kwargs)
+        with _animation_render_context(self._fig, renderer):
+            with writer.saving(self._fig, str(filename), dpi):
+                for anim in all_anim:
+                    anim._init_draw()
+                frame_number = 0
+                for data in zip(*[anim.new_saved_frame_seq() for anim in all_anim]):
+                    for anim, datum in zip(all_anim, data):
+                        anim._draw_next_frame(datum, blit=False)
+                        if progress_callback is not None:
+                            progress_callback(frame_number, total_frames)
+                            frame_number += 1
+                    writer.grab_frame(**savefig_kwargs)
 
     # -- HTML ------------------------------------------------------------------------
 
@@ -1723,6 +1820,9 @@ class TimedAnimation(Animation):
         timeline.set_loop("loop" if self._repeat else "once")
         timeline.play()
         self._live_timeline = timeline
+        register_timeline = getattr(fig, "register_live_animation_timeline", None)
+        if callable(register_timeline):
+            register_timeline(timeline)
 
         live_seq = {"iter": self.frame_seq}
         state = {"last_index": None}

{glplot-0.1.10 → glplot-0.1.11}/glplot/engine.py

@@ -2,7 +2,9 @@ from __future__ import annotations
 
 import logging
 import math
+import sys
 import time
+from contextlib import contextmanager
 from typing import Any, Callable, Dict, List, Optional, Tuple
 
 import glfw
@@ -160,6 +162,11 @@ class GPULinePlot:
         #: Per-frame callbacks, run at the top of the main loop. See
         #: :meth:`add_frame_callback` — the hook that makes live animation possible.
         self._frame_callbacks: List[Callable[[float], None]] = []
+        #: Timelines currently driving live ``FuncAnimation`` objects. A camera click may
+        #: activate a different subplot, but transport controls must keep addressing the
+        #: animation they were created for instead of toggling the newly active panel's
+        #: unrelated timeline.
+        self._live_animation_timelines: List[Any] = []
         self._axes3d_labels: List[axes3d.LabelAnchor] = []
         #: The padded box those anchors were computed against, so the HUD projects them
         #: with exactly the matrix the geometry was drawn with.
@@ -794,6 +801,33 @@ class GPULinePlot:
         self._frame_callbacks.append(fn)
         return fn
 
+    def register_live_animation_timeline(self, timeline: Any) -> Any:
+        """Remember a timeline controlled by a live animation and return it.
+
+        The list is identity-deduplicated because several animations may deliberately
+        share one panel timeline. Keeping this on the figure lets keyboard and GUI
+        transports survive active-panel changes caused by camera interaction.
+        """
+        if not any(existing is timeline for existing in self._live_animation_timelines):
+            self._live_animation_timelines.append(timeline)
+        return timeline
+
+    def transport_timeline(self) -> Any:
+        """Return the timeline global playback controls should operate on.
+
+        Prefer the active panel when it owns a live animation. If exactly one live
+        animation exists elsewhere, keep controlling that one after the user clicks or
+        orbits another subplot. Figures without a live animation retain the historical
+        per-active-panel behaviour.
+        """
+        active = self.active_panel.timeline
+        live = self._live_animation_timelines
+        if any(candidate is active for candidate in live):
+            return active
+        if len(live) == 1:
+            return live[0]
+        return active
+
     def remove_frame_callback(self, fn: Callable[[float], None]) -> bool:
         """Unregister a callback added by :meth:`add_frame_callback`."""
         for i, existing in enumerate(self._frame_callbacks):
@@ -1835,6 +1869,29 @@ class GPULinePlot:
             glfw.swap_buffers(self.window)
             return
 
+        # On macOS, especially after an earlier invisible export context, Cocoa may not
+        # finish registering the new native window until its first event-pump pass. Focus
+        # requested directly after ``create_window`` is then ignored. Present it only once
+        # all GUI modules are ready, drain those creation events, and request focus after.
+        glfw.show_window(self.window)
+        glfw.poll_events()
+        if sys.platform == "darwin":
+            try:
+                # A process whose first Cocoa window was the invisible export context is
+                # treated as a background application. GLFW can mark the later window
+                # visible, but ``focus_window`` alone cannot activate the application, so
+                # the GUI remains behind every normal app. PyObjC is optional: when it is
+                # present, ask Cocoa to activate this process before requesting GLFW focus.
+                from AppKit import NSApplication, NSApplicationActivationPolicyRegular
+
+                application = NSApplication.sharedApplication()
+                application.setActivationPolicy_(NSApplicationActivationPolicyRegular)
+                application.unhide_(None)
+                application.activateIgnoringOtherApps_(True)
+            except Exception:  # pragma: no cover - optional platform bridge
+                pass
+        glfw.focus_window(self.window)
+        glfw.poll_events()
         self._main_loop()
 
     def save_current_view(self, filename: Optional[str] = None, scale: float = 2.0) -> None:
@@ -1855,7 +1912,7 @@ class GPULinePlot:
     # Init
     # --------------------------------------------------------
 
-    def _init_window(self) -> None:
+    def _init_window(self, *, visible: Optional[bool] = None) -> None:
         if not glfw.init():
             raise RuntimeError("Failed to initialize GLFW")
 
@@ -1876,8 +1933,12 @@ class GPULinePlot:
         if self.options.enable_multisample:
             glfw.window_hint(glfw.SAMPLES, 4)
 
-        if self._is_test_mode:
-            glfw.window_hint(glfw.VISIBLE, glfw.FALSE)
+        # GLFW hints persist until they are changed or reset. Set visibility on every
+        # creation so a temporary invisible animation-export window cannot accidentally
+        # make the next interactive ``show()`` window invisible as well.
+        if visible is None:
+            visible = not self._is_test_mode
+        glfw.window_hint(glfw.VISIBLE, glfw.TRUE if visible else glfw.FALSE)
 
         self.window = glfw.create_window(self.width, self.height, self.options.title, None, None)
         if not self.window:
@@ -1934,6 +1995,80 @@ class GPULinePlot:
         if self.scene.lines.count > 0:
             self.exact_renderer.upload(self.scene.lines)
 
+    def _reset_layer_gl_state(self) -> None:
+        """Forget context-owned layer handles and request a fresh GPU upload.
+
+        A layer may belong to any panel, not only the currently active one. Temporary
+        animation contexts are destroyed after saving, so every VAO/VBO allocated in that
+        context becomes invalid and must not survive into a later interactive ``show()``.
+        """
+        for panel in self.panels:
+            for layer in panel.scene.layers:
+                if hasattr(layer, "_gl"):
+                    layer._gl = None
+                layer.dirty.gpu_dirty = True
+
+    def _init_export_modules(self) -> None:
+        """Initialize only the OpenGL modules needed by offscreen figure export.
+
+        The export pass draws through ``RendererManager`` (and optionally the density
+        renderer). It does not need picking, the interaction cache, post-processing, or an
+        ImGui context. Keeping those out is both faster and avoids constructing GUI state
+        for a window which is deliberately never shown.
+        """
+        self._reset_layer_gl_state()
+        self.density_renderer.initialize(self.fb_width, self.fb_height)
+        self.renderer_manager.initialize()
+
+    @contextmanager
+    def _offscreen_export_context(self):
+        """Provide a current GL context, creating one invisible window when necessary.
+
+        A newly created context lives for the whole ``with`` block so an animation can
+        render hundreds of frames without rebuilding shaders for every frame. Existing
+        interactive contexts are borrowed, never destroyed. Temporary-context resources
+        are discarded with the GLFW window and Python-side handles are reset before a
+        later ``show()`` can reuse the figure.
+        """
+        # ``glfw.get_current_context()`` itself emits GLFW_NOT_INITIALIZED when this is
+        # the first GL operation in a headless script, so initialize before asking which
+        # context (if any) needs to be restored afterwards.
+        if not glfw.init():
+            raise RuntimeError("Failed to initialize GLFW")
+        previous_context = glfw.get_current_context()
+
+        if self.window is not None:
+            glfw.make_context_current(self.window)
+            try:
+                yield
+            finally:
+                if previous_context != self.window:
+                    glfw.make_context_current(previous_context)
+            return
+
+        temporary_window = None
+        try:
+            self._init_window(visible=False)
+            temporary_window = self.window
+            self._init_gl()
+            self._init_export_modules()
+            yield
+        finally:
+            if temporary_window is not None:
+                # Destroying a context releases all of its GL objects. Replace managers
+                # that still contain numeric names from that context, otherwise a later
+                # interactive initialization could mistake stale IDs for live resources.
+                glfw.make_context_current(temporary_window)
+                glfw.destroy_window(temporary_window)
+                if self.window == temporary_window:
+                    self.window = None
+                self.renderer_manager = RendererManager(self)
+                self.density_renderer = DensityRenderer(self)
+                self._reset_layer_gl_state()
+
+            if previous_context != temporary_window:
+                glfw.make_context_current(previous_context)
+
     # --------------------------------------------------------
     # Frame policies
     # --------------------------------------------------------
@@ -3393,6 +3528,22 @@ class GPULinePlot:
     def _on_key(self, window: Any, key: int, sc: int, action: int, mods: int) -> None:
         self.frame.dirty_ui = True
         self.hud.on_key(window, key, sc, action, mods)
+
+        # Workspace shortcuts are normally dispatched from ``Workspace.draw``. With the
+        # HUD disabled that method is intentionally never called, so Space used to vanish
+        # until F3 made the GUI visible. Handle the transport key here only in that hidden
+        # state; when the HUD is enabled the regular action registry remains the sole owner
+        # (including its text-input safety), avoiding a double toggle.
+        if (
+            not self.options.enable_hud
+            and action == glfw.PRESS
+            and key == glfw.KEY_SPACE
+        ):
+            self.transport_timeline().toggle()
+            self.frame.dirty_scene = True
+            self.cache.refresh_requested = True
+            return
+
         if self.hud.wants_keyboard():
             return
 

{glplot-0.1.10 → glplot-0.1.11}/glplot/gui/panels/timeline.py

@@ -1074,7 +1074,7 @@ def queue_playback(panel: Panel) -> None:
     if engine_drives_playback(panel):
         return
 
-    timeline = panel.plot.active_panel.timeline
+    timeline = panel.timeline
     now = _time.perf_counter()
 
     def apply() -> None:
@@ -1161,8 +1161,14 @@ class TimelinePanel(Panel):
 
     @property
     def timeline(self) -> Timeline:
-        """The active panel's timeline. One per panel, like the cameras."""
-        return self.plot.active_panel.timeline
+        """The timeline currently addressed by the figure's transport controls.
+
+        Ordinarily this is the active panel's timeline. A sole live ``FuncAnimation``
+        keeps ownership after a camera click activates another subplot, so pausing,
+        orbiting and resuming cannot accidentally toggle an empty timeline instead.
+        """
+        resolve = getattr(self.plot, "transport_timeline", None)
+        return resolve() if callable(resolve) else self.plot.active_panel.timeline
 
     def _sync_selection(self) -> None:
         """Drop a selection whose track or keyframe has left the timeline."""

{glplot-0.1.10 → glplot-0.1.11}/glplot/gui/workspace.py

@@ -1662,9 +1662,10 @@ class Workspace:
         return "presentation" in self.panels
 
     def _timeline(self) -> Optional[Any]:
-        """The active panel's :class:`~glplot.core.timeline.Timeline`, or None."""
+        """The timeline addressed by global transport controls, or None."""
         try:
-            return self.plot.active_panel.timeline
+            resolve = getattr(self.plot, "transport_timeline", None)
+            return resolve() if callable(resolve) else self.plot.active_panel.timeline
         except Exception:  # pragma: no cover - defensive: a plot without panels
             return None
 

{glplot-0.1.10 → glplot-0.1.11}/glplot/utils/export.py

@@ -50,6 +50,25 @@ class ExportManager:
         """
         Renders the current scene to an offscreen buffer at high resolution.
         """
+        image = self.render_rgb(scale=scale, mode=mode, exact_budget=exact_budget)
+
+        import matplotlib.pyplot as plt
+
+        plt.imsave(filename, image)
+        print(f"Exported high-res image to {filename} ({image.shape[1]}x{image.shape[0]})")
+
+    def render_rgb(
+        self,
+        scale: float = 1.0,
+        mode: Optional[RenderMode] = None,
+        exact_budget: Optional[int] = None,
+    ) -> np.ndarray:
+        """Render the current scene with OpenGL and return top-down RGB pixels.
+
+        This is the in-memory counterpart of :meth:`savefig`. Animation export uses it so
+        each frame goes directly from the OpenGL framebuffer to the movie writer instead
+        of being encoded to a temporary PNG and immediately decoded again.
+        """
         # 1. Prepare target resolution
         width = int(self.engine.fb_width * scale)
         height = int(self.engine.fb_height * scale)
@@ -79,7 +98,8 @@ class ExportManager:
         # 3. Save engine state and configure for export
         old_viewport = glGetIntegerv(GL_VIEWPORT)
         glViewport(0, 0, width, height)
-        glClearColor(1.0, 1.0, 1.0, 1.0)
+        background = self.engine.options.visual.background_color
+        glClearColor(background[0], background[1], background[2], 1.0)
         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
 
         # 4. Render
@@ -198,11 +218,7 @@ class ExportManager:
         glFinish()
         pixels = glReadPixels(0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE)
         image = np.frombuffer(pixels, dtype=np.uint8).reshape((height, width, 3))
-        image = np.flipud(image)
-
-        import matplotlib.pyplot as plt
-
-        plt.imsave(filename, image)
+        image = np.ascontiguousarray(np.flipud(image))
 
         # 6. Cleanup
         glBindFramebuffer(GL_FRAMEBUFFER, 0)
@@ -210,5 +226,4 @@ class ExportManager:
         glDeleteFramebuffers(1, [fbo])
         glDeleteTextures(1, [tex])
         glDeleteRenderbuffers(1, [rbo])
-
-        print(f"Exported high-res image to {filename} ({width}x{height})")
+        return image

{glplot-0.1.10 → glplot-0.1.11}/glplot/utils/preview.py

@@ -25,6 +25,22 @@ LEGEND_FONTSIZE = 24
 #: area, which is what "the default points are tiny" was.
 DEFAULT_SCATTER_SIZE_PT2 = (2.0 * 6.0) ** 2  # 6.0 == matplotlib's rcParams lines.markersize
 
+
+def _point_diameter_px_to_area_pt2(size_px, engine: object = None):
+    """Convert GLPlot's marker diameter in pixels to matplotlib's marker area in pt^2.
+
+    The live 3D renderer reads ``scatter3d(s=...)`` as a screen-space pixel diameter,
+    whereas matplotlib's ``Axes3D.scatter`` reads the same number as an area in points
+    squared. Passing the number through unchanged therefore makes the two views diverge
+    quadratically: a value such as 72 is a huge 72 px disc live but only an 8.5 pt marker
+    in an exported GIF. Convert the units before squaring so both paths represent the same
+    physical marker diameter at the figure's configured DPI.
+    """
+    figure_dpi = float(getattr(engine, "_figure_dpi", 100.0) or 100.0)
+    diameter_pt = np.maximum(np.asarray(size_px, dtype=float), 0.5) * 72.0 / figure_dpi
+    area_pt2 = diameter_pt * diameter_pt
+    return float(area_pt2) if area_pt2.ndim == 0 else area_pt2
+
 #: A colorbar's own chrome. Smaller than the panel-scale sizes above (the bar is a
 #: narrow strip beside a full axis, not an axis itself) but nowhere near matplotlib's
 #: unstyled ~10pt default, which is what these used to fall through to -- a bar's
@@ -207,6 +223,11 @@ def _draw_layers(ax: object, layers, has_3d: bool, engine: object = None) -> Non
             continue
         if layer.layer_type in {"scatter3d", "volume3d"} and layer.vertices is not None:
             verts = layer.vertices
+            size_px = (
+                layer.sizes
+                if layer.sizes is not None and len(layer.sizes) == len(verts)
+                else layer.style.point_size
+            )
             # A marker's outline is its edge, which matplotlib takes as a keyword pair
             # rather than as a path effect. `_outline_edge_kwargs` is empty for a layer with
             # no outline, so the call is character-for-character the historical one.
@@ -215,7 +236,7 @@ def _draw_layers(ax: object, layers, has_3d: bool, engine: object = None) -> Non
                 verts[:, 1],
                 verts[:, 2],
                 c=layer.colors,
-                s=max(layer.style.point_size, 0.5),
+                s=_point_diameter_px_to_area_pt2(size_px, engine),
                 depthshade=False,
                 label=_legend_label(layer),
                 **_outline_edge_kwargs(layer.style),

{glplot-0.1.10 → glplot-0.1.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "glplot"
-version = "0.1.10"
+version = "0.1.11"
 description = "High-performance OpenGL plotting library for Python"
 readme = "README.md"
 requires-python = ">=3.11"