glplot 0.1.0__tar.gz → 0.1.1__tar.gz

{glplot-0.1.0 → glplot-0.1.1}/PKG-INFO

@@ -1,9 +1,26 @@
 Metadata-Version: 2.4
 Name: glplot
-Version: 0.1.0
-Summary: High-performance OpenGL plotting library, similar to Matplotlib
+Version: 0.1.1
+Summary: High-performance OpenGL plotting library for Python
+Project-URL: Homepage, https://github.com/AkarisDimitry/GLPlot
+Project-URL: Repository, https://github.com/AkarisDimitry/GLPlot
+Project-URL: Issues, https://github.com/AkarisDimitry/GLPlot/issues
 Author-email: Juan Manuel Lombardi <lombardi@fhi-berlin.mpg.de>
+License: MIT
 License-File: LICENSE
+Keywords: gpu,opengl,plotting,scientific plotting,visualization
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.9
 Requires-Dist: glfw
 Requires-Dist: imgui
@@ -12,6 +29,12 @@ Requires-Dist: matplotlib
 Requires-Dist: numpy
 Requires-Dist: pyopengl
 Requires-Dist: scipy
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest-mock; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
 Provides-Extra: test
 Requires-Dist: pytest; extra == 'test'
 Requires-Dist: pytest-cov; extra == 'test'

glplot-0.1.1/examples/ex_aspect_ratio_fix.py

@@ -0,0 +1,57 @@
+import os
+import sys
+# Force local glplot import
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
+import glplot.pyplot as gplt
+import numpy as np
+
+def test_aspect_ratio():
+    print("Testing aspect ratio fix...")
+    
+    # 1. Create data with extreme ranges
+    x = np.linspace(-2, 2, 1000)
+    y = 500 * np.sin(x * 10)
+    
+    gplt.figure("Aspect Ratio Test", width=800, height=600)
+    gplt.plot(x, y, color='blue', label="Sinusoidal")
+    
+    # 2. Set extreme limits
+    gplt.xlim(-2, 2)
+    gplt.ylim(-1000, 1000)
+    
+    # 3. Verify limits via API
+    lx = gplt.xlim()
+    ly = gplt.ylim()
+    
+    print(f"Current X limits: {lx}")
+    print(f"Current Y limits: {ly}")
+    
+    expected_x = (-2.0, 2.0)
+    expected_y = (-1000.0, 1000.0)
+    
+    # Allow small floating point epsilon
+    assert abs(lx[0] - expected_x[0]) < 1e-5
+    assert abs(lx[1] - expected_x[1]) < 1e-5
+    assert abs(ly[0] - expected_y[0]) < 1e-5
+    assert abs(ly[1] - expected_y[1]) < 1e-5
+    
+    print("Success: API returns correct decoupled limits.")
+    
+    # 4. Test Zero Span (Horizontal Line)
+    gplt.cla()
+    gplt.plot([-10, 10], [5, 5], color='red', label="Horizontal")
+    gplt.autoscale()
+    
+    lx_zero = gplt.xlim()
+    ly_zero = gplt.ylim()
+    print(f"Autoscale on horizontal line: X={lx_zero}, Y={ly_zero}")
+    
+    # Should have a sane Y range despite zero span in data
+    assert ly_zero[1] > ly_zero[0]
+    
+    print("Verification complete.")
+    # gplt.show() # Uncomment to see visually if running locally
+
+if __name__ == "__main__":
+    test_aspect_ratio()

{glplot-0.1.0 → glplot-0.1.1}/examples/ex_density.py

@@ -1,11 +1,17 @@
 import numpy as np
+import os
+import sys
+# Force local glplot import
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
 import glplot.pyplot as gplt
+factor = 1000
 
 # 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
+b = np.random.randn(N) * 0.5 * factor
 
 # Assign a random color with transparency
 colors = np.random.rand(N, 4)
@@ -27,7 +33,8 @@ 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")
-
+gplt.xlim(-5, 5) 
+gplt.ylim(-factor, factor)
 print("\nControls:")
 print("  [ D ]            : Toggle Density/Exact view.")
 print("  [ UP/DOWN ]      : Adjust density gain.")

