glplot 0.1.0__py3-none-any.whl

glplot/__init__.py

@@ -0,0 +1,6 @@
+from .engine import GPULinePlot
+from .options import EngineOptions, RenderMode, BlendMode
+
+__version__ = "0.1.0"
+
+__all__ = ["GPULinePlot", "EngineOptions", "RenderMode", "BlendMode"]

glplot/backend.py

@@ -0,0 +1,15 @@
+"""
+Backward compatibility shim for glplot.backend.
+New code should import from glplot or specific modules.
+"""
+import warnings
+from .engine import GPULinePlot
+from .options import EngineOptions, RenderMode, BlendMode
+
+warnings.warn(
+    "Importing from glplot.backend is deprecated. "
+    "Please import from 'glplot' directly.",
+    DeprecationWarning, stacklevel=2
+)
+
+__all__ = ["GPULinePlot", "EngineOptions", "RenderMode", "BlendMode"]

glplot/controllers.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+from typing import Tuple, Optional, TYPE_CHECKING
+import numpy as np
+from .utils.gl_utils import ortho
+
+if TYPE_CHECKING:
+    from .core.legacy import CameraState
+    from .options import EngineOptions
+
+class CameraController:
+    def __init__(self, camera: CameraState, options: EngineOptions):
+        self.camera = camera
+        self.options = options
+
+    def world_window(self, width: int, height: int, padding: float = 1.0) -> Tuple[float, float, float, float]:
+        aspect = max(width, 1) / max(height, 1)
+        half_h = padding / self.camera.zoom
+        half_w = half_h * aspect
+        l = self.camera.cx - half_w
+        r = self.camera.cx + half_w
+        b = self.camera.cy - half_h
+        t = self.camera.cy + half_h
+        return l, r, b, t
+
+    def mvp(self, width: int, height: int, window: Optional[Tuple[float, float, float, float]] = None) -> np.ndarray:
+        l, r, b, t = window if window is not None else self.world_window(width, height)
+        return ortho(l, r, b, t)
+
+    def screen_to_world(self, sx: float, sy: float, width: int, height: int) -> Tuple[float, float]:
+        l, r, b, t = self.world_window(width, height)
+        x = l + (sx / width) * (r - l)
+        y = b + ((height - sy) / height) * (t - b)
+        return x, y
+
+    def apply_zoom_at_cursor(self, factor: float, mx: float, my: float, width: int, height: int) -> None:
+        wx0, wy0 = self.screen_to_world(mx, my, width, height)
+        self.camera.zoom = float(np.clip(self.camera.zoom * factor, self.camera.zoom_min, self.camera.zoom_max))
+        wx1, wy1 = self.screen_to_world(mx, my, width, height)
+        self.camera.cx += (wx0 - wx1)
+        self.camera.cy += (wy0 - wy1)
+
+    def fit_bounds(self, xmin: float, xmax: float, ymin: float, ymax: float, width: int, height: int) -> None:
+        """Calculate best cx, cy, and zoom to fit the given bounds into the current viewport."""
+        self.camera.cx = 0.5 * (xmin + xmax)
+        self.camera.cy = 0.5 * (ymin + ymax)
+        
+        span_x = max(1e-9, xmax - xmin)
+        span_y = max(1e-9, ymax - ymin)
+        
+        aspect = max(width, 1) / max(height, 1)
+        
+        # Calculate zooms required for each axis
+        # Zoom = 1.0 / half_h
+        # half_h_required = span_y / 2.0
+        # half_w_required = span_x / 2.0
+        
+        # In our world_window logic: half_w = (1.0 / zoom) * aspect
+        # So zoom_x = aspect / half_w_req = (2.0 * aspect) / span_x
+        # zoom_y = 1.0 / half_h_req = 2.0 / span_y
+        
+        zx = (2.0 * aspect) / span_x
+        zy = 2.0 / span_y
+        
+        self.camera.zoom = float(np.clip(min(zx, zy), self.camera.zoom_min, self.camera.zoom_max))
+
+    def reset_view(self) -> None:
+        self.camera.cx = 0.0
+        self.camera.cy = 0.0
+        self.camera.zoom = 1.0

