glplot 0.1.0__tar.gz

glplot-0.1.0/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: glplot
+Version: 0.1.0
+Summary: High-performance OpenGL plotting library, similar to Matplotlib
+Author-email: Juan Manuel Lombardi <lombardi@fhi-berlin.mpg.de>
+License-File: LICENSE
+Requires-Python: >=3.9
+Requires-Dist: glfw
+Requires-Dist: imgui
+Requires-Dist: imgui[glfw]
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: pyopengl
+Requires-Dist: scipy
+Provides-Extra: test
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: pytest-cov; extra == 'test'
+Requires-Dist: pytest-mock; extra == 'test'
+Description-Content-Type: text/markdown
+
+# GLPlot
+
+High-performance, GPU-accelerated plotting library in Python, designed to handle **millions** of lines effortlessly. It provides an API similar to Matplotlib but runs natively over an OpenGL/GLFW backend, performing instanced rendering directly on the GPU.
+
+## Features
+- **Matplotlib API Compatibility**: Familiar `plot(x, y)`, `show()`, `savefig()`.
+- **Phase Diagram Optimized (`plot_lines`)**: Explicitly supports passing millions of line parameters $(a, b)$ to calculate functions $y = ax + b$ securely bounded to bounds using shader math.
+- **Logarithmic Density Heaps**: By displaying overlaps, `density=True` handles millions of parallel curves seamlessly for heatmaps.
+- **Dynamic Camera**: Drag to pan, scroll to zoom with on-the-fly resolution subsampling.
+
+## Installation
+
+You can install this locally:
+
+```bash
+pip install .
+```
+
+Requirements: `numpy`, `glfw`, `PyOpenGL`, `scipy`, `matplotlib`.
+
+## Usage
+
+**Traditional Polylines**
+```python
+import numpy as np
+import glplot.pyplot as gplt
+
+x = np.linspace(0, 10, 100)
+y = np.sin(x)
+
+gplt.figure("Sine Wave")
+gplt.plot(x, y, color=(1.0, 0.0, 0.0, 1.0))
+gplt.show()
+```
+
+**Bulk Lines (Density Map)**
+```python
+import numpy as np
+import glplot.pyplot as gplt
+
+N = 1000000
+a = np.random.randn(N)
+b = np.random.randn(N)
+
+gplt.figure("Density")
+gplt.plot_lines(a, b, x_range=(-2, 2))
+gplt.show(density=True)
+```
+
+## Testing
+
+Uses `pytest` covering 100% of the internal application logic without popping visible windows:
+```bash
+pytest
+```

glplot-0.1.0/README.md

@@ -0,0 +1,55 @@
+# GLPlot
+
+High-performance, GPU-accelerated plotting library in Python, designed to handle **millions** of lines effortlessly. It provides an API similar to Matplotlib but runs natively over an OpenGL/GLFW backend, performing instanced rendering directly on the GPU.
+
+## Features
+- **Matplotlib API Compatibility**: Familiar `plot(x, y)`, `show()`, `savefig()`.
+- **Phase Diagram Optimized (`plot_lines`)**: Explicitly supports passing millions of line parameters $(a, b)$ to calculate functions $y = ax + b$ securely bounded to bounds using shader math.
+- **Logarithmic Density Heaps**: By displaying overlaps, `density=True` handles millions of parallel curves seamlessly for heatmaps.
+- **Dynamic Camera**: Drag to pan, scroll to zoom with on-the-fly resolution subsampling.
+
+## Installation
+
+You can install this locally:
+
+```bash
+pip install .
+```
+
+Requirements: `numpy`, `glfw`, `PyOpenGL`, `scipy`, `matplotlib`.
+
+## Usage
+
+**Traditional Polylines**
+```python
+import numpy as np
+import glplot.pyplot as gplt
+
+x = np.linspace(0, 10, 100)
+y = np.sin(x)
+
+gplt.figure("Sine Wave")
+gplt.plot(x, y, color=(1.0, 0.0, 0.0, 1.0))
+gplt.show()
+```
+
+**Bulk Lines (Density Map)**
+```python
+import numpy as np
+import glplot.pyplot as gplt
+
+N = 1000000
+a = np.random.randn(N)
+b = np.random.randn(N)
+
+gplt.figure("Density")
+gplt.plot_lines(a, b, x_range=(-2, 2))
+gplt.show(density=True)
+```
+
+## Testing
+
+Uses `pytest` covering 100% of the internal application logic without popping visible windows:
+```bash
+pytest
+```

