arrayview 0.46.2__tar.gz → 0.47.1__tar.gz

{arrayview-0.46.2 → arrayview-0.47.1}/PKG-INFO

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

{arrayview-0.46.2 → arrayview-0.47.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "arrayview"
-version = "0.46.2"
+version = "0.47.1"
 description = "Fast multi-dimensional array viewer"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.12"

{arrayview-0.46.2 → arrayview-0.47.1}/src/arrayview/_io.py

@@ -1863,3 +1863,44 @@ def _peek_file_shape(fpath: str, ext: str):
     except Exception:
         pass
     return None
+
+
+def nifti_grid_meta(filepath):
+    """Return a NIfTI file's native-order spatial metadata (header only), or None."""
+    if not (filepath.endswith(".nii") or filepath.endswith(".nii.gz")):
+        return None
+    return _nifti_header_with_meta(filepath, native=True)[1]
+
+
+def align_overlay_to_base(ov_path, ov_data, base_meta):
+    """Resample a NIfTI overlay onto the base volume's voxel grid.
+
+    Only used when the overlay's spatial shape differs from the base, which
+    otherwise leaves the overlay undisplayable. Both files' affines place the
+    voxels in world space; label data uses nearest-neighbour so mask values
+    stay exact. Returns ``ov_data`` unchanged when alignment does not apply.
+    """
+    if not base_meta or not (ov_path.endswith(".nii") or ov_path.endswith(".nii.gz")):
+        return ov_data
+    base_shape = base_meta.get("spatial_shape")
+    base_affine = base_meta.get("data_affine")
+    if base_shape is None or base_affine is None:
+        return ov_data
+    ov_shape = tuple(int(v) for v in ov_data.shape)
+    if len(ov_shape) != 3 or ov_shape == tuple(base_shape):
+        return ov_data
+    from scipy.ndimage import affine_transform
+
+    ov_affine = np.asarray(_nib().load(ov_path).affine, dtype=np.float64)
+    base_to_ov = np.linalg.inv(ov_affine) @ np.asarray(base_affine, dtype=np.float64)
+    src = np.asarray(ov_data)
+    is_label = np.issubdtype(src.dtype, np.integer) or src.dtype == bool
+    return affine_transform(
+        src.astype(np.float32) if not is_label else src,
+        base_to_ov[:3, :3],
+        offset=base_to_ov[:3, 3],
+        output_shape=tuple(base_shape),
+        order=0 if is_label else 1,
+        mode="constant",
+        cval=0,
+    )

{arrayview-0.46.2 → arrayview-0.47.1}/src/arrayview/_launcher.py

@@ -1314,6 +1314,7 @@ def _load_session_from_filepath(
     watch: bool = False,
     initial_view: dict | None = None,
     code_source: dict | None = None,
+    align_to: str | None = None,
 ) -> dict:
     requested_sid = uuid.uuid4().hex
     payload = {
@@ -1329,6 +1330,8 @@ def _load_session_from_filepath(
     }
     if source_staging_dir:
         payload["source_staging_dir"] = source_staging_dir
+    if align_to:
+        payload["align_to"] = align_to
     if watch:
         payload["watch"] = True
     if initial_view:
@@ -1686,6 +1689,7 @@ def _register_cli_session_with_existing_server_impl(
             ov_name,
             expected_server_id=expected_server_id,
             source_staging_dir=(source_staging_dirs or {}).get(ov_path),
+            align_to=os.path.abspath(base_file),
         )
         if "error" in ov_result:
             raise RuntimeError(
@@ -4803,6 +4807,7 @@ def _serve_daemon(
             array_choice_placeholder,
             load_data,
             load_data_with_meta,
+            align_overlay_to_base,
             load_dir_collection,
             list_array_keys,
         )
@@ -4928,6 +4933,7 @@ def _serve_daemon(
             ):
                 try:
                     ov_data = load_data(ov_path)
+                    ov_data = align_overlay_to_base(ov_path, ov_data, spatial_meta)
                     ov_session = _session_mod.Session(
                         ov_data, filepath=ov_path, name=ov_name
                     )

{arrayview-0.46.2 → arrayview-0.47.1}/src/arrayview/_routes_loading.py

@@ -96,10 +96,12 @@ def register_loading_routes(app, *, notify_shells, setup_rgb) -> None:
         result = []
         for session in SESSIONS.values():
             dtype_str = str(getattr(session.data, "dtype", "unknown"))
+            code = getattr(session, "code_source", None) or {}
             result.append(
                 {
                     "sid": session.sid,
                     "name": session.name,
+                    "var": code.get("name") or None,
                     "shape": [int(x) for x in session.shape],
                     "filepath": session.filepath,
                     "dtype": dtype_str,
@@ -275,6 +277,7 @@ def register_loading_routes(app, *, notify_shells, setup_rgb) -> None:
                     and os.path.abspath(existing.filepath) == abs_path
                     and current_signature is not None
                     and getattr(existing, "file_signature", None) == current_signature
+                    and getattr(existing, "aligned_to", None) == body.get("align_to")
                 ):
                     if acquire_session_leases([existing.sid]):
                         return {"sid": existing.sid, "name": existing.name, "notified": False}
@@ -456,6 +459,17 @@ def register_loading_routes(app, *, notify_shells, setup_rgb) -> None:
                         key=_key,
                         select=body.get("select"),
                     )
+                    if body.get("align_to"):
+                        from ._io import align_overlay_to_base, nifti_grid_meta
+
+                        base_meta = await asyncio.to_thread(
+                            nifti_grid_meta, str(body["align_to"])
+                        )
+                        aligned = await asyncio.to_thread(
+                            align_overlay_to_base, filepath, data, base_meta
+                        )
+                        if aligned is not data:
+                            data, spatial_meta = aligned, base_meta
             except Exception as e:
                 if staging_dir:
                     cleanup_staging_directory(staging_dir)
@@ -477,6 +491,7 @@ def register_loading_routes(app, *, notify_shells, setup_rgb) -> None:
                 str(value) for value in body.get("related_sids", [])
             ]
             apply_launch_view(session, body)
+            session.aligned_to = body.get("align_to")
             if staging_dir:
                 session._source_staging_dirs = [str(staging_dir)]
             if not dir_patterns:

{arrayview-0.46.2 → arrayview-0.47.1}/src/arrayview/_session.py

@@ -765,6 +765,12 @@ def upgrade_memmap_in_background(session) -> bool:
                 from ._io import _nifti_display_array
 
                 loaded = _nifti_display_array(data)
+                # An uncompressed proxy whose dtype needs no conversion comes
+                # back as a view of the file map, so nothing was read yet and
+                # every new orientation would still fault from disk. Copy in
+                # file order to make it one sequential read.
+                if not loaded.flags.owndata:
+                    loaded = np.array(loaded, copy=True, order="K")
         except Exception:
             return  # keep serving from the lazy source
         # A /reload or a released session must not be clobbered by a read that

{arrayview-0.46.2 → arrayview-0.47.1}/src/arrayview/_viewer.html

@@ -236,22 +236,24 @@
             border-radius: 10px;
             overflow: hidden;
         }
-        /* Orientation arrow — hovering a dim label in the DimBar shows a
-           small arrow near that dimension's zero point, pointing toward
-           increasing values. See _showOrientEdgeHighlight(). */
-        .orient-arrow {
-            position: absolute; width: 32px; height: 32px;
-            pointer-events: none; z-index: 5;
+        /* Orientation cross — hovering the DimBar (or pressing r / t) shows a
+           small axis cross in the origin corner of every image pane, one arrow
+           per in-plane direction with its letter. See _showOrientEdgeHighlight().
+           Yellow with a black outline so it reads on bright and dark image
+           content alike. */
+        .orient-cross {
+            position: fixed; left: 0; top: 0; width: 64px; height: 64px;
+            transform-origin: 0 0; pointer-events: none; z-index: 60;
             opacity: 0; transition: opacity 0.15s ease;
         }
-        .orient-arrow.showing { opacity: 0.9; }
-        /* Dark halo so the arrow reads against bright/washed-out image content
-           regardless of the active colormap (same technique used elsewhere
-           for on-canvas markers). A single polygon (not a separate shaft +
-           head) so the outline wraps one shape with no seam down the middle. */
-        .orient-arrow polygon {
-            paint-order: stroke;
-            stroke: var(--bg); stroke-width: 3px; stroke-linejoin: round;
+        .orient-cross.showing { opacity: 1; }
+        .orient-cross .oc-halo { stroke: rgba(0, 0, 0, 0.7); stroke-width: 4px; fill: none; stroke-linecap: round; }
+        .orient-cross .oc-ln { stroke: var(--active-dim); stroke-width: 1.5px; fill: none; stroke-linecap: round; }
+        .orient-cross .oc-hd { fill: var(--active-dim); stroke: rgba(0, 0, 0, 0.7); stroke-width: 2.5px; stroke-linejoin: round; paint-order: stroke; }
+        .orient-cross text {
+            font-family: 'SF Mono', ui-monospace, 'Cascadia Code', 'JetBrains Mono', monospace;
+            font-size: 12px; font-weight: 600; fill: var(--active-dim);
+            stroke: rgba(0, 0, 0, 0.7); stroke-width: 3px; stroke-linejoin: round; paint-order: stroke;
         }
         #slim-cb-wrap {
             text-align: center;
@@ -2087,6 +2089,18 @@
         .drop-action:hover:not(:disabled) { color: var(--active-dim); background: var(--surface-2); }
         .drop-action:disabled { color: var(--muted); cursor: default; opacity: 0.5; }
         .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));
+            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);
+            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-key { color: var(--muted); margin-right: 8px; }
         .mode-badge {
             display: inline-block; font-size: 0.62em; font-weight: 600;
             letter-spacing: 0.08em; padding: 2px 6px; border-radius: 4px;
@@ -4247,6 +4261,13 @@
         /* qMRI 3-plane multiview: one map per row (3 planes) + a vertical colorbar on the right */
         .qmri-mv-row { display: flex; flex-direction: row; align-items: center; justify-content: center; gap: 14px; }
         .qmri-mv-row .qv-canvas-clip { align-items: center; justify-content: center; }
+        /* qMRI ortho: the 3x3 panes touch and read as one block, so only the
+           outer corners of the block are rounded. */
+        body.rounded-panes .qmri-mv-row .qv-canvas-clip { border-radius: 0; }
+        body.rounded-panes .qmri-mv-row .qv-canvas-clip.qmv-tl { border-top-left-radius: 10px; }
+        body.rounded-panes .qmri-mv-row .qv-canvas-clip.qmv-tr { border-top-right-radius: 10px; }
+        body.rounded-panes .qmri-mv-row .qv-canvas-clip.qmv-bl { border-bottom-left-radius: 10px; }
+        body.rounded-panes .qmri-mv-row .qv-canvas-clip.qmv-br { border-bottom-right-radius: 10px; }
         .qmri-mv-row > .qv-row { flex: 0 1 auto; }
         .qmri-mv-cb { display: flex; align-items: center; flex-shrink: 0; }
         .qmri-mv-vcb-island { padding: 4px 8px; margin-top: 0; flex-direction: column !important; gap: 3px; }
@@ -5741,6 +5762,11 @@
         <div id="drop-action-summary"></div>
         <div id="drop-action-list"></div>
     </div>
+    <div id="compare-with-menu" aria-hidden="true">
+        <div id="compare-with-title">Compare with…</div>
+        <div id="compare-with-summary"></div>
+        <div id="compare-with-list"></div>
+    </div>
     <div id="help-overlay">
         <div id="help-box">
             <div id="help-tabs"></div>
@@ -7507,6 +7533,7 @@
         let _cmvCrosshairAnim = null;  // animation frame id for compare-mv crosshair fade
         let _qmvCrosshairAlpha = 0;    // current crosshair opacity for qMRI multiview
         let _qmvCrosshairTarget = 0;   // target opacity for qMRI multiview
+        let _qmvCrosshairMap = null;   // map row the lines are limited to (click-hold); null = every row
         let _qmvCrosshairAnim = null;  // animation frame id for qMRI-mv crosshair fade
         let _qmvScrollHintTimer = null; // fade-out timer after scrolling a qMRI-mv pane
         let _qmvScrollHintDir = -1;    // plane being scrolled (its own lines stay hidden)
@@ -20994,6 +21021,20 @@
             return `<span class="${cls}">${_dimIndexHtml(shownValue, maxValue)}</span>`;
         }
 
+        // Axis letters follow the data, not the screen: the array axis that
+        // started out as x keeps the letter x after t / r, so the DimBar and the
+        // orientation cross both show which way each axis now runs. Remembered
+        // per pair of displayed dims; picking different dims starts over.
+        let _axisIdent = null;
+        function _axisLetter(d) {
+            const key = Math.min(dim_x, dim_y) + ',' + Math.max(dim_x, dim_y);
+            if (!_axisIdent || _axisIdent.key !== key) {
+                _axisIdent = { key, letters: { [dim_x]: 'x', [dim_y]: 'y' } };
+            }
+            if (d === dim_z) return 'z';
+            return _axisIdent.letters[d] || (d === dim_x ? 'x' : 'y');
+        }
+
         function renderInfo() {
             _ensureQmriActiveDimVisible();
             _syncOverlayPaletteSlice();
@@ -21046,13 +21087,13 @@
                 }
                 if (i === dim_x) {
                     const sign = flip_x ? '<span class="dim-flip-sign">-</span>' : '';
-                    const inner = sign + '<span class="dim-axis-letter">x</span>' + `<span class="dim-slash">/</span><span class="dim-size" id="dim-x-size">${sizeOf(i)}</span>`;
+                    const inner = sign + `<span class="dim-axis-letter">${_axisLetter(i)}</span>` + `<span class="dim-slash">/</span><span class="dim-size" id="dim-x-size">${sizeOf(i)}</span>`;
                     return (active || playing) ? `<span class="spatial-dim ${dimCls} dim-label" ${d}>${inner}</span>`
                                   : `<span class="spatial-dim dim-label" ${d}>${inner}</span>`;
                 }
                 if (i === dim_y) {
                     const sign = flip_y ? '<span class="dim-flip-sign">-</span>' : '';
-                    const inner = sign + '<span class="dim-axis-letter">y</span>' + `<span class="dim-slash">/</span><span class="dim-size" id="dim-y-size">${sizeOf(i)}</span>`;
+                    const inner = sign + `<span class="dim-axis-letter">${_axisLetter(i)}</span>` + `<span class="dim-slash">/</span><span class="dim-size" id="dim-y-size">${sizeOf(i)}</span>`;
                     return (active || playing) ? `<span class="spatial-dim ${dimCls} dim-label" ${d}>${inner}</span>`
                                   : `<span class="spatial-dim dim-label" ${d}>${inner}</span>`;
                 }
@@ -21272,60 +21313,122 @@
             if (typeof obliqueVecs !== 'undefined' && obliqueVecs) return false;
             return true;
         }
-        function _clearOrientEdgeHighlight() {
-            document.querySelectorAll('.orient-arrow.showing').forEach(el => {
-                el.classList.remove('showing');
-            });
+        const _ORIENT_CROSS_BOX = 64;
+        const _ORIENT_CROSS_MARGIN = 8;
+        let _orientCrossEls = [];
+        let _orientShown = false;
+        let _orientHovering = false;
+        let _orientRaf = 0;
+        let _orientFlashTimer = 0;
+        // Every image pane in the current mode: its canvas, the letters of its
+        // horizontal / vertical dims, and which way each axis is flipped.
+        function _orientPanes() {
+            const out = [];
+            const add = (cv, lx, ly, fx, fy) => { if (cv) out.push({ cv, lx, ly, fx: !!fx, fy: !!fy }); };
+            const grid = (views, dims) => {
+                const letter = (d) => ['x', 'y', 'z'][Math.max(0, dims.indexOf(d))];
+                (views || []).forEach(v => add(v.canvas, letter(v.dimX), letter(v.dimY), _mvFlipX(v), _mvFlipY(v)));
+            };
+            const plain = (cvs) => cvs.forEach(cv => add(cv, _axisLetter(dim_x), _axisLetter(dim_y), flip_x, flip_y));
+            if (stackMosaicActive) plain((stackMosaicViews || []).map(v => v.canvas));
+            else if (compareQmriActive) plain((compareQmriViews || []).map(v => v.canvas));
+            else if (compareMvActive) grid(compareMvViews, compareMvDims);
+            else if (multiViewActive) grid(mvViews, mvDims);
+            else if (compareActive) plain([...document.querySelectorAll('#compare-panes .compare-canvas')]);
+            else if (qmriMvActive) grid(qmriMvViews, qmriMvDims);
+            else if (qmriActive) plain((qmriViews || []).map(v => v.canvas));
+            else if (mipActive || cutawayActive) return out;
+            // Mosaic tiles are flipped one by one, so the whole canvas has no single origin corner.
+            else if (!(dim_z >= 0 && (flip_x || flip_y))) plain([canvas]);
+            return out;
         }
-        const _ORIENT_ARROW_MARGIN = 10;
-        function _orientArrowEl(container) {
-            if (!container) return null;
-            let el = container.querySelector(':scope > .orient-arrow');
-            if (!el) {
-                const NS = 'http://www.w3.org/2000/svg';
-                el = document.createElementNS(NS, 'svg');
-                el.setAttribute('class', 'orient-arrow');
-                el.setAttribute('viewBox', '0 0 32 32');
-                el.innerHTML = '<polygon points="3,14.5 21,14.5 21,10 31,16 21,22 21,17.5 3,17.5" fill="var(--active-dim)"/>';
-                container.appendChild(el);
-            }
-            return el;
+        // The part of `cv` that is actually on screen: its box clipped by every scrolling/clipping ancestor.
+        function _orientVisibleRect(cv) {
+            const r = cv.getBoundingClientRect();
+            let l = r.left, t = r.top, rt = r.right, bt = r.bottom;
+            for (let el = cv.parentElement; el && el !== document.body; el = el.parentElement) {
+                const cs = getComputedStyle(el);
+                if (cs.overflowX === 'visible' && cs.overflowY === 'visible') continue;
+                const pr = el.getBoundingClientRect();
+                l = Math.max(l, pr.left); t = Math.max(t, pr.top);
+                rt = Math.min(rt, pr.right); bt = Math.min(bt, pr.bottom);
+            }
+            return (rt - l > 8 && bt - t > 8) ? { left: l, top: t, right: rt, bottom: bt } : null;
+        }
+        function _orientCrossSvg(el, letterX, letterY, flipX, flipY) {
+            const key = letterX + letterY + (flipX ? 1 : 0) + (flipY ? 1 : 0);
+            if (el._ocKey === key) return;
+            el._ocKey = key;
+            const B = _ORIENT_CROSS_BOX, o = 8, len = 30, hl = 7, hw = 3.6;
+            const sx = flipX ? -1 : 1, sy = flipY ? -1 : 1;
+            const ox = flipX ? B - o : o, oy = flipY ? B - o : o;
+            const xTip = ox + sx * len, yTip = oy + sy * len;
+            const xHead = `${xTip},${oy} ${xTip - sx * hl},${oy - hw} ${xTip - sx * hl},${oy + hw}`;
+            const yHead = `${ox},${yTip} ${ox - hw},${yTip - sy * hl} ${ox + hw},${yTip - sy * hl}`;
+            const segs = [[ox, oy, xTip - sx * 4, oy], [ox, oy, ox, yTip - sy * 4]];
+            el.innerHTML = segs.map(([x1, y1, x2, y2]) => `<line class="oc-halo" x1="${x1}" y1="${y1}" x2="${x2}" y2="${y2}"/>`
+                    + `<line class="oc-ln" x1="${x1}" y1="${y1}" x2="${x2}" y2="${y2}"/>`).join('')
+                + `<polygon class="oc-hd" points="${xHead}"/><polygon class="oc-hd" points="${yHead}"/>`
+                + `<circle class="oc-hd" cx="${ox}" cy="${oy}" r="2"/>`
+                + `<text x="${xTip + sx * 9}" y="${oy + 4}" text-anchor="${flipX ? 'end' : 'start'}">${letterX}</text>`
+                + `<text x="${ox}" y="${yTip + sy * 13}" text-anchor="middle">${letterY}</text>`;
+        }
+        // Puts one cross in the origin corner of each pane: the x arrow runs
+        // along the top (bottom when flipped) edge toward increasing x, the y
+        // arrow along the left (right when flipped) edge toward increasing y.
+        function _placeOrientCrosses() {
+            const panes = _orientPanes().map(p => ({ p, r: _orientVisibleRect(p.cv) })).filter(q => q.r);
+            while (_orientCrossEls.length < panes.length) {
+                const el = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
+                el.setAttribute('class', 'orient-cross');
+                el.setAttribute('viewBox', `0 0 ${_ORIENT_CROSS_BOX} ${_ORIENT_CROSS_BOX}`);
+                document.body.appendChild(el);
+                _orientCrossEls.push(el);
+            }
+            _orientCrossEls.forEach((el, i) => {
+                const q = panes[i];
+                if (!q) { el.classList.remove('showing'); return; }
+                const { p, r } = q;
+                _orientCrossSvg(el, p.lx, p.ly, p.fx, p.fy);
+                const w = r.right - r.left, h = r.bottom - r.top;
+                // Small panes (grids, mosaics) get a proportionally smaller cross.
+                const k = Math.max(0.55, Math.min(1, Math.min(w, h) / 230));
+                const size = _ORIENT_CROSS_BOX * k, m = _ORIENT_CROSS_MARGIN * k;
+                const x = p.fx ? r.right - m - size : r.left + m;
+                const y = p.fy ? r.bottom - m - size : r.top + m;
+                el.style.transform = `translate(${Math.round(x)}px, ${Math.round(y)}px) scale(${k})`;
+                el.classList.add('showing');
+            });
         }
-        // Places a small arrow near the (flipX, flipY) origin corner of `container`,
-        // pointing along `axis` ('x' or 'y') in the direction that dim increases.
-        // `flipOwn` is the flip of `axis` itself (picks the arrow's direction and
-        // which edge it hugs along that axis); `flipOther` is the flip of the
-        // perpendicular axis (picks where along that axis the arrow sits).
-        function _placeOrientArrow(container, axis, flipOwn, flipOther) {
-            const el = _orientArrowEl(container);
-            if (!el) return;
-            const m = _ORIENT_ARROW_MARGIN + 'px';
-            el.style.left = el.style.right = el.style.top = el.style.bottom = '';
-            if (axis === 'x') {
-                if (flipOwn) el.style.right = m; else el.style.left = m;
-                if (flipOther) el.style.bottom = m; else el.style.top = m;
-                el.style.transform = flipOwn ? 'rotate(180deg)' : 'rotate(0deg)';
-            } else {
-                if (flipOwn) el.style.bottom = m; else el.style.top = m;
-                if (flipOther) el.style.right = m; else el.style.left = m;
-                el.style.transform = flipOwn ? 'rotate(-90deg)' : 'rotate(90deg)';
-            }
-            el.classList.add('showing');
+        // Panes can still be moving or re-rendering when this starts (after
+        // r / t, or while zooming), so keep the crosses glued to them.
+        function _orientLoop() {
+            _orientRaf = 0;
+            if (!_orientShown) return;
+            _placeOrientCrosses();
+            _orientRaf = requestAnimationFrame(_orientLoop);
         }
-        function _showOrientEdgeHighlight(dim) {
-            _clearOrientEdgeHighlight();
-            if (!_orientEdgeAllowed() || dim == null || dim < 0) return;
-            if (multiViewActive) {
-                if (!Array.isArray(mvViews)) return;
-                mvViews.forEach(v => {
-                    if (v.dimX === dim) _placeOrientArrow(v.cvBox, 'x', _mvFlipX(v), _mvFlipY(v));
-                    else if (v.dimY === dim) _placeOrientArrow(v.cvBox, 'y', _mvFlipY(v), _mvFlipX(v));
-                });
-                return;
-            }
-            const viewport = document.getElementById('canvas-viewport');
-            if (dim === dim_x) _placeOrientArrow(viewport, 'x', flip_x, flip_y);
-            else if (dim === dim_y) _placeOrientArrow(viewport, 'y', flip_y, flip_x);
+        function _clearOrientEdgeHighlight() {
+            _orientShown = false;
+            if (_orientRaf) { cancelAnimationFrame(_orientRaf); _orientRaf = 0; }
+            if (_orientFlashTimer) { clearTimeout(_orientFlashTimer); _orientFlashTimer = 0; }
+            _orientCrossEls.forEach(el => el.classList.remove('showing'));
+        }
+        // Shown for every image pane while the pointer is over the DimBar.
+        function _showOrientEdgeHighlight() {
+            if (!_orientEdgeAllowed()) { _clearOrientEdgeHighlight(); return; }
+            _orientShown = true;
+            if (!_orientRaf) _orientLoop();
+        }
+        // Brief look after r / t so a rotate or transpose can be read off the cross.
+        function _flashOrientCross(ms = 1400) {
+            if (!_orientEdgeAllowed()) return;
+            _showOrientEdgeHighlight();
+            if (_orientFlashTimer) clearTimeout(_orientFlashTimer);
+            _orientFlashTimer = setTimeout(() => {
+                _orientFlashTimer = 0;
+                if (!_orientHovering) _clearOrientEdgeHighlight();
+            }, ms);
         }
 
         function setStatus(msg) {
@@ -23317,6 +23420,79 @@
             }
         }, true);
 
+        // ── Compare with an array that is open in another tab ─────────
+        let _compareWithMenuVisible = false;
+        let _compareWithChoices = [];
+
+        function _closeCompareWithMenu() {
+            if (!_compareWithMenuVisible) return;
+            _compareWithMenuVisible = false;
+            _compareWithChoices = [];
+            _reconcileUI();
+            try { document.getElementById('keyboard-sink').focus(); } catch (_) {}
+        }
+
+        async function _pickCompareWith(choice) {
+            if (!choice || !choice.enabled) return;
+            _closeCompareWithMenu();
+            const ok = await enterCompareModeBySid(choice.sid, choice.label);
+            if (ok !== false) showStatus(`Compare: ${choice.label}`);
+        }
+
+        async function openCompareWithMenu() {
+            let sessions = [];
+            try {
+                const res = await proxyFetch('/sessions');
+                if (res.ok) sessions = await res.json();
+            } catch (_) {}
+            const ownShape = JSON.stringify((shape || []).map(Number));
+            _compareWithChoices = sessions
+                .filter(s => s.sid && s.sid !== sid)
+                .map(s => {
+                    const sameShape = JSON.stringify((s.shape || []).map(Number)) === ownShape;
+                    const label = s.var || s.name || s.sid.slice(0, 8);
+                    if (s.name) compareNameBySid[s.sid] = label;
+                    return {
+                        sid: s.sid,
+                        label,
+                        detail: `${(s.shape || []).join(' x ')}${s.var && s.name ? ` · ${s.name}` : ''}`,
+                        enabled: sameShape,
+                    };
+                });
+            if (!_compareWithChoices.length) {
+                showStatus('No other open arrays to compare with');
+                return;
+            }
+            const list = document.getElementById('compare-with-list');
+            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>`;
+            }).join('');
+            list.querySelectorAll('.drop-action:not(:disabled)').forEach(button => {
+                button.addEventListener('click', () => _pickCompareWith(_compareWithChoices[Number(button.dataset.compareWith)]));
+            });
+            document.getElementById('compare-with-summary').textContent =
+                'Arrays open in your other tabs · click or press a number · Esc to cancel';
+            _compareWithMenuVisible = true;
+            _reconcileUI();
+        }
+
+        document.addEventListener('pointerdown', (event) => {
+            if (_compareWithMenuVisible && !document.getElementById('compare-with-menu').contains(event.target)) {
+                _closeCompareWithMenu();
+            }
+        });
+        window.addEventListener('keydown', (event) => {
+            if (!_compareWithMenuVisible) return;
+            if (['Shift', 'Control', 'Alt', 'Meta'].includes(event.key)) return;
+            event.preventDefault();
+            event.stopImmediatePropagation();
+            if (event.key === 'Escape') { _closeCompareWithMenu(); return; }
+            const n = Number(event.key);
+            if (Number.isInteger(n) && n >= 1 && n <= 9) _pickCompareWith(_compareWithChoices[n - 1]);
+        }, true);
+
         /* ── JS: Rendering Pipeline (updateView, play, screenshot) ── */
 
         function updateView() {
@@ -27757,6 +27933,7 @@
                         _roiClearOnDimChange();
                         if (typeof _cropReconcileBindings === 'function') _cropReconcileBindings();
                         renderInfo(); saveState();
+                        _flashOrientCross();
                         return;
                     }
                     const wasMosaic = dim_z >= 0;
@@ -27772,6 +27949,7 @@
                     showStatus(wasMosaic ? 'transposed x/y (mosaic)' : 'transposed x/y');
                     if (typeof _cropReconcileBindings === 'function') _cropReconcileBindings();
                     renderInfo(); saveState();
+                    _flashOrientCross();
                 },
             },
             'view.rotateOrFlip': {
@@ -27802,6 +27980,7 @@
                         showStatus('rotated 90°'); saveState();
                     }
                     if (typeof _cropReconcileBindings === 'function') _cropReconcileBindings();
+                    _flashOrientCross();
                 },
             },
             'theme.cycle': {
@@ -29084,6 +29263,11 @@
                     commands['qmri.cycle'].run(ctx, e);
                 },
             },
+            'compare.withOpenArray': {
+                title: 'Compare with an array open in another tab',
+                when: [],
+                run: (ctx, e) => { openCompareWithMenu(); },
+            },
             'tool.comparecenterDirect': {
                 title: 'Cycle compare center mode',
                 when: [],
@@ -29515,11 +29699,12 @@
             },
             {
                 id: 'compare', label: 'Compare',
-                desc: 'View two or more arrays side by side, blend them together, or compute a difference map. Useful for checking registration, comparing model outputs, or inspecting before-and-after changes. Open multiple arrays with the file picker first.',
+                desc: 'View two or more arrays side by side, blend them together, or compute a difference map. Useful for checking registration, comparing model outputs, or inspecting before-and-after changes. Press / then c to compare with an array open in another tab.',
                 sections: [
                     {
                         title: 'Layout',
                         entries: [
+                            { key: '/ c', action: 'Compare with…', hint: 'pick an array that is open in another tab; it must have the same shape' },
                             { key: 'g', action: 'Cycle layout', hint: 'horizontal → vertical → grid; with exactly 2 arrays + center mode active, toggles horizontal ↔ big-left' },
                             { key: 'Drag title', action: 'Reorder panes by dragging their title bar' },
                         ]
@@ -29558,6 +29743,7 @@
                     {
                         title: 'After /', columnBreak: true,
                         entries: [
+                            { key: '/ c', action: 'Compare with…', hint: 'side by side with an array open in another tab' },
                             { key: '/ r', action: 'ROI', hint: 'measure a region and see live stats' },
                             { key: '/ S', action: 'Segmentation', hint: 'local mask editing and nnInteractive options' },
                             { key: '/ o', action: 'Overlays', hint: 'show mask names and visibility' },
@@ -29983,6 +30169,16 @@
                 { key: 'q', toolId: 'qmri', command: 'tool.qmriDirect' },
                 { key: 's', toolId: 'save', command: 'saveMenu.open' },
                 { key: 'C', toolId: 'crop', command: 'tool.cropDirect' },
+                {
+                    key: 'c',
+                    id: 'comparewith',
+                    label: 'Compare with…',
+                    command: 'compare.withOpenArray',
+                    icon: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round"><rect x="3" y="5" width="8" height="14" rx="1"/><rect x="13" y="5" width="8" height="14" rx="1"/></svg>',
+                    enabled: () => !isInlineEmbed,
+                    active: () => compareActive,
+                    unavailableReason: () => 'Not available in notebook output.',
+                },
                 { key: 'P', toolId: 'comparecenter', command: 'tool.comparecenterDirect' },
                 { key: 'r', toolId: 'roi', command: 'tool.roiDirect' },
                 { key: 'S', toolId: 'segmentation', command: 'tool.segmentationDirect' },
@@ -37771,6 +37967,7 @@
                         if (e.shiftKey || e.metaKey || e.ctrlKey || e.altKey) return;
                         sink.focus();
                         _qmriMvDragView = view;
+                        _qmvCrosshairMap = view.qmriIdx;
                         _qmvRecomputeCrosshairTarget();
                         handleQmriMvPointer(view, e);
                         const onMove = (me) => { if (_qmriMvDragView === view) handleQmriMvPointer(view, me); };
@@ -37923,7 +38120,7 @@
             _hoveredQmriMvView = null;
             if (_qmvCrosshairAnim) { cancelAnimationFrame(_qmvCrosshairAnim); _qmvCrosshairAnim = null; }
             if (_qmvScrollHintTimer) { clearTimeout(_qmvScrollHintTimer); _qmvScrollHintTimer = null; }
-            _qmvCrosshairAlpha = 0; _qmvCrosshairTarget = 0; _qmvScrollHintDir = -1;
+            _qmvCrosshairAlpha = 0; _qmvCrosshairTarget = 0; _qmvScrollHintDir = -1; _qmvCrosshairMap = null;
             _reconcileOrthoCursorHidden();
             _reconcileMvOrientationVisibility();
             qmriMvViews.forEach(v => { if (v.ws) { v.ws.onclose = null; v.ws.close(); } });
@@ -38097,7 +38294,9 @@
         }
         /** Position lines on the pane's overlay, like compareMvDrawFrame. */
         function _qmvDrawCrosshair(v) {
-            const alpha = (_qmvScrollHintTimer && v.sliceDir === _qmvScrollHintDir) ? 0 : _qmvCrosshairAlpha;
+            const alpha = (_qmvScrollHintTimer && v.sliceDir === _qmvScrollHintDir) ? 0
+                : (_qmvCrosshairMap !== null && v.qmriIdx !== _qmvCrosshairMap) ? 0
+                : _qmvCrosshairAlpha;
             const ov = _getMvCrosshairOverlay(v);
             if (!ov) return;
             const metrics = _getMvCrosshairMetrics(v);
@@ -38130,8 +38329,8 @@
             if (!ready.length) return;
             const nRows = Math.max(1, Math.round(qmriMvViews.length / 3));
             const nCols = 3;
-            const colGap = 24;
-            const rowGap = 14;
+            const colGap = 0;
+            const rowGap = 0;
             const sidePad = 120;
             const vcbW = 80;  // vertical colorbar island horizontal footprint (bar + padding)
             const bottomPad = 16;
@@ -38147,6 +38346,13 @@
             const baseScale = absMaxT / maxSide;
             const panStub = { x: 0, y: 0, clamp: () => {}, apply: () => {} };
             for (const v of ready) {
+                const qi = qmriMvViews.indexOf(v), qr = Math.floor(qi / 3), qc = qi % 3;
+                if (v.clip) {
+                    v.clip.classList.toggle('qmv-tl', qr === 0 && qc === 0);
+                    v.clip.classList.toggle('qmv-tr', qr === 0 && qc === 2);
+                    v.clip.classList.toggle('qmv-bl', qr === nRows - 1 && qc === 0);
+                    v.clip.classList.toggle('qmv-br', qr === nRows - 1 && qc === 2);
+                }
                 _scalePane(
                     { canvas: v.canvas, w: v.lastW, h: v.lastH, pan: panStub },
                     v.clip || null,
@@ -39155,6 +39361,7 @@
          *  scrolled plane's own lines stay put, so they are left hidden. */
         function _qmvScrollHint(view) {
             _qmvScrollHintDir = view ? view.sliceDir : -1;
+            if (!_qmriMvDragView && view) _qmvCrosshairMap = view.qmriIdx;
             if (_qmvScrollHintTimer) clearTimeout(_qmvScrollHintTimer);
             _qmvScrollHintTimer = setTimeout(() => {
                 _qmvScrollHintTimer = null;
@@ -39887,9 +40094,10 @@
         let _histDimHovering = false;
         infoEl.addEventListener('mouseover', (e) => {
             const span = e.target.closest('[data-dim]');
+            _orientHovering = true;
+            _showOrientEdgeHighlight();
             if (span) {
                 hoveredDim = parseInt(span.dataset.dim);
-                _showOrientEdgeHighlight(hoveredDim);
                 if (_histDimControlsVisible()) {
                     _histDimHovering = true;
                     _showHistTooltip(_tooltipTextForDim(hoveredDim), infoEl.getBoundingClientRect());
@@ -39905,7 +40113,6 @@
                     return;
                 }
                 _histDimHovering = false;
-                _clearOrientEdgeHighlight();
                 _hideHistTooltip();
                 if (!_lebesgueManual && primaryCb && primaryCb._expanded && !_histAutoDismissTimer) {
                     _restartHistAutoDismiss();
@@ -39915,6 +40122,7 @@
         infoEl.addEventListener('mouseleave', () => {
             hoveredDim = -1;
             _histDimHovering = false;
+            _orientHovering = false;
             _clearOrientEdgeHighlight();
             _hideHistTooltip();
             if (!_lebesgueManual && primaryCb && primaryCb._expanded && !_histAutoDismissTimer) {
@@ -41644,6 +41852,11 @@
                 dropMenu.classList.toggle('visible', _dropMenuVisible);
                 dropMenu.setAttribute('aria-hidden', _dropMenuVisible ? 'false' : 'true');
             }
+            const compareWithMenu = document.getElementById('compare-with-menu');
+            if (compareWithMenu) {
+                compareWithMenu.classList.toggle('visible', _compareWithMenuVisible);
+                compareWithMenu.setAttribute('aria-hidden', _compareWithMenuVisible ? 'false' : 'true');
+            }
             if (_zenActive) _setZenQmriChromeOpacity('0');
             renderToolMenu();
             if (typeof _reconcileOverlayPalette === 'function') _reconcileOverlayPalette();

{arrayview-0.46.2 → arrayview-0.47.1}/src/arrayview/_vscode_extension.py

@@ -58,7 +58,7 @@ _VSCODE_EXT_FRESH_INSTALL = False  # True if we just installed it this session
 _VSCODE_EXT_RELOAD_REQUIRED = False  # installed files are newer than the live host
 _VSCODE_EXT_INSTALL_FAILED = False  # automatic install could not complete safely
 _VSCODE_EXT_NO_LIVE_WINDOW = False  # no live host claims this terminal's window id
-_VSCODE_EXT_VERSION = "0.15.61"  # current bundled extension version
+_VSCODE_EXT_VERSION = "0.15.62"  # current bundled extension version
 _VSCODE_CONFIGURED_PORTS: set[int] = set()
 # Version-skew notices already printed, so a long-lived process (Jupyter, a
 # script opening several arrays) states the mismatch once instead of per call.

{arrayview-0.46.2 → arrayview-0.47.1}/tests/test_api.py

@@ -7844,3 +7844,23 @@ class TestViewDisplayRouting:
         finally:
             for sid in set(session_mod.SESSIONS) - before_sids:
                 session_mod.SESSIONS.pop(sid, None)
+
+
+def test_load_aligns_nifti_overlay_to_requested_base_grid(client, tmp_path):
+    nib = pytest.importorskip("nibabel")
+    import arrayview._session as session_mod
+
+    affine = np.diag([1.0, 1.0, 2.0, 1.0])
+    base = tmp_path / "base.nii.gz"
+    nib.save(nib.Nifti1Image(np.zeros((6, 6, 5), np.float32), affine), str(base))
+    mask = tmp_path / "mask.nii.gz"
+    nib.save(nib.Nifti1Image(np.ones((6, 6, 4), np.uint8), affine), str(mask))
+
+    plain = client.post("/load", json={"filepath": str(mask)}).json()["sid"]
+    aligned = client.post(
+        "/load", json={"filepath": str(mask), "align_to": str(base)}
+    ).json()["sid"]
+
+    assert aligned != plain
+    assert session_mod.SESSIONS[plain].shape == (6, 6, 4)
+    assert session_mod.SESSIONS[aligned].shape == (6, 6, 5)

{arrayview-0.46.2 → arrayview-0.47.1}/tests/test_nifti_meta.py

@@ -172,3 +172,26 @@ def test_explicit_ras_conversion_reorients_native_volume(client, tmp_path):
     reverted = client.post(f"/resample_ras/{sid}", json={"enabled": False})
     reverted.raise_for_status()
     assert reverted.json()["shape"] == [3, 4, 5]
+
+
+def test_overlay_on_different_grid_is_resampled_onto_base(tmp_path):
+    from arrayview._io import align_overlay_to_base, load_data, load_data_with_meta
+
+    base_affine = np.diag([1.0, 1.0, 2.0, 1.0])
+    nib.save(nib.Nifti1Image(np.zeros((8, 8, 6), np.float32), base_affine), tmp_path / "base.nii.gz")
+    # Mask has one slice fewer and starts one base slice (2 mm) higher.
+    mask = np.zeros((8, 8, 5), np.uint8)
+    mask[2:4, 3:5, 1] = 1
+    mask_affine = base_affine.copy()
+    mask_affine[2, 3] = 2.0
+    nib.save(nib.Nifti1Image(mask, mask_affine), tmp_path / "mask.nii.gz")
+
+    _base, meta = load_data_with_meta(str(tmp_path / "base.nii.gz"))
+    path = str(tmp_path / "mask.nii.gz")
+    aligned = align_overlay_to_base(path, load_data(path), meta)
+
+    assert aligned.shape == (8, 8, 6)
+    assert aligned.dtype == np.uint8
+    expected = np.zeros((8, 8, 6), np.uint8)
+    expected[2:4, 3:5, 2] = 1
+    np.testing.assert_array_equal(aligned, expected)