glplot 0.1.0__py3-none-any.whl

glplot/renderers/scatter.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+import ctypes as C
+import numpy as np
+from OpenGL.GL import *
+from typing import TYPE_CHECKING, Optional, Tuple
+
+from .base import GLScatterBuffers
+from ..utils.shaders import SCATTER_VS, SCATTER_FS, DENSITY_POINTS_VS, DENSITY_POINTS_FS
+from ..utils.gl_utils import link_program
+
+if TYPE_CHECKING:
+    from ..core.layers import ScatterLayer
+    from ..core.context import RenderContext
+    from ..options import EngineOptions
+
+class ScatterRenderer:
+    """
+    Primitive renderer for ScatterLayer.
+    Specialized for point clouds (GL_POINTS).
+    """
+    def __init__(self, options: EngineOptions):
+        self.options = options
+        self.prog = 0
+        
+        # Uniform locations
+        self.u_mvp = -1
+        self.u_size = -1
+        self.u_alpha = -1
+        self.u_offset = -1
+        
+        # Accumulation uniforms
+        self.accum_prog = 0
+        self.u_accum_mvp = -1
+        self.u_accum_size = -1
+        self.u_accum_alpha = -1
+        self.u_accum_offset = -1
+
+    def initialize(self) -> None:
+        """Link shaders and setup uniform locations."""
+        self.prog = link_program(SCATTER_VS, SCATTER_FS)
+        self.u_mvp = glGetUniformLocation(self.prog, "u_mvp")
+        self.u_size = glGetUniformLocation(self.prog, "u_size")
+        self.u_alpha = glGetUniformLocation(self.prog, "u_alpha")
+        self.u_offset = glGetUniformLocation(self.prog, "u_layer_offset")
+        self.u_point_size_px = glGetUniformLocation(self.prog, "u_point_size_px")
+        self.u_outline_enabled = glGetUniformLocation(self.prog, "u_outline_enabled")
+        self.u_outline_color = glGetUniformLocation(self.prog, "u_outline_color")
+        self.u_outline_width_px = glGetUniformLocation(self.prog, "u_outline_width_px")
+
+        # Density Accumulation Program
+        self.accum_prog = link_program(DENSITY_POINTS_VS, DENSITY_POINTS_FS)
+        self.u_accum_mvp = glGetUniformLocation(self.accum_prog, "u_mvp")
+        self.u_accum_size = glGetUniformLocation(self.accum_prog, "u_size")
+        self.u_accum_alpha = glGetUniformLocation(self.accum_prog, "u_alpha")
+        self.u_accum_offset = glGetUniformLocation(self.accum_prog, "u_layer_offset")
+
+    def _create_buffers(self, layer: ScatterLayer) -> GLScatterBuffers:
+        """Create and initialize GPU buffers for a scatter layer."""
+        vao = glGenVertexArrays(1)
+        glBindVertexArray(vao)
+        
+        # 1. Point Positions
+        vbo_pts = glGenBuffers(1)
+        glBindBuffer(GL_ARRAY_BUFFER, vbo_pts)
+        glBufferData(GL_ARRAY_BUFFER, 16, None, GL_STATIC_DRAW) # Pre-allocate to avoid segfault
+        glEnableVertexAttribArray(0)
+        glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, C.c_void_p(0))
+        
+        # 2. Point Colors
+        vbo_col = glGenBuffers(1)
+        glBindBuffer(GL_ARRAY_BUFFER, vbo_col)
+        glBufferData(GL_ARRAY_BUFFER, 16, None, GL_STATIC_DRAW) # Pre-allocate to avoid segfault
+        glEnableVertexAttribArray(1)
+        glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 0, C.c_void_p(0))
+        
+        glBindVertexArray(0)
+        return GLScatterBuffers(vao=vao, vbo_pts=vbo_pts, vbo_col=vbo_col)
+
+    def update_gpu_data(self, layer: ScatterLayer, bufs: GLScatterBuffers) -> None:
+        """Upload semantic points and colors to GPU buffers."""
+        if layer.pts is None or len(layer.pts) == 0: return
+        
+        # Upload Positions
+        glBindBuffer(GL_ARRAY_BUFFER, bufs.vbo_pts)
+        glBufferData(GL_ARRAY_BUFFER, layer.pts.nbytes, layer.pts, GL_STATIC_DRAW)
+        
+        # Upload Colors
+        if layer.colors is not None:
+            # If colors are provided as a single color, broadcast it
+            if layer.colors.ndim == 1 and len(layer.colors) == 4:
+                cols = np.tile(layer.colors, (len(layer.pts), 1)).astype(np.float32)
+            else:
+                cols = layer.colors.astype(np.float32)
+                
+            glBindBuffer(GL_ARRAY_BUFFER, bufs.vbo_col)
+            glBufferData(GL_ARRAY_BUFFER, cols.nbytes, cols, GL_STATIC_DRAW)
+        
+        bufs.count = len(layer.pts)
+        layer.dirty.gpu_dirty = False
+
+    def draw(self, layer: ScatterLayer, ctx: RenderContext) -> None:
+        """Draw the scatter layer using current context."""
+        if layer.pts is None or len(layer.pts) == 0: return
+
+        # 1. Resource Management
+        if not hasattr(layer, "_gl") or layer._gl is None:
+            layer._gl = self._create_buffers(layer)
+            layer.dirty.gpu_dirty = True
+        
+        if layer.dirty.gpu_dirty:
+            self.update_gpu_data(layer, layer._gl)
+
+        # 2. Setup OpenGL State & Shaders
+        glUseProgram(self.prog)
+        glEnable(GL_PROGRAM_POINT_SIZE)
+        
+        glUniformMatrix4fv(self.u_mvp, 1, GL_TRUE, ctx.mvp)
+        
+        # Style Resolution: Base * Multipliers
+        overrides = self.options.visual.overrides
+        effective_size = float(layer.style.point_size) * ctx.dpr * overrides.point_size_multiplier
+        effective_alpha = ctx.global_alpha * layer.style.alpha * overrides.alpha_multiplier
+        
+        glUniform1f(self.u_size, effective_size)
+        glUniform1f(self.u_alpha, float(effective_alpha))
+        glUniform1f(self.u_point_size_px, effective_size)
+        
+        # Outline logic
+        glUniform1i(self.u_outline_enabled, 1 if layer.style.point_outline_enabled else 0)
+        if layer.style.point_outline_enabled:
+            glUniform4f(self.u_outline_color, *layer.style.point_outline_color)
+            glUniform1f(self.u_outline_width_px, float(layer.style.point_outline_width) * ctx.dpr)
+        
+        glUniform2f(self.u_offset, *layer.translation)
+
+        # 3. Draw call
+        glBindVertexArray(layer._gl.vao)
+        glDrawArrays(GL_POINTS, 0, layer._gl.count)
+        
+        # Cleanup
+        glBindVertexArray(0)
+        glUseProgram(0)
+        glDisable(GL_PROGRAM_POINT_SIZE)
+
+    def draw_density(self, layer: ScatterLayer, ctx: RenderContext) -> None:
+        """Accumulate point density into the current R32F target."""
+        if layer.pts is None or len(layer.pts) == 0: return
+
+        # 1. Resource Management
+        if not hasattr(layer, "_gl") or layer._gl is None:
+            layer._gl = self._create_buffers(layer)
+            layer.dirty.gpu_dirty = True
+        
+        if layer.dirty.gpu_dirty:
+            self.update_gpu_data(layer, layer._gl)
+
+        # 2. Setup Shaders
+        glUseProgram(self.accum_prog)
+        glEnable(GL_PROGRAM_POINT_SIZE)
+        
+        glUniformMatrix4fv(self.u_accum_mvp, 1, GL_TRUE, ctx.mvp)
+        
+        overrides = self.options.visual.overrides
+        # Use a slightly smaller size for density to prevent over-blurring
+        # unless user explicitly requested massive points.
+        effective_size = max(1.0, float(layer.style.point_size) * ctx.dpr * 0.5 * overrides.point_size_multiplier)
+        glUniform1f(self.u_accum_size, effective_size)
+
+        # Weighted Accumulation
+        if self.options.density_weighted:
+            alpha = ctx.global_alpha * layer.style.alpha * overrides.alpha_multiplier
+            glUniform1f(self.u_accum_alpha, float(alpha))
+        else:
+            glUniform1f(self.u_accum_alpha, 1.0) # Simple counting mode
+        
+        glUniform2f(self.u_accum_offset, *layer.translation)
+
+        # 3. Draw call
+        glBindVertexArray(layer._gl.vao)
+        glDrawArrays(GL_POINTS, 0, layer._gl.count)
+        
+        # Cleanup
+        glBindVertexArray(0)
+        glUseProgram(0)
+        glDisable(GL_PROGRAM_POINT_SIZE)