glplot-0.1.0/examples/ex_density.py

@@ -0,0 +1,34 @@
+import numpy as np
+import glplot.pyplot as gplt
+
+# Generate 10 million lines y = a*x + b
+N = 1_000_000
+print(f"Generating {N} lines. This tests memory throughput and GPU geometry performance.")
+a = np.random.randn(N) * 2.0
+b = np.random.randn(N) * 0.5
+
+# Assign a random color with transparency
+colors = np.random.rand(N, 4)
+colors[:, 3] = 0.05 # alpha
+
+# Configure figure with optimizations
+gplt.figure("Massive Density Map (10M Lines)", 
+            width=1280, height=800,
+            density=True,
+            lod=True,
+            budget=200,   # High budget for dense detail
+            clipping=True, hud=True)
+
+# Performance Tuning: Render density at 0.5x resolution for massive speedup
+# This is ideal when N is very large or GPU is limited.
+gplt.options(density_resolution_scale=0.5, density_gain=1.5)
+
+gplt.plot_lines(a, b, x_range=(-5, 5), colors=colors)
+
+gplt.text(-4.5, 4.0, "10,000,000 Lines", fontsize=32, color="white")
+gplt.text(-4.5, 3.5, "Optimized: 0.5x Resolution Scale", fontsize=20, color="gray")
+
+print("\nControls:")
+print("  [ D ]            : Toggle Density/Exact view.")
+print("  [ UP/DOWN ]      : Adjust density gain.")
+gplt.show()

glplot-0.1.0/examples/ex_density_gain.py

@@ -0,0 +1,18 @@
+import numpy as np
+import glplot.pyplot as gplt
+
+def demo_density_gain():
+    n = 1000000
+    a = np.random.randn(n) * 0.1
+    b = np.random.randn(n) * 0.1
+    
+    # Pre-set some gain
+    gplt.density_gain(15.0)
+    gplt.figure("Density Gain Test", density=True, hud=True)
+    gplt.lines(a, b, x_range=(-1, 1), color='yellow')
+    
+    print("Check if the 'Density Factor' slider appears in the HUD and affects the heatmap.")
+    gplt.show()
+
+if __name__ == "__main__":
+    demo_density_gain()

glplot-0.1.0/examples/ex_expert_performance.py

@@ -0,0 +1,40 @@
+import numpy as np
+import glplot.pyplot as gplt
+import time
+
+# Stress Test: 50,000,000 lines
+N = 50_000_000
+print(f"STRESS TEST: Generating {N:,} lines. This will consume ~400MB of GPU memory.")
+
+# Generate data clusters
+a = np.random.normal(0, 1.0, N)
+b = np.random.normal(0, 1.0, N)
+
+# Optimization Setup
+# We enable:
+# - HUD: To monitor performance (FPS, budgets)
+# - Budgeting: To ensure interactivity even during massive draw calls
+# - Clipping: To avoid drawing lines outside the view
+gplt.figure("Expert Performance Stress Test (50M Lines)", 
+            hud=True, 
+            budget=5,   # Very aggressive budget for fluid interaction
+            clipping=True,
+            cache=True)
+
+# Advanced Tuning: Fine-tune the Hybrid Cache
+# - Increase refresh rate for more up-to-date impostors
+# - Increase padding to reduce refresh frequency during slow pans
+gplt.options(
+    cache_refresh_hz=60.0,
+    cache_padding=4.0,
+    default_global_alpha=0.1
+)
+
+gplt.plot_lines(a, b, x_range=(-5, 5))
+
+print("\n--- PERFORMANCE GUIDE ---")
+print("1. Interactive Path: Drag the mouse. The engine uses a reprojected cache.")
+print("2. Exact Path: Release the mouse. The engine draws the exact geometry (LOD).")
+print("3. HUD: Observe the FPS and Line Count in the top-left overlay.")
+
+gplt.show()