{glplot-0.1.0 → glplot-0.1.1}/examples/ex_mpl_bridge.py

@@ -54,7 +54,7 @@ def run_bridge_example():
     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
+    plot.to_matplotlib(ax=ax2, scale=1.0, )#alpha=0.5) # Semi-transparent background
     ax2.set_title("With Matplotlib Overlays")
     ax2.legend()
 

{glplot-0.1.0 → glplot-0.1.1}/glplot/__init__.py

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

glplot-0.1.1/glplot/controllers.py

@@ -0,0 +1,86 @@
+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]:
+        """
+        Returns the world-space bounds (l, r, b, t) of the view, 
+        potentially expanded by padding for cache utility.
+        """
+        half_w = padding / max(self.camera.zoom_x, 1e-12)
+        half_h = padding / max(self.camera.zoom_y, 1e-12)
+        
+        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:
+        """Isotropic zoom centered at cursor position."""
+        wx0, wy0 = self.screen_to_world(mx, my, width, height)
+        
+        self.camera.zoom_x = float(np.clip(self.camera.zoom_x * factor, self.camera.zoom_min, self.camera.zoom_max))
+        self.camera.zoom_y = float(np.clip(self.camera.zoom_y * 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,
+        axes: str = "both"
+    ) -> None:
+        """
+        Calculates independent zoom_x and zoom_y to fit the requested bounds.
+        Handles zero-span degenerate cases by providing a sane default unit span.
+        """
+        # Handle degenerate spans
+        if abs(xmax - xmin) < 1e-9:
+            xmin -= 0.5
+            xmax += 0.5
+        if abs(ymax - ymin) < 1e-9:
+            ymin -= 0.5
+            ymax += 0.5
+
+        cx = 0.5 * (xmin + xmax)
+        cy = 0.5 * (ymin + ymax)
+        span_x = xmax - xmin
+        span_y = ymax - ymin
+        
+        if "x" in axes or axes == "both":
+            self.camera.cx = float(cx)
+            self.camera.zoom_x = float(np.clip(2.0 / span_x, self.camera.zoom_min, self.camera.zoom_max))
+            
+        if "y" in axes or axes == "both":
+            self.camera.cy = float(cy)
+            self.camera.zoom_y = float(np.clip(2.0 / span_y, 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_x = 1.0
+        self.camera.zoom_y = 1.0

{glplot-0.1.0 → glplot-0.1.1}/glplot/core/context.py

@@ -21,6 +21,7 @@ class RenderContext:
     fb_height: int # Framebuffer height
     
     mode: RenderMode # EXACT, INTERACTIVE, or PICKING
+    is_density: bool = False # Flag for density/heatmap accumulation mode
     
     # Passing global settings
     global_alpha: float = 1.0

{glplot-0.1.0 → glplot-0.1.1}/glplot/core/legacy.py

@@ -51,9 +51,25 @@ class SceneData:
 class CameraState:
     cx: float = 0.0
     cy: float = 0.0
-    zoom: float = 1.0
-    zoom_min: float = 0.02
-    zoom_max: float = 500.0
+    zoom_x: float = 1.0
+    zoom_y: float = 1.0
+    zoom_min: float = 1e-12
+    zoom_max: float = 1e12
+
+    @property
+    def zoom(self) -> float:
+        """Legacy property: returns the vertical zoom."""
+        return self.zoom_y
+
+    @zoom.setter
+    def zoom(self, value: float) -> None:
+        """Legacy setter: scales both axes proportionally to preserve anisotropy."""
+        if self.zoom_y == 0:
+            self.zoom_x = self.zoom_y = float(value)
+        else:
+            factor = float(value) / self.zoom_y
+            self.zoom_x *= factor
+            self.zoom_y *= factor
 
 @dataclass
 class InteractionState:
@@ -67,10 +83,12 @@ class InteractionState:
     ctrl_down: bool = False
     alt_down: bool = False
 
-    drag_mode: str = "pan"            # "pan", "move"
+    drag_mode: str = "pan"            # "pan", "move", "ratio"
     selected_layer_id: Optional[int] = None
     drag_start_world: Tuple[float, float] = (0.0, 0.0)
     drag_start_translation: Optional[Tuple[float, float]] = None
+    drag_start_zoom_x: float = 1.0
+    drag_start_zoom_y: float = 1.0
     explicit_pick_requested: bool = False  # Set on Shift+Click; bypasses the shift_down gate
 
     hover_idx: int = -1

{glplot-0.1.0 → glplot-0.1.1}/glplot/engine.py

@@ -175,46 +175,33 @@ class GPULinePlot:
     def set_view(self, xlim: Optional[Tuple[float, float]] = None, ylim: Optional[Tuple[float, float]] = None) -> None:
         """
         Sets the world-space view limits, mimicking Matplotlib's xlim/ylim.
-        Calculates required center and zoom while maintaining the window aspect ratio.
+        Allows independent scaling of X and Y axes (unforcing 1:1 data aspect).
         """
         if xlim is None and ylim is None:
             return
 
-        # 1. Resolve requested bounds
-        cur_xlim = self.get_xlim()
-        cur_ylim = self.get_ylim()
+        tx = xlim if xlim is not None else self.get_xlim()
+        ty = ylim if ylim is not None else self.get_ylim()
         
-        target_x = xlim if xlim is not None else cur_xlim
-        target_y = ylim if ylim is not None else cur_ylim
-        
-        # 2. Calculate world center and required span
-        cx = (target_x[0] + target_x[1]) * 0.5
-        cy = (target_y[0] + target_y[1]) * 0.5
-        span_x = abs(target_x[1] - target_x[0])
-        span_y = abs(target_y[1] - target_y[0])
-        
-        # 3. Fit to aspect ratio
-        aspect = self.width / max(self.height, 1)
-        required_zoom_y = 2.0 / max(span_y, 1e-12)
-        required_zoom_x = (2.0 * aspect) / max(span_x, 1e-12)
-        
-        # Use the most restrictive zoom to fit both ranges
-        new_zoom = min(required_zoom_x, required_zoom_y)
-        
-        self.camera.cx = float(cx)
-        self.camera.cy = float(cy)
-        self.camera.zoom = float(np.clip(new_zoom, self.camera.zoom_min, self.camera.zoom_max))
+        self.camera_controller.fit_bounds(
+            tx[0], tx[1], 
+            ty[0], ty[1], 
+            self.width, self.height
+        )
         
+        # Flush interaction cache on manual view changes
+        self.cache.active = False
+        self.cache.capture_window = None
         self.frame.dirty_scene = True
         self.cache.refresh_requested = True
 
     def get_xlim(self) -> Tuple[float, float]:
-        l, r, _, _ = self.camera_controller.world_window(self.width, self.height)
-        return float(l), float(r)
+        l, r, b, t = self.camera_controller.world_window(self.width, self.height)
+        return (float(l), float(r))
 
     def get_ylim(self) -> Tuple[float, float]:
-        _, _, b, t = self.camera_controller.world_window(self.width, self.height)
-        return float(b), float(t)
+        l, r, b, t = self.camera_controller.world_window(self.width, self.height)
+        return (float(b), float(t))
 
     def set_hud_enabled(self, enabled: bool) -> None:
         self.options.enable_hud = bool(enabled)
@@ -282,31 +269,6 @@ class GPULinePlot:
             self.options.enable_cache_interaction_path = False
         self.frame.dirty_scene = True
 
-    def set_view(self, xlim: Optional[Tuple[float, float]] = None, ylim: Optional[Tuple[float, float]] = None) -> None:
-        """Set the view limits. If both are provided, finds a zoom that fits both."""
-        if xlim is None and ylim is None:
-            return
-            
-        cur_xlim = xlim or self.get_xlim()
-        cur_ylim = ylim or self.get_ylim()
-        
-        self.camera_controller.fit_bounds(
-            cur_xlim[0], cur_xlim[1], 
-            cur_ylim[0], cur_ylim[1], 
-            self.width, self.height
-        )
-        # Flush interaction cache on manual view changes
-        self.cache.active = False
-        self.cache.capture_window = None
-        self.frame.dirty_scene = True
-
-    def get_xlim(self) -> Tuple[float, float]:
-        l, r, b, t = self.camera_controller.world_window(self.width, self.height)
-        return (l, r)
-
-    def get_ylim(self) -> Tuple[float, float]:
-        l, r, b, t = self.camera_controller.world_window(self.width, self.height)
-        return (b, t)
 
     def _get_all_layers(self) -> List[BaseLayer]:
         """
@@ -316,26 +278,38 @@ class GPULinePlot:
         """
         return list(self.scene.layers)
 
-    def autoscale(self) -> None:
-        """Autoscale view to fit all (legacy and layer) data."""
+    def autoscale(self, axes: str = "both", padding: float = 0.05) -> None:
+        """
+        Autoscale view to fit all (legacy and layer) data.
+        Supports axes="x", "y", or "both".
+        """
         layers = self._get_all_layers()
         bounds = self.renderer_manager.get_bounds(layers)
         
         if bounds is None:
-             self.camera_controller.reset_view()
+             if axes == "both":
+                 self.camera_controller.reset_view()
              return
 
         xmin, xmax, ymin, ymax = bounds
-        dx = (xmax - xmin) * 0.05
-        if dx == 0: dx = 1.0 
-        dy = (ymax - ymin) * 0.05
-        if dy == 0: dy = 1.0 
+        
+        # Apply fractional padding
+        dx = (xmax - xmin) * padding
+        dy = (ymax - ymin) * padding
+        
+        # Sane defaults: only apply a fixed buffer if the original data span is zero
+        # to prevent division by zero in camera projection.
+        if (xmax - xmin) < 1e-9: dx = 0.5
+        if (ymax - ymin) < 1e-9: dy = 0.5
         
         self.camera_controller.fit_bounds(
             xmin - dx, xmax + dx, 
             ymin - dy, ymax + dy, 
-            self.width, self.height
+            self.width, self.height,
+            axes=axes
         )
+        
+        self.cache.active = False
         self.frame.dirty_scene = True
 
     def reset_view(self) -> None:
@@ -490,6 +464,7 @@ class GPULinePlot:
             mode=self.policy.runtime.current_mode,
             global_alpha=self.options.default_global_alpha,
             lod_keep_prob=1.0,
+            is_density=self.display_density,
             time=time.perf_counter()
         )
         
@@ -555,6 +530,7 @@ class GPULinePlot:
             mode=self.policy.runtime.current_mode,
             global_alpha=base_alpha,
             lod_keep_prob=prob,
+            is_density=self.display_density,
             time=time.perf_counter()
         )
 
@@ -634,6 +610,7 @@ class GPULinePlot:
             mode=RenderMode.INTERACTIVE,
             global_alpha=base_alpha,
             lod_keep_prob=prob,
+            is_density=self.display_density,
             time=time.perf_counter()
         )
 