glplot/renderers/text.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional
+import numpy as np
+
+try:
+    import imgui
+    IMGUI_AVAILABLE = True
+except ImportError:
+    IMGUI_AVAILABLE = False
+
+if TYPE_CHECKING:
+    from ..core.layers import TextLayer
+    from ..core.context import RenderContext
+    from ..options import EngineOptions
+
+class TextRenderer:
+    """
+    Primitive renderer for TextLayer.
+    Uses ImGui's background draw list to render proyected labels.
+    """
+    def __init__(self, options: EngineOptions):
+        self.options = options
+
+    def initialize(self) -> None:
+        pass
+
+    def draw(self, layer: TextLayer, ctx: RenderContext) -> None:
+        if not IMGUI_AVAILABLE or not layer.style.visible:
+            return
+
+        # 1. Project world coordinate to NDC
+        # Use the MVP matrix provided in the context
+        tx, ty = layer.translation
+        pos_world = np.array([layer.x + tx, layer.y + ty, 0.0, 1.0], dtype=np.float32)
+        pos_ndc = ctx.mvp @ pos_world
+        
+        # Perspective divide
+        if pos_ndc[3] != 0:
+            pos_ndc /= pos_ndc[3]
+        
+        # Clipping: if outside NDC [-1, 1], don't draw
+        if abs(pos_ndc[0]) > 1.1 or abs(pos_ndc[1]) > 1.1:
+            return
+
+        # 2. Convert NDC to screen-space (pixels)
+        # NDC (-1, 1) -> Screen (0, Width)
+        # Note: y is flipped in screen-space
+        screen_x = (pos_ndc[0] + 1.0) * 0.5 * ctx.width_px
+        screen_y = (1.0 - pos_ndc[1]) * 0.5 * ctx.height_px
+        
+        # 3. Draw using ImGui
+        draw_list = imgui.get_background_draw_list()
+        
+        color = layer.style.color if layer.style.color is not None else (0.0, 0.0, 0.0, 1.0)
+        # ImGui expects packed color or separate components depending on the call
+        # imgui.get_color_u32_rgba takes (r, g, b, a) in 0..1
+        u32_color = imgui.get_color_u32_rgba(*color)
+        
+        # In V1, we just use the default font. 
+        # Future enhancement: custom font sizes via pusher/pop
+        draw_list.add_text(screen_x, screen_y, u32_color, layer.text)
+
+    def draw_all(self, layers: List[BaseLayer], ctx: RenderContext) -> None:
+        """Helper to draw all text layers in the scene."""
+        if not IMGUI_AVAILABLE: return
+        for l in layers:
+            if l.layer_type == "text":
+                self.draw(l, ctx)
+
+    def draw_density(self, layer: TextLayer, ctx: RenderContext) -> None:
+        # Text does not participate in density
+        pass