glplot-0.1.0/examples/ex_full_showcase.py

@@ -0,0 +1,85 @@
+import numpy as np
+import time
+import math
+import glplot.pyplot as gplt
+
+def generate_flow_field(n=200_000):
+    """Generate a vector field of lines."""
+    ab = np.zeros((n, 2), dtype=np.float32)
+    # y = ax + b
+    a = np.random.uniform(-0.1, 0.1, n).astype(np.float32)
+    b = np.random.normal(0, 1.5, n).astype(np.float32)
+    xr = (-5.0, 5.0)
+    
+    # Colors based on slope/intensity
+    cols = np.ones((n, 4), dtype=np.float32)
+    cols[:, 0] = 0.2 + 0.8 * (a + 0.1) / 0.2 # R based on slope
+    cols[:, 1] = 0.7 + 0.3 * np.random.rand(n) # G
+    cols[:, 2] = 0.9 # B
+    cols[:, 3] = 0.15 # Low alpha for layering
+    
+    return a, b, xr, cols
+
+def generate_particles(m=10_000):
+    """Generate random stars/particles."""
+    pts = np.random.normal(0, 2.5, (m, 2)).astype(np.float32)
+    # Subtle color variations
+    cols = np.ones((m, 4), dtype=np.float32)
+    cols[:, 0] = 1.0 # White/Redish
+    cols[:, 1] = 0.9
+    cols[:, 2] = 1.0
+    return pts, cols
+
+def generate_spiral(k=2000):
+    """Generate a high-res spiral trajectory."""
+    t = np.linspace(0, 20 * math.pi, k)
+    x = t * np.cos(t) / 10.0
+    y = t * np.sin(t) / 10.0
+    return x.astype(np.float32), y.astype(np.float32)
+
+def showcase_demo():
+    print("Preparing GLPlot Full Showcase Demo...")
+    
+    # 1. Background Flow Field (Millions of Lines)
+    a, b, xr, cols = generate_flow_field(250_000)
+    # Use a higher alpha since we have dark background
+    cols[:, 3] = 0.4 # Higher base alpha
+    gplt.plot_lines(a, b, xr, colors=cols)
+    
+    # 2. Particle Cloud (Scatter)
+    pts, pcols = generate_particles(20_000)
+    gplt.scatter(pts[:, 0], pts[:, 1], size=6.0, color=(1, 1, 1, 0.9))
+    
+    # 3. Primary Trajectories (Polylines)
+    sx, sy = generate_spiral(2000)
+    gplt.plot(sx, sy, color=(0.4, 1.0, 0.6, 1.0)) # Neon Green
+    gplt.plot(sx * 1.2, sy * 1.2, color=(1.0, 0.4, 0.8, 0.8)) # Pink
+    
+    # 4. Global Settings & Aesthetics
+    gplt.title("GLPlot Core V1 Showcase")
+    
+    # Set premium visuals
+    plot = gplt._get_or_create_plot()
+    plot.autoscale() # Ensure we see the data
+    
+    # Disable aggressive alpha scaling for this showcase to keep it bold
+    plot.options.default_global_alpha = 1.0
+    
+    v = plot.options.visual
+    
+    # Neon Bloom - Lower threshold to capture the transparent lines
+    #v.glow.enabled = True
+    #v.glow.intensity = 2.0
+    #v.glow.threshold = 0.05 # Lower to see more glow from faint lines
+    #v.glow.radius_px = 6.0
+    
+    # Deep Dark Nebula Gradient (Slightly brighter than before)
+    v.gradient_background.enabled = True
+    v.gradient_background.top_color = (0.08, 0.08, 0.25) 
+    v.gradient_background.bottom_color = (0.02, 0.02, 0.05)
+    
+    print("Showcase Ready (High Visibility Mode). Opening Window...")
+    gplt.show()
+
+if __name__ == "__main__":
+    showcase_demo()

