glplot 0.1.1__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.1 → glplot-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: glplot
-Version: 0.1.1
+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

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

@@ -28,12 +28,71 @@ class CameraController:
 
     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)
+        
+        # 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)
-        x = l + (sx / width) * (r - l)
-        y = b + ((height - sy) / height) * (t - b)
+        
+        # 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:

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

@@ -64,6 +64,7 @@ class GPULinePlot:
         
         self.effects = EffectManager(self)
         self._shim_cache: Dict[str, BaseLayer] = {}
+        self._apply_background_mode()
 
     # --------------------------------------------------------
     # Public API
@@ -353,6 +354,15 @@ class GPULinePlot:
         fname = filename or f"plot_{int(time.time())}.png"
         self.savefig(fname, scale=scale)
 
+    def get_density_array(self) -> np.ndarray:
+        """
+        Read back the accumulated density values from the GPU framebuffer texture 
+        and return them as a 2D numpy array of shape (height, width).
+        """
+        if self.window:
+            glfw.make_context_current(self.window)
+        return self.density_renderer.get_density_array()
+
     # --------------------------------------------------------
     # Init
     # --------------------------------------------------------
@@ -419,7 +429,29 @@ class GPULinePlot:
     # --------------------------------------------------------
 
     def _update_runtime_policy(self) -> None:
+        prev_mode = self.policy.runtime.current_mode
         self.policy.update(self.scene, self.interaction, self.cache)
+        if prev_mode == RenderMode.INTERACTIVE and self.policy.runtime.current_mode == RenderMode.EXACT:
+            self.frame.dirty_scene = True
+        if self.hud.state.show_profiler:
+            self.policy.runtime.hud_enabled_this_frame = True
+            
+    def _apply_background_mode(self) -> None:
+        """Apply style overrides for background, axes, and grid based on light_bg_mode."""
+        if getattr(self.options, "light_bg_mode", False):
+            # Light BG mode
+            self.options.visual.background_color = (1.0, 1.0, 1.0)
+            self.options.visual.gradient_background.enabled = True
+            self.options.visual.gradient_background.top_color = (1.0, 1.0, 1.0)
+            self.options.visual.gradient_background.bottom_color = (0.95, 0.95, 0.95)
+            self.options.axis_grid_color = (0.8, 0.8, 0.8)
+        else:
+            # Dark BG mode
+            self.options.visual.background_color = (0.0, 0.0, 0.0)
+            self.options.visual.gradient_background.enabled = True
+            self.options.visual.gradient_background.top_color = (0.0, 0.0, 0.0)
+            self.options.visual.gradient_background.bottom_color = (0.08, 0.08, 0.12)
+            self.options.axis_grid_color = (0.2, 0.2, 0.2)
 
     def _get_adaptive_alpha(self, count: int) -> float:
         """
@@ -543,7 +575,8 @@ class GPULinePlot:
         
         if self.display_density:
              # Modular Density Pass (Lines, Scatters)
-             self.renderer_manager.draw_density(layers, ctx)
+             current_fbo = glGetIntegerv(GL_FRAMEBUFFER_BINDING)
+             self.renderer_manager.draw_density(layers, ctx, target_fbo=current_fbo)
         else:
              # Standard Pass
              self.renderer_manager.draw_exact(layers, ctx)
@@ -563,7 +596,8 @@ class GPULinePlot:
             
         current_window = self.camera_controller.world_window(self.width, self.height)
         if self.options.enable_cache_interaction_path and self.cache.capture_window is not None:
-            self.interaction_renderer.draw_cached_impostor(self.cache.capture_window, current_window)
+            current_fbo = glGetIntegerv(GL_FRAMEBUFFER_BINDING)
+            self.interaction_renderer.draw_cached_impostor(self.cache.capture_window, current_window, target_fbo=current_fbo)
         else:
             self._draw_exact_view()
             
@@ -662,11 +696,34 @@ class GPULinePlot:
         glfw.swap_interval(1)
 
         while not glfw.window_should_close(self.window):
-            glfw.poll_events()
+            if self.options.reactive_rendering:
+                glfw.wait_events_timeout(0.02)
+            else:
+                glfw.poll_events()
             
             # 1. Update Input and State
             self.hud.process_inputs()
             self._update_runtime_policy()
+            self._apply_background_mode()
+
+            # Check cache release deadline
+            t_now = glfw.get_time()
+            if self.cache.active and not self.interaction.drag_active and not self.interaction.right_drag_active and t_now >= self.cache.release_deadline:
+                self.cache.active = False
+                self.frame.dirty_scene = True
+
+            need_render = (
+                not self.options.reactive_rendering or
+                self.frame.dirty_scene or 
+                self.frame.dirty_ui or 
+                self.frame.dirty_pick or 
+                self.interaction.drag_active or
+                self.interaction.right_drag_active or
+                self.hud.state.show_profiler
+            )
+
+            if not need_render:
+                continue
 
             # 2. Start ImGui frame before ANY rendering/processing happens
             self.hud.begin()
@@ -687,23 +744,28 @@ class GPULinePlot:
 
             t0 = glfw.get_time()
 
-            self.effects.begin_scene()
+            t_scene_start = time.perf_counter()
+            if self.frame.dirty_scene or not self.effects.any_post_enabled():
+                self.effects.begin_scene()
 
-            self.effects.draw_background()
-            self._apply_blending_policy()
+                self.effects.draw_background()
+                self._apply_blending_policy()
 
-            if self.policy.runtime.current_mode == RenderMode.INTERACTIVE:
-                self._draw_interaction_view()
-            else:
-                self._draw_exact_view()
+                if self.policy.runtime.current_mode == RenderMode.INTERACTIVE:
+                    self._draw_interaction_view()
+                else:
+                    self._draw_exact_view()
 
-            # Draw zoom box if active
-            if self.interaction.right_drag_active:
-                if self.options.enable_clipping_optimization:
-                    for i in range(4): glDisable(GL_CLIP_DISTANCE0 + i)
-                self._draw_zoom_box()
-                
-            self.effects.end_scene()
+                # Draw zoom box if active
+                if self.interaction.right_drag_active:
+                    if self.options.enable_clipping_optimization:
+                        for i in range(4): glDisable(GL_CLIP_DISTANCE0 + i)
+                    self._draw_zoom_box()
+                    
+                self.effects.end_scene()
+            else:
+                self.effects.resolve()
+            self.hud.state.gpu_timings["Render Scene"] = time.perf_counter() - t_scene_start
 
             # Update HUD metrics and Draw
             self._service_hud_metrics(t0)
@@ -712,15 +774,43 @@ class GPULinePlot:
             if self.options.enable_clipping_optimization:
                 for i in range(4): glDisable(GL_CLIP_DISTANCE0 + i)
 
+            t_hud_start = time.perf_counter()
+            # Draw Axis Labels (Scale) on every frame so they update dynamically and persist when the scene is cached.
+            if self.options.axis_show_labels:
+                window_world = self.camera_controller.world_window(self.width, self.height)
+                mvp = self.camera_controller.mvp(self.width, self.height)
+                ndc_scale, ndc_offset = self._get_ndc_transform(window_world)
+                ctx_labels = RenderContext(
+                    mvp=mvp,
+                    window_world=window_world,
+                    ndc_scale=ndc_scale,
+                    ndc_offset=ndc_offset,
+                    width_px=self.width,
+                    height_px=self.height,
+                    fb_width=self.fb_width,
+                    fb_height=self.fb_height,
+                    dpr=self.fb_width / max(self.width, 1),
+                    mode=self.policy.runtime.current_mode,
+                    global_alpha=1.0,
+                    lod_keep_prob=1.0,
+                    is_density=self.display_density,
+                    time=time.perf_counter()
+                )
+                self.axis_manager.update(ctx_labels)
+                self.renderer_manager.renderers["axis"]._draw_labels(self.axis_manager, ctx_labels)
+
             # HUD panels are only updated if HUD is enabled, but begin/end must wrap all
             if self.policy.runtime.hud_enabled_this_frame:
                 self.hud.update()
             
             self.hud.end()
+            self.hud.state.gpu_timings["UI Panels"] = time.perf_counter() - t_hud_start
             
             # Note: GL state is cleaned up/reset at start of next frame or specific renderers
 
+            t_swap_start = time.perf_counter()
             glfw.swap_buffers(self.window)
+            self.hud.state.gpu_timings["Buffer Swap"] = time.perf_counter() - t_swap_start
             t1 = glfw.get_time()
 
             dt = max(t1 - t0, 1e-6)
@@ -729,10 +819,6 @@ class GPULinePlot:
             self.frame.dirty_scene = False
             self.frame.dirty_ui = False
 
-            if self.cache.active and not self.interaction.drag_active and not self.interaction.right_drag_active and t1 >= self.cache.release_deadline:
-                self.cache.active = False
-                self.frame.dirty_scene = True
-
         self.effects.shutdown()
 
     def _service_hud_metrics(self, t0: float) -> None:
@@ -834,6 +920,7 @@ class GPULinePlot:
         self.frame.dirty_pick = True
 
     def _on_mouse_button(self, window, button, action, mods) -> None:
+        self.frame.dirty_ui = True
         self.hud.on_mouse_button(window, button, action, mods)
         if self.hud.wants_mouse():
             return
@@ -903,14 +990,16 @@ class GPULinePlot:
                 self.frame.dirty_scene = True
 
     def _on_cursor(self, window, x, y) -> None:
-        if self.hud.wants_mouse():
-            # Still update world coords for status panel
-            self.mouse_world = self.camera_controller.screen_to_world(x, y, self.width, self.height)
+        if (x, y) == self.interaction.last_mouse:
             return
-
+        
         self.mouse_world = self.camera_controller.screen_to_world(x, y, self.width, self.height)
         self.frame.dirty_ui = True
 
+        if self.hud.wants_mouse():
+            self.interaction.last_mouse = (x, y)
+            return
+
         if self.interaction.drag_active:
             px, py = self.interaction.press_mouse
             dist2 = (x - px) ** 2 + (y - py) ** 2
@@ -965,6 +1054,8 @@ class GPULinePlot:
         elif self.interaction.right_drag_active:
             self.interaction.last_mouse = (x, y)
             self.frame.dirty_ui = True
+        else:
+            self.interaction.last_mouse = (x, y)
 
     def _run_picking_pass(self) -> None:
         if not self.interaction.last_mouse:
@@ -1144,11 +1235,11 @@ class GPULinePlot:
             transparent=transparent
         )
 
-    def to_matplotlib(self, ax=None, **kwargs):
+    def to_matplotlib(self, ax: Optional[Axes] = None, mpl_kwargs: dict = {}, **kwargs):
         """Level 2 API: Render and embed directly into Matplotlib."""
         from .utils.mpl_bridge import snapshot_to_matplotlib
         snap = self.capture_snapshot(**kwargs)
-        return snapshot_to_matplotlib(snap, ax=ax)
+        return snapshot_to_matplotlib(snap, ax=ax, **mpl_kwargs)
 
     def set_matplotlib_transfer_target(self, ax=None, callback=None):
         """Level 3 API Setup: Redirect 'M' key transfers."""
@@ -1173,6 +1264,7 @@ class GPULinePlot:
         self.frame.dirty_scene = True
 
     def _on_key(self, window, key, sc, action, mods) -> None:
+        self.frame.dirty_ui = True
         self.hud.on_key(window, key, sc, action, mods)
 
         if action in (glfw.PRESS, glfw.REPEAT):
@@ -1190,6 +1282,13 @@ class GPULinePlot:
             elif key == glfw.KEY_C and action == glfw.PRESS:
                 self.toggle_line_colormap()
 
+            elif key == glfw.KEY_F3 and action == glfw.PRESS:
+                self.hud.state.show_profiler = not self.hud.state.show_profiler
+                if self.hud.state.show_profiler:
+                    self.options.enable_hud = True
+                self.frame.dirty_scene = True
+                self.frame.dirty_ui = True
+
             # --- Visual Parameters (Arrows) ---
             if key == glfw.KEY_UP:
                 if self.display_density:
@@ -1242,11 +1341,11 @@ class GPULinePlot:
                 self.frame.dirty_scene = True
 
             elif key == glfw.KEY_LEFT_BRACKET and action in (glfw.PRESS, glfw.REPEAT):
-                self.options.density_log_scale = max(0.1, self.options.density_log_scale - 0.2)
+                self.decrease_density_gain()
                 self.frame.dirty_scene = True
 
             elif key == glfw.KEY_RIGHT_BRACKET and action in (glfw.PRESS, glfw.REPEAT):
-                self.options.density_log_scale += 0.2
+                self.increase_density_gain()
                 self.frame.dirty_scene = True
 
             elif key == glfw.KEY_H and action == glfw.PRESS:
@@ -1268,4 +1367,5 @@ class GPULinePlot:
                 self.interaction.shift_down = False
 
     def _on_char(self, window, char) -> None:
+        self.frame.dirty_ui = True
         self.hud.on_char(window, char)

{glplot-0.1.1 → glplot-0.1.2}/glplot/managers/effects.py

@@ -74,6 +74,8 @@ class EffectManager:
     # ------------------------------------------------------------------
 
     def any_post_enabled(self) -> bool:
+        if self.options.reactive_rendering:
+            return True
         v = self.options.visual
         return v.glow.enabled
 
@@ -168,6 +170,18 @@ class EffectManager:
         """
         Draw the background into whichever framebuffer is currently bound.
         """
+        # Overwrite background color with the colormap's minimum color in density mode
+        if getattr(self.plot, "display_density", False):
+            scheme_idx = getattr(self.options, "density_scheme_index", 0)
+            invert = getattr(self.options, "density_invert", False)
+            ltc = getattr(self.options, "density_light_to_color", True)
+            
+            from ..utils.shaders import get_colormap_min_color
+            c = get_colormap_min_color(scheme_idx, invert, ltc)
+            glClearColor(c[0], c[1], c[2], 1.0)
+            glClear(GL_COLOR_BUFFER_BIT)
+            return
+
         v = self.options.visual.gradient_background
 
         if not v.enabled:

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

@@ -359,13 +359,43 @@ class HudManager:
                 self.plot.frame.dirty_scene = True
             imgui.pop_item_width()
             
+            # Light BG Mode
+            light_mode = getattr(self.options, "light_bg_mode", False)
+            changed_bg, val_bg = imgui.checkbox("Light BG Mode", light_mode)
+            if changed_bg:
+                self.options.light_bg_mode = val_bg
+                self.options.density_invert = val_bg
+                self.plot.frame.dirty_scene = True
+                self.plot.frame.dirty_ui = True
+
+            # Invert Colors
+            invert_mode = getattr(self.options, "density_invert", False)
+            changed_inv, val_inv = imgui.checkbox("Invert Colors", invert_mode)
+            if changed_inv:
+                self.options.density_invert = val_inv
+                self.plot.frame.dirty_scene = True
+                self.plot.frame.dirty_ui = True
+
+            # Light to Color Only option
+            is_inverted = getattr(self.options, "density_invert", False)
+            label = "Light to Color Only" if is_inverted else "Dark to Color Only"
+            light_to_color = getattr(self.options, "density_light_to_color", True)
+            changed_ltc, val_ltc = imgui.checkbox(label, light_to_color)
+            if changed_ltc:
+                self.options.density_light_to_color = val_ltc
+                self.plot.frame.dirty_scene = True
+                self.plot.frame.dirty_ui = True
+            
             # Gain and Scale
             imgui.push_item_width(180)
             changed, gain = imgui.drag_float("Gain (Intensity)", self.options.density_gain, 1.0, 0.1, 10000.0, "%.1f")
             if changed: self.options.density_gain = gain; self.plot.frame.dirty_scene = True
             
-            changed, lscale = imgui.drag_float("Log Scale (Contrast)", self.options.density_log_scale, 0.05, 0.1, 20.0, "%.2f")
-            if changed: self.options.density_log_scale = lscale; self.plot.frame.dirty_scene = True
+            is_log = getattr(self.options, "density_is_log", True)
+            changed_log, val_log = imgui.checkbox("Logarithmic Scale", is_log)
+            if changed_log:
+                self.options.density_is_log = val_log
+                self.plot.frame.dirty_scene = True
 
             changed, res = imgui.slider_float("Inner Resolution", self.options.density_resolution_scale, 0.1, 1.0, "%.2f")
             if changed: self.controller.set_density_resolution(res)
@@ -378,28 +408,25 @@ class HudManager:
             pos = imgui.get_cursor_screen_pos()
             w, h = 220, 18
             
-            def get_scheme_col(v):
-                scheme = self.options.density_scheme_index
-                if scheme == 1: # Viridis
-                    if v < 0.5: return (0.2+v*0.1, 0.1+v*0.8, 0.4+v*0.2)
-                    return (0.3+(v-0.5)*1.4, 0.5+(v-0.5)*0.8, 0.5-(v-0.5)*0.8)
-                if scheme == 2: # Plasma
-                    return (0.1+v*1.8, 0.0, 0.5+v*0.5) if v < 0.5 else (1.0, (v-0.5)*2.0, 1.0-v)
-                if scheme == 3: # Inferno
-                    return (v*0.5, 0.0, v*0.2) if v < 0.5 else (v, (v-0.5)*1.5, (v-0.5)*2.0)
-                if scheme == 4: # Turbo
-                    if v < 0.33: return (0.2, v*2.5, 0.8)
-                    if v < 0.66: return (v*1.5, 0.8, 0.2)
-                    return (0.9, 0.2, 0.1)
-                if scheme == 5: # Ink Fire (White BG)
-                    return (1.0, 1.0-(v*0.5), 1.0-(v*1.5)) if v < 0.5 else (1.0-(v-0.5)*2.0, 0.25-(v-0.5)*0.5, 0.0)
-                if scheme == 6: # Magma
-                    return (v*0.4, 0.1, 0.5) if v < 0.5 else (v, 0.5+(v-0.5), 0.8+(v-0.5)*0.4)
-                return (v, v, v)
-                
+            from ..utils.shaders import eval_colormap
+            is_inverted = getattr(self.options, "density_invert", False)
+            ltc = getattr(self.options, "density_light_to_color", True)
+            scheme_idx = self.options.density_scheme_index
+
             for i in range(20):
                 v = i / 19.0
-                c = get_scheme_col(v)
+                if is_inverted:
+                    if ltc:
+                        norm = 1.0 - 0.75 * v
+                    else:
+                        norm = 1.0 - v
+                else:
+                    if ltc:
+                        norm = 0.75 * v
+                    else:
+                        norm = v
+                
+                c = eval_colormap(scheme_idx, norm)
                 color = imgui.get_color_u32_rgba(max(0,min(1,c[0])), max(0,min(1,c[1])), max(0,min(1,c[2])), 1.0)
                 draw_list.add_rect_filled(pos.x + i*(w/20), pos.y, pos.x + (i+1)*(w/20), pos.y + h, color)
             
@@ -456,23 +483,49 @@ class HudManager:
         imgui.end()
 
     def _draw_profiler_panel(self):
-        imgui.set_next_window_size(300, 200, imgui.FIRST_USE_EVER)
-        imgui.begin("Profiler", True)
-        
-        if self.state.cpu_frame_times:
-            avg_ms = sum(self.state.cpu_frame_times) / len(self.state.cpu_frame_times) * 1000.0
-            imgui.text(f"Avg CPU Frame: {avg_ms:5.2f} ms")
-            
-            # Sparkline
-            import numpy as np
-            history = np.array(self.state.cpu_frame_times, dtype=np.float32)
-            imgui.plot_lines("##FPSGraph", history, overlay_text=f"{1000.0/avg_ms:.1f} FPS", 
-                             scale_min=0, scale_max=0.033, graph_size=(0, 60))
+        imgui.set_next_window_size(350, 420, imgui.FIRST_USE_EVER)
+        expanded, opened = imgui.begin("Profiler", True)
+        if not opened:
+            self.state.show_profiler = False
+            imgui.end()
+            return
         
-        imgui.separator()
-        for k, v in self.state.gpu_timings.items():
-            imgui.text(f"{k}: {v*1000.0:5.2f} ms")
+        if expanded:
+            # 1. Performance Overview
+            imgui.text_colored("PERFORMANCE OVERVIEW", 0.3, 0.8, 1.0)
+            if self.state.cpu_frame_times:
+                avg_ms = sum(self.state.cpu_frame_times) / len(self.state.cpu_frame_times) * 1000.0
+                imgui.text(f"Avg CPU Frame: {avg_ms:5.2f} ms ({1000.0/avg_ms:.1f} FPS)")
+                
+                # Sparkline
+                import numpy as np
+                history = np.array(self.state.cpu_frame_times, dtype=np.float32)
+                imgui.plot_lines("##FPSGraph", history, overlay_text="", 
+                                 scale_min=0, scale_max=0.033, graph_size=(0, 50))
+            
+            imgui.separator()
+            
+            # 2. Rendering Pipelines Detailed Timings
+            imgui.text_colored("SUB-OPERATION TIMINGS", 0.3, 0.8, 1.0)
+            for k, v in sorted(self.state.gpu_timings.items()):
+                imgui.text(f" - {k}: {v*1000.0:5.2f} ms")
             
+            imgui.separator()
+
+            # 3. Engine State & Statistics
+            imgui.text_colored("ENGINE STATISTICS", 0.3, 0.8, 1.0)
+            mode_str = self.plot.policy.runtime.current_mode.name
+            imgui.text(f"Render Mode: {mode_str}")
+            
+            sleep_str = "SLEEPING (Reactive)" if self.plot.options.reactive_rendering and not self.plot.hud.state.show_profiler else "ACTIVE Redrawing"
+            imgui.text(f"Gating Loop: {sleep_str}")
+            
+            imgui.text(f"Total Lines: {self.plot.scene.lines.count:,}")
+            
+            win = self.plot.camera_controller.world_window(self.plot.width, self.plot.height)
+            imgui.text(f"X range: [{win[0]:.2f}, {win[1]:.2f}]")
+            imgui.text(f"Y range: [{win[2]:.2f}, {win[3]:.2f}]")
+
         imgui.end()
 
     def _draw_selection_panel(self):

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

@@ -88,6 +88,7 @@ class EngineOptions:
     enable_multisample: bool = False
     enable_antialiasing: bool = True
     always_lod: bool = False
+    reactive_rendering: bool = True
 
     # Picking policy
     shift_required_for_picking: bool = True
@@ -99,10 +100,14 @@ class EngineOptions:
     # 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_scheme_index: int = 9
     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
+    density_invert: bool = True
+    density_is_log: bool = True             # Enable logarithmic colormap scaling by default
+    light_bg_mode: bool = True
+    density_light_to_color: bool = True     # Go from white to color (instead of white to color to black)
 
     # Style
     blend_mode: BlendMode = BlendMode.AUTO