glplot/utils/export.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+import time
+import numpy as np
+from OpenGL.GL import *
+from typing import Optional, Tuple, TYPE_CHECKING
+from ..options import RenderMode, BlendMode
+from ..core.context import RenderContext
+
+if TYPE_CHECKING:
+    from ..engine import GPULinePlot
+
+class ExportManager:
+    """
+    Handles offscreen rendering for high-resolution exports.
+    """
+    def __init__(self, engine: GPULinePlot):
+        self.engine = engine
+
+    def savefig(
+        self, 
+        filename: str, 
+        scale: float = 1.0, 
+        mode: Optional[RenderMode] = None,
+        exact_budget: Optional[int] = None
+    ) -> None:
+        """
+        Renders the current scene to an offscreen buffer at high resolution.
+        """
+        # 1. Prepare target resolution
+        width = int(self.engine.fb_width * scale)
+        height = int(self.engine.fb_height * scale)
+
+        # 2. Create offscreen resources
+        fbo = glGenFramebuffers(1)
+        glBindFramebuffer(GL_FRAMEBUFFER, fbo)
+        
+        tex = glGenTextures(1)
+        glBindTexture(GL_TEXTURE_2D, tex)
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, None)
+        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0)
+        
+        if glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE:
+            glBindFramebuffer(GL_FRAMEBUFFER, 0)
+            glDeleteFramebuffers(1, [fbo])
+            glDeleteTextures(1, [tex])
+            raise RuntimeError("Failed to create export framebuffer")
+
+        # 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)
+        glClear(GL_COLOR_BUFFER_BIT)
+
+        # 4. Render
+        # Create a proper RenderContext for high-resolution export
+        mvp = self.engine.camera_controller.mvp(width, height)
+        window = self.engine.camera_controller.world_window(width, height)
+        
+        # Calculate NDC transform for high-res
+        ndc_scale, ndc_offset = self.engine._get_ndc_transform(window)
+        
+        # Quality policy for exports
+        prob = 1.0
+        if exact_budget is not None and self.engine.scene.lines.count > 0:
+            prob = min(1.0, (exact_budget * width) / self.engine.scene.lines.count)
+
+        alpha = self.engine.options.default_global_alpha
+        if prob < 1.0:
+            alpha = min(1.0, alpha / (prob**0.5))
+
+        ctx = RenderContext(
+            mvp=mvp,
+            window_world=window,
+            ndc_scale=ndc_scale,
+            ndc_offset=ndc_offset,
+            width_px=width,
+            height_px=height,
+            fb_width=width,
+            fb_height=height,
+            dpr=scale * (self.engine.fb_width / max(self.engine.width, 1)),
+            mode=mode or self.engine.policy.runtime.current_mode,
+            global_alpha=alpha,
+            lod_keep_prob=prob,
+            time=time.perf_counter()
+        )
+
+        # Apply engine blending policy
+        self.engine._apply_blending_policy()
+
+        # Render all layers via the modular manager
+        layers = self.engine._get_all_layers()
+        if self.engine.display_density:
+            self.engine.renderer_manager.draw_density(layers, ctx, target_fbo=fbo, target_size=(width, height))
+        else:
+            self.engine.renderer_manager.draw_exact(layers, ctx)
+
+        # 5. Read back and save
+        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)
+        
+        # 6. Cleanup
+        glBindFramebuffer(GL_FRAMEBUFFER, 0)
+        glViewport(*old_viewport)
+        glDeleteFramebuffers(1, [fbo])
+        glDeleteTextures(1, [tex])
+        
+        print(f"Exported high-res image to {filename} ({width}x{height})")