glplot-0.1.0/examples/ex_mpl_bridge.py

@@ -0,0 +1,65 @@
+import numpy as np
+import glplot.pyplot as gplt
+import matplotlib.pyplot as plt
+
+def run_bridge_example():
+    # 1. Generate some interesting data (Sine wave with noise)
+    n_lines = 100
+    x = np.linspace(-10, 10, 1000)
+    
+    # Create multiple lines with varying amplitude and phase
+    for i in range(n_lines):
+        phase = i * 0.1
+        amp = 1.0 + np.sin(i * 0.2)
+        y = amp * np.sin(x + phase) + np.random.normal(0, 0.05, len(x))
+        gplt.plot(x, y, label=f"Line {i}")
+
+    print("\n--- GLPlot with Matplotlib Bridge ---")
+    print("Instructions:")
+    print("1. An interactive GLPlot window will open.")
+    print("2. Adjust the view (zoom/pan) to your liking.")
+    print("3. Press 'M' on your keyboard to 'Teleport' the view to Matplotlib.")
+    print("4. Or, see the code below for programmatic transfer.")
+    
+    # 2. Get the engine instance
+    plot = gplt.get_engine()
+    
+    # You can configure where 'M' sends the data if you want:
+    # plot.set_matplotlib_transfer_target(ax=some_existing_ax)
+
+    # 3. Show the interactive plot
+    gplt.show()
+
+    # --- Programmatic Transfer Example ---
+    # After you close the GLPlot window, or if running in a script:
+    print("\nProgrammatically transferring current view to Matplotlib...")
+    
+    # We create a Matplotlib figure with subplots
+    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))
+    
+    # Transfer view to the first subplot
+    plot.to_matplotlib(
+        ax=ax1, 
+        scale=2.0,           # High-res capture
+        transparent=True, 
+        include_axes=False   # We want Matplotlib to handle the axes
+    )
+    ax1.set_title("Transferred Raster (High Res)")
+    ax1.set_xlabel("Time (s)")
+    ax1.set_ylabel("Amplitude")
+    ax1.grid(True, alpha=0.3)
+
+    # We can even add Matplotlib geometry ON TOP of the GLPlot raster
+    x_mark = np.linspace(-10, 10, 10)
+    ax2.plot(x_mark, np.cos(x_mark), 'ro--', label="MPL Overlay")
+    
+    # Transfer the same view to the second subplot as a background
+    plot.to_matplotlib(ax=ax2, scale=1.0, alpha=0.5) # Semi-transparent background
+    ax2.set_title("With Matplotlib Overlays")
+    ax2.legend()
+
+    plt.tight_layout()
+    plt.show()
+
+if __name__ == "__main__":
+    run_bridge_example()

glplot-0.1.0/examples/ex_scatter.py

