arrayview 0.26.3__py3-none-any.whl → 0.27.2__py3-none-any.whl

arrayview/_analysis.py

@@ -67,7 +67,7 @@ def _safe_float(v) -> float | None:
     return f if np.isfinite(f) else None
 
 
-def _histogram_payload(finite: np.ndarray, bins: int) -> dict:
+def _histogram_payload(finite: np.ndarray, bins: int, log_bins: bool = False) -> dict:
     """Build a histogram response from finite values."""
     if finite.size == 0:
         return {"counts": [], "edges": [], "vmin": 0.0, "vmax": 1.0}
@@ -81,7 +81,13 @@ def _histogram_payload(finite: np.ndarray, bins: int) -> dict:
             "vmax": vmax,
         }
     bins = max(8, min(int(bins), 512))
-    counts, edges = np.histogram(finite, bins=bins)
+    if log_bins and vmin > 0:
+        log_data = np.log10(finite)
+        _, log_edges = np.histogram(log_data, bins=bins)
+        edges = np.power(10.0, log_edges)
+        counts, _ = np.histogram(finite, bins=edges)
+    else:
+        counts, edges = np.histogram(finite, bins=bins)
     return {
         "counts": counts.tolist(),
         "edges": [float(e) for e in edges],
@@ -113,7 +119,8 @@ def _slice_histogram(
     data = apply_complex_mode(raw, complex_mode)
     finite = data.ravel()
     finite = finite[np.isfinite(finite)]
-    return _histogram_payload(finite, bins)
+    log_bins = qmri_role in ("t1", "t2")
+    return _histogram_payload(finite, bins, log_bins=log_bins)
 
 
 def _parse_fixed_indices(fixed_indices: str) -> dict[int, int]:
@@ -172,6 +179,7 @@ def _volume_histogram(
         session, dim_x, dim_y, scroll_dim, scroll_dims
     )
 
+    log_bins = qmri_role in ("t1", "t2")
     cache_key = (
         dim_x,
         dim_y,
@@ -179,6 +187,8 @@ def _volume_histogram(
         tuple(sorted(fixed.items())),
         complex_mode,
         qmri_role,
+        bins,
+        log_bins,
     )
     if not hasattr(session, "_volume_hist_cache"):
         session._volume_hist_cache = {}
@@ -224,7 +234,7 @@ def _volume_histogram(
             pixels.append(finite)
 
     if pixels:
-        result = _histogram_payload(np.concatenate(pixels), bins)
+        result = _histogram_payload(np.concatenate(pixels), bins, log_bins=log_bins)
     else:
         result = {"counts": [], "edges": [], "vmin": 0.0, "vmax": 1.0}
     session._volume_hist_cache[cache_key] = {
@@ -241,14 +251,19 @@ def _lebesgue_slice(
     indices,
     complex_mode: int = 0,
     log_scale: bool = False,
+    qmri_role: str = "",
 ) -> np.ndarray:
     """Return float32 slice data for Lebesgue mode."""
+    from arrayview._synthetic_mri import normalize_relaxation_ms
+
     idx_tuple = (
         tuple(int(v) for v in indices.split(","))
         if isinstance(indices, str)
         else tuple(indices)
     )
     raw = extract_slice(session, dim_x, dim_y, list(idx_tuple))
+    if qmri_role:
+        raw = normalize_relaxation_ms(raw, qmri_role)
     data = apply_complex_mode(raw, complex_mode).astype(np.float32)
     if log_scale:
         data = np.log10(np.abs(data) + 1).astype(np.float32)

arrayview/_launcher.py

@@ -1148,6 +1148,7 @@ def _handle_cli_spawned_daemon(
         stdout=subprocess.DEVNULL,
         stderr=subprocess.DEVNULL,
         close_fds=True,
+        start_new_session=(sys.platform != "win32"),
     )
 
     early_webview_opened = False
@@ -1245,7 +1246,7 @@ def _open_cli_spawned_view(
             _print_viewer_location(url)
             _open_browser(
                 url,
-                blocking=False,
+                blocking=(window_mode == "vscode"),
                 force_vscode=(window_mode == "vscode"),
                 title=f"ArrayView: {name}",
                 floating=floating,

arrayview/_platform.py

@@ -419,19 +419,27 @@ def _can_native_window() -> bool:
 
 
 def _native_window_gui() -> str | None:
-    """Return the pywebview GUI backend name to use, or None if unavailable."""
+    """Return the pywebview GUI backend name to use, or None if unavailable.
+
+    On macOS/Windows and Linux we return ``""`` so pywebview uses its own
+    backend auto-detection, which is more robust than forcing a specific
+    backend: it probes each installed binding and falls back across them.
+    Forcing ``"qt"`` because ``find_spec("qtpy")`` succeeds is a bad probe —
+    qtpy being importable does not mean QtWebEngine can actually initialise
+    (missing libnss/libxkbcommon/QtWebEngineProcess is common on Linux), and
+    a failed forced backend hangs for ~10s before the watchdog falls back to a
+    browser. Letting pywebview pick avoids that. We still require a display
+    server on Linux and the webview package itself everywhere.
+    """
     if importlib.util.find_spec("webview") is None:
         return None
     if sys.platform in ("darwin", "win32"):
         return ""
-    # Linux/BSD: need a display server AND pywebview's GUI bindings.
+    # Linux/BSD: need a display server. pywebview probes Qt/GTK/Tk backends
+    # itself, so we don't pin one — we only confirm a display is reachable.
     if not (os.environ.get("DISPLAY") or os.environ.get("WAYLAND_DISPLAY")):
         return None
-    if importlib.util.find_spec("qtpy") is not None:
-        return "qt"
-    if importlib.util.find_spec("gi") is not None:
-        return "gtk"
-    return None
+    return ""
 
 
 # ---------------------------------------------------------------------------

arrayview/_routes_analysis.py

@@ -1,3 +1,5 @@
+import base64
+import io
 import itertools
 import math
 
@@ -250,11 +252,24 @@ def register_analysis_routes(app, get_session_or_404) -> None:
         py: int,
         tolerance: float = 0.1,
         complex_mode: int = 0,
+        scope_dim: int | None = None,
         session=Depends(get_session_or_404),
     ):
         if session.rgb_axis is not None:
             return {"error": "not supported for RGB sessions"}
         idx_tuple = tuple(int(v) for v in indices.split(","))
+        if scope_dim is not None:
+            return _scoped_floodfill_response(
+                session,
+                dim_x,
+                dim_y,
+                list(idx_tuple),
+                px,
+                py,
+                tolerance,
+                complex_mode,
+                scope_dim,
+            )
         raw = extract_slice(session, dim_x, dim_y, list(idx_tuple))
         data = apply_complex_mode(raw, complex_mode)
         h, w = data.shape
@@ -313,6 +328,85 @@ def register_analysis_routes(app, get_session_or_404) -> None:
             "mask_b64": _encode_mask_b64(component, bbox),
         }
 
+    @app.post("/roi_stats/{sid}")
+    def get_roi_stats_structured(
+        sid: str,
+        body: dict = Body(...),
+        session=Depends(get_session_or_404),
+    ):
+        if session.rgb_axis is not None:
+            return {"error": "not supported for RGB sessions"}
+        dim_x = int(body.get("dim_x", 1 if session.data.ndim > 1 else 0))
+        dim_y = int(body.get("dim_y", 0))
+        indices = _roi_indices_from_body(body, session.data.ndim, session.shape)
+        complex_mode = int(body.get("complex_mode", 0))
+        rois = body.get("rois", [])
+        if not isinstance(rois, list):
+            return {"error": "rois must be a list"}
+
+        results = []
+        for roi_idx, roi in enumerate(rois):
+            rows = []
+            for idx in _roi_scope_indices(roi, indices, session.shape, {dim_x, dim_y}):
+                raw = extract_slice(session, dim_x, dim_y, idx)
+                data = apply_complex_mode(raw, complex_mode)
+                mask = _roi_mask_for_shape(roi, data.shape, idx)
+                finite = _roi_finite_values(data, mask)
+                if finite.size:
+                    rows.append(
+                        {
+                            "indices": list(idx),
+                            "dims": _roi_scope_dims_string(idx, indices, {dim_x, dim_y}),
+                            "min": _safe_float(finite.min()),
+                            "max": _safe_float(finite.max()),
+                            "mean": _safe_float(finite.mean()),
+                            "std": _safe_float(finite.std()),
+                            "n": int(finite.size),
+                        }
+                    )
+            combined = _combine_roi_rows(rows)
+            results.append(
+                {
+                    "roi": roi.get("id", roi_idx),
+                    "name": roi.get("name", f"ROI {roi_idx + 1}"),
+                    "shape": roi.get("type", "rect"),
+                    "rows": rows,
+                    "stats": combined,
+                }
+            )
+        return {"results": results}
+
+    @app.post("/roi_mask/{sid}")
+    def export_roi_mask_structured(
+        sid: str,
+        body: dict = Body(...),
+        session=Depends(get_session_or_404),
+    ):
+        if session.rgb_axis is not None:
+            return Response(status_code=400, content="not supported for RGB sessions")
+        dim_x = int(body.get("dim_x", 1 if session.data.ndim > 1 else 0))
+        dim_y = int(body.get("dim_y", 0))
+        indices = _roi_indices_from_body(body, session.data.ndim, session.shape)
+        rois = body.get("rois", [])
+        if not isinstance(rois, list):
+            return Response(status_code=400, content="rois must be a list")
+
+        labels = np.zeros(session.shape, dtype=np.uint16)
+        for roi_idx, roi in enumerate(rois):
+            label = roi_idx + 1
+            for idx in _roi_scope_indices(roi, indices, session.shape, {dim_x, dim_y}):
+                raw = extract_slice(session, dim_x, dim_y, idx)
+                mask = _roi_mask_for_shape(roi, raw.shape, idx)
+                _write_roi_mask(labels, mask, idx, dim_x, dim_y, label)
+
+        buf = io.BytesIO()
+        np.save(buf, labels)
+        return Response(
+            content=buf.getvalue(),
+            media_type="application/octet-stream",
+            headers={"Content-Disposition": "attachment; filename=roi_mask.npy"},
+        )
+
     @app.get("/line_profile/{sid}")
     def get_line_profile(
         sid: str,
@@ -453,9 +547,10 @@ def register_analysis_routes(app, get_session_or_404) -> None:
         indices: str,
         complex_mode: int = 0,
         log_scale: bool = False,
+        qmri_role: str = "",
         session=Depends(get_session_or_404),
     ):
-        data = _lebesgue_slice(session, dim_x, dim_y, indices, complex_mode, log_scale)
+        data = _lebesgue_slice(session, dim_x, dim_y, indices, complex_mode, log_scale, qmri_role)
         return Response(
             content=data.tobytes(),
             media_type="application/octet-stream",
@@ -468,9 +563,353 @@ def register_analysis_routes(app, get_session_or_404) -> None:
 
 
 def _encode_mask_b64(mask: np.ndarray, bbox: dict) -> str:
-    import base64
-
     x0, y0 = bbox["x0"], bbox["y0"]
     x1, y1 = bbox["x1"], bbox["y1"]
     sub = mask[y0 : y1 + 1, x0 : x1 + 1].astype(np.uint8)
     return base64.b64encode(sub.tobytes()).decode("ascii")
+
+
+def _scoped_floodfill_response(
+    session,
+    dim_x: int,
+    dim_y: int,
+    indices: list[int],
+    px: int,
+    py: int,
+    tolerance: float,
+    complex_mode: int,
+    scope_dim: int,
+) -> dict:
+    shape = session.shape
+    if len(indices) < len(shape):
+        indices.extend(s // 2 for s in shape[len(indices) :])
+    indices = [
+        min(max(int(v), 0), shape[i] - 1)
+        for i, v in enumerate(indices[: len(shape)])
+    ]
+    scope_dim = int(scope_dim)
+    if scope_dim in {dim_x, dim_y} or not (0 <= scope_dim < len(shape)):
+        return {"error": "scope_dim must be exactly one non-display dimension"}
+
+    values = list(range(shape[scope_dim]))
+    planes = []
+    for value in values:
+        idx = list(indices)
+        idx[scope_dim] = value
+        planes.append(
+            apply_complex_mode(
+                extract_slice(session, dim_x, dim_y, idx), complex_mode
+            )
+        )
+    volume = np.stack(planes, axis=0)
+    depth, h, w = volume.shape
+    if not (0 <= py < h and 0 <= px < w):
+        return {"error": "seed out of bounds"}
+
+    seed_z = values.index(indices[scope_dim])
+    seed_val = float(volume[seed_z, py, px])
+    abs_tol = tolerance * (
+        np.nanmax(np.abs(volume)) - np.nanmin(np.abs(volume)) + 1e-10
+    )
+    mask = np.abs(volume - seed_val) <= abs_tol
+    component = _connected_component(mask, (seed_z, py, px))
+    roi_values = volume[component]
+    finite = roi_values[np.isfinite(roi_values)]
+
+    slices = []
+    scoped_values = []
+    for z in range(depth):
+        plane_mask = component[z]
+        if not plane_mask.any():
+            continue
+        ys, xs = np.where(plane_mask)
+        bbox = {
+            "x0": int(xs.min()),
+            "y0": int(ys.min()),
+            "x1": int(xs.max()),
+            "y1": int(ys.max()),
+        }
+        scope_value = values[z]
+        scoped_values.append(scope_value)
+        slices.append(
+            {
+                "index": int(scope_value),
+                "bbox": bbox,
+                "mask_b64": _encode_mask_b64(plane_mask, bbox),
+            }
+        )
+
+    roi = {
+        "type": "floodfill",
+        "scope_dim": int(scope_dim),
+        "scope": {
+            "indices": list(indices),
+            "broadcast_dims": [int(scope_dim)],
+            "values": {str(scope_dim): scoped_values},
+        },
+        "slices": slices,
+        # Full 3D component so the frontend can render the grown region in
+        # every multiview pane, not just the plane it was seeded on. Shape
+        # axes are [scope_dim, dim_y, dim_x] (the grow axes); grow_dim_x /
+        # grow_dim_y record which data dims those are.
+        "mask3d_b64": base64.b64encode(component.astype(np.uint8).tobytes()).decode("ascii"),
+        "mask3d_shape": [int(s) for s in component.shape],
+        "grow_dim_x": int(dim_x),
+        "grow_dim_y": int(dim_y),
+    }
+    current_slice = next(
+        (entry for entry in slices if int(entry["index"]) == int(indices[scope_dim])),
+        None,
+    )
+    return {
+        "min": _safe_float(finite.min()) if finite.size else None,
+        "max": _safe_float(finite.max()) if finite.size else None,
+        "mean": _safe_float(finite.mean()) if finite.size else None,
+        "std": _safe_float(finite.std()) if finite.size else None,
+        "n": int(finite.size),
+        "seed_value": _safe_float(seed_val),
+        "tolerance": tolerance,
+        "bbox": current_slice["bbox"] if current_slice else {"x0": 0, "y0": 0, "x1": 0, "y1": 0},
+        "mask_b64": current_slice["mask_b64"] if current_slice else "",
+        "scope": roi["scope"],
+        "slices": slices,
+        "roi": roi,
+    }
+
+
+def _connected_component(mask: np.ndarray, seed: tuple[int, int, int]) -> np.ndarray:
+    try:
+        from scipy.ndimage import label
+
+        labeled, _n_features = label(mask)
+        seed_label = labeled[seed]
+        if seed_label == 0:
+            return np.zeros(mask.shape, dtype=bool)
+        return labeled == seed_label
+    except ImportError:
+        component = np.zeros(mask.shape, dtype=bool)
+        if not mask[seed]:
+            return component
+        stack = [seed]
+        component[seed] = True
+        while stack:
+            cz, cy, cx = stack.pop()
+            for dz, dy, dx in [
+                (-1, 0, 0),
+                (1, 0, 0),
+                (0, -1, 0),
+                (0, 1, 0),
+                (0, 0, -1),
+                (0, 0, 1),
+            ]:
+                nz, ny, nx = cz + dz, cy + dy, cx + dx
+                if (
+                    0 <= nz < mask.shape[0]
+                    and 0 <= ny < mask.shape[1]
+                    and 0 <= nx < mask.shape[2]
+                    and mask[nz, ny, nx]
+                    and not component[nz, ny, nx]
+                ):
+                    component[nz, ny, nx] = True
+                    stack.append((nz, ny, nx))
+        return component
+
+
+def _roi_indices_from_body(body: dict, ndim: int, shape: tuple[int, ...]) -> list[int]:
+    raw = body.get("indices", "")
+    if isinstance(raw, str):
+        vals = [int(v) for v in raw.split(",") if v != ""]
+    else:
+        vals = [int(v) for v in raw]
+    if len(vals) < ndim:
+        vals.extend(s // 2 for s in shape[len(vals) :])
+    return [min(max(v, 0), shape[i] - 1) for i, v in enumerate(vals[:ndim])]
+
+
+def _roi_scope_indices(
+    roi: dict,
+    base_indices: list[int],
+    shape: tuple[int, ...],
+    spatial_dims: set[int],
+):
+    scope = roi.get("scope") or {}
+    fixed = scope.get("indices") or base_indices
+    if isinstance(fixed, str):
+        fixed = [int(v) for v in fixed.split(",") if v != ""]
+    fixed = list(fixed)
+    if len(fixed) < len(shape):
+        fixed.extend(base_indices[len(fixed) :])
+    fixed = [min(max(int(v), 0), shape[i] - 1) for i, v in enumerate(fixed[: len(shape)])]
+
+    raw_dims = scope.get("broadcast_dims", [])
+    broadcast_dims = []
+    for d in raw_dims:
+        d = int(d)
+        if 0 <= d < len(shape) and d not in spatial_dims:
+            broadcast_dims.append(d)
+
+    ranges = scope.get("ranges") or {}
+    values = scope.get("values") or {}
+    choices = []
+    for d in broadcast_dims:
+        key = str(d)
+        if key in values:
+            vals = [int(v) for v in values[key]]
+        elif d in values:
+            vals = [int(v) for v in values[d]]
+        elif key in ranges:
+            lo, hi = ranges[key]
+            vals = list(range(int(lo), int(hi) + 1))
+        elif d in ranges:
+            lo, hi = ranges[d]
+            vals = list(range(int(lo), int(hi) + 1))
+        else:
+            vals = list(range(shape[d]))
+        vals = [v for v in vals if 0 <= v < shape[d]]
+        choices.append((d, vals or [fixed[d]]))
+
+    if not choices:
+        yield fixed
+        return
+    for combo in itertools.product(*(vals for _d, vals in choices)):
+        idx = list(fixed)
+        for (d, _vals), v in zip(choices, combo):
+            idx[d] = v
+        yield idx
+
+
+def _roi_scope_dims_string(idx: list[int], base_idx: list[int], spatial_dims: set[int]) -> str:
+    bits = []
+    for d, val in enumerate(idx):
+        bits.append("1" if d in spatial_dims or val != base_idx[d] else "0")
+    return "".join(bits)
+
+
+def _roi_mask_for_shape(
+    roi: dict, data_shape: tuple[int, int], indices: list[int] | None = None
+) -> np.ndarray:
+    h, w = data_shape
+    roi_type = roi.get("type", "rect")
+    if roi_type == "circle":
+        cx = float(roi.get("cx", 0))
+        cy = float(roi.get("cy", 0))
+        r = max(0.0, float(roi.get("r", 0)))
+        ys, xs = np.ogrid[:h, :w]
+        return (xs - cx) ** 2 + (ys - cy) ** 2 <= r**2
+    if roi_type == "freehand":
+        points = roi.get("points", [])
+        if len(points) < 3:
+            return np.zeros((h, w), dtype=bool)
+        from PIL import Image as _PILImage, ImageDraw as _PILDraw
+
+        mask_img = _PILImage.new("L", (w, h), 0)
+        _PILDraw.Draw(mask_img).polygon([(p[0], p[1]) for p in points], fill=255)
+        return np.array(mask_img) > 0
+    if roi_type == "floodfill":
+        return _floodfill_roi_mask(roi, data_shape, indices)
+
+    x0 = int(round(float(roi.get("x0", 0))))
+    y0 = int(round(float(roi.get("y0", 0))))
+    x1 = int(round(float(roi.get("x1", x0))))
+    y1 = int(round(float(roi.get("y1", y0))))
+    xa = max(0, min(x0, x1, w - 1))
+    xb = min(w, max(x0, x1) + 1)
+    ya = max(0, min(y0, y1, h - 1))
+    yb = min(h, max(y0, y1) + 1)
+    mask = np.zeros((h, w), dtype=bool)
+    if xa < xb and ya < yb:
+        mask[ya:yb, xa:xb] = True
+    return mask
+
+
+def _floodfill_roi_mask(
+    roi: dict, data_shape: tuple[int, int], indices: list[int] | None = None
+) -> np.ndarray:
+    h, w = data_shape
+    mask = np.zeros((h, w), dtype=bool)
+    if indices is not None and roi.get("slices"):
+        scope_dim = roi.get("scope_dim")
+        if scope_dim is None:
+            scope = roi.get("scope") or {}
+            raw_dims = scope.get("broadcast_dims") or []
+            scope_dim = raw_dims[0] if len(raw_dims) == 1 else None
+        if scope_dim is None:
+            return mask
+        scope_dim = int(scope_dim)
+        if not (0 <= scope_dim < len(indices)):
+            return mask
+        target = int(indices[scope_dim])
+        for entry in roi.get("slices") or []:
+            if int(entry.get("index", -1)) == target:
+                roi = entry
+                break
+        else:
+            return mask
+    bbox = roi.get("bbox") or {}
+    encoded = roi.get("mask_b64")
+    if not encoded:
+        return mask
+    try:
+        x0 = int(bbox.get("x0", 0))
+        y0 = int(bbox.get("y0", 0))
+        x1 = int(bbox.get("x1", x0))
+        y1 = int(bbox.get("y1", y0))
+        bw = x1 - x0 + 1
+        bh = y1 - y0 + 1
+        if bw <= 0 or bh <= 0:
+            return mask
+        sub = np.frombuffer(base64.b64decode(encoded), dtype=np.uint8)
+        sub = sub.reshape((bh, bw)).astype(bool)
+    except Exception:
+        return mask
+    xa0, ya0 = max(0, x0), max(0, y0)
+    xa1, ya1 = min(w, x1 + 1), min(h, y1 + 1)
+    if xa0 >= xa1 or ya0 >= ya1:
+        return mask
+    sx0, sy0 = xa0 - x0, ya0 - y0
+    sx1, sy1 = sx0 + (xa1 - xa0), sy0 + (ya1 - ya0)
+    mask[ya0:ya1, xa0:xa1] = sub[sy0:sy1, sx0:sx1]
+    return mask
+
+
+def _roi_finite_values(data: np.ndarray, mask: np.ndarray) -> np.ndarray:
+    if mask.shape != data.shape:
+        return np.array([])
+    roi = data[mask]
+    return roi[np.isfinite(roi)]
+
+
+def _combine_roi_rows(rows: list[dict]) -> dict | None:
+    if not rows:
+        return None
+    n = sum(int(r["n"]) for r in rows)
+    if n <= 0:
+        return None
+    means = np.array([float(r["mean"]) for r in rows], dtype=np.float64)
+    stds = np.array([float(r["std"]) for r in rows], dtype=np.float64)
+    counts = np.array([int(r["n"]) for r in rows], dtype=np.float64)
+    mean = float(np.sum(means * counts) / np.sum(counts))
+    variance = float(np.sum((stds**2 + (means - mean) ** 2) * counts) / np.sum(counts))
+    return {
+        "min": min(r["min"] for r in rows),
+        "max": max(r["max"] for r in rows),
+        "mean": _safe_float(mean),
+        "std": _safe_float(math.sqrt(max(0.0, variance))),
+        "n": int(n),
+    }
+
+
+def _write_roi_mask(
+    labels: np.ndarray,
+    mask_2d: np.ndarray,
+    indices: list[int],
+    dim_x: int,
+    dim_y: int,
+    label: int,
+) -> None:
+    ys, xs = np.nonzero(mask_2d)
+    for y, x in zip(ys, xs):
+        idx = list(indices)
+        idx[dim_y] = int(y)
+        idx[dim_x] = int(x)
+        labels[tuple(idx)] = label

arrayview/_routes_rendering.py

@@ -25,6 +25,7 @@ from arrayview._render import (
 )
 from arrayview._session import HEAVY_OP_LIMIT_BYTES, SESSIONS
 from arrayview._synthetic_mri import (
+    _qmri_adjust_vmin_vmax,
     qmri_display_slice,
     render_qmri_mosaic_rgba,
     synthetic_qmri_slice,
@@ -256,6 +257,8 @@ def register_rendering_routes(app, *, get_session_or_404) -> None:
                     vmin_override=vmin_override,
                     vmax_override=vmax_override,
                 )
+                if qmri_role:
+                    vmin, vmax = _qmri_adjust_vmin_vmax(vmin, vmax, qmri_role)
         render_ms = (time.perf_counter() - render_t0) * 1000.0
         encode_t0 = time.perf_counter()
         img = _pil_image().fromarray(rgba[:, :, :3], mode="RGB")

arrayview/_routes_websocket.py

@@ -31,6 +31,7 @@ from arrayview._session import (
 )
 from arrayview._vectorfield import _compute_vfield_arrows
 from arrayview._synthetic_mri import (
+    _qmri_adjust_vmin_vmax,
     qmri_display_slice,
     render_qmri_mosaic_rgba,
     synthetic_qmri_slice,
@@ -319,6 +320,8 @@ def register_websocket_routes(app) -> None:
                         vmin_override=vmin_override,
                         vmax_override=vmax_override,
                     )
+                    if qmri_role:
+                        vmin, vmax = _qmri_adjust_vmin_vmax(vmin, vmax, qmri_role)
 
                     overlay_sid = msg.get("overlay_sid")
                     overlay_colors = msg.get("overlay_colors")

arrayview/_stdio_server.py

@@ -52,6 +52,7 @@ from arrayview._render import (
 )
 from arrayview._session import SESSIONS, Session
 from arrayview._synthetic_mri import (
+    _qmri_adjust_vmin_vmax,
     qmri_display_slice,
     render_qmri_mosaic_rgba,
     synthetic_qmri_slice,
@@ -290,8 +291,9 @@ def _handle_lebesgue(sid: str, params: dict[str, str]) -> None:
     indices_str = params.get("indices", "")
     complex_mode = int(params.get("complex_mode", "0"))
     log_scale = params.get("log_scale", "false").lower() == "true"
+    qmri_role = params.get("qmri_role", "")
 
-    data = _lebesgue_slice(session, dim_x, dim_y, indices_str, complex_mode, log_scale)
+    data = _lebesgue_slice(session, dim_x, dim_y, indices_str, complex_mode, log_scale, qmri_role)
     import base64
     _write_json({
         "_binary": True,
@@ -637,6 +639,8 @@ def _build_slice_payload(msg: dict) -> bytes:
             session, raw, complex_mode, dr, log_scale,
             vmin_override=vmin_override, vmax_override=vmax_override,
         )
+        if qmri_role:
+            vmin, vmax = _qmri_adjust_vmin_vmax(vmin, vmax, qmri_role)
 
         # Overlay compositing
         overlay_sid = msg.get("overlay_sid")