glplot/utils/gl_utils.py

@@ -0,0 +1,32 @@
+import numpy as np
+from OpenGL.GL import *
+
+def ortho(l: float, r: float, b: float, t: float, n: float = -1.0, f: float = 1.0) -> np.ndarray:
+    rl, tb, fn = (r - l), (t - b), (f - n)
+    return np.array([
+        [2.0 / rl, 0.0,      0.0,      -(r + l) / rl],
+        [0.0,      2.0 / tb, 0.0,      -(t + b) / tb],
+        [0.0,      0.0,     -2.0 / fn, -(f + n) / fn],
+        [0.0,      0.0,      0.0,       1.0],
+    ], dtype=np.float32)
+
+def compile_shader(src: str, stype: int) -> int:
+    sid = glCreateShader(stype)
+    glShaderSource(sid, src)
+    glCompileShader(sid)
+    if not glGetShaderiv(sid, GL_COMPILE_STATUS):
+        raise RuntimeError(glGetShaderInfoLog(sid).decode(errors="ignore"))
+    return sid
+
+def link_program(vs_src: str, fs_src: str) -> int:
+    vs = compile_shader(vs_src, GL_VERTEX_SHADER)
+    fs = compile_shader(fs_src, GL_FRAGMENT_SHADER)
+    pid = glCreateProgram()
+    glAttachShader(pid, vs)
+    glAttachShader(pid, fs)
+    glLinkProgram(pid)
+    glDeleteShader(vs)
+    glDeleteShader(fs)
+    if not glGetProgramiv(pid, GL_LINK_STATUS):
+        raise RuntimeError(glGetProgramInfoLog(pid).decode(errors="ignore"))
+    return pid

glplot/utils/mpl_bridge.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Tuple, Optional
+import numpy as np
+
+@dataclass
+class GLPlotSnapshot:
+    """
+    Serializable container for a snapshot of a GLPlot viewport.
+    This can be used to transfer high-fidelity renders to other 
+    plotting libraries like Matplotlib.
+    """
+    rgba: np.ndarray                     # H x W x 4 uint8
+    extent: Tuple[float, float, float, float]   # xmin, xmax, ymin, ymax
+    xlim: Tuple[float, float]
+    ylim: Tuple[float, float]
+    width_px: int
+    height_px: int
+    transparent: bool
+
+def snapshot_to_matplotlib(
+    snapshot: GLPlotSnapshot, 
+    ax=None, 
+    interpolation: str = "nearest",
+    preserve_aspect: bool = True,
+    set_limits: bool = True,
+    zorder: float = 0.0
+):
+    """
+    Standalone utility to embed a GLPlotSnapshot into a Matplotlib axis.
+    Does not require a live OpenGL context.
+    """
+    import matplotlib.pyplot as plt
+
+    if ax is None:
+        fig, ax = plt.subplots()
+    else:
+        fig = ax.figure
+
+    xmin, xmax, ymin, ymax = snapshot.extent
+
+    # Matplotlib's imshow with extent handles the coordinate mapping.
+    # We use origin="lower" because OpenGL starts at bottom-left.
+    artist = ax.imshow(
+        snapshot.rgba,
+        extent=(xmin, xmax, ymin, ymax),
+        origin="lower",
+        interpolation=interpolation,
+        zorder=zorder
+    )
+
+    if set_limits:
+        ax.set_xlim(xmin, xmax)
+        ax.set_ylim(ymin, ymax)
+
+    if preserve_aspect:
+        # Matches GLPlot's likely aspect if it was consistent
+        ax.set_aspect("equal", adjustable="box")
+
+    return fig, ax, artist