@@ -0,0 +1,39 @@
+import numpy as np
+import glplot.pyplot as gplt
+
+# Generate 5 million points
+N = 5_000_000
+print(f"Generating {N} points cloud...")
+
+# Clusters
+x = np.concatenate([
+    np.random.normal(-2, 1.0, N//4),
+    np.random.normal(2, 0.5, N//4),
+    np.random.normal(0, 3.0, N//2) # Noise
+])
+y = np.concatenate([
+    np.random.normal(1, 0.5, N//4),
+    np.random.normal(-2, 1.0, N//4),
+    np.random.normal(0, 3.0, N//2)
+])
+
+# Per-point RGBA colors
+colors = np.random.rand(N, 4).astype(np.float32)
+colors[:, 3] = 0.1 # Very transparent for blending
+
+# Figure with multi-sampling (AA) and HUD
+gplt.figure("Optimized Scatter (5M Points)", 
+            width=1280, height=800,
+            multisample=True,
+            hud=True,
+            lod=True,
+            budget=100)
+
+gplt.scatter(x, y, color=colors, size=2.0)
+
+gplt.text(-4, 4, "5,000,000 Points", fontsize=28, color="black")
+gplt.text(-4, 3.5, "SDF Mathematical Primitives", fontsize=18, color="blue")
+
+print("\nNotice how panning remains locked at 60 FPS.")
+print("The Hybrid Cache (on by default) allows fluid movement through millions of points.")
+gplt.show()

glplot-0.1.0/examples/ex_simple.py

@@ -0,0 +1,19 @@
+import numpy as np
+import glplot.pyplot as gplt
+
+# Simple sequence example
+x = np.linspace(0, 10, 100)
+y = np.sin(x)
+
+gplt.figure("Simple Plot Demo")
+
+# Activate adaptive subsampling for massive plots in standard sequences
+gplt.set_lod(enabled=True, max_lines_per_px=200)
+
+
+for n in range(10000):
+    gplt.plot(x, y + float(n)**2/100000.0, color=(1.0, 0.0, 0.0, 1.0)) # Red line
+    gplt.scatter(x, y+ float(n)**2/100000.0, color=(0.0, 0.0, 1.0, 1.0), size=12.0) # Blue points
+
+gplt.set_global_alpha(1.0)
+gplt.show()

glplot-0.1.0/examples/ex_v2_layers.py

@@ -0,0 +1,56 @@
+import numpy as np
+from glplot import GPULinePlot
+import time
+
+def run_verification():
+    plot = GPULinePlot(title="GLPlot V2: Layer Architecture Verification")
+    
+    # 1. Background Filled Area (PatchLayer)
+    # Sinusoidal band
+    x = np.linspace(0, 10, 200)
+    y1 = np.sin(x) - 0.5
+    y2 = np.sin(x) + 0.5
+    
+    # Pre-calculate triangle strip vertices for fill_between
+    vertices = []
+    for i in range(len(x)):
+        vertices.append([x[i], y1[i]])
+        vertices.append([x[i], y2[i]])
+    vertices = np.array(vertices, dtype=np.float32)
+    
+    plot.add_patch(vertices, mode="strip", face_color=(0.2, 0.4, 0.8, 0.3), label="Sinusoidal Band")
+    
+    # 2. Scatter with Outlines
+    n_scat = 100
+    xs = np.random.uniform(0, 10, n_scat)
+    ys = np.random.uniform(-2, 2, n_scat)
+    colors = np.ones((n_scat, 4), dtype=np.float32)
+    colors[:, 0] = np.random.rand(n_scat) # Random red
+    colors[:, 2] = np.random.rand(n_scat) # Random blue
+    
+    plot.add_scatter(xs, ys, colors, size=12.0)
+    # Note: We can fine-tune outlines via the layer object afterward
+    scat_layer = plot.scene.layers[-1]
+    scat_layer.label = "Research Points"
+    scat_layer.style.point_outline_enabled = True
+    scat_layer.style.point_outline_color = (0, 0, 0, 1)
+    scat_layer.style.point_outline_width = 1.5
+    
+    # 3. Polyline (Thick curve)
+    xp = np.linspace(0, 10, 100)
+    yp = np.cos(xp) * 1.5
+    plot.add_line_strip(xp, yp, color=(1, 0.2, 0.1, 1), width=4.0)
+    plot.scene.layers[-1].label = "Main Signal"
+    
+    # 4. Text Labels
+    plot.add_text(5, 1.8, "Upper Bound", fontsize=15, color=(1,1,1,1))
+    plot.add_text(2, -1.8, "Minima reached", fontsize=12, color=(0.8, 0.1, 0.1, 1))
+    
+    # 5. Global Overrides Testing
+    # We can set default overrides here
+    plot.options.visual.overrides.alpha_multiplier = 0.9
+    
+    plot.run()
+
+if __name__ == "__main__":
+    run_verification()

glplot-0.1.0/examples/ex_viewports.py

@@ -0,0 +1,44 @@
+import numpy as np
+import glplot.pyplot as gplt
+import time
+
+def demo_viewports_and_performance():
+    """
+    Verification script for deterministic viewports and mass-scale performance.
+    """
+    print("--- GLPlot Performance & Viewport Test ---")
+    
+    # 1. Dataset: 500,000 Polylines (Total 2.5M segments)
+    # This specifically tests the new GPU Instanced PolylineRenderer
+    n_curves = 100
+    n_points = 5000
+    x = np.linspace(-10, 10, n_points)
+    
+    print(f"Loading {n_curves} high-density polylines ({n_curves * n_points} points)...")
+    for i in range(n_curves):
+        offset = i * 0.1
+        y = np.sin(x + offset) + np.random.normal(0, 0.05, n_points)
+        color = (0.2, 0.5, 0.8, 0.4)
+        gplt.plot(x, y, color=color, width=1.5, label=f"Curve {i}")
+
+    # 2. Dataset: 1,000,000 Line Family (High-performance path)
+    print("Loading 1,000,000 instanced lines...")
+    n_lines = 1000000
+    ab = np.zeros((n_lines, 2), dtype=np.float32)
+    ab[:, 0] = np.random.normal(0, 0.5, n_lines) # slopes
+    ab[:, 1] = np.random.normal(0, 1.0, n_lines) # intercepts
+    gplt.lines(ab[:, 0], ab[:, 1], x_range=(-10, 10), alpha=0.01, width=1.0, label="Massive Dataset")
+
+    # 3. Deterministic Viewport
+    # We want to start zoomed into a specific feature
+    print("Setting deterministic initial view: X[-2, 2], Y[-1.5, 1.5]")
+    gplt.xlim(-2, 2)
+    gplt.ylim(-1.5, 1.5)
+    
+    gplt.title("Deterministic Viewport & 1.5M Primitives")
+    
+    print("Launching engine...")
+    gplt.show()
+
+if __name__ == "__main__":
+    demo_viewports_and_performance()

glplot-0.1.0/examples/verify_polyline_cmap.py

@@ -0,0 +1,32 @@
+import numpy as np
+import glplot.pyplot as gplt
+import time
+
+def test_polyline_colormapping():
+    # Generate multiple overlapping polylines
+    n_curves = 10
+    x = np.linspace(-5, 5, 200)
+    
+    print(f"Creating {n_curves} polylines...")
+    for i in range(n_curves):
+        # Different frequencies and phases
+        y = np.sin(x * (1 + i * 0.1) + i * 0.5) + i * 0.2
+        label = f"Curve {i}"
+        
+        # We plot with a default color (black/gray), 
+        # but we expect it to change when 'Line Colormap' is toggled.
+        gplt.plot(x, y, color=(0.2, 0.2, 0.2, 1.0), width=2.0, label=label)
+
+    print("\nControls:")
+    print(" - Press 'C' to toggle Line Colormap (once implemented, or use HUD)")
+    print(" - Press 'D' to toggle Density/Exact view")
+    
+    # Enable colormap by default for this test
+    plot = gplt.get_engine()
+    plot.options.line_colormap_enabled = True
+    plot.options.density_scheme_index = 0  # Inferno (usually)
+    
+    gplt.show()
+
+if __name__ == "__main__":
+    test_polyline_colormapping()

glplot-0.1.0/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-0.1.0/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-0.1.0/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