glplot/core/context.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Tuple, TYPE_CHECKING, Optional
+import numpy as np
+
+if TYPE_CHECKING:
+    from ..options import EngineOptions, RenderMode
+
+@dataclass
+class RenderContext:
+    """
+    Stable rendering state provided to compilers and renderers.
+    Ensures consistent projection and policy across a single frame.
+    """
+    mvp: np.ndarray # 4x4 Ortho projection matrix
+    window_world: Tuple[float, float, float, float] # (l, r, b, t) in world units
+    
+    width_px: int # Screen width
+    height_px: int # Screen height
+    fb_width: int # Framebuffer width (for multisampling/HighDPI)
+    fb_height: int # Framebuffer height
+    
+    mode: RenderMode # EXACT, INTERACTIVE, or PICKING
+    
+    # Passing global settings
+    global_alpha: float = 1.0
+    lod_keep_prob: float = 1.0
+    
+    # Picking context
+    id_offset: int = 0
+    
+    # Time for animated effects (grain, shimmer, etc)
+    time: float = 0.0
+    
+    # Device Pixel Ratio for HighDPI / Retina consistency
+    dpr: float = 1.0
+
+    # Orthographic specialization (skip 4x4 matrix multiplication in hot paths)
+    ndc_scale: Tuple[float, float] = (1.0, 1.0)
+    ndc_offset: Tuple[float, float] = (0.0, 0.0)
+
+    @property
+    def aspect(self) -> float:
+        return max(self.width_px, 1) / max(self.height_px, 1)
+
+    def screen_to_world(self, sx: float, sy: float) -> Tuple[float, float]:
+        l, r, b, t = self.window_world
+        x = l + (sx / self.width_px) * (r - l)
+        y = b + ((self.height_px - sy) / self.height_px) * (t - b)
+        return x, y