@@ -881,7 +858,21 @@ class GPULinePlot:
                 self.interaction.drag_start_world = self.camera_controller.screen_to_world(mx, my, self.width, self.height)
                 
                 # 3. Determine Drag Mode
-                if (mods & glfw.MOD_CONTROL) or (mods & glfw.MOD_SHIFT):
+                if (mods & glfw.MOD_CONTROL):
+                    # For professional UX, resolve the mode ONCE at the start of the drag
+                    self._run_picking_pass()
+                    
+                    if self.interaction.selected_layer_id is not None:
+                        self.interaction.drag_mode = "move"
+                        layer = next((l for l in self.scene.layers if l.layer_id == self.interaction.selected_layer_id), None)
+                        if layer:
+                            self.interaction.drag_start_translation = layer.translation
+                    else:
+                        # Scientific ratio scaling mode
+                        self.interaction.drag_mode = "ratio"
+                        self.interaction.drag_start_zoom_x = self.camera.zoom_x
+                        self.interaction.drag_start_zoom_y = self.camera.zoom_y
+                elif (mods & glfw.MOD_SHIFT):
                     self.interaction.drag_mode = "move"
                     if self.interaction.selected_layer_id is not None:
                         layer = next((l for l in self.scene.layers if l.layer_id == self.interaction.selected_layer_id), None)
