arrayview 0.48.3__py3-none-any.whl → 0.48.4__py3-none-any.whl

arrayview/_diff.py

@@ -85,6 +85,43 @@ def _resize_normalized_like(source: np.ndarray, target: np.ndarray) -> np.ndarra
     return np.array(image, dtype=np.float32) / 255.0
 
 
+def _render_values(session, dim_x, dim_y, idx_tuple, complex_mode, log_scale):
+    """Extract a slice in the array's own units (complex/log applied, no rescale)."""
+    raw = extract_slice(session, dim_x, dim_y, list(idx_tuple))
+    data = apply_complex_mode(raw, complex_mode)
+    if log_scale:
+        data = np.log1p(np.abs(data))
+    return np.asarray(data, dtype=np.float32)
+
+
+def _render_values_mosaic(session, dim_x, dim_y, dim_z, idx_tuple, complex_mode, log_scale):
+    """Mosaic of every dim_z slice in the array's own units, plus separator mask."""
+    idx_list = list(idx_tuple)
+    frames = [
+        _render_values(
+            session,
+            dim_x,
+            dim_y,
+            [i if j == dim_z else idx_list[j] for j in range(len(session.shape))],
+            complex_mode,
+            log_scale,
+        )
+        for i in range(session.shape[dim_z])
+    ]
+    all_data = np.stack(frames)
+    grid, _, _ = _build_mosaic_grid(all_data, len(frames))
+    return grid.astype(np.float32), np.isnan(grid)
+
+
+def _resize_values_like(source: np.ndarray, target: np.ndarray) -> np.ndarray:
+    """Resize float source data to target shape without quantising it."""
+    if source.shape == target.shape:
+        return source
+    image = _pil_image().fromarray(np.nan_to_num(source).astype(np.float32), mode="F")
+    image = image.resize((target.shape[1], target.shape[0]), _pil_image().BILINEAR)
+    return np.array(image, dtype=np.float32)
+
+
 def _compute_diff(
     session_a,
     session_b,
@@ -114,65 +151,41 @@ def _compute_diff(
     idx_b = _parse_indices(indices_b)[:ndim_b] if indices_b is not None else idx_tuple[:ndim_b]
     nan_mask = None
 
+    # True A−B in the arrays' own units. Each side used to be rescaled to its
+    # own per-slice display range first, which cancelled real differences
+    # (B = 0.9·A showed as zero) and made the map flicker while scrolling.
     if dim_z >= 0:
-        a, nan_mask_a = _render_normalized_mosaic(
-            session_a,
-            dim_x,
-            dim_y,
-            dim_z,
-            idx_a,
-            dr,
-            complex_mode,
-            log_scale,
+        a, nan_mask_a = _render_values_mosaic(
+            session_a, dim_x, dim_y, dim_z, idx_a, complex_mode, log_scale
         )
-        b, nan_mask_b = _render_normalized_mosaic(
-            session_b,
-            dim_x,
-            dim_y,
-            dim_z,
-            idx_b,
-            dr,
-            complex_mode,
-            log_scale,
+        b, nan_mask_b = _render_values_mosaic(
+            session_b, dim_x, dim_y, dim_z, idx_b, complex_mode, log_scale
         )
-        nan_mask = nan_mask_a | nan_mask_b
+        b = _resize_values_like(b, a)
+        if nan_mask_b.shape == nan_mask_a.shape:
+            nan_mask = nan_mask_a | nan_mask_b
+        else:
+            nan_mask = nan_mask_a
     else:
-        a = _render_normalized(
-            session_a,
-            dim_x,
-            dim_y,
-            idx_a,
-            dr,
-            complex_mode,
-            log_scale,
-        )
-        b = _render_normalized(
-            session_b,
-            dim_x,
-            dim_y,
-            idx_b,
-            dr,
-            complex_mode,
-            log_scale,
-        )
-
-    b = _resize_normalized_like(b, a)
+        a = _render_values(session_a, dim_x, dim_y, idx_a, complex_mode, log_scale)
+        b = _render_values(session_b, dim_x, dim_y, idx_b, complex_mode, log_scale)
+        b = _resize_values_like(b, a)
     if diff_mode == 1:
         raw = a - b
         lo = float(np.nanpercentile(raw, 1))
         hi = float(np.nanpercentile(raw, 99))
         vmax = max(abs(lo), abs(hi)) or 1.0
         vmin = -vmax
-        colormap = "RdBu_r"
+        colormap = "icefire"
     elif diff_mode == 2:
         raw = np.abs(a - b)
-        vmax = float(raw.max()) or 1.0
+        vmax = float(np.nanmax(raw)) or 1.0
         vmin = 0.0
         colormap = "afmhot"
     else:
         raw = np.abs(a - b) / np.maximum(np.abs(a), 1e-6)
         raw = np.clip(raw, 0.0, 2.0).astype(np.float32)
-        vmax = float(raw.max()) or 1.0
+        vmax = float(np.nanmax(raw)) or 1.0
         vmin = 0.0
         colormap = "afmhot"
 
@@ -188,7 +201,7 @@ def _render_diff_rgba(
 ) -> np.ndarray:
     """Map raw diff data to RGBA."""
     if vmax > vmin:
-        normalized = np.clip((raw - vmin) / (vmax - vmin), 0, 1)
+        normalized = np.clip(np.nan_to_num((raw - vmin) / (vmax - vmin)), 0, 1)
     else:
         normalized = np.zeros_like(raw)
     _ensure_lut(colormap)
@@ -201,9 +214,12 @@ def _render_diff_rgba(
 
 def _diff_histogram(raw: np.ndarray, bins: int) -> dict[str, object]:
     """Return histogram payload for raw diff data."""
+    raw = raw[np.isfinite(raw)]
+    if raw.size == 0:
+        raw = np.zeros(1, dtype=np.float32)
     vmin = float(raw.min())
     vmax = float(raw.max())
-    counts, edges = np.histogram(raw.ravel(), bins=bins)
+    counts, edges = np.histogram(raw, bins=bins)
     return {
         "counts": counts.tolist(),
         "edges": edges.tolist(),

arrayview/_render.py

@@ -34,6 +34,43 @@ _mpl_colormaps = None
 _luts_lock = threading.Lock()
 
 
+_ICEFIRE_STOPS = [
+    (0.7394, 0.9044, 0.8576),
+    (0.6645, 0.8497, 0.8387),
+    (0.5749, 0.7908, 0.8202),
+    (0.4818, 0.734, 0.8084),
+    (0.3863, 0.6778, 0.8043),
+    (0.3052, 0.6184, 0.8053),
+    (0.2418, 0.5555, 0.8106),
+    (0.2141, 0.4873, 0.8157),
+    (0.2487, 0.4134, 0.7887),
+    (0.2831, 0.3444, 0.715),
+    (0.2846, 0.2908, 0.6028),
+    (0.2577, 0.2497, 0.4821),
+    (0.2205, 0.2121, 0.3737),
+    (0.182, 0.1769, 0.2809),
+    (0.1492, 0.1465, 0.2053),
+    (0.1276, 0.1254, 0.1501),
+    (0.1213, 0.1183, 0.1188),
+    (0.1538, 0.1167, 0.1227),
+    (0.2063, 0.1255, 0.1416),
+    (0.2734, 0.1407, 0.1703),
+    (0.3514, 0.157, 0.2039),
+    (0.4375, 0.1703, 0.2357),
+    (0.5298, 0.1784, 0.2601),
+    (0.6251, 0.1832, 0.2686),
+    (0.7138, 0.2028, 0.2533),
+    (0.7898, 0.2469, 0.2268),
+    (0.85, 0.3142, 0.2058),
+    (0.8971, 0.3932, 0.2012),
+    (0.9279, 0.482, 0.2415),
+    (0.9479, 0.5722, 0.3318),
+    (0.9659, 0.659, 0.4438),
+    (0.9829, 0.7447, 0.5597),
+    (0.9992, 0.831, 0.6764),
+]
+
+
 def _init_luts():
     """Build colourmap LUTs on first use (defers matplotlib + qmricolors import)."""
     global _mpl_colormaps
@@ -46,6 +83,12 @@ def _init_luts():
         from matplotlib import colormaps
         from matplotlib.colors import LinearSegmentedColormap
 
+        if "icefire" not in colormaps:
+            # seaborn's icefire (blue → near-black → red), sampled at 33 stops so
+            # we don't depend on seaborn. Default for the A−B compare center.
+            colormaps.register(
+                LinearSegmentedColormap.from_list("icefire", _ICEFIRE_STOPS)
+            )
         _mpl_colormaps = colormaps
         for name in COLORMAPS:
             lut = np.concatenate(
@@ -210,6 +253,12 @@ def _read_slice(session, dim_x, dim_y, idx_list, progress):
     if progress is None:
         progress = getattr(session, 'progress_sink', None)
     data = session.data
+    if not getattr(session, "_ram_upgrade_started", False):
+        # Not every loading route asks for this (compare arrays, for one), and
+        # without it a scattered plane is re-read from the file on every step.
+        from ._session import upgrade_memmap_in_background
+
+        upgrade_memmap_in_background(session)
     if isinstance(data, np.memmap) and data.filename:
         # A slice scattered one element per page reads far faster as many
         # parallel small reads than by faulting through the map (local disks).

arrayview/_routes_rendering.py

@@ -441,6 +441,54 @@ def register_rendering_routes(app, *, get_session_or_404) -> None:
             return Response(status_code=422)
         return _diff_histogram(raw, bins)
 
+    @app.get("/diff-values/{sid_a}/{sid_b}")
+    def get_diff_values(
+        sid_a: str,
+        sid_b: str,
+        dim_x: int,
+        dim_y: int,
+        indices: str,
+        indices_a: str | None = None,
+        indices_b: str | None = None,
+        dim_z: int = -1,
+        dr: int = 1,
+        complex_mode: int = 0,
+        log_scale: bool = False,
+        diff_mode: int = 1,
+    ):
+        """Raw float32 diff values, so hovering a histogram bin can highlight pixels."""
+        session_a = SESSIONS.get(sid_a)
+        session_b = SESSIONS.get(sid_b)
+        if not session_a or not session_b:
+            return Response(status_code=404)
+        try:
+            raw, _, _, _, _ = _compute_diff(
+                session_a,
+                session_b,
+                dim_x,
+                dim_y,
+                indices,
+                dim_z,
+                dr,
+                complex_mode,
+                log_scale,
+                diff_mode,
+                indices_a=indices_a,
+                indices_b=indices_b,
+            )
+        except Exception:
+            return Response(status_code=422)
+        raw = np.ascontiguousarray(raw, dtype=np.float32)
+        return Response(
+            content=raw.tobytes(),
+            media_type="application/octet-stream",
+            headers={
+                "X-ArrayView-Width": str(raw.shape[1]),
+                "X-ArrayView-Height": str(raw.shape[0]),
+                "Cache-Control": "no-cache",
+            },
+        )
+
     @app.get("/oblique/{sid}")
     def get_oblique(
         sid: str,

arrayview/_routes_websocket.py

@@ -50,6 +50,47 @@ _RECOVERABLE_DISCONNECT_GRACE_SECONDS = float(
 )
 
 
+# Leading word of a compressed frame: b"AVZ1" read as a little-endian uint32.
+# A raw frame starts with its sequence number, which never gets this large.
+_FRAME_Z_MAGIC = b"AVZ1"
+# Below this a frame crosses any link quickly enough as it is.
+_FRAME_Z_MIN_BYTES = 32 * 1024
+_frame_z_remote = None
+
+
+def _frame_compression_wanted() -> bool:
+    """True when frames should be deflated before they are sent.
+
+    Over a VS Code tunnel or Remote-SSH forward every frame crosses the network
+    as raw RGBA: three compared 224x224 slices are 600 KB per scroll step, and
+    that transfer, not rendering, is the lag. Locally the bytes are free, so
+    frames stay raw. ``ARRAYVIEW_FRAME_COMPRESS=1``/``0`` forces either way.
+    """
+    global _frame_z_remote
+    forced = os.environ.get("ARRAYVIEW_FRAME_COMPRESS")
+    if forced in ("0", "1"):
+        return forced == "1"
+    if _frame_z_remote is None:
+        try:
+            from arrayview._platform import _is_vscode_remote
+
+            _frame_z_remote = bool(_is_vscode_remote())
+        except Exception:
+            _frame_z_remote = False
+    return _frame_z_remote
+
+
+def _pack_frame(payload: bytes) -> bytes:
+    """Deflate *payload* behind the magic word, or return it unchanged when
+    that does not save at least a third (noise-like images barely shrink)."""
+    import zlib
+
+    packed = zlib.compress(payload, 1)
+    if len(packed) * 3 > len(payload) * 2:
+        return payload
+    return _FRAME_Z_MAGIC + packed
+
+
 def _advance_viewer_epoch(sid: str) -> int:
     epoch = _session_mod.VIEWER_CONNECTION_EPOCHS.get(sid, 0) + 1
     _session_mod.VIEWER_CONNECTION_EPOCHS[sid] = epoch
@@ -368,6 +409,10 @@ def register_websocket_routes(app) -> None:
         native_request_id = ws.query_params.get("native_request_id")
         launch_request_id = ws.query_params.get("launch_request_id")
         launch_token = ws.query_params.get("launch_token")
+        # Only viewers that can inflate frames ask for them packed.
+        compress_frames = (
+            ws.query_params.get("frame_z") == "1" and _frame_compression_wanted()
+        )
         # Answer the handshake before the array is ready.  Holding it closed
         # until the load finished made the viewer decide the backend was dead:
         # it gives up after three attempts and shows "could not connect", which
@@ -752,6 +797,9 @@ def register_websocket_routes(app) -> None:
                         ).tobytes()
                         vf_scale = np.array([vf_result["scale"]], dtype=np.float32).tobytes()
                         payload += vf_hdr + vf_scale + arrows.tobytes()
+                if compress_frames and len(payload) >= _FRAME_Z_MIN_BYTES:
+                    raw_payload = payload
+                    payload = await _render(loop, lambda: _pack_frame(raw_payload))
                 await ws.send_bytes(payload)
                 if perf:
                     total_ms = (time.perf_counter() - total_t0) * 1000.0

arrayview/_session.py

@@ -870,6 +870,9 @@ def upgrade_memmap_in_background(session) -> bool:
     identical, so a render already holding the lazy array stays correct and the
     slice caches stay valid.
     """
+    if getattr(session, "_ram_upgrade_started", False):
+        return False
+    session._ram_upgrade_started = True
     data = getattr(session, "data", None)
     filepath = getattr(session, "filepath", None)
     if data is None or not filepath:

arrayview/_viewer.html

@@ -81,6 +81,9 @@
                         + 'launch_request_id=' + encodeURIComponent(requestId)
                         + '&launch_token=' + encodeURIComponent(token);
                 }
+                if (typeof DecompressionStream === 'function') {
+                    target += (target.indexOf('?') >= 0 ? '&' : '?') + 'frame_z=1';
+                }
                 var proto = location.protocol === 'https:' ? 'wss:' : 'ws:';
                 var url = proto + '//' + location.host + target;
                 var early = { url: url, ws: new WebSocket(url), opened: false, events: [] };
@@ -2130,15 +2133,19 @@
         .drop-action-reason { display: block; margin-top: 2px; font-size: 9px; color: var(--muted); }
         #compare-with-menu {
             display: none; position: fixed; z-index: 70; left: 50%; top: 50%;
-            transform: translate(-50%, -50%); width: min(340px, calc(100vw - 24px));
+            transform: translate(-50%, -50%); width: min(560px, calc(100vw - 24px));
             max-height: calc(100vh - 48px); overflow-y: auto;
             padding: 8px; background: var(--surface); border: 1px solid var(--border);
-            border-radius: var(--radius-lg); color: var(--text); font: 11px var(--mono);
+            border-radius: var(--radius-lg); color: var(--text); font: 9px var(--mono);
             backdrop-filter: var(--blur); -webkit-backdrop-filter: var(--blur);
         }
         #compare-with-menu.visible { display: block; }
         #compare-with-title { padding: 4px 6px 2px; }
-        #compare-with-summary { color: var(--muted); padding: 0 6px 7px; font-size: 10px; }
+        #compare-with-summary { color: var(--muted); padding: 0 6px 7px; font-size: 9px; }
+        #compare-with-title { font-size: 10px; }
+        #compare-with-list { font-size: 10px; }
+        .compare-with-path { word-break: break-all; }
+        #compare-with-list .drop-action-reason { font-size: 8px; }
         .compare-with-key { color: var(--muted); margin-right: 8px; }
         .mode-badge {
             display: inline-block; font-size: 0.62em; font-weight: 600;
@@ -6359,6 +6366,41 @@
             return ws;
         }
 
+        const _FRAME_Z_SUPPORTED = typeof DecompressionStream === 'function';
+        const _FRAME_Z_MAGIC = 0x315A5641;  // "AVZ1" read little-endian
+
+        function _inflateFrame(buf) {
+            const body = new Blob([new Uint8Array(buf, 4)]).stream()
+                .pipeThrough(new DecompressionStream('deflate'));
+            return new Response(body).arrayBuffer();
+        }
+
+        /**
+         * Wrap a socket message handler so deflated frames arrive as the raw
+         * frames every handler expects. Inflating is asynchronous, so while
+         * one is in flight later messages queue behind it and keep their
+         * order; with none pending a message is handed over synchronously.
+         */
+        function _inflatingMessageHandler(handler) {
+            let pending = null;
+            return function (event) {
+                const data = event.data;
+                const packed = data instanceof ArrayBuffer && data.byteLength >= 8
+                    && new Uint32Array(data, 0, 1)[0] === _FRAME_Z_MAGIC;
+                if (!packed && !pending) { handler.call(this, event); return; }
+                const self = this;
+                const ready = packed ? _inflateFrame(data) : null;
+                const step = (pending || Promise.resolve())
+                    .then(() => ready)
+                    .then(raw => {
+                        handler.call(self, raw ? new MessageEvent('message', { data: raw }) : event);
+                    })
+                    .catch(err => console.error('frame inflate failed', err));
+                pending = step;
+                step.then(() => { if (pending === step) pending = null; });
+            };
+        }
+
         function createTransport(transportSid, onMessage, onOpen, onClose, onError, adoptEarly = false) {
             let wsTarget = resolveServerPath(`/ws/${transportSid}`);
             const nativeRequestId = urlParams.get('native_request_id');
@@ -6376,6 +6418,12 @@
                 wsTarget += `${separator}launch_request_id=${encodeURIComponent(launchRequestId)}`;
                 wsTarget += `&launch_token=${encodeURIComponent(launchToken)}`;
             }
+            // Ask for frames deflated; the server only does so over a remote
+            // link. Must stay last so the URL matches the early socket's.
+            if (_FRAME_Z_SUPPORTED) {
+                const separator = wsTarget.includes('?') ? '&' : '?';
+                wsTarget += `${separator}frame_z=1`;
+            }
             const socketUrl = () => {
                 if (_embeddedServerOrigin) {
                     const wsUrl = new URL(wsTarget);
@@ -6393,7 +6441,7 @@
             const ws = early || (hedged ? _createHedgedWebSocket(makeSocket) : makeSocket());
             ws.binaryType = 'arraybuffer';
             if (onOpen) ws.onopen = onOpen;
-            if (onMessage) ws.onmessage = onMessage;
+            if (onMessage) ws.onmessage = _inflatingMessageHandler(onMessage);
             if (onClose) ws.onclose = onClose;
             if (onError) ws.onerror = onError;
             return ws;
@@ -7487,7 +7535,12 @@
         let _diffAutoRangeKey = null;
         let _diffCenterColormap = ''; // override colormap for diff/center pane; '' = server default
         let _diffCenterColormapStops = null; // gradient stops for center pane colorbar
-        const DIFF_COLORMAPS = ['RdBu_r', 'coolwarm', 'bwr', 'seismic', 'PiYG', 'PRGn', 'BrBG', 'PuOr', 'RdYlBu_r', 'RdYlGn', 'twilight_shifted'];
+        const DIFF_COLORMAPS = ['icefire', 'RdBu_r', 'coolwarm', 'bwr', 'seismic', 'PiYG', 'PRGn', 'BrBG', 'PuOr', 'RdYlBu_r', 'RdYlGn', 'twilight_shifted'];
+        // A−B default follows the theme: icefire's dark centre blends into the
+        // dark viewport (masked voxels stay dark); light theme keeps RdBu_r.
+        function _diffDefaultColormap() {
+            return diffMode === 1 ? (isDark ? 'icefire' : 'RdBu_r') : 'afmhot';
+        }
         const ABS_DIFF_COLORMAPS = ['afmhot', 'hot', 'inferno', 'magma', 'plasma', 'viridis', 'gray', 'cividis'];
         let _mouseOverCenterPane = false; // true when mouse hovers diff or wipe pane
         let compareFrames = [];
@@ -10295,6 +10348,7 @@
                         });
                     },
                     fetchHistogram: () => _fetchHistogramCompare(),
+                    getHistogramVersion: () => _compareHistogramVersion(),
                     onWindowChange: () => { compareRender(); },
                 }));
             }
@@ -10356,13 +10410,18 @@
                     hoverValueInEggs: true,
                     hoverValueAnchor: () => modeManager.getViewById('compare-diff-center')?.canvas
                         || document.getElementById('compare-diff-pane'),
-                    getStops: () => _diffCenterColormapStops || COLORMAP_GRADIENT_STOPS[diffMode === 1 ? 'RdBu_r' : 'afmhot'] || COLORMAP_GRADIENT_STOPS['gray'] || [],
+                    getStops: () => _diffCenterColormapStops || COLORMAP_GRADIENT_STOPS[_diffDefaultColormap()] || COLORMAP_GRADIENT_STOPS['gray'] || [],
                     getRange: () => ({ vmin: _lastDiffVmin, vmax: _lastDiffVmax }),
                     getWindow: () => ({ vmin: _diffManualVmin ?? _lastDiffVmin, vmax: _diffManualVmax ?? _lastDiffVmax }),
                     setWindow: (lo, hi) => { _diffManualVmin = lo; _diffManualVmax = hi; { const _dv = modeManager.getViewById('compare-diff-center'); if (_dv) { _dv.displayState.vmin = _diffManualVmin; _dv.displayState.vmax = _diffManualVmax; } } },
                     fetchHistogram: () => _fetchDiffHistogram(),
                     getHistogramVersion: () => _diffHistogramVersion(),
                     onWindowChange: () => { fetchAndDrawDiff(); },
+                    onMouseEnter: () => { _colorbarLebesgueHover = true; },
+                    onMouseLeave: () => { _stopColorbarLebesgueHover(); },
+                    onDragStart: () => { _stopColorbarLebesgueHover(); },
+                    onDragEnd: () => { if (_diffCenterCb?._mouseOver) _colorbarLebesgueHover = true; },
+                    onBinHover: (binIdx) => { _drawLebesgueHighlightForColorbar(_diffCenterCb, binIdx); },
                 });
             }
         }
@@ -14049,7 +14108,7 @@
             getWindow: () => ({ vmin: manualVmin ?? currentVmin, vmax: manualVmax ?? currentVmax }),
             setWindow: (lo, hi) => { manualVmin = lo; manualVmax = hi; { const _dv = modeManager.getFocusedView() || modeManager.currentViews[0]; if (_dv) { _dv.displayState.vmin = manualVmin; _dv.displayState.vmax = manualVmax; } } },
             fetchHistogram: () => compareActive ? _fetchHistogramCompare() : _fetchVolumeHistogram(_volHistSpatialOpts()),
-            getHistogramVersion: () => compareActive ? null : _volumeHistCacheKey(_volHistSpatialOpts()),
+            getHistogramVersion: () => compareActive ? _compareHistogramVersion() : _volumeHistCacheKey(_volHistSpatialOpts()),
             onAnimFrame: (cb) => {
                 // Layout recalculation during expand/collapse animation
                 if (multiViewActive || compareMvActive) {
@@ -14149,7 +14208,8 @@
             const sdKey = scrollDims.slice().sort((a, b) => a - b).join(',');
             const qmriRole = opts.qmriRole || '';
             const numBins = opts.bins || 64;
-            return `${fetchDimX}:${fetchDimY}:${sdKey}:${fixedIndices}:${cMode}:${qmriRole}:${numBins}`;
+            const sidKey = opts.sid && opts.sid !== sid ? `${opts.sid}|` : '';
+            return `${sidKey}${fetchDimX}:${fetchDimY}:${sdKey}:${fixedIndices}:${cMode}:${qmriRole}:${numBins}`;
         }
 
         async function _fetchVolumeHistogram(opts = {}) {
@@ -14181,7 +14241,9 @@
             const qmriRole = opts.qmriRole || '';
             const numBins = opts.bins || 64;
             const exclZ = excludeZeros ? '1' : '0';
-            const cacheKey = `${fetchDimX}:${fetchDimY}:${sdKey}:${fixedIndices}:${cMode}:${qmriRole}:${numBins}:ez${exclZ}`;
+            const fetchSid = opts.sid || sid;
+            const sidKey = fetchSid !== sid ? `${fetchSid}|` : '';
+            const cacheKey = `${sidKey}${fetchDimX}:${fetchDimY}:${sdKey}:${fixedIndices}:${cMode}:${qmriRole}:${numBins}:ez${exclZ}`;
 
             if (_volHistCache[cacheKey]) {
                 _histDataVersion = cacheKey;
@@ -14203,13 +14265,9 @@
             if (qmriRole) params.set('qmri_role', qmriRole);
             if (excludeZeros) params.set('exclude_zeros', '1');
             const request = (async () => {
-                try {
-                    const resp = await proxyFetch(`/volume-histogram/${sid}?${params}`);
-                    if (!resp.ok) return null;
-                    const data = await resp.json();
-                    _volHistCache[cacheKey] = data;
-                    return data;
-                } catch (_) { return null; }
+                const data = await _fetchHistogramJson(`/volume-histogram/${fetchSid}?${params}`);
+                if (data) _volHistCache[cacheKey] = data;
+                return data;
             })();
             _volHistInFlight.set(cacheKey, request);
             try {
@@ -14612,12 +14670,7 @@
             if (!normalized) return null;
             const lo = normalized.vmin;
             const hi = normalized.vmax;
-            view.lockedVmin = lo;
-            view.lockedVmax = hi;
-            const ownerViews = compareQmriActive ? compareQmriViews : qmriViews;
-            const idx = ownerViews.indexOf(view);
-            const qv = idx >= 0 ? modeManager.currentViews[idx] : null;
-            if (qv) { qv.displayState.vmin = lo; qv.displayState.vmax = hi; }
+            _qmriStoreWindow(view, lo, hi);
             return { vmin: lo, vmax: hi };
         }
 
@@ -14642,6 +14695,11 @@
                         vmax: range.vmin + span * preset.hi,
                     };
                 }
+            } else if (compareQmriActive) {
+                hist = await _cqFetchColumnHistogram(view);
+                if (generation != null && generation !== _qmriPresetCycleGeneration) return false;
+                win = _quantileWindowFromHistogram(hist, preset);
+                hist = _normalizeQmriHistogramForColorbar(view, hist);
             } else {
                 const fixedIndices = `${qmriDim}:${view.qmriIdx}`;
                 hist = await _fetchVolumeHistogram({
@@ -14680,14 +14738,17 @@
                 });
             }
             if (view._colorBar) { view._colorBar.draw(); view._colorBar.updateLabels(); }
-            if (compareQmriActive) compareQmriRender(view);
-            else qvRender(view);
+            _qmriRenderWindowOwners(view);
             return true;
         }
 
         async function _cycleQmriPaneRangePreset() {
             if (qmriMvActive) { await _cycleQmriMvRangePreset(); return true; }
-            const view = _hoveredQmriView;
+            // In compare-qMRI only the bottom row shows colorbars, and each map
+            // column shares one range, so act through the column's bottom pane.
+            const view = compareQmriActive && _hoveredQmriView
+                ? _cqColumnLead(_hoveredQmriView)
+                : _hoveredQmriView;
             const activeCb = view
                 ? (qmriMosaicActive && view._mosaicColorBar ? view._mosaicColorBar : view._colorBar)
                 : null;
@@ -14712,7 +14773,9 @@
             if (view) {
                 await _applyQmriRangePresetToView(view, preset, generation);
             } else {
-                const paneViews = compareQmriActive ? compareQmriViews : qmriViews;
+                const paneViews = compareQmriActive
+                    ? compareQmriViews.filter(v => _cqColumnLead(v) === v)
+                    : qmriViews;
                 await Promise.all(paneViews.map(v => _applyQmriRangePresetToView(v, preset, generation)));
                 if (!compareQmriActive) qvScaleAllCanvases();
             }
@@ -14843,8 +14906,46 @@
         }
 
         /** Fetch histogram for all compare sessions and merge bins element-wise. */
-        async function _fetchHistogramCompare() {
-            if (_histFetching) return;
+        /**
+         * Identity of the slice histogram `_fetchHistogramCompare` builds.
+         * Without it the colorbars kept the first histogram for good, so after
+         * moving to another map `d` cut presets from the old map's values.
+         */
+        function _compareHistogramVersion() {
+            return [
+                getCompareRenderSids().join('/'), indices.join(','),
+                dim_x, dim_y, complexMode,
+            ].join('|');
+        }
+
+        // `d` waits on the histogram request in flight, and every later press
+        // joins that same request. One lost on a forwarded link never settles,
+        // which left `d` dead for the rest of the session, so cap the wait;
+        // the next press then asks again.
+        const _HIST_FETCH_TIMEOUT_MS = 15000;
+        async function _fetchHistogramJson(url) {
+            const ctl = typeof AbortController === 'function' ? new AbortController() : null;
+            const timer = ctl ? setTimeout(() => ctl.abort(), _HIST_FETCH_TIMEOUT_MS) : null;
+            try {
+                const resp = await proxyFetch(url, ctl ? { signal: ctl.signal } : undefined);
+                return resp.ok ? await resp.json() : null;
+            } catch (_) {
+                return null;
+            } finally {
+                if (timer) clearTimeout(timer);
+            }
+        }
+
+        let _histCompareInFlight = null;
+        function _fetchHistogramCompare() {
+            if (_histCompareInFlight) return _histCompareInFlight;
+            const request = _fetchHistogramCompareOnce();
+            _histCompareInFlight = request;
+            request.finally(() => { if (_histCompareInFlight === request) _histCompareInFlight = null; });
+            return request;
+        }
+
+        async function _fetchHistogramCompareOnce() {
             _histFetching = true;
             const allSids = getCompareRenderSids();
             const fetchDimX = dim_x;
@@ -14857,12 +14958,10 @@
                 bins: 64,
             });
             try {
-                const histPromises = allSids.map(s =>
-                    proxyFetch(`/histogram/${s}?${params}`).then(r => r.ok ? r.json() : null)
-                );
+                const histPromises = allSids.map(s => _fetchHistogramJson(`/histogram/${s}?${params}`));
                 const allHists = await Promise.all(histPromises);
                 const valid = allHists.filter(Boolean);
-                if (!valid.length) { _histFetching = false; return; }
+                if (!valid.length) { _histFetching = false; return null; }
                 // Start from first valid result, then sum counts from the rest
                 const merged = JSON.parse(JSON.stringify(valid[0]));
                 for (let i = 1; i < valid.length; i++) {
@@ -14895,7 +14994,8 @@
             ].join('|');
         }
 
-        async function _fetchDiffHistogram() {
+        /** sids + query shared by the diff histogram and diff value requests. */
+        function _diffAnalysisQuery() {
             if (!diffMode || !compareActive || compareDisplaySids.length < 2) return null;
             const [sid_a, sid_b] = compareDisplaySids;
             const params = new URLSearchParams({
@@ -14906,7 +15006,6 @@
                 complex_mode: String(complexMode),
                 log_scale: String(logScale),
                 diff_mode: String(diffMode),
-                bins: '64',
             });
             if (detachedDimMode && detachedDim >= 0) {
                 const indicesA = [...indices];
@@ -14916,8 +15015,14 @@
                 params.set('indices_a', indicesA.join(','));
                 params.set('indices_b', indicesB.join(','));
             }
+            return { path: `${sid_a}/${sid_b}?${params}` };
+        }
+
+        async function _fetchDiffHistogram() {
+            const q = _diffAnalysisQuery();
+            if (!q) return null;
             try {
-                const resp = await proxyFetch(`/diff-histogram/${sid_a}/${sid_b}?${params}`);
+                const resp = await proxyFetch(`/diff-histogram/${q.path}&bins=64`);
                 if (!resp.ok) return null;
                 return await resp.json();
             } catch (_) { return null; }
@@ -15142,7 +15247,7 @@
         }
 
         /** Draw Lebesgue highlight on a single overlay canvas using the given slice data. */
-        function _drawLebesgueOnCanvas(overlayCv, targetCv, sliceData, sliceW, sliceH, binLow, binHigh) {
+        function _drawLebesgueOnCanvas(overlayCv, targetCv, sliceData, sliceW, sliceH, binLow, binHigh, flipLikeDiff = false) {
             const octx = overlayCv.getContext('2d');
             if (!octx) return;
             const cw = targetCv.width, ch = targetCv.height;
@@ -15152,7 +15257,9 @@
             }
             overlayCv.style.width = targetCv.style.width;
             overlayCv.style.height = targetCv.style.height;
-            const fx = flip_x, fy = flip_y;
+            // The diff pane flips through applyFlips (per mosaic tile), so its
+            // mask is built unflipped and flipped the same way afterwards.
+            const fx = flipLikeDiff ? false : flip_x, fy = flipLikeDiff ? false : flip_y;
             if (!overlayCv._lebesgueMask) overlayCv._lebesgueMask = document.createElement('canvas');
             const maskCv = overlayCv._lebesgueMask;
             if (maskCv.width !== sliceW || maskCv.height !== sliceH) {
@@ -15161,7 +15268,7 @@
             }
             const mctx = maskCv.getContext('2d');
             if (!mctx) return;
-            const img = mctx.createImageData(sliceW, sliceH);
+            let img = mctx.createImageData(sliceW, sliceH);
             const buf = img.data;
             const alpha = Math.round(255 * 0.55);
             for (let y = 0; y < sliceH; y++) {
@@ -15175,6 +15282,7 @@
                     buf[i + 3] = alpha;
                 }
             }
+            if (flipLikeDiff && (flip_x || flip_y)) img = applyFlips(img, sliceW, sliceH);
             mctx.putImageData(img, 0, 0);
             octx.clearRect(0, 0, cw, ch);
             octx.imageSmoothingEnabled = false;
@@ -15196,11 +15304,11 @@
             return overlay;
         }
 
-        function _drawLebesgueHighlightOnCanvas(targetCv, sliceEntry, binLow, binHigh) {
+        function _drawLebesgueHighlightOnCanvas(targetCv, sliceEntry, binLow, binHigh, flipLikeDiff = false) {
             if (!targetCv || !sliceEntry || !sliceEntry.slice || !sliceEntry.w || !sliceEntry.h) return false;
             const overlay = _getLebesgueOverlay(targetCv);
             if (!overlay) return false;
-            _drawLebesgueOnCanvas(overlay, targetCv, sliceEntry.slice, sliceEntry.w, sliceEntry.h, binLow, binHigh);
+            _drawLebesgueOnCanvas(overlay, targetCv, sliceEntry.slice, sliceEntry.w, sliceEntry.h, binLow, binHigh, flipLikeDiff);
             return true;
         }
 
@@ -15228,6 +15336,41 @@
             }
         }
 
+        // Raw diff values for the centre pane, keyed by the diff query they answer.
+        let _diffLebesgueEntry = null;
+        let _diffLebesguePending = null;
+
+        async function _fetchDiffLebesgueValues(path) {
+            try {
+                const resp = await proxyFetch(`/diff-values/${path}`);
+                if (!resp.ok) return null;
+                const w = parseInt(resp.headers.get('X-ArrayView-Width')) || 0;
+                const h = parseInt(resp.headers.get('X-ArrayView-Height')) || 0;
+                return { slice: new Float32Array(await resp.arrayBuffer()), w, h, key: path };
+            } catch (_) { return null; }
+        }
+
+        function _drawDiffLebesgueHighlight(cb, binIdx, binLow, binHigh) {
+            const q = _diffAnalysisQuery();
+            const target = document.getElementById('compare-diff-canvas');
+            if (!q || !target) return;
+            if (_diffLebesgueEntry && _diffLebesgueEntry.key === q.path) {
+                _drawLebesgueHighlightOnCanvas(target, _diffLebesgueEntry, binLow, binHigh, true);
+                return;
+            }
+            if (_diffLebesguePending === q.path) return;
+            _diffLebesguePending = q.path;
+            _fetchDiffLebesgueValues(q.path).then(entry => {
+                if (_diffLebesguePending === q.path) _diffLebesguePending = null;
+                if (!entry) return;
+                _diffLebesgueEntry = entry;
+                // Still hovering the diff colorbar → draw the bin under the cursor now.
+                if (_colorbarLebesgueHoverActive() && _lastLebesgueColorBar === cb && _lastLebesgueBin >= 0) {
+                    _drawLebesgueHighlightForColorbar(cb, _lastLebesgueBin, true);
+                }
+            });
+        }
+
         function _drawLebesgueHighlightForColorbar(cb, binIdx, force = false) {
             if (!_colorbarLebesgueHoverActive()) return;
             const hd = cb?._histData;
@@ -15246,6 +15389,7 @@
             const binLow = edges[binIdx];
             const binHigh = edges[binIdx + 1] + (binIdx === counts.length - 1 ? 1e-9 : 0);
             if (cb?._lebesgueView) _drawLebesgueHighlightForQmriPane(cb._lebesgueView, binLow, binHigh);
+            else if (cb && cb === _diffCenterCb) _drawDiffLebesgueHighlight(cb, binIdx, binLow, binHigh);
             else _drawLebesgueHighlight(binLow, binHigh);
             if (cb === primaryCb) _highlightHistBin(binIdx);
         }
@@ -16265,7 +16409,7 @@
                 if (_metadataProcessed) updateView();  // reconnect: metadata already known
             };
 
-            ws.onmessage = (event) => {
+            ws.onmessage = _inflatingMessageHandler((event) => {
                 // Text message: server pushes metadata as first JSON message
                 if (typeof event.data === 'string') {
                     try {
@@ -16396,7 +16540,7 @@
                 } else if (isPlaying) {
                     playNext();
                 }
-            };
+            });
 
             ws.onclose = () => {
                 _clearWsOpenTimer();
@@ -17106,7 +17250,7 @@
                 params.set('indices_a', indicesA.join(','));
                 params.set('indices_b', indicesB.join(','));
             }
-            if (_diffCenterColormap) params.set('diff_colormap', _diffCenterColormap);
+            params.set('diff_colormap', _diffCenterColormap || _diffDefaultColormap());
             const requestVmin = _diffManualVmin ?? _diffAutoVmin;
             const requestVmax = _diffManualVmax ?? _diffAutoVmax;
             if (requestVmin !== null) params.set('vmin_override', String(requestVmin));
@@ -23908,6 +24052,7 @@
                     return {
                         sid: s.sid,
                         label,
+                        display: s.filepath || label,
                         detail: `${(s.shape || []).join(' x ')}${s.var && s.name ? ` · ${s.name}` : ''}`,
                         enabled: sameShape,
                     };
@@ -23920,7 +24065,7 @@
             list.innerHTML = _compareWithChoices.map((c, i) => {
                 const keyHint = i < 9 ? `<span class="compare-with-key">${i + 1}</span>` : '';
                 const reason = c.enabled ? c.detail : `${c.detail} · needs shape ${(shape || []).join(' x ')}`;
-                return `<button class="drop-action" data-compare-with="${i}" ${c.enabled ? '' : 'disabled'}>${keyHint}${_escapeHtml(c.label)}<span class="drop-action-reason">${_escapeHtml(reason)}</span></button>`;
+                return `<button class="drop-action" data-compare-with="${i}" ${c.enabled ? '' : 'disabled'}>${keyHint}<span class="compare-with-path">${_escapeHtml(c.display)}</span><span class="drop-action-reason">${_escapeHtml(reason)}</span></button>`;
             }).join('');
             list.querySelectorAll('.drop-action:not(:disabled)').forEach(button => {
                 button.addEventListener('click', () => _pickCompareWith(_compareWithChoices[Number(button.dataset.compareWith)]));
@@ -24522,6 +24667,7 @@
                 if (idx >= 0) {
                     applyTheme(idx);
                     _reconcileLayout();
+                    if (compareActive && diffMode === 1 && !_diffCenterColormap) fetchAndDrawDiff();
                 }
             } else if (key === 'rounded_panes') {
                 roundedPanes = !!value;
@@ -25017,11 +25163,8 @@
             const nextVmin = center - w / 2;
             const nextVmax = center + w / 2;
             if (_bcTargetView) {
-                _bcTargetView.lockedVmin = nextVmin;
-                _bcTargetView.lockedVmax = nextVmax;
-                const _qv = modeManager.currentViews.find(v => v && v.qmriIdx === _bcTargetView.qmriIdx);
-                if (_qv) { _qv.displayState.vmin = nextVmin; _qv.displayState.vmax = nextVmax; }
-                qvRender(_bcTargetView);
+                _qmriStoreWindow(_bcTargetView, nextVmin, nextVmax);
+                _qmriRenderWindowOwners(_bcTargetView);
             } else {
                 manualVmin = nextVmin;
                 manualVmax = nextVmax;
@@ -25361,6 +25504,7 @@
         }
         function _qmriArmWindowLevel(view, e) {
             if (_pixelInfoHeld) { _pixelInfoHeld = false; hideAllPixelInfo(); }
+            if (compareQmriActive) view = _cqColumnLead(view);
             const pending = _bcPendingDrag = {
                 startX: e.clientX, startY: e.clientY,
                 targetView: view, targetCb: view._colorBar,
@@ -25407,7 +25551,7 @@
                 ? under.closest(_INFO_CURSOR_CANVAS_SELECTOR)
                 : null;
             _reconcileInfoCursor();
-            if (targetView) qvRender(targetView);
+            if (targetView) _qmriRenderWindowOwners(targetView);
             else updateView();
             saveState();
             // The drag has definitively ended (this is mouseup, not a hover
@@ -27985,7 +28129,7 @@
                         // Only diff modes 1-3 have their own center colorbar; overlay/wipe/flicker/checker do not
                         if (diffMode === 0) return;
                         const pool = (diffMode === 1) ? DIFF_COLORMAPS : ABS_DIFF_COLORMAPS;
-                        const idx = pool.indexOf(_diffCenterColormap);
+                        const idx = pool.indexOf(_diffCenterColormap || _diffDefaultColormap());
                         const next = (idx + 1) % pool.length;
                         _diffCenterColormap = pool[next];
                         _diffCenterColormapStops = COLORMAP_GRADIENT_STOPS[_diffCenterColormap] || null;
@@ -28466,6 +28610,7 @@
                 run: (ctx, e) => {
                     applyTheme((themeIdx + 1) % THEMES.length);
                     drawSlimColorbar(cbMarkerFrac);
+                    if (compareActive && diffMode === 1 && !_diffCenterColormap) fetchAndDrawDiff();
                     showStatus(`theme: ${THEMES[themeIdx]}`);
                     saveState();
                 },
@@ -29471,7 +29616,7 @@
                     if ((_cmapStrip && _cmapStrip.classList.contains('visible')) && !qmriActive && !compareQmriActive && !rgbMode) {
                         if (_cmapStripMode === 'diff-center') {
                             const pool = (diffMode === 1) ? DIFF_COLORMAPS : ABS_DIFF_COLORMAPS;
-                            const idx = pool.indexOf(_diffCenterColormap);
+                            const idx = pool.indexOf(_diffCenterColormap || _diffDefaultColormap());
                             _diffCenterColormap = pool[(idx <= 0 ? pool.length - 1 : idx - 1)];
                             _diffCenterColormapStops = COLORMAP_GRADIENT_STOPS[_diffCenterColormap] || null;
                             fetchAndDrawDiff();
@@ -29541,7 +29686,7 @@
                     if ((_cmapStrip && _cmapStrip.classList.contains('visible')) && !qmriActive && !compareQmriActive && !rgbMode) {
                         if (_cmapStripMode === 'diff-center') {
                             const pool = (diffMode === 1) ? DIFF_COLORMAPS : ABS_DIFF_COLORMAPS;
-                            const idx = pool.indexOf(_diffCenterColormap);
+                            const idx = pool.indexOf(_diffCenterColormap || _diffDefaultColormap());
                             _diffCenterColormap = pool[(idx + 1) % pool.length];
                             _diffCenterColormapStops = COLORMAP_GRADIENT_STOPS[_diffCenterColormap] || null;
                             fetchAndDrawDiff();
@@ -37225,6 +37370,96 @@
 
         // --------------- Compare + qMRI combined mode ---------------
         // Layout: rows = compared arrays, columns = parameter maps
+        // Each map column shares one display range across the compared arrays:
+        // only the bottom row shows colorbars, so that one bar must be true
+        // for every pane above it.
+
+        function _cqColumnViews(view) {
+            return compareQmriViews.filter(v => v.qmriIdx === view.qmriIdx);
+        }
+
+        /** The bottom-row pane of a column — the one whose colorbar is shown. */
+        function _cqColumnLead(view) {
+            const col = _cqColumnViews(view);
+            return col.length ? col[col.length - 1] : view;
+        }
+
+        /** Store a display window on a qMRI pane; in compare-qMRI on its whole column. */
+        function _qmriStoreWindow(view, lo, hi) {
+            const ownerViews = compareQmriActive ? compareQmriViews : qmriViews;
+            const targets = compareQmriActive && ownerViews.includes(view) ? _cqColumnViews(view) : [view];
+            targets.forEach(t => {
+                t.lockedVmin = lo;
+                t.lockedVmax = hi;
+                const idx = ownerViews.indexOf(t);
+                const qv = idx >= 0 ? modeManager.currentViews[idx] : null;
+                if (qv && qv.displayState) { qv.displayState.vmin = lo; qv.displayState.vmax = hi; }
+            });
+        }
+
+        function _qmriRenderWindowOwners(view) {
+            if (compareQmriActive && compareQmriViews.includes(view)) {
+                _cqColumnViews(view).forEach(v => {
+                    compareQmriRender(v);
+                    if (v._colorBar) { v._colorBar.draw(); v._colorBar.updateLabels(); }
+                });
+            } else {
+                qvRender(view);
+            }
+        }
+
+        /** First frame of a pane: once every pane in its column has reported
+         *  its own range, lock the column to the union so all arrays share it. */
+        function _cqNoteFrameRange(v, lo, hi) {
+            if (v.lockedVmin != null) return;
+            v._cqNaturalRange = { vmin: lo, vmax: hi };
+            const col = _cqColumnViews(v);
+            if (!col.every(c => c._cqNaturalRange)) return;
+            const win = _normalizeQmriWindowPolicy(v, {
+                vmin: Math.min(...col.map(c => c._cqNaturalRange.vmin)),
+                vmax: Math.max(...col.map(c => c._cqNaturalRange.vmax)),
+            });
+            if (!win) return;
+            _qmriStoreWindow(v, win.vmin, win.vmax);
+            col.forEach(c => compareQmriRender(c));
+        }
+
+        function _cqHistogramOpts(view, sidVal) {
+            return {
+                sid: sidVal,
+                dimX: dim_x, dimY: dim_y,
+                scrollDim: current_slice_dim,
+                complexMode: complexMode,
+                fixedIndices: compareQmriDim + ':' + view.qmriIdx,
+                qmriRole: view.qmriRole,
+                bins: 128,
+            };
+        }
+
+        /** One histogram of a map across every compared array, re-binned
+         *  onto a common range so presets and the shown bar cover them all. */
+        async function _cqFetchColumnHistogram(view) {
+            const sids = _cqColumnViews(view).map(v => v.sid);
+            const hists = (await Promise.all(sids.map(s => _fetchVolumeHistogram(_cqHistogramOpts(view, s)))))
+                .filter(h => h && h.counts && h.counts.length && h.edges && h.edges.length === h.counts.length + 1);
+            if (!hists.length) return null;
+            if (hists.length === 1) return hists[0];
+            const lo = Math.min(...hists.map(h => Number(h.vmin)));
+            const hi = Math.max(...hists.map(h => Number(h.vmax)));
+            if (!Number.isFinite(lo) || !Number.isFinite(hi) || hi <= lo) return hists[0];
+            const bins = 128;
+            const step = (hi - lo) / bins;
+            const counts = new Array(bins).fill(0);
+            for (const h of hists) {
+                for (let i = 0; i < h.counts.length; i++) {
+                    const c = (Number(h.edges[i]) + Number(h.edges[i + 1])) / 2;
+                    const b = Math.max(0, Math.min(bins - 1, Math.floor((c - lo) / step)));
+                    counts[b] += h.counts[i];
+                }
+            }
+            const edges = Array.from({ length: bins + 1 }, (_, i) => lo + i * step);
+            return { counts, edges, vmin: lo, vmax: hi };
+        }
         function enterCompareQmri() {
             if (!compareActive) return;
             _qmriRenderGeneration++;
@@ -37327,35 +37562,19 @@
                         getStops: () => COLORMAP_GRADIENT_STOPS[view.colormap] || COLORMAP_GRADIENT_STOPS['gray'] || [],
                         getRange: () => ({ vmin: view.vmin, vmax: view.vmax }),
                         getWindow: () => ({ vmin: view.lockedVmin ?? view.vmin, vmax: view.lockedVmax ?? view.vmax }),
-                        setWindow: (lo, hi) => { view.lockedVmin = lo; view.lockedVmax = hi; },
+                        setWindow: (lo, hi) => { _qmriStoreWindow(view, lo, hi); },
                         fetchHistogram: async () => {
-                            const fixedPairs = [];
-                            fixedPairs.push(compareQmriDim + ':' + view.qmriIdx);
-                            const fixedIndices = fixedPairs.join(',');
-                            const hist = await _fetchVolumeHistogram({
-                                dimX: dim_x, dimY: dim_y,
-                                scrollDim: current_slice_dim,
-                                complexMode: complexMode,
-                                fixedIndices,
-                                qmriRole: view.qmriRole,
-                                bins: 128,
-                            });
+                            const hist = await _cqFetchColumnHistogram(view);
                             return _normalizeQmriHistogramForColorbar(view, hist);
                         },
-                        getHistogramVersion: () => _volumeHistCacheKey({
-                            dimX: dim_x, dimY: dim_y,
-                            scrollDim: current_slice_dim,
-                            complexMode: complexMode,
-                            fixedIndices: compareQmriDim + ':' + view.qmriIdx,
-                            qmriRole: view.qmriRole,
-                            bins: 128,
-                        }),
+                        getHistogramVersion: () => _cqColumnViews(view)
+                            .map(v => _volumeHistCacheKey(_cqHistogramOpts(view, v.sid))).join(';'),
                         onMouseEnter: () => { _startColorbarLebesgueHover(); },
                         onMouseLeave: () => { _stopColorbarLebesgueHover(); },
                         onDragStart: () => { _stopColorbarLebesgueHover(); },
                         onDragEnd: () => { if (cqCb && cqCb._mouseOver) _startColorbarLebesgueHover(); },
                         onBinHover: (binIdx, frac) => { _drawLebesgueHighlightForColorbar(_cqCb, binIdx); },
-                        onWindowChange: () => { compareQmriRender(view); },
+                        onWindowChange: () => { _cqColumnViews(view).forEach(v => compareQmriRender(v)); },
                         onAnimFrame: () => { compareQmriScaleAllCanvases(); },
                     });
                     _cqCb._lebesgueView = view;
@@ -37521,6 +37740,8 @@
                 canvas_h: _qch,
                 projection_mode: projectionMode,
                 projection_dim: projectionMode > 0 ? projectionDim : -1,
+                vmin_override: v.lockedVmin != null && v.lockedVmax != null ? v.lockedVmin : undefined,
+                vmax_override: v.lockedVmin != null && v.lockedVmax != null ? v.lockedVmax : undefined,
                 perf: _PERF_ENABLED,
             }));
         }
@@ -37560,10 +37781,7 @@
                 const frameWindow = _normalizeQmriWindowPolicy(v, { vmin: frame.vmin, vmax: frame.vmax }) || frame;
                 v.vmin = frameWindow.vmin;
                 v.vmax = frameWindow.vmax;
-                if (v.lockedVmin === undefined || v.lockedVmin === null) {
-                    v.lockedVmin = v.vmin;
-                    v.lockedVmax = v.vmax;
-                }
+                _cqNoteFrameRange(v, v.vmin, v.vmax);
                 v.lastImageData = frame.imageData;
                 v.lastW = frame.width;
                 v.lastH = frame.height;
@@ -37675,7 +37893,9 @@
             const width = h32[1], height = h32[2];
             if (h32[0] === v.seq && compareQmriActive && v._qmriGeneration === _qmriRenderGeneration && compareQmriViews.includes(v)) {
                 const f32 = new Float32Array(buf, 12, 2);
-                v.vmin = f32[0]; v.vmax = f32[1];
+                const frameWindow = _normalizeQmriWindowPolicy(v, { vmin: f32[0], vmax: f32[1] }) || { vmin: f32[0], vmax: f32[1] };
+                v.vmin = frameWindow.vmin; v.vmax = frameWindow.vmax;
+                _cqNoteFrameRange(v, v.vmin, v.vmax);
                 const rgba = new Uint8ClampedArray(buf.slice(20, 20 + width * height * 4));
                 const drawT0 = _perfNow();
                 const frame = _applyAutoCropIfReady(
@@ -42807,7 +43027,7 @@
                         preview: _ensureCmapPreviewEl(host),
                         pool,
                         currentIdx: () => {
-                            const idx = pool.indexOf(_diffCenterColormap);
+                            const idx = pool.indexOf(_diffCenterColormap || _diffDefaultColormap());
                             return idx >= 0 ? idx : 0;
                         },
                         captureState: () => ({

{arrayview-0.48.3.dist-info → arrayview-0.48.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: arrayview
-Version: 0.48.3
+Version: 0.48.4
 Summary: Fast multi-dimensional array viewer
 Project-URL: Home, https://github.com/oscarvanderheide/arrayview
 Project-URL: Source, https://github.com/oscarvanderheide/arrayview

{arrayview-0.48.3.dist-info → arrayview-0.48.4.dist-info}/RECORD

@@ -7,7 +7,7 @@ arrayview/_bootstrap_app.py,sha256=ljiZ0o5D3nkJqEGcyyVF06dFWxXujBufQjbcn50QzXM,4
 arrayview/_config.py,sha256=5ovQTO2I-j3fxCxEKcZKE2pqiahLESGTGS24nQdP61I,13493
 arrayview/_diagnostics.py,sha256=XB0rCoDn3cpfhz4H-ayLktOgCMIoVJ0wM9N0ep_kKkQ,11018
 arrayview/_dicom.py,sha256=tNY353MNWTvcXavHeIkqj3242dbgfH_ctwcx9NDee-E,19607
-arrayview/_diff.py,sha256=10Uqvccr7Ocouphl14dMJzLMUHPhsD81LkM1IbsmLqg,5826
+arrayview/_diff.py,sha256=mWLyRSJ6cy-hngyhINxNM88P1QsXXhpMFMFO0PBxidQ,7374
 arrayview/_extra_ports.py,sha256=MZcx04NI9Eg4coydb-yPIHp7uJbE6UscyYGnw8fxid0,11125
 arrayview/_icon.png,sha256=a8RTAbvweLhh3hzD5eGg76Peq-KSDcS6YrCphRb_HEs,2748
 arrayview/_imaging.py,sha256=MQX1uy4m1lofOeoLDhCp6cHO5p_V5fXm4qlSu9Ykn-c,534
@@ -19,7 +19,7 @@ arrayview/_launcher.py,sha256=Hljfeq4AmxVTDiDgYyMtHT5eiatgFdrvcr6bq75onZY,243267
 arrayview/_lifecycle.py,sha256=bqG0oKr-e-5S1ssCTlGmF-yBE47ilrpO1S_Owfjs9Z8,5365
 arrayview/_overlays.py,sha256=CksypG9rWfCz_3RRGIeyaKeXse17AFxvkEjmYyXnIIE,5399
 arrayview/_platform.py,sha256=qSWjRcx9rLIdLvKrRArSueFnbyn5GPKfTEMOc5mCIUs,29970
-arrayview/_render.py,sha256=W2FyrBYNt2dwim_CjYMM5U_Dq_vL5DEU4PL6_ybxIZ8,38564
+arrayview/_render.py,sha256=PwbDVzaVNCqJQw2AGuXS5TG5is5lq9N4yBJt3Ge40MI,40220
 arrayview/_routes_analysis.py,sha256=Xz9Ysr04u07pzSRB4Fzmcl6XwVxyaG6xCWxGwYZi_80,33085
 arrayview/_routes_drop.py,sha256=FC4e7STdCo3hYIA0C4Yy9Ka2UKFx7nLDU5dkujmc1Vo,12477
 arrayview/_routes_export.py,sha256=Ha8mMO2E9TlRL5x25-ADV8_8xUiC-jRz9N1oWwgKOsg,3898
@@ -28,14 +28,14 @@ arrayview/_routes_persistence.py,sha256=T03csHb7ppGT-8yMDf227XkqhnhjgSLYj0RW2wmg
 arrayview/_routes_preferences.py,sha256=xoMHbPKliYspgjaclhx2r8HbP9mFo9Td-nTF76eWVMg,4680
 arrayview/_routes_preload.py,sha256=KOsankNguxdIWmFW9iZcY9p2SvUN1mOKY7KkW1qMGcc,1729
 arrayview/_routes_query.py,sha256=HEEmMKuFycUTBNVUSWtUFXCnWB7ZrM3hv9IZWbXz11o,25012
-arrayview/_routes_rendering.py,sha256=6DD8VxPglnPsG0rnE-qk6ogcNRe2S_KAh3K54QYUHFQ,23380
+arrayview/_routes_rendering.py,sha256=5373qwaNYVedPnBHNo0b2PXBGIiVx37SqEcMCksFNJo,24874
 arrayview/_routes_segmentation.py,sha256=x2bBjQffZryeTMmOH38YdBWethw1o3KpA8V0chJcZHI,23599
 arrayview/_routes_state.py,sha256=T_xoYcRlv7L47ydTxxiXb0Fp5M5x9KR2U-wkxaVeuMY,12462
 arrayview/_routes_vectorfield.py,sha256=OWZtAONwRKQHdYnbDAMbOVf0q6pH7kqV8fa1icDhKHM,9734
-arrayview/_routes_websocket.py,sha256=zfwojLG-c6NaxZanZgmiPpoQUpCmQFqCOglaydjtzJ4,43675
+arrayview/_routes_websocket.py,sha256=405t-7gSERkNlO2pYarkWNzz3Y7CsZ_8CwCU8emXTWU,45541
 arrayview/_segmentation.py,sha256=aENWHmefrKDScXhcZL1X3KgYXE784dpMkmFFo83qnrw,7377
 arrayview/_server.py,sha256=Ejh-6rWpWo0luhBhtsVq1Z4RFIyOPVv5nzExHtXb7iA,23042
-arrayview/_session.py,sha256=D4I6FLazLEXbo0IdkyRrzhvMNhvAI6dSyYu5I3tMCaM,42137
+arrayview/_session.py,sha256=BX94Zx3J4YsqR0t5mr4SJrsVGG5pf_UJK4Ij45iubPc,42254
 arrayview/_session_spec.py,sha256=mKDfMRsPYQdEmN9hLXmDU_9N7etiDyBXr8mz-fB8QBo,6825
 arrayview/_shell.html,sha256=vNa2Kiwx_eoB5H329jolYafLhwJDCH9DsJafBqvVMWU,13194
 arrayview/_source_safety.py,sha256=cI7JAL7DWYuxuB_LnYExvJZaICX2R2qJEJWD1M0z_gg,27664
@@ -43,7 +43,7 @@ arrayview/_synthetic_mri.py,sha256=KcSYC26dgjBH25bUoqHT0IgJIzOxgXCSLkWr-ZnFq08,7
 arrayview/_torch.py,sha256=13sqIMCUu_-b9SQ9KfDCExDz2UMStL87EDVjnbJxAEo,7536
 arrayview/_tutorial.py,sha256=2zZHJGJDa4n30GE1-9ADjKFAifGBH9vvHXP4uDt7BaA,19547
 arrayview/_vectorfield.py,sha256=eDqMCMEGjO8Jdt-6Auh01cz3WD9dbF7xYUWD9xHAf1E,8115
-arrayview/_viewer.html,sha256=jKI9Ic8YwKYoIKhii_k019xb0ujcf-tgi8kkzfLyyl0,2402661
+arrayview/_viewer.html,sha256=LhC5-SnDwxyA20T8AwKE2MWtbvKSOrPi1-kO4e_ywdI,2414456
 arrayview/_vscode.py,sha256=EKnGN2zrjlybc4FQOmYA8BvYdtkcJbLHDEdgtvO7ul4,837
 arrayview/_vscode_browser.py,sha256=VCH9JpAAjFuhO0wQe8tIGjAL5837AXg_bpmBFtWOQqc,20573
 arrayview/_vscode_extension.py,sha256=eYsWAQmik2tt7HMWad9vBnn2kpRyRpLrh42FBGQy0M4,53156
@@ -52,8 +52,8 @@ arrayview/_watch.py,sha256=PxxS_5hcj_S6xQf9Ep4p1HLRkrI5iDMh1aRa4olV7ew,1873
 arrayview/arrayview-opener.vsix,sha256=44uiTM39qj_RXji3pFQaR8TA1jhNB3LYwVU_dGFbP4c,62284
 arrayview/gsap.min.js,sha256=VGihm4idI0E1uqrWezWsiScB9F_jMosn7qs6pPSkeac,72304
 arrayview/todo.md,sha256=KhnRzpn6_jezR0nDDB61-zhox-rbOmEGW-A7Z0_7FnU,622
-arrayview-0.48.3.dist-info/METADATA,sha256=fYsnZ0m9pQEfwNxFPezS5qk0lTNE6FQQ-jQkaJ1mV5I,2288
-arrayview-0.48.3.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-arrayview-0.48.3.dist-info/entry_points.txt,sha256=-0s08axutXkTbINiKs0Q7iv-33aWuTaamUg2q2-NyQ4,60
-arrayview-0.48.3.dist-info/licenses/LICENSE,sha256=34OivjM9faB2QaPjZpMRTIiSx31V3U9cEyQ6F2k-bH0,1062
-arrayview-0.48.3.dist-info/RECORD,,
+arrayview-0.48.4.dist-info/METADATA,sha256=PLSqbJ2d6fFpvAkOLc3Vw8xxcq7F4yuXohp11HXsK9I,2288
+arrayview-0.48.4.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+arrayview-0.48.4.dist-info/entry_points.txt,sha256=-0s08axutXkTbINiKs0Q7iv-33aWuTaamUg2q2-NyQ4,60
+arrayview-0.48.4.dist-info/licenses/LICENSE,sha256=34OivjM9faB2QaPjZpMRTIiSx31V3U9cEyQ6F2k-bH0,1062
+arrayview-0.48.4.dist-info/RECORD,,