glplot/core/layers.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Optional, Tuple, List, Any, Protocol, TYPE_CHECKING
+import numpy as np
+import uuid
+
+if TYPE_CHECKING:
+    from .context import RenderContext
+
+@dataclass
+class LayerStyle:
+    """Encapsulates all non-geometric visual properties of a layer."""
+    visible: bool = True
+    alpha: float = 1.0
+    zorder: int = 0
+    pickable: bool = False
+
+    # Colors
+    color: Optional[Tuple[float, float, float, float]] = None       # Primary (Lines, edges)
+    edge_color: Optional[Tuple[float, float, float, float]] = None  # Edges for patches
+    face_color: Optional[Tuple[float, float, float, float]] = None  # Fill for patches
+
+    # Geometry
+    line_width: float = 1.0
+    point_size: float = 6.0
+    
+    # Scatter Polish
+    point_outline_enabled: bool = False
+    point_outline_color: Tuple[float, float, float, float] = (0.0, 0.0, 0.0, 1.0)
+    point_outline_width: float = 1.0
+
+    # Colormapping
+    use_colormap: bool = False
+    cmap: Optional[str] = None
+    vmin: Optional[float] = None
+    vmax: Optional[float] = None
+    
+    # Text
+    text_size_px: float = 12.0
+
+@dataclass
+class LayerDirtyState:
+    """Fine-grained invalidation flags to optimize GPU updates."""
+    data_dirty: bool = True
+    style_dirty: bool = True
+    gpu_dirty: bool = True
+    bounds_dirty: bool = True
+
+    def clear(self):
+        self.data_dirty = False
+        self.style_dirty = False
+        self.gpu_dirty = False
+        self.bounds_dirty = False
+
+class CompiledLayer:
+    """GPU-ready geometry and cached bounds."""
+    def __init__(self, layer_id: int):
+        self.layer_id = layer_id
+        self.bounds_world: Optional[Tuple[float, float, float, float]] = None
+        self.gpu_initialized: bool = False
+
+class BaseLayer:
+    """Abstract base for all visual primitives."""
+    def __init__(self, layer_type: str, label: str = ""):
+        self.layer_id = uuid.uuid4().int & (1<<31)-1 
+        self.layer_type = layer_type
+        self.label = label
+        self.style = LayerStyle()
+        self.dirty = LayerDirtyState()
+        self.bounds_world: Optional[Tuple[float, float, float, float]] = None
+        self.translation: Tuple[float, float] = (0.0, 0.0)
+        self.metadata: dict[str, Any] = {}
+
+    def get_intrinsic_bounds(self) -> Optional[Tuple[float, float, float, float]]:
+        return None
+
+@dataclass
+class LineFamilyLayer(BaseLayer):
+    """High-performance layer for millions of lines y = ax + b."""
+    ab: Optional[np.ndarray] = None
+    colors: Optional[np.ndarray] = None
+    x_range: Tuple[float, float] = (-1.0, 1.0)
+    
+    def __init__(self, ab: Optional[np.ndarray] = None, colors: Optional[np.ndarray] = None, x_range: Tuple[float, float] = (-1.0, 1.0), label: str = ""):
+        super().__init__(layer_type="line_family", label=label)
+        self.ab = ab
+        self.colors = colors
+        self.x_range = x_range
+        
+    def get_intrinsic_bounds(self) -> Optional[Tuple[float, float, float, float]]:
+        if self.ab is None or len(self.ab) == 0: return None
+        x0, x1 = self.x_range
+        y_at_x0 = self.ab[:, 0] * x0 + self.ab[:, 1]
+        y_at_x1 = self.ab[:, 0] * x1 + self.ab[:, 1]
+        return (x0, x1, float(min(np.min(y_at_x0), np.min(y_at_x1))), float(max(np.max(y_at_x0), np.max(y_at_x1))))
+
+@dataclass
+class ScatterLayer(BaseLayer):
+    """Layer for point clouds."""
+    pts: Optional[np.ndarray] = None
+    colors: Optional[np.ndarray] = None
+    
+    def __init__(self, pts: Optional[np.ndarray] = None, colors: Optional[np.ndarray] = None, size: float = 6.0, label: str = ""):
+        super().__init__(layer_type="scatter", label=label)
+        self.pts = pts
+        self.colors = colors
+        self.style.point_size = size
+        
+    def get_intrinsic_bounds(self) -> Optional[Tuple[float, float, float, float]]:
+        if self.pts is None or len(self.pts) == 0: return None
+        return (float(np.min(self.pts[:, 0])), float(np.max(self.pts[:, 0])),
+                float(np.min(self.pts[:, 1])), float(np.max(self.pts[:, 1])))
+
+@dataclass
+class PolylineLayer(BaseLayer):
+    """Layer for connected line segments (Polyline)."""
+    pts: Optional[np.ndarray] = None
+    
+    def __init__(self, pts: Optional[np.ndarray] = None, color: Optional[Tuple[float, float, float, float]] = None, width: float = 1.0, label: str = ""):
+        super().__init__(layer_type="polyline", label=label)
+        self.pts = pts
+        if color: self.style.color = color
+        self.style.line_width = width
+            
+    def get_intrinsic_bounds(self) -> Optional[Tuple[float, float, float, float]]:
+        if self.pts is None or len(self.pts) == 0: return None
+        return (float(np.min(self.pts[:, 0])), float(np.max(self.pts[:, 0])),
+                float(np.min(self.pts[:, 1])), float(np.max(self.pts[:, 1])))
+
+@dataclass
+class PatchLayer(BaseLayer):
+    """Layer for filled areas (tri-strips, bars, rects)."""
+    vertices: Optional[np.ndarray] = None # (N, 2)
+    indices: Optional[np.ndarray] = None  # (M,)
+    mode: str = "strip" # "strip", "triangles", "rects"
+
+    def __init__(self, vertices: Optional[np.ndarray] = None, indices: Optional[np.ndarray] = None, mode: str = "strip", label: str = ""):
+        super().__init__(layer_type="patch", label=label)
+        self.vertices = vertices
+        self.indices = indices
+        self.mode = mode
+
+    def get_intrinsic_bounds(self) -> Optional[Tuple[float, float, float, float]]:
+        if self.vertices is None or len(self.vertices) == 0: return None
+        return (float(np.min(self.vertices[:, 0])), float(np.max(self.vertices[:, 0])),
+                float(np.min(self.vertices[:, 1])), float(np.max(self.vertices[:, 1])))
+
+@dataclass
+class TextLayer(BaseLayer):
+    """Layer for text labels proyected from world coordinates."""
+    x: float = 0.0
+    y: float = 0.0
+    text: str = ""
+
+    def __init__(self, x: float = 0.0, y: float = 0.0, text: str = "", label: str = ""):
+        super().__init__(layer_type="text", label=label)
+        self.x = x
+        self.y = y
+        self.text = text
+        
+    def get_intrinsic_bounds(self) -> Optional[Tuple[float, float, float, float]]:
+        # Text does not participate in autoscale by default
+        return None

