glplot 0.1.0__py3-none-any.whl

glplot/managers/picking.py

@@ -0,0 +1,174 @@
+from __future__ import annotations
+import numpy as np
+from OpenGL.GL import *
+from typing import Optional, TYPE_CHECKING, Tuple
+from ..renderers.base import GLOffscreenTarget
+from ..utils.gl_utils import link_program
+from ..utils.shaders import (
+    PICKING_LINES_VS, PICKING_LINES_FS,
+    PICKING_SCATTER_VS, PICKING_SCATTER_FS,
+    PICKING_STRIP_VS, PICKING_STRIP_FS,
+    PICKING_PATCH_VS, PICKING_PATCH_FS
+)
+
+if TYPE_CHECKING:
+    from ..options import EngineOptions
+    from ..core import SceneData
+    from ..renderers.exact import GLLineBuffers
+
+class PickingManager:
+    def __init__(self, options: EngineOptions):
+        self.options = options
+        self.target = GLOffscreenTarget()
+        self.pid_lines = -1
+        self.pid_scatter = -1
+        self.pid_strip = -1
+        self.pid_patch = -1
+
+    def initialize(self, fb_width: int, fb_height: int) -> None:
+        self.pid_lines = link_program(PICKING_LINES_VS, PICKING_LINES_FS)
+        self.pid_scatter = link_program(PICKING_SCATTER_VS, PICKING_SCATTER_FS)
+        self.pid_strip = link_program(PICKING_STRIP_VS, PICKING_STRIP_FS)
+        self.pid_patch = link_program(PICKING_PATCH_VS, PICKING_PATCH_FS)
+        self.rebuild_target(fb_width, fb_height)
+
+    def rebuild_target(self, fb_width: int, fb_height: int) -> None:
+        if self.target.fbo:
+            glDeleteFramebuffers(1, [self.target.fbo])
+            glDeleteTextures(1, [self.target.tex])
+
+        tex = glGenTextures(1)
+        glBindTexture(GL_TEXTURE_2D, tex)
+        # We store 32-bit Integer IDs
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_R32I, fb_width, fb_height, 0, GL_RED_INTEGER, GL_INT, None)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
+
+        fbo = glGenFramebuffers(1)
+        glBindFramebuffer(GL_FRAMEBUFFER, fbo)
+        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0)
+        
+        status = glCheckFramebufferStatus(GL_FRAMEBUFFER)
+        if status != GL_FRAMEBUFFER_COMPLETE:
+            print(f"Picking Framebuffer incomplete: {status}")
+            
+        glBindFramebuffer(GL_FRAMEBUFFER, 0)
+        self.target = GLOffscreenTarget(fbo=fbo, tex=tex, width=fb_width, height=fb_height)
+
+    def draw_pick_scene(
+        self, 
+        scene: SceneData, 
+        buffers: Any, 
+        mvp: np.ndarray,
+        window: Tuple[float, float, float, float]
+    ) -> None:
+        glBindFramebuffer(GL_FRAMEBUFFER, self.target.fbo)
+        glViewport(0, 0, self.target.width, self.target.height)
+        
+        # 1. State for picking: no blending, no multisampling
+        glDisable(GL_BLEND)
+        glDisable(GL_MULTISAMPLE)
+        
+        # Clear with 0 (no object) using integer clear
+        glClearBufferiv(GL_COLOR, 0, np.array([0], dtype=np.int32))
+        
+        current_offset = 0
+        for i, layer in enumerate(scene.layers):
+            if not layer.style.visible:
+                continue
+            
+            # IDs are 1-based, 0 is "nothing"
+            layer_id_start = current_offset + 1
+            
+            if layer.layer_type == "line_family":
+                if layer.ab is not None and hasattr(layer, "_gl"):
+                    glUseProgram(self.pid_lines)
+                    glUniformMatrix4fv(glGetUniformLocation(self.pid_lines, "u_mvp"), 1, GL_FALSE, mvp)
+                    glUniform2f(glGetUniformLocation(self.pid_lines, "u_xrange"), *layer.x_range)
+                    glUniform4f(glGetUniformLocation(self.pid_lines, "u_window"), *window)
+                    glUniform2f(glGetUniformLocation(self.pid_lines, "u_layer_offset"), *layer.translation)
+                    glUniform1i(glGetUniformLocation(self.pid_lines, "u_id_offset"), current_offset)
+                    layer._gl.render(len(layer.ab))
+                    current_offset += len(layer.ab)
+
+            elif layer.layer_type == "scatter":
+                if hasattr(layer, "_gl"):
+                    glUseProgram(self.pid_scatter)
+                    glEnable(GL_PROGRAM_POINT_SIZE)
+                    glUniformMatrix4fv(glGetUniformLocation(self.pid_scatter, "u_mvp"), 1, GL_FALSE, mvp)
+                    glUniform1f(glGetUniformLocation(self.pid_scatter, "u_size"), float(layer.style.point_size))
+                    glUniform1i(glGetUniformLocation(self.pid_scatter, "u_id_offset"), current_offset)
+                    glUniform2f(glGetUniformLocation(self.pid_scatter, "u_layer_offset"), *layer.translation)
+                    glBindVertexArray(layer._gl.vao)
+                    glDrawArrays(GL_POINTS, 0, layer._gl.count)
+                    current_offset += layer._gl.count
+                    
+            elif layer.layer_type == "polyline":
+                if hasattr(layer, "_gl"):
+                    # Polyline is treated as 1 object for now
+                    glUseProgram(self.pid_strip)
+                    glUniformMatrix4fv(glGetUniformLocation(self.pid_strip, "u_mvp"), 1, GL_FALSE, mvp)
+                    glUniform1i(glGetUniformLocation(self.pid_strip, "u_id"), current_offset + 1)
+                    glUniform2f(glGetUniformLocation(self.pid_strip, "u_layer_offset"), *layer.translation)
+                    glBindVertexArray(layer._gl.vao)
+                    # Polyline uses instanced quads (6 verts per segment)
+                    glDrawElements(GL_TRIANGLES, layer._gl.instance_count * 6, GL_UNSIGNED_SHORT, None)
+                    current_offset += 1
+
+            elif layer.layer_type == "patch":
+                if hasattr(layer, "_gl"):
+                    glUseProgram(self.pid_patch)
+                    glUniformMatrix4fv(glGetUniformLocation(self.pid_patch, "u_mvp"), 1, GL_FALSE, mvp)
+                    glUniform1i(glGetUniformLocation(self.pid_patch, "u_id"), current_offset + 1)
+                    glUniform2f(glGetUniformLocation(self.pid_patch, "u_layer_offset"), *layer.translation)
+                    glBindVertexArray(layer._gl.vao)
+                    mode = GL_TRIANGLE_STRIP
+                    if getattr(layer, "mode", "") == "triangles": mode = GL_TRIANGLES
+                    if layer._gl.ebo:
+                        glDrawElements(mode, layer._gl.count, GL_UNSIGNED_INT, None)
+                    else:
+                        glDrawArrays(mode, 0, layer._gl.count)
+                    current_offset += 1
+
+        glBindFramebuffer(GL_FRAMEBUFFER, 0)
+        glUseProgram(0)
+
+    def pick_readback(self, sx: float, sy: float, scene: SceneData) -> Optional[dict]:
+        """sx, sy must be in framebuffer/pixel coordinates (already DPR-scaled)."""
+        gx = int(sx)
+        gy = int(self.target.height - sy)
+
+        if gx < 0 or gx >= self.target.width or gy < 0 or gy >= self.target.height:
+            return None
+
+        glBindFramebuffer(GL_FRAMEBUFFER, self.target.fbo)
+        pixels = glReadPixels(gx, gy, 1, 1, GL_RED_INTEGER, GL_INT)
+        glBindFramebuffer(GL_FRAMEBUFFER, 0)
+        
+        val = int(np.frombuffer(pixels, dtype=np.int32)[0])
+        if val <= 0:
+            return None
+
+        # Decode based on global offsets
+        current_offset = 0
+        for i, layer in enumerate(scene.layers):
+            if not layer.style.visible: continue
+            
+            count = 0
+            if layer.layer_type == "line_family":
+                count = len(layer.ab) if layer.ab is not None else 0
+            elif layer.layer_type == "scatter":
+                count = layer._gl.count if hasattr(layer, "_gl") else 0
+            elif layer.layer_type in ["polyline", "patch"]:
+                count = 1
+                
+            if current_offset < val <= current_offset + count:
+                return {
+                    "type": layer.layer_type,
+                    "layer_id": layer.layer_id,  # Use stable ID
+                    "element_idx": val - current_offset - 1,
+                    "layer": layer
+                }
+            current_offset += count
+            
+        return None