@@ -933,10 +924,7 @@ class GPULinePlot:
                 # MOVE MODE: Translate the layer
                 layer = next((l for l in self.scene.layers if l.layer_id == self.interaction.selected_layer_id), None)
                 if layer:
-                    # Late capture of start translation if it's the first frame for this layer
                     if self.interaction.drag_start_translation is None:
-                         # We adjust the start world to the current world to prevent a "jump" 
-                         # when selection is delayed by one frame
                          self.interaction.drag_start_translation = layer.translation
                          self.interaction.drag_start_world = self.camera_controller.screen_to_world(x, y, self.width, self.height)
 
@@ -947,9 +935,21 @@ class GPULinePlot:
                     dx = curr_world[0] - start_world[0]
                     dy = curr_world[1] - start_world[1]
                     layer.translation = (start_trans[0] + dx, start_trans[1] + dy)
-                    
-                    # Force cache to redraw so we see it moving
                     self.cache.refresh_requested = True
+            elif self.interaction.drag_mode == "ratio":
+                # RATIO MODE: Exponential Anisotropic Scaling
+                dx = x - px
+                dy = y - py
+                
+                # Base-2 Exponential Law (100px = factor of 2.0 change)
+                sensitivity = 0.01 
+                self.camera.zoom_x = self.interaction.drag_start_zoom_x * (2.0 ** (dx * sensitivity))
+                self.camera.zoom_y = self.interaction.drag_start_zoom_y * (2.0 ** (-dy * sensitivity)) 
+                
+                # Clamp to safe camera limits
+                self.camera.zoom_x = float(np.clip(self.camera.zoom_x, self.camera.zoom_min, self.camera.zoom_max))
+                self.camera.zoom_y = float(np.clip(self.camera.zoom_y, self.camera.zoom_min, self.camera.zoom_max))
+                self.cache.refresh_requested = True
             else:
                 # PAN MODE: Translate the camera
                 lx, ly = self.interaction.last_mouse
