glplot 0.1.0__tar.gz → 0.1.2__tar.gz

glplot-0.1.2/.gitignore

@@ -0,0 +1 @@
+.DS_Store

glplot-0.1.2/.vscode/settings.json

@@ -0,0 +1,11 @@
+{
+    "python.testing.unittestArgs": [
+        "-v",
+        "-s",
+        "./tests",
+        "-p",
+        "test*.py"
+    ],
+    "python.testing.pytestEnabled": false,
+    "python.testing.unittestEnabled": true
+}

glplot-0.1.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Juan Manuel Lombardi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{glplot-0.1.0 → glplot-0.1.2}/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.2
+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.2/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.2}/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.2}/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.2/examples/ex_read_density.py

@@ -0,0 +1,33 @@
+import numpy as np
+import glplot.pyplot as gplt
+
+def demo_read_density():
+    n = 500000
+    a = np.random.randn(n) * 0.15
+    b = np.random.randn(n) * 0.15
+    
+    # Enable density mode
+    gplt.figure("Read Density Example", density=True, hud=True)
+    gplt.lines(a, b, x_range=(-1, 1), color='cyan')
+    
+    # We retrieve the GPULinePlot engine instance
+    plot = gplt.gcf()
+    
+    # Force a single frame draw so densities are accumulated on the GPU before readback.
+    plot._draw_exact_view()
+    
+    # Retrieve the densities as a 2D numpy array
+    densities = plot.get_density_array()
+    
+    print("\n--- Density Array Extracted via API ---")
+    print(f"Array shape: {densities.shape} (height, width)")
+    print(f"Data type:   {densities.dtype}")
+    print(f"Min density: {densities.min()}")
+    print(f"Max density: {densities.max()}")
+    print(f"Mean density: {densities.mean()}")
+    print("----------------------------------------\n")
+    
+    gplt.show()
+
+if __name__ == "__main__":
+    demo_read_density()

{glplot-0.1.0 → glplot-0.1.2}/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.2/glplot/controllers.py

@@ -0,0 +1,145 @@
+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)
+        
+        # Apply inset margins for axes and labels visibility
+        margin_l = 60.0
+        margin_r = 20.0
+        margin_b = 40.0
+        margin_t = 20.0
+        
+        rl, tb = (r - l), (t - b)
+        
+        # Calculate NDC scale and translation for margins
+        w_px = max(width, 1e-12)
+        h_px = max(height, 1e-12)
+        sx = (width - margin_l - margin_r) / w_px
+        tx = (margin_l - margin_r) / w_px
+        sy = (height - margin_t - margin_b) / h_px
+        ty = (margin_b - margin_t) / h_px
+        
+        # Standard ortho values
+        m00 = 2.0 / max(rl, 1e-12)
+        m03 = -(r + l) / max(rl, 1e-12)
+        m11 = 2.0 / max(tb, 1e-12)
+        m13 = -(t + b) / max(tb, 1e-12)
+        
+        # Apply transformation
+        r00 = sx * m00
+        r03 = sx * m03 + tx
+        r11 = sy * m11
+        r13 = sy * m13 + ty
+        
+        return np.array([
+            [r00, 0.0, 0.0, r03],
+            [0.0, r11, 0.0, r13],
+            [0.0, 0.0, -1.0, 0.0],
+            [0.0, 0.0, 0.0,  1.0]
+        ], dtype=np.float32)
+
+    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)
+        
+        # Apply inset margins for axes and labels visibility
+        margin_l = 60.0
+        margin_r = 20.0
+        margin_b = 40.0
+        margin_t = 20.0
+        
+        w_px = max(width, 1e-12)
+        h_px = max(height, 1e-12)
+        
+        # Scale and translation in NDC space
+        scale_x = (width - margin_l - margin_r) / w_px
+        trans_x = (margin_l - margin_r) / w_px
+        scale_y = (height - margin_t - margin_b) / h_px
+        trans_y = (margin_b - margin_t) / h_px
+        
+        # Screen to NDC inset
+        ndc_x_inset = (sx / w_px) * 2.0 - 1.0
+        ndc_y_inset = ((height - sy) / h_px) * 2.0 - 1.0
+        
+        # NDC inset to standard NDC
+        ndc_x = (ndc_x_inset - trans_x) / max(scale_x, 1e-12)
+        ndc_y = (ndc_y_inset - trans_y) / max(scale_y, 1e-12)
+        
+        # Standard NDC to world
+        x = l + (ndc_x + 1.0) * 0.5 * (r - l)
+        y = b + (ndc_y + 1.0) * 0.5 * (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.2}/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.2}/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