glplot/managers/renderer_manager.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, List, Dict, Optional, Type, Tuple, Any, Iterable
+from enum import Flag, auto
+import numpy as np
+
+if TYPE_CHECKING:
+    from ..engine import GPULinePlot
+    from ..core.layers import BaseLayer
+    from ..options import EngineOptions
+
+from ..renderers.line_family import LineFamilyRenderer
+from ..renderers.polyline import PolylineRenderer
+from ..renderers.scatter import ScatterRenderer
+from ..renderers.patch import PatchRenderer
+from ..renderers.text import TextRenderer
+from ..renderers.axis import AxisRenderer
+
+class LayerCapability(Flag):
+    """Flags defining what a layer can participate in."""
+    NONE = 0
+    EXACT = auto()      # Can be rendered in the main pass
+    DENSITY = auto()    # Can be rendered in the density pass
+    PICKING = auto()    # Can be rendered in the picking pass
+    EXPORT = auto()     # Can be exported to image
+    OVERLAY = auto()    # Is an overlay (HUD-like)
+
+class RendererManager:
+    """
+    Orchestrates the rendering of layers, sorting by z-order, 
+    and dispatching to specialized primitive renderers.
+    """
+    def __init__(self, plot: GPULinePlot):
+        self.plot = plot
+        self.options = plot.options
+        
+        # Capability-based renderer registration
+        # Map: layer_type -> renderer instance
+        self.renderers: Dict[str, Any] = {}
+        
+        # Performance cache
+        self._sorted_layers: List[BaseLayer] = []
+        self._last_scene_hash: int = 0
+
+    def initialize(self) -> None:
+        """Initialize all registered primitive renderers."""
+        self.renderers["line_family"] = LineFamilyRenderer(self.options)
+        self.renderers["polyline"] = PolylineRenderer(self.options)
+        self.renderers["scatter"] = ScatterRenderer(self.options)
+        self.renderers["patch"] = PatchRenderer(self.options)
+        self.renderers["text"] = TextRenderer(self.options)
+        self.renderers["axis"] = AxisRenderer(self.options)
+        for renderer in self.renderers.values():
+            renderer.initialize()
+
+    def filter_layers(self, layers: Iterable[BaseLayer], capability: LayerCapability) -> List[BaseLayer]:
+        """
+        Filter and sort layers based on visibility and capability.
+        This fulfils the Phase 2 Capability Filtering requirement.
+        """
+        # 1. Filter by visibility and capability metadata
+        # (In V1, we assume all layers support EXACT/EXPORT unless specified)
+        eligible = []
+        for l in layers:
+            if not l.style.visible:
+                continue
+            
+            # Capability check
+            # Default to EXACT | EXPORT | DENSITY if not specified
+            caps = l.metadata.get("capabilities", LayerCapability.EXACT | LayerCapability.EXPORT | LayerCapability.DENSITY)
+            if capability in caps:
+                eligible.append(l)
+        
+        # 2. Sort by zorder, maintaining stable insertion order for ties
+        return sorted(eligible, key=lambda l: l.style.zorder)
+
+    def draw_density(self, layers: List[BaseLayer], context: Any, target_fbo: int = 0, target_size: Optional[Tuple[int, int]] = None) -> None:
+        """Modular DENSITY pass render loop."""
+        sorted_layers = self.filter_layers(layers, LayerCapability.DENSITY)
+        
+        # 1. Prepare the density manager for accumulation
+        self.plot.density_renderer.begin_accum()
+        
+        # 2. Accumulate each layer
+        for layer in sorted_layers:
+            renderer = self.renderers.get(layer.layer_type)
+            if renderer and hasattr(renderer, "draw_density"):
+                renderer.draw_density(layer, context)
+                
+        # 3. Resolve to the target FBO
+        self.plot.density_renderer.resolve(target_fbo=target_fbo, target_size=target_size)
+
+    def draw_exact(self, layers: List[BaseLayer], context: Any) -> None:
+        """Main EXACT pass render loop."""
+        sorted_layers = self.filter_layers(layers, LayerCapability.EXACT)
+        
+        # Pre-count types for normalization
+        type_totals = {}
+        for l in sorted_layers:
+            type_totals[l.layer_type] = type_totals.get(l.layer_type, 0) + 1
+            
+        type_counters = {}
+        for layer in sorted_layers:
+            total = type_totals[layer.layer_type]
+            current = type_counters.get(layer.layer_type, 0)
+            
+            # Calculate normalized ID for colormapping (sequential across layers of same type)
+            id_norm = float(current) / float(max(1, total - 1)) if total > 1 else 0.5
+            
+            self._dispatch_draw(layer, context, id_norm=id_norm)
+            type_counters[layer.layer_type] = current + 1
+
+    def draw_axes(self, axis_manager: Any, context: Any) -> None:
+        """Draw the coordinate framework."""
+        self.renderers["axis"].draw(axis_manager, context)
+
+    def _dispatch_draw(self, layer: BaseLayer, context: Any, id_norm: float = 0.0) -> None:
+        """Internal dispatcher for primitive types."""
+        renderer = self.renderers.get(layer.layer_type)
+        if renderer:
+            # Check if renderer expects id_norm
+            import inspect
+            sig = inspect.signature(renderer.draw)
+            if "id_norm" in sig.parameters:
+                renderer.draw(layer, context, id_norm=id_norm)
+            else:
+                renderer.draw(layer, context)
+        else:
+            # Fallback for Phase 0-2: legacy bridge handles drawing
+            pass
+
+    def get_bounds(self, layers: List[BaseLayer]) -> Optional[Tuple[float, float, float, float]]:
+        """Calculate collective bounds of all layers contributing to autoscale."""
+        xmin, xmax, ymin, ymax = float('inf'), float('-inf'), float('inf'), float('-inf')
+        found = False
+        
+        for layer in layers:
+            # Autoscale policy: visible layers + no semantic guide lines
+            if not layer.style.visible: continue
+            
+            # Policy check: does this layer type participate in autoscale?
+            # V1 NON-GOAL: Text and guide lines (axvline) don't count by default
+            is_guide = layer.layer_type in ["semantic_line", "semantic_span", "text"]
+            if is_guide: continue
+
+            b = layer.get_intrinsic_bounds()
+            if b:
+                if not all(np.isfinite(b)): continue
+                tx, ty = layer.translation
+                xmin = min(xmin, b[0] + tx)
+                xmax = max(xmax, b[1] + tx)
+                ymin = min(ymin, b[2] + ty)
+                ymax = max(ymax, b[3] + ty)
+                found = True
+                
+        if not found or xmin == float('inf'):
+            return None
+            
+        return (xmin, xmax, ymin, ymax)