@@ -1101,6 +1101,7 @@ class GPULinePlot:
                 mode=self.policy.runtime.current_mode,
                 global_alpha=alpha,
                 lod_keep_prob=prob,
+                is_density=self.display_density,
                 time=time.perf_counter()
             )
 

{glplot-0.1.0 → glplot-0.1.1}/glplot/managers/hud.py

@@ -161,7 +161,11 @@ class HudManager:
             imgui.text(f"Mouse: ({self.plot.mouse_world[0]:.4f}, {self.plot.mouse_world[1]:.4f}) | ")
             imgui.same_line()
         
-        imgui.text(f"Alpha: {self.options.default_global_alpha:.3f}")
+        imgui.text(f"Alpha: {self.options.default_global_alpha:.3f} | ")
+        imgui.same_line()
+        
+        mode = self.plot.interaction.drag_mode
+        imgui.text_colored(f"Drag: {mode.upper()}", 1.0, 1.0, 0.4)
         
         imgui.end()
 
@@ -327,6 +331,12 @@ class HudManager:
                 self.options.blend_mode = list(BlendMode)[clicked]
                 self.plot.frame.dirty_scene = True
             imgui.pop_item_width()
+            
+            # Antialiasing Toggle
+            changed, aa_en = imgui.checkbox("Antialiasing (SDF)", self.options.enable_antialiasing)
+            if changed:
+                self.options.enable_antialiasing = aa_en
+                self.plot.frame.dirty_scene = True
         
         if imgui.collapsing_header("Density Engine", imgui.TREE_NODE_DEFAULT_OPEN)[0]:
             from ..utils.shaders import DENSITY_SCHEMES

{glplot-0.1.0 → glplot-0.1.1}/glplot/managers/renderer_manager.py

@@ -78,13 +78,20 @@ class RendererManager:
         sorted_layers = self.filter_layers(layers, LayerCapability.DENSITY)
         
         # 1. Prepare the density manager for accumulation
