jarvisplot 1.4.0__tar.gz → 1.4.2__tar.gz

{jarvisplot-1.4.0 → jarvisplot-1.4.2}/JarvisPLOT.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: JarvisPLOT
-Version: 1.4.0
+Version: 1.4.2
 Summary: Jarvis-PLOT: YAML-driven plotting engine
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{jarvisplot-1.4.0 → jarvisplot-1.4.2}/JarvisPLOT.egg-info/SOURCES.txt

@@ -28,6 +28,7 @@ jarvisplot/Figure/colorbar_runtime.py
 jarvisplot/Figure/config_runtime.py
 jarvisplot/Figure/data_pipelines.py
 jarvisplot/Figure/density_cell_runtime.py
+jarvisplot/Figure/design_runtime.py
 jarvisplot/Figure/dynesty_runtime.py
 jarvisplot/Figure/figure.py
 jarvisplot/Figure/figure_types.py

{jarvisplot-1.4.0 → jarvisplot-1.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: JarvisPLOT
-Version: 1.4.0
+Version: 1.4.2
 Summary: Jarvis-PLOT: YAML-driven plotting engine
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{jarvisplot-1.4.0 → jarvisplot-1.4.2}/jarvisplot/Figure/colorbar_runtime.py

@@ -394,6 +394,8 @@ def collect_and_attach_colorbar(
     if not axc._cb.get("used"):
         frame = getattr(fig, "frame", {})
         color_cfg = axc_color_config(frame, cb_name)
+        if color_cfg.get("cmap") is None and style.get("cmap") is not None:
+            color_cfg["cmap"] = style.get("cmap")
         data_range = collect_layer_color_range(
             df,
             coor,

jarvisplot-1.4.2/jarvisplot/Figure/design_runtime.py

@@ -0,0 +1,137 @@
+#!/usr/bin/env python3
+"""Design-reference debug overlay for Jarvis-PLOT figures.
+
+When a figure is rendered with ``debug: true`` in the YAML, this module draws a
+dimension overlay on top of the finished figure: every axes defined by the style
+card is outlined and annotated with
+
+  - its name (``ax`` / ``axc`` / ``axtri`` / ``ax0`` ...),
+  - its position rect ``[left, bottom, width, height]`` in figure fractions
+    (exactly the ``Frame.axes.<name>.rect`` value from the style JSON card), and
+  - its width / height converted to centimetres from ``figure.figsize``.
+
+The primary axes additionally gets margin dimension lines (left / top / bottom
+insets), and colorbar axes get a gap dimension to the primary axes.
+
+The overlay never participates in data rendering; it is a read-only annotation
+layer added just before the figure is saved.  All drawing is wrapped so a
+failure here can never break a normal plot.
+"""
+
+from __future__ import annotations
+
+import matplotlib as mpl
+
+
+# overlay palette
+_DIM    = "#0A7FB6"   # blue dimension lines + labels
+_BOX    = "#111111"   # axes outline
+_NAME   = "#1A237E"   # axes name + rect text
+_MARGIN = "#FF3FA4"   # pink figure border / caption
+
+# order in which we look for the "primary" axes to fully dimension
+_PRIMARY_ORDER = ("ax", "ax0", "ax1", "axtri")
+
+
+def _raw(ax):
+    """Return the underlying matplotlib Axes for an adapter or raw Axes."""
+    return getattr(ax, "ax", ax)
+
+
+def _position(ax):
+    try:
+        bb = _raw(ax).get_position()
+        return float(bb.x0), float(bb.y0), float(bb.width), float(bb.height)
+    except Exception:
+        return None
+
+
+def draw_design_reference(fig) -> None:
+    """Draw the dimension overlay onto ``fig`` (a JarvisPLOT Figure wrapper)."""
+    try:
+        _draw(fig)
+    except Exception as exc:  # never break a real plot because of the overlay
+        logger = getattr(fig, "logger", None)
+        if logger is not None:
+            try:
+                logger.debug(f"design-reference overlay skipped: {exc}")
+            except Exception:
+                pass
+
+
+def _draw(fig) -> None:
+    F = fig.fig
+    w_in, h_in = (float(v) for v in F.get_size_inches())
+    w_cm, h_cm = w_in * 2.54, h_in * 2.54
+
+    ov = F.add_axes([0.0, 0.0, 1.0, 1.0], zorder=10_000)
+    ov.set_xlim(0.0, 1.0)
+    ov.set_ylim(0.0, 1.0)
+    ov.set_axis_off()
+    ov.patch.set_alpha(0.0)
+
+    def label(x, y, text, *, color=_DIM, size=5.0, ha="center", va="center",
+              rotation=0, weight="normal", family="monospace", boxed=True):
+        bbox = dict(boxstyle="square,pad=0.12", fc="white", ec="none", alpha=0.82) if boxed else None
+        ov.text(x, y, text, color=color, fontsize=size, ha=ha, va=va,
+                rotation=rotation, fontweight=weight, family=family, bbox=bbox,
+                zorder=10_002, clip_on=False)
+
+    def dim(x0, y0, x1, y1, text, *, vertical=False):
+        ov.annotate("", xy=(x1, y1), xytext=(x0, y0),
+                    arrowprops=dict(arrowstyle="<|-|>", color=_DIM, lw=0.7,
+                                    shrinkA=0, shrinkB=0, mutation_scale=6),
+                    zorder=10_001)
+        label((x0 + x1) / 2.0, (y0 + y1) / 2.0, text,
+              rotation=90 if vertical else 0)
+
+    # figure border + size caption
+    ov.add_patch(mpl.patches.Rectangle((0, 0), 1, 1, fill=False, ec=_MARGIN,
+                                       lw=0.9, zorder=10_001))
+    label(0.5, 0.995, f"design reference  ·  figure {w_cm:.2f} cm × {h_cm:.2f} cm",
+          color=_MARGIN, size=6.0, va="top", weight="bold", family="DejaVu Sans")
+
+    # total figure height marker on the far left
+    dim(0.012, 0.0, 0.012, 1.0, f"{h_cm:.2f} cm", vertical=True)
+
+    # pick the primary axes to fully dimension
+    primary = next((n for n in _PRIMARY_ORDER if n in fig.axes), None)
+    primary_pos = _position(fig.axes[primary]) if primary else None
+
+    for name, ax in fig.axes.items():
+        pos = _position(ax)
+        if pos is None:
+            continue
+        l, b, w, h = pos
+
+        # outline only, so the real plot underneath keeps its true colors
+        ov.add_patch(mpl.patches.Rectangle((l, b), w, h, fill=False, ec=_BOX,
+                                           lw=0.9, zorder=10_001))
+
+        # name + rect + cm sizes — anchored so the text stays inside the figure
+        if l + w / 2.0 > 0.6:            # axes sits in the right half
+            tx, ha = min(l + w, 0.992), "right"
+        else:
+            tx, ha = max(l + 0.012, 0.008), "left"
+        ty = min(b + h - 0.015, 0.93)
+        label(tx, ty, name, color=_NAME, size=7.0, ha=ha, va="top",
+              weight="bold", boxed=True)
+        label(tx, ty - 0.057,
+              f"[{l:.3f}, {b:.3f}, {w:.3f}, {h:.3f}]\n"
+              f"width: {w * w_cm:.3f} cm   height: {h * h_cm:.3f} cm",
+              color=_NAME, size=4.6, ha=ha, va="top", boxed=True)
+
+        if name == primary:
+            yt = b + h
+            # left inset (figure left edge → axes left edge), drawn along the top edge
+            dim(0.0, yt, l, yt, f"{l * w_cm:.3f} cm")
+            # top inset (axes top edge → figure top)
+            dim(l, yt, l, 1.0, f"{(1.0 - yt) * h_cm:.3f} cm", vertical=True)
+            # bottom inset (figure bottom → axes bottom edge)
+            dim(l, 0.0, l, b, f"{b * h_cm:.3f} cm", vertical=True)
+        elif name.startswith("axc") and primary_pos is not None:
+            # gap between the primary axes' right edge and this colorbar's left edge
+            pl, pb, pw, ph = primary_pos
+            ygap = b + h / 2.0
+            if l > pl + pw:
+                dim(pl + pw, ygap, l, ygap, f"{(l - (pl + pw)) * w_cm:.3f} cm")

{jarvisplot-1.4.0 → jarvisplot-1.4.2}/jarvisplot/Figure/figure.py

@@ -13,6 +13,7 @@ from .adapters_ternary import TernaryAxesAdapter
 from .method_registry import resolve_callable
 from .style_runtime import resolve_style_bundle_payload
 from .config_runtime import apply_figure_config
+from .design_runtime import draw_design_reference
 from .layer_runtime import (
     load_layer_runtime_data as runtime_load_layer_runtime_data,
     release_layer_runtime_data as runtime_release_layer_runtime_data,
@@ -711,6 +712,7 @@ class Figure:
         read-only during the main render loop.
         """
         cb_ranges: dict[str, list] = {}
+        cb_style_cmaps: dict[str, object] = {}
 
         for ax, ly in self._render_queue:
             cb_name = ly.get("colorbar", "axc")
@@ -724,6 +726,9 @@ class Figure:
             if not layer_uses_color(style, coor, method_key):
                 continue
 
+            if style.get("cmap") is not None:
+                cb_style_cmaps.setdefault(cb_name, style.get("cmap"))
+
             # Load data (pipeline cache hit on second call in render loop)
             runtime_load_layer_runtime_data(self, ly)
             df = ly.get("data")
@@ -742,6 +747,8 @@ class Figure:
             if axc_obj is None or not hasattr(axc_obj, "_cb"):
                 continue
             color_cfg = axc_color_config(self.frame, cb_name)
+            if color_cfg.get("cmap") is None and cb_name in cb_style_cmaps:
+                color_cfg["cmap"] = cb_style_cmaps[cb_name]
             axc_obj._cb.update(
                 precompute_colorbar_cb(color_cfg, ranges, logger=self.logger)
             )
@@ -969,16 +976,8 @@ class Figure:
     def plot(self):
         self.render()
         # for layer in self.layers:
-        if self.debug: 
-            if "axtri" in self.axes.keys():
-                # Demo of Scatter Clip
-                x = np.linspace(-1, 2, 121)
-                y = np.linspace(-1, 2, 121)
-                X, Y = np.meshgrid(x, y)
-                self.axtri.scatter(x=X.ravel() + 0.5 *  Y.ravel(), y=Y.ravel(), marker='.', s=1, facecolor="#0277BA", edgecolor="None")
-
-                # Demo of Plot Clip 
-                self.axtri.plot(x=[-1, 0.5, 0.5, 2], y=[-1.1, 0.6, 0.3, 1.8], linestyle="-", color="#0277BA")
+        if self.debug:
+            draw_design_reference(self)
         self.savefig()
         import matplotlib.pyplot as plt
         plt.close(self.fig)

{jarvisplot-1.4.0 → jarvisplot-1.4.2}/jarvisplot/Figure/layer_runtime.py

@@ -6,6 +6,7 @@ from pathlib import Path
 
 import numpy as np
 import pandas as pd
+from matplotlib.path import Path as MplPath
 
 from .preprocessor_runtime import add_column, filter_df, sort_by
 from .profile_runtime import profiling
@@ -15,6 +16,117 @@ from .interp_natural_neighbor import resolve_backend
 from .dynesty_runtime import render_dynesty_runplot
 from .posterior_hpd import prepare_hpd_contour_style
 
+_MISSING_CLIP_PATH = object()
+
+
+def _clip_expr_inside(expr: str, point) -> bool:
+    px, py = float(point[0]), float(point[1])
+    env = {
+        "x": px,
+        "y": py,
+        "np": np,
+        "numpy": np,
+        "abs": abs,
+        "min": min,
+        "max": max,
+    }
+    try:
+        return bool(eval(expr, {"__builtins__": {}}, env))
+    except Exception as exc:
+        raise ValueError(f"layer clip_expr failed for {expr!r}: {exc}") from exc
+
+
+def _clip_polygon_to_expr(poly, expr: str, *, iterations: int = 48):
+    """Clip a polygon to the region where expr is True in data coordinates."""
+    expr = str(expr or "").strip()
+    if not expr or not poly:
+        return poly
+
+    def inside(pt) -> bool:
+        return _clip_expr_inside(expr, pt)
+
+    def intersect(a, b):
+        pa = np.asarray(a, dtype=float)
+        pb = np.asarray(b, dtype=float)
+        a_inside = inside(pa)
+        lo = pa
+        hi = pb
+        for _ in range(iterations):
+            mid = 0.5 * (lo + hi)
+            if inside(mid) == a_inside:
+                lo = mid
+            else:
+                hi = mid
+        return tuple(0.5 * (lo + hi))
+
+    out = []
+    start = poly[-1]
+    start_inside = inside(start)
+    for end in poly:
+        end_inside = inside(end)
+        if end_inside:
+            if not start_inside:
+                out.append(intersect(start, end))
+            out.append(end)
+        elif start_inside:
+            out.append(intersect(start, end))
+        start = end
+        start_inside = end_inside
+    return out
+
+
+def _layer_clip_path_from_style(ax, style: dict):
+    expr = style.pop("clip_expr", style.pop("clip_where", None))
+    if expr is None:
+        return None
+    raw_ax = getattr(ax, "ax", ax)
+    try:
+        x0, x1 = raw_ax.get_xlim()
+        y0, y1 = raw_ax.get_ylim()
+    except Exception as exc:
+        raise ValueError("layer clip_expr requires axes with data limits") from exc
+
+    xmin, xmax = sorted((float(x0), float(x1)))
+    ymin, ymax = sorted((float(y0), float(y1)))
+    rect = [(xmin, ymin), (xmax, ymin), (xmax, ymax), (xmin, ymax)]
+    clipped = _clip_polygon_to_expr(rect, str(expr))
+    if len(clipped) < 3:
+        return MplPath([(xmin, ymin), (xmin, ymin)], [MplPath.MOVETO, MplPath.CLOSEPOLY])
+
+    vertices = list(clipped) + [tuple(clipped[0])]
+    codes = [MplPath.MOVETO] + [MplPath.LINETO] * (len(clipped) - 1) + [MplPath.CLOSEPOLY]
+    return MplPath(vertices, codes)
+
+
+def _layer_clip_targets(ax):
+    raw_ax = getattr(ax, "ax", None)
+    targets = []
+    for obj in (ax, raw_ax):
+        if obj is not None and not any(obj is prev for prev in targets):
+            targets.append(obj)
+    return targets
+
+
+def _call_with_layer_clip(ax, clip_path, func, *args, **kwargs):
+    if clip_path is None:
+        return func(*args, **kwargs)
+
+    states = []
+    for target in _layer_clip_targets(ax):
+        states.append((target, getattr(target, "_clip_path", _MISSING_CLIP_PATH)))
+        target._clip_path = clip_path
+    try:
+        return func(*args, **kwargs)
+    finally:
+        for target, previous in reversed(states):
+            if previous is _MISSING_CLIP_PATH:
+                try:
+                    delattr(target, "_clip_path")
+                except Exception:
+                    pass
+            else:
+                target._clip_path = previous
+
 
 def _resolve_csv_export_path(fig, target):
     if isinstance(target, dict):
@@ -664,6 +776,7 @@ def render_layer(fig, ax, layer_info):
             pass
     if layer_info.get("style", {}) is not None:
         style.update(layer_info.get("style", {}))
+    layer_clip_path = _layer_clip_path_from_style(ax, style)
 
     cb_name = layer_info.get("colorbar", "axc")
 
@@ -696,8 +809,8 @@ def render_layer(fig, ax, layer_info):
                 required_keys=("z",),
                 include_diagnostics=method_key in {"jpcontour", "jpcontourf"},
             )
-            return method(**jp_kwargs)
-        return method(**style)
+            return _call_with_layer_clip(ax, layer_clip_path, method, **jp_kwargs)
+        return _call_with_layer_clip(ax, layer_clip_path, method, **style)
 
     elif getattr(ax, "_type", None) == "rect":
         df = fig._ensure_pandas_data(layer_info["data"], reason=f"render:{layer_info.get('name', '')}")
@@ -724,7 +837,7 @@ def render_layer(fig, ax, layer_info):
                 for kk, vv in coor.items():
                     style[kk] = fig._eval_series(df, vv)
 
-            return method(**style)
+            return _call_with_layer_clip(ax, layer_clip_path, method, **style)
         if method_key in {"jpcontour", "jpcontourf", "jpfield"}:
             jp_kwargs = _prepare_jpcontour_style(
                 fig,
@@ -737,7 +850,7 @@ def render_layer(fig, ax, layer_info):
                 required_keys=("x", "y", "z"),
                 include_diagnostics=method_key in {"jpcontour", "jpcontourf"},
             )
-            return method(**jp_kwargs)
+            return _call_with_layer_clip(ax, layer_clip_path, method, **jp_kwargs)
         if method_key in {"contour", "contourf"}:
             contour_coor = {}
             for kk in ("x", "y", "z"):
@@ -759,7 +872,7 @@ def render_layer(fig, ax, layer_info):
             contour_args, style = _prepare_contour_args(fig, ax.ax if hasattr(ax, "ax") else ax, method_key, style, contour_coor, df=df)
             if contour_args is None:
                 return []
-            return method(*contour_args, **style)
+            return _call_with_layer_clip(ax, layer_clip_path, method, *contour_args, **style)
         else:
             if not ({"x", "y"} <= set(coor.keys())):
                 raise ValueError("Rectangular layer must define coordinates: {x,y} with exprs.")
@@ -777,7 +890,7 @@ def render_layer(fig, ax, layer_info):
             if method_key == "pcolormesh":
                 style["__df__"] = df
             style.pop("interp", None)
-            return method(**style)
+            return _call_with_layer_clip(ax, layer_clip_path, method, **style)
 
     else:
         raise ValueError(f"Axes '{ax}' has unknown _type='{getattr(ax, '_type', None)}'.")

{jarvisplot-1.4.0/jarvisplot/cards/a4paper/4x1 → jarvisplot-1.4.2/jarvisplot/cards/a4paper/2x1}/rect.json

@@ -86,6 +86,10 @@
                     "loc": "top",
                     "fontsize": 12,
                     "fontfamily": "STIXGeneral"
+                },
+                "ylabel_coords": {
+                    "x": -0.1,
+                    "y": 0.5
                 }
             }
         },

{jarvisplot-1.4.0/jarvisplot/cards/gambit → jarvisplot-1.4.2/jarvisplot/cards/a4paper}/2x1/ternary.json

@@ -124,6 +124,9 @@
                     "va":"center"
                 }
             }
+        },
+        "axlogo": {
+            "file": "&JP/jarvisplot/cards/icons/jarvisHEP.png"
         }
     },
     "Style": {

{jarvisplot-1.4.0/jarvisplot/cards/a4paper/4x1 → jarvisplot-1.4.2/jarvisplot/cards/gambit/2x1}/ternary.json

@@ -124,6 +124,23 @@
                     "va":"center"
                 }
             }
+        },
+        "axlogo": {
+            "file": "&JP/jarvisplot/cards/icons/gambit_small.png",
+            "text": [
+                {
+                    "x": 0.0,
+                    "y": -0.5,
+                    "s": "GAMBIT 2.7",
+                    "ha": "left",
+                    "va": "bottom",
+                    "color": "black",
+                    "fontfamily": "Fira code",
+                    "fontsize": 5.0,
+                    "fontstyle": "normal",
+                    "fontweight": "normal"
+                }
+            ]
         }
     },
     "Style": {

{jarvisplot-1.4.0 → jarvisplot-1.4.2}/jarvisplot/flowchart.py

@@ -276,13 +276,20 @@ class FlowchartRenderer:
         from shapely.geometry import Point, box
         from shapely.ops import unary_union
         x, y = item["pos"] 
-        circle1 = Point(x-0.15, y).buffer(0.15, resolution=128)
-        circle2 = Point(x+0.15, y).buffer(0.15, resolution=128)
+
+        def point_buffer(point, radius, segments=128):
+            try:
+                return point.buffer(radius, quad_segs=segments)
+            except TypeError:
+                return point.buffer(radius, resolution=segments)
+
+        circle1 = point_buffer(Point(x-0.15, y), 0.15)
+        circle2 = point_buffer(Point(x+0.15, y), 0.15)
         square = box(x - 0.15, y - 0.15, x + 0.15, y + 0.15)
         merged = unary_union([circle1, circle2, square])
         xx, yy = merged.exterior.xy
         ax.fill(xx, yy, alpha=0.95, edgecolor="#F9F9F8", facecolor="#00D86B", linewidth=0.1, zorder=120)
-        circle3 = Point(x-0.15, y).buffer(0.12, resolution=128)
+        circle3 = point_buffer(Point(x-0.15, y), 0.12)
         xx, yy = circle3.exterior.xy
         ax.fill(xx, yy, alpha=0.95, edgecolor="#FFFFFF", facecolor="#F9F9F8", linewidth=0.8, zorder=120)
         import matplotlib.patheffects as pe

{jarvisplot-1.4.0 → jarvisplot-1.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "JarvisPLOT"
-version = "1.4.0"
+version = "1.4.2"
 description = "Jarvis-PLOT: YAML-driven plotting engine"
 readme = "README.md"
 requires-python = ">=3.10"

{jarvisplot-1.4.0 → jarvisplot-1.4.2}/tests/test_figure_contracts.py

@@ -224,6 +224,41 @@ def test_figure_set_alias_removed():
     assert not hasattr(Figure, "set")
 
 
+def test_layer_clip_expr_builds_data_space_clip_path():
+    _, raw_ax = plt.subplots()
+    raw_ax.set_xlim(0.0, 10.0)
+    raw_ax.set_ylim(0.0, 10.0)
+    ax = SimpleNamespace(ax=raw_ax)
+    style = {"clip_expr": "x >= 2 * y", "cmap": "viridis"}
+
+    clip_path = layer_runtime_mod._layer_clip_path_from_style(ax, style)
+
+    assert "clip_expr" not in style
+    assert style["cmap"] == "viridis"
+    assert len(clip_path.vertices) >= 3
+    assert all(px >= 2 * py - 1e-10 for px, py in clip_path.vertices)
+    plt.close(raw_ax.figure)
+
+
+def test_layer_clip_is_temporary_on_adapter_and_raw_axes():
+    raw_ax = SimpleNamespace(_clip_path="raw-original")
+    adapter = SimpleNamespace(ax=raw_ax, _clip_path="adapter-original")
+    clip_path = object()
+    observed = {}
+
+    def draw():
+        observed["adapter"] = adapter._clip_path
+        observed["raw"] = raw_ax._clip_path
+        return "drawn"
+
+    out = layer_runtime_mod._call_with_layer_clip(adapter, clip_path, draw)
+
+    assert out == "drawn"
+    assert observed == {"adapter": clip_path, "raw": clip_path}
+    assert adapter._clip_path == "adapter-original"
+    assert raw_ax._clip_path == "raw-original"
+
+
 def test_colorbar_contract_uses_frame_color_config():
     class DummyColorbarAxis:
         def __init__(self):
@@ -259,6 +294,106 @@ def test_colorbar_contract_uses_frame_color_config():
     assert fig.axc._cb["vmax"] == 10.0
 
 
+def test_colorbar_contract_falls_back_to_layer_cmap_when_frame_omits_cmap():
+    class DummyColorbarAxis:
+        def __init__(self):
+            self._cb = {
+                "cmap": None,
+                "vmin": None,
+                "vmax": None,
+                "norm": None,
+                "levels": None,
+                "used": False,
+            }
+
+    fig = SimpleNamespace(
+        axes={"axc": DummyColorbarAxis()},
+        frame={"axc": {"color": {"scale": "linear"}}},
+        logger=_logger(),
+    )
+
+    out = collect_and_attach_colorbar(
+        fig,
+        style={"cmap": "jarvis_rainbow2_r"},
+        coor={"z": {"expr": "z"}},
+        method_key="voronoi",
+        df=pd.DataFrame({"z": [1, 2, 5]}),
+    )
+
+    assert out["cmap"] == "jarvis_rainbow2_r"
+    assert fig.axes["axc"]._cb["cmap"] == "jarvis_rainbow2_r"
+
+
+def test_prescan_colorbar_uses_layer_cmap_when_frame_omits_cmap():
+    class DummyColorbarAxis:
+        def __init__(self):
+            self._cb = {
+                "cmap": None,
+                "vmin": None,
+                "vmax": None,
+                "norm": None,
+                "levels": None,
+                "used": False,
+            }
+
+    fig = Figure()
+    fig.logger = _logger()
+    fig.frame = {"axc": {"color": {"scale": "linear"}}}
+    fig.axes = {"axc": DummyColorbarAxis()}
+    layer = {
+        "name": "colored_voronoi",
+        "method": "voronoi",
+        "style": {"cmap": "jarvis_rainbow2_r"},
+        "coor": {"z": {"expr": "z"}},
+        "colorbar": "axc",
+        "data": pd.DataFrame({"z": [1, 2, 5]}),
+        "data_loaded": True,
+        "layer_spec": {},
+        "source_refs": [],
+        "share_name": None,
+    }
+    fig._render_queue = [(None, layer)]
+
+    fig._prescan_colorbar_ranges()
+
+    assert fig.axes["axc"]._cb["cmap"] == "jarvis_rainbow2_r"
+
+
+def test_prescan_colorbar_frame_cmap_overrides_layer_cmap():
+    class DummyColorbarAxis:
+        def __init__(self):
+            self._cb = {
+                "cmap": None,
+                "vmin": None,
+                "vmax": None,
+                "norm": None,
+                "levels": None,
+                "used": False,
+            }
+
+    fig = Figure()
+    fig.logger = _logger()
+    fig.frame = {"axc": {"color": {"scale": "linear", "cmap": "viridis"}}}
+    fig.axes = {"axc": DummyColorbarAxis()}
+    layer = {
+        "name": "colored_voronoi",
+        "method": "voronoi",
+        "style": {"cmap": "jarvis_rainbow2_r"},
+        "coor": {"z": {"expr": "z"}},
+        "colorbar": "axc",
+        "data": pd.DataFrame({"z": [1, 2, 5]}),
+        "data_loaded": True,
+        "layer_spec": {},
+        "source_refs": [],
+        "share_name": None,
+    }
+    fig._render_queue = [(None, layer)]
+
+    fig._prescan_colorbar_ranges()
+
+    assert fig.axes["axc"]._cb["cmap"] == "viridis"
+
+
 def test_colorbar_attachment_skips_plain_scatter_without_color_channel():
     class DummyColorbarAxis:
         def __init__(self):