glplot/options.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from enum import Enum, auto
+
+class RenderMode(Enum):
+    EXACT = auto()
+    INTERACTIVE = auto()
+
+class BlendMode(Enum):
+    ALPHA = auto()      # Standard transparency (SrcAlpha, OneMinusSrcAlpha)
+    ADDITIVE = auto()   # Glowing accumulation (SrcAlpha, One)
+    SUBTRACTIVE = auto()# Anti-glow (RevSub, SrcAlpha, One)
+    SCREEN = auto()     # Lightening (One, OneMinusSrcColor)
+    AUTO = auto()       # Smart switching based on count
+    OFF = auto()        # No blending
+
+@dataclass
+class GlowOptions:
+    enabled: bool = False
+    threshold: float = 0.7
+    intensity: float = 0.8
+    radius_px: float = 6.0
+    resolution_scale: float = 0.5
+
+@dataclass
+class GradientBackgroundOptions:
+    enabled: bool = False
+    top_color: tuple = (1.0, 1.0, 1.0)
+    bottom_color: tuple = (0.95, 0.97, 1.0)
+
+@dataclass
+class GlobalStyleOverrides:
+    """Centralized multipliers to adjust the entire scene at once."""
+    enabled: bool = True
+    alpha_multiplier: float = 1.0
+    line_width_multiplier: float = 1.0
+    point_size_multiplier: float = 1.0
+
+@dataclass
+class VisualOptions:
+    background_color: tuple = (0.0, 0.0, 0.0)
+    glow: GlowOptions = field(default_factory=GlowOptions)
+    gradient_background: GradientBackgroundOptions = field(default_factory=GradientBackgroundOptions)
+    overrides: GlobalStyleOverrides = field(default_factory=GlobalStyleOverrides)
+
+@dataclass
+class EngineOptions:
+    window_width: int = 1400
+    window_height: int = 900
+    title: str = "Hybrid GPU Line Renderer"
+
+    # Quality / scale policy
+    lod_enabled: bool = True
+    lod_target_coverage: float = 0.35
+    default_global_alpha: float = 0.20
+    default_line_budget_per_px: int = 8
+    global_line_width: float = 1.0
+    interaction_budget_lines_per_screen_px: int = 2
+    auto_disable_blending_threshold: int = 100_000_000
+
+    # Interaction
+    drag_threshold_px: float = 4.0
+    hover_pick_hz: float = 0.0          # 0 means disabled; picking is shift-only
+    cache_refresh_hz: float = 10.0
+    cache_padding: float = 3.0
+    cache_safe_margin: float = 0.15
+    zoom_scroll_factor: float = 1.10
+    
+    # Navigation tuning (Phase 2 additions planned)
+    pan_key_fraction: float = 0.08
+    zoom_key_factor: float = 1.15
+    zoom_scroll_factor: float = 1.10
+    box_zoom_min_pixels: int = 8
+
+    # Feature policies
+    enable_hud: bool = False            # ask user beforehand, or set explicitly
+    
+    # Axis / Framework visibility
+    axis_show_grid: bool = True
+    axis_show_labels: bool = True
+    axis_show_frame: bool = True
+    axis_grid_alpha: float = 0.1
+    axis_grid_color: tuple = (0.2, 0.2, 0.2)
+
+    enable_density_interaction_path: bool = True
+    enable_cache_interaction_path: bool = True
+    enable_clipping_optimization: bool = True
+    enable_multisample: bool = False
+    always_lod: bool = False
+
+    # Picking policy
+    shift_required_for_picking: bool = True
+    picking_radius_px: int = 5
+
+    # Export
+    export_scale: float = 2.0
+
+    # Density rendering
+    density_gain: float = 1.0
+    density_resolution_scale: float = 1.0   # 1.0 = full-res, 0.5 = faster
+    density_scheme_index: int = 0
+    density_gain_step: float = 1.25
+    density_log_scale: float = 3.0           # Divisor for log normalization
+    density_weighted: bool = False          # Accumulate alpha instead of 1.0
+
+    # Style
+    blend_mode: BlendMode = BlendMode.AUTO
+    line_colormap_enabled: bool = False
+    enable_auto_alpha: bool = True          # Scale alpha based on N
+    
+    # Visual Effects
+    visual: VisualOptions = field(default_factory=VisualOptions)
+
+@dataclass
+class RuntimePolicy:
+    # Mutable runtime decisions derived from dataset size and state.
+    blending_enabled: bool = True
+    current_mode: RenderMode = RenderMode.EXACT
+    picking_enabled_this_frame: bool = False
+    hud_enabled_this_frame: bool = False

glplot/policy.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+import numpy as np
+from typing import TYPE_CHECKING, Tuple
+from .options import RenderMode
+
+if TYPE_CHECKING:
+    from .options import EngineOptions
+    from .core.legacy import SceneData, InteractionState, CacheState
+    from .core.context import RenderContext
+
+class RenderPolicyManager:
+    """
+    Orchestrates rendering policies including LOD, blending, and density fallbacks.
+    Implements 'Width-Aware' scaling to protect against fill-rate bottlenecks.
+    """
+    def __init__(self, options: EngineOptions):
+        from .options import RuntimePolicy
+        self.options = options
+        self.runtime = RuntimePolicy()
+
+    def update(self, scene: SceneData, interaction: InteractionState, cache: CacheState) -> None:
+        n = scene.lines.count
+
+        if interaction.drag_active or cache.active:
+            self.runtime.current_mode = RenderMode.INTERACTIVE
+        else:
+            self.runtime.current_mode = RenderMode.EXACT
+
+        if self.options.shift_required_for_picking:
+            self.runtime.picking_enabled_this_frame = interaction.shift_down and not interaction.drag_active
+        else:
+            self.runtime.picking_enabled_this_frame = not interaction.drag_active
+
+        if self.options.enable_hud and self.runtime.current_mode == RenderMode.EXACT:
+            self.runtime.hud_enabled_this_frame = True
+        else:
+            self.runtime.hud_enabled_this_frame = False
+
+        # Blending policy
+        from .options import BlendMode
+        m = self.options.blend_mode
+        if m == BlendMode.OFF:
+            self.runtime.blending_enabled = False
+        elif m == BlendMode.AUTO:
+            self.runtime.blending_enabled = (n <= self.options.auto_disable_blending_threshold)
+        else:
+            self.runtime.blending_enabled = True
+
+    def estimate_polyline_screen_length_px(self, pts: np.ndarray, ctx: RenderContext, max_samples: int = 4096) -> float:
+        """Estimate the total length of a polyline in screen pixels (cheaply)."""
+        if pts is None or len(pts) < 2:
+            return 0.0
+
+        # Sample long polylines to keep policy update fast
+        stride = max(1, (len(pts) - 1) // max_samples)
+        sample = pts[::stride]
+        if len(sample) < 2:
+            return 0.0
+
+        l, r, b, t = ctx.window_world
+        # Screen units per world unit
+        sx = ctx.fb_width / max(r - l, 1e-12)
+        sy = ctx.fb_height / max(t - b, 1e-12)
+
+        diffs = np.diff(sample, axis=0)
+        # Transform diffs to px and get length
+        seg_px = np.linalg.norm(diffs * np.array([sx, sy], dtype=np.float32)[None, :], axis=1)
+
+        return float(seg_px.sum() * stride)
+
+    def calculate_width_aware_lod(self, scene: SceneData, ctx: RenderContext) -> float:
+        """
+        Calculates keep_prob based on 'Fill-Rate' budget rather than just primitive count.
+        Avoids performance degradation when using thick lines.
+        """
+        target_coverage = self.options.lod_target_coverage
+        total_est_px2 = 0.0
+        target_px2 = target_coverage * ctx.fb_width * ctx.fb_height
+        
+        overrides = self.options.visual.overrides
+
+        # 1. Line Families (Approx coverage: Count * ViewportWidth * Width)
+        if scene.lines.ab is not None:
+            width = self.options.global_line_width * overrides.line_width_multiplier
+            est = float(len(scene.lines.ab)) * ctx.fb_width * max(1.0, width)
+            total_est_px2 += est
+
+        # 2. Polylines (Approx coverage: Length * Width)
+        for layer in scene.layers:
+            from .core.layers import PolylineLayer
+            if isinstance(layer, PolylineLayer):
+                width = layer.style.line_width * overrides.line_width_multiplier
+                length = self.estimate_polyline_screen_length_px(layer.pts, ctx)
+                total_est_px2 += length * max(1.0, width)
+
+        if total_est_px2 <= target_px2:
+            return 1.0
+            
+        return max(0.001, min(1.0, target_px2 / total_est_px2))
+
+    def should_force_density_mode(self, scene: SceneData, ctx: RenderContext, factor: float = 3.0) -> bool:
+        """Determines if the scene is so complex that density mode should be forced during interaction."""
+        target_px2 = ctx.fb_width * ctx.fb_height * factor
+        
+        # Reuse LOD calc logic but for a higher threshold
+        # (This is a simplified version for V1)
+        prob = self.calculate_width_aware_lod(scene, ctx, target_coverage=factor)
+        return prob < 1.0