glplot/core/legacy.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Optional, Tuple, List, Dict, Any
+import numpy as np
+from .layers import BaseLayer
+
+
+@dataclass
+class LineDataset:
+    ab: Optional[np.ndarray] = None              # shape (N, 2)
+    colors: Optional[np.ndarray] = None          # shape (N, 4)
+    x_range: Tuple[float, float] = (-3.0, 3.0)
+
+    def validate(self) -> None:
+        if self.ab is None:
+            return
+        if self.ab.ndim != 2 or self.ab.shape[1] != 2:
+            raise ValueError("ab must have shape (N,2)")
+        if self.ab.dtype != np.float32:
+            raise ValueError("ab must be float32")
+        if self.colors is not None:
+            if self.colors.shape != (self.ab.shape[0], 4):
+                raise ValueError("colors must have shape (N,4)")
+            if self.colors.dtype != np.float32:
+                raise ValueError("colors must be float32")
+
+    @property
+    def count(self) -> int:
+        return 0 if self.ab is None else int(self.ab.shape[0])
+
+@dataclass
+class ScatterDataset:
+    pts: Optional[np.ndarray] = None             # shape (M,2)
+    colors: Optional[np.ndarray] = None          # shape (M,4)
+    size: float = 5.0
+
+@dataclass
+class StripDataset:
+    pts: Optional[np.ndarray] = None             # shape (K,2)
+    color: Tuple[float, float, float, float] = (0.0, 0.0, 0.0, 1.0)
+
+@dataclass
+class SceneData:
+    layers: List[BaseLayer] = field(default_factory=list)
+    lines: LineDataset = field(default_factory=LineDataset)
+    scatters: List[ScatterDataset] = field(default_factory=list)
+    strips: List[StripDataset] = field(default_factory=list)
+    texts: List[Dict[str, Any]] = field(default_factory=list)
+
+@dataclass
+class CameraState:
+    cx: float = 0.0
+    cy: float = 0.0
+    zoom: float = 1.0
+    zoom_min: float = 0.02
+    zoom_max: float = 500.0
+
+@dataclass
+class InteractionState:
+    drag_active: bool = False
+    drag_confirmed: bool = False
+    right_drag_active: bool = False
+    last_mouse: Tuple[float, float] = (0.0, 0.0)
+    press_mouse: Tuple[float, float] = (0.0, 0.0)
+    right_press_mouse: Tuple[float, float] = (0.0, 0.0)
+    shift_down: bool = False
+    ctrl_down: bool = False
+    alt_down: bool = False
+
+    drag_mode: str = "pan"            # "pan", "move"
+    selected_layer_id: Optional[int] = None
+    drag_start_world: Tuple[float, float] = (0.0, 0.0)
+    drag_start_translation: Optional[Tuple[float, float]] = None
+    explicit_pick_requested: bool = False  # Set on Shift+Click; bypasses the shift_down gate
+
+    hover_idx: int = -1
+    hover_type: Optional[str] = None
+    selected_idx: Any = -1
+    selected_type: Optional[str] = None
+
+    last_hover_pick_time: float = 0.0
+    hover_resume_time: float = 0.0
+
+@dataclass
+class CacheState:
+    active: bool = False
+    capture_window: Optional[Tuple[float, float, float, float]] = None
+    refresh_requested: bool = False
+    last_capture_time: float = 0.0
+    release_deadline: float = 0.0
+
+@dataclass
+class FrameState:
+    dirty_scene: bool = True
+    dirty_ui: bool = True
+    dirty_pick: bool = True
+    last_frame_time: float = 0.0
+    fps_estimate: float = 0.0