+        target = self.plot.density_renderer.accum_target
         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)
+        # 2. Accumulate each layer (with context override for the density surface size)
+        old_w, old_h = context.fb_width, context.fb_height
+        context.fb_width, context.fb_height = target.width, target.height
+        
+        try:
+            for layer in sorted_layers:
+                renderer = self.renderers.get(layer.layer_type)
+                if renderer and hasattr(renderer, "draw_density"):
+                    renderer.draw_density(layer, context)
+        finally:
+            context.fb_width, context.fb_height = old_w, old_h
                 
         # 3. Resolve to the target FBO
         self.plot.density_renderer.resolve(target_fbo=target_fbo, target_size=target_size)

{glplot-0.1.0 → glplot-0.1.1}/glplot/options.py

@@ -86,6 +86,7 @@ class EngineOptions:
     enable_cache_interaction_path: bool = True
     enable_clipping_optimization: bool = True
     enable_multisample: bool = False
+    enable_antialiasing: bool = True
     always_lod: bool = False
 
     # Picking policy

{glplot-0.1.0 → glplot-0.1.1}/glplot/policy.py

@@ -81,9 +81,13 @@ class RenderPolicyManager:
 
         # 1. Line Families (Approx coverage: Count * ViewportWidth * Width)
         if scene.lines.ab is not None:
+            from .options import RenderMode
+            # Relax budget for density mode as overdraw is the goal
+            mode_multiplier = 100.0 if ctx.is_density else 1.0
+            
             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
+            total_est_px2 += est / mode_multiplier
 
         # 2. Polylines (Approx coverage: Length * Width)
         for layer in scene.layers:

{glplot-0.1.0 → glplot-0.1.1}/glplot/pyplot.py

@@ -521,6 +521,10 @@ def xlim(left: Optional[float] = None, right: Optional[float] = None) -> Optiona
     if left is None and right is None:
         return plot.get_xlim()
     
+    # Handle single tuple argument like matplotlib
+    if left is not None and right is None and isinstance(left, (tuple, list, np.ndarray)):
+        left, right = left[0], left[1]
+
     plot.set_view(xlim=(left, right))
     _set_dirty(plot)
     return (left, right)
@@ -534,6 +538,10 @@ def ylim(bottom: Optional[float] = None, top: Optional[float] = None) -> Optiona
     if bottom is None and top is None:
         return plot.get_ylim()
     
+    # Handle single tuple argument like matplotlib
+    if bottom is not None and top is None and isinstance(bottom, (tuple, list, np.ndarray)):
+        bottom, top = bottom[0], bottom[1]
+
     plot.set_view(ylim=(bottom, top))
     _set_dirty(plot)
     return (bottom, top)
@@ -572,11 +580,18 @@ def axis(mode: Union[str, Tuple[float, float, float, float]] = "auto") -> Option
     return (xmin, xmax, ymin, ymax)
 
 
-def autoscale() -> None:
+def autoscale(enable: bool = True, axis: str = "both", tight: Optional[bool] = None) -> None:
+    """
+    Autoscale the view to fit data.
+    """
     plot = _get_or_create_plot()
-    if _call_if_exists(plot, ("autoscale", "auto_view", "fit_view")) is None:
-        raise AttributeError("Backend does not expose autoscale()/fit_view()")
-    _set_dirty(plot)
+    
+    # Handle tight parameter
+    padding = 0.0 if tight else 0.05
+    
+    if enable:
+        plot.autoscale(axes=axis, padding=padding)
+        _set_dirty(plot)
 
 
 def reset_view() -> None:

{glplot-0.1.0 → glplot-0.1.1}/glplot/renderers/density.py

@@ -82,6 +82,7 @@ class DensityRenderer:
         # DENSITY ALWAYS NEEDS ADDITIVE BLENDING for accumulation
         glEnable(GL_BLEND)
         glBlendFunc(GL_ONE, GL_ONE)
+        glDisable(GL_DEPTH_TEST)
 
         # Handle clipping state if enabled globally
         if self.options.enable_clipping_optimization: