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

arrayview/_routes_rendering.py

@@ -226,6 +226,16 @@ def register_rendering_routes(app, *, get_session_or_404) -> None:
                     if qmri_role
                     else extract_slice(session, dim_x, dim_y, list(idx_tuple))
                 )
+                if qmri_role and (vmin_override is None or vmax_override is None):
+                    # Colour with the role-adjusted window reported back to the
+                    # viewer, which locks it for later slices; otherwise the
+                    # first scroll step visibly changes contrast.
+                    _, _lo, _hi = _prepare_display(
+                        session, raw, complex_mode, dr, log_scale
+                    )
+                    vmin_override, vmax_override = _qmri_adjust_vmin_vmax(
+                        _lo, _hi, qmri_role
+                    )
                 rgba = (
                     render_rgba_from_prepared(
                         session,

arrayview/_routes_websocket.py

@@ -271,9 +271,10 @@ def _render_qmri_rgba(
     Kept separate from the generic path so the slice read and the window
     computation happen exactly once, and so multi-pane qMRI/ortho renders run in
     the render thread pool instead of blocking the event loop serially. The
-    colour map is applied with the unadjusted window (matching the previous
-    synchronous path); the returned window is the qMRI-role-adjusted value sent
-    in the frame header.
+    colour map is applied with the qMRI-role-adjusted window, the same one sent
+    in the frame header: the viewer locks that window and sends it back on the
+    next slice, so colouring with anything else made the first scroll step
+    visibly change the contrast while the colorbar labels stayed put.
     """
     raw = qmri_display_slice(session, dim_x, dim_y, list(idx_tuple), qmri_role)
     data, vmin, vmax = _prepare_display(
@@ -285,6 +286,7 @@ def _render_qmri_rgba(
         vmin_override=vmin_override,
         vmax_override=vmax_override,
     )
+    vmin, vmax = _qmri_adjust_vmin_vmax(vmin, vmax, qmri_role)
     if vmax > vmin:
         normalized = np.clip((data - vmin) / (vmax - vmin), 0, 1)
     else:
@@ -301,7 +303,6 @@ def _render_qmri_rgba(
         if transparent.any():
             rgba = rgba.copy()
             rgba[transparent, 3] = 0
-    vmin, vmax = _qmri_adjust_vmin_vmax(vmin, vmax, qmri_role)
     return rgba, vmin, vmax
 
 

arrayview/_viewer.html

@@ -8818,19 +8818,36 @@
             return ranked.slice(0, 3).sort((a, b) => a - b);
         }
 
+        /** Anatomical axes of a NIfTI's three spatial dims, from its stored
+         *  orientation (any order, e.g. RAS or IAL): {R, A, S} each
+         *  {dim, positive}, where positive means the index grows toward R / A / S.
+         *  null when the orientation is unknown or the dims are not 0, 1, 2. */
+        function _labelAnatomy(dims) {
+            const labels = spatialMeta && spatialMeta.axis_labels;
+            if (!Array.isArray(labels) || labels.length < 3) return null;
+            if (!(dims[0] === 0 && dims[1] === 1 && dims[2] === 2)) return null;
+            const axes = {};
+            for (let d = 0; d < 3; d++) {
+                const l = String(labels[d]).toUpperCase();
+                const key = (l === 'R' || l === 'L') ? 'R' : (l === 'A' || l === 'P') ? 'A' : (l === 'S' || l === 'I') ? 'S' : null;
+                if (!key || axes[key]) return null;
+                axes[key] = { dim: d, positive: l === key };
+            }
+            return axes;
+        }
+
         function multiViewPlaneDefs(dims) {
-            // NIfTI volumes are reoriented to RAS before they reach the viewer.
-            // Keep their three clinical planes upright: axial R/L × A/P,
-            // coronal R/L × S/I, and sagittal A/P × S/I. Canvas y grows
-            // downward, so the two planes containing S/I need a vertical flip.
-            const rasSpatialDims = spatialMeta && Array.isArray(spatialMeta.axis_labels)
-                && spatialMeta.axis_labels.join(',') === 'R,A,S'
-                && dims[0] === 0 && dims[1] === 1 && dims[2] === 2;
-            if (rasSpatialDims) {
+            // NIfTI volumes: keep the three clinical planes upright whatever
+            // order the file stores its axes in: axial R/L × A/P, coronal
+            // R/L × S/I, sagittal A/P × S/I. R and A grow toward screen
+            // right/down as in RAS; canvas y grows downward, so S/I axes are
+            // flipped when needed to put superior at the top.
+            const ax = _labelAnatomy(dims);
+            if (ax) {
                 return [
-                    { dimX: dims[0], dimY: dims[1], sliceDir: dims[2], flipX: false, flipY: false },
-                    { dimX: dims[0], dimY: dims[2], sliceDir: dims[1], flipX: false, flipY: true },
-                    { dimX: dims[1], dimY: dims[2], sliceDir: dims[0], flipX: false, flipY: true },
+                    { dimX: ax.R.dim, dimY: ax.A.dim, sliceDir: ax.S.dim, flipX: !ax.R.positive, flipY: !ax.A.positive },
+                    { dimX: ax.R.dim, dimY: ax.S.dim, sliceDir: ax.A.dim, flipX: !ax.R.positive, flipY: ax.S.positive },
+                    { dimX: ax.A.dim, dimY: ax.S.dim, sliceDir: ax.R.dim, flipX: !ax.A.positive, flipY: ax.S.positive },
                 ];
             }
             // Preserve the established generic-array layout where no anatomical
@@ -8842,6 +8859,215 @@
             ];
         }
 
+        // ── View Cycling & Physical Proportions ──
+        // Shift+P steps a single view through the same three planes the
+        // 3-plane view shows. Per array, the viewer keeps:
+        //  - _viewMemory: screen axes + flips last used for each plane, keyed
+        //    by the plane's slice dim, so r/t adjustments survive cycling.
+        //  - _userAnatomy: {R, A, S} dims for arrays without an orientation
+        //    (named via Shift+A), which labels the planes and lays them out
+        //    like NIfTI ones.
+        //  - _userVoxelSizes: {dim: mm} for arrays without a voxel size.
+        let _viewMemory = {};
+        let _userAnatomy = null;
+        let _userVoxelSizes = null;
+        const _PLANE_NAMES = ['axial', 'coronal', 'sagittal'];
+
+        function _reservedNonSpatialDim() {
+            if (qmriActive) return qmriDim;
+            if (compareQmriActive) return compareQmriDim;
+            return -1;
+        }
+
+        /** The three spatial dims the plane cycle works on, ascending; null if none. */
+        function _cycleSpatialDims() {
+            const reserved = _reservedNonSpatialDim();
+            if (reserved < 0) {
+                const dims = defaultMultiViewDims();
+                return dims.length === 3 && dims.every(d => shape[d] > 1) ? dims : null;
+            }
+            const spatialLimit = collectionSpatialNdim >= 0 ? collectionSpatialNdim : shape.length;
+            const ranked = [...Array(spatialLimit).keys()]
+                .filter(d => d !== reserved)
+                .sort((a, b) => shape[b] - shape[a]);
+            const dims = ranked.slice(0, 3).sort((a, b) => a - b);
+            return dims.length === 3 && dims.every(d => shape[d] > 1) ? dims : null;
+        }
+
+        function _userAnatomyFits(dims) {
+            if (!_userAnatomy) return false;
+            const named = [_userAnatomy.R, _userAnatomy.A, _userAnatomy.S];
+            return named.every(d => dims.includes(d)) && new Set(named).size === 3;
+        }
+
+        /** Planes in cycle order: [{dimX, dimY, sliceDir, flipX, flipY, name}]. */
+        function _cyclePlanes() {
+            const dims = _cycleSpatialDims();
+            if (!dims) return null;
+            if (!spatialMeta && _userAnatomyFits(dims)) {
+                const { R, A, S } = _userAnatomy;
+                // Same screen layout as NIfTI planes; directions are unknown,
+                // so no flips until the user sets them with r/t.
+                return [
+                    { dimX: R, dimY: A, sliceDir: S, flipX: false, flipY: false, name: 'axial' },
+                    { dimX: R, dimY: S, sliceDir: A, flipX: false, flipY: false, name: 'coronal' },
+                    { dimX: A, dimY: S, sliceDir: R, flipX: false, flipY: false, name: 'sagittal' },
+                ];
+            }
+            const named = !!_labelAnatomy(dims);
+            return multiViewPlaneDefs(dims).map((p, i) => ({
+                dimX: p.dimX, dimY: p.dimY, sliceDir: p.sliceDir,
+                flipX: !!p.flipX, flipY: !!p.flipY,
+                name: named ? _PLANE_NAMES[i] : null,
+            }));
+        }
+
+        /** Index of the plane the single view is showing, or -1. */
+        function _currentPlaneIndex(planes) {
+            return planes.findIndex(p =>
+                (p.dimX === dim_x && p.dimY === dim_y) || (p.dimX === dim_y && p.dimY === dim_x));
+        }
+
+        function _planeLabel(planes, i) {
+            return planes[i].name || `view ${i + 1} of 3`;
+        }
+
+        /** Physical size (mm) of one step along `dim`, or null when unknown. */
+        function _voxelSizeOf(dim) {
+            if (_userVoxelSizes && Number.isFinite(_userVoxelSizes[dim]) && _userVoxelSizes[dim] > 0) {
+                return _userVoxelSizes[dim];
+            }
+            const vs = spatialMeta && spatialMeta.voxel_sizes;
+            if (Array.isArray(vs) && dim >= 0 && dim < 3 && Number.isFinite(vs[dim]) && vs[dim] > 0) return vs[dim];
+            return null;
+        }
+
+        /** On-screen height of one pixel relative to its width for a plane
+         *  showing dimX across and dimY down: 1 unless both voxel sizes are known. */
+        function _pixelAspect(dimX, dimY) {
+            if (squareStretch) return 1;
+            const sx = _voxelSizeOf(dimX), sy = _voxelSizeOf(dimY);
+            if (!sx || !sy) return 1;
+            return Math.max(0.05, Math.min(20, sy / sx));
+        }
+
+        /** Shift+P: show the plane after the current one, keeping each plane's
+         *  remembered screen axes and flips. */
+        function _switchToNextPlane(planes) {
+            const cur = _currentPlaneIndex(planes);
+            if (cur >= 0) {
+                _viewMemory[planes[cur].sliceDir] = { dimX: dim_x, dimY: dim_y, flipX: flip_x, flipY: flip_y };
+            }
+            const next = (cur + 1) % planes.length;
+            const plane = planes[next];
+            const mem = _viewMemory[plane.sliceDir];
+            const pick = (mem && [mem.dimX, mem.dimY].every(d => d === plane.dimX || d === plane.dimY)) ? mem : plane;
+            const wasSliceActive = activeDim === current_slice_dim || activeDim === dim_x || activeDim === dim_y;
+            dim_x = pick.dimX; dim_y = pick.dimY;
+            flip_x = !!pick.flipX; flip_y = !!pick.flipY;
+            current_slice_dim = plane.sliceDir;
+            if (wasSliceActive) activeDim = current_slice_dim;
+            if (projectionMode > 0) projectionDim = current_slice_dim;
+            _roiClearOnDimChange();
+            if (qmriActive || compareQmriActive) qvScaleAllCanvases();
+            updateView();
+            if (!qmriActive && !compareQmriActive) triggerPreload();
+            if (typeof _cropReconcileBindings === 'function') _cropReconcileBindings();
+            renderInfo(); saveState();
+            showStatus(_planeLabel(planes, next));
+        }
+
+        /** Briefly fade the dimbar out, run `change`, and fade it back in, so
+         *  its labels don't jump. Runs `change` straight away when the dimbar
+         *  is hidden or a fade is already under way. */
+        let _dimbarFadeAnim = null;
+        function _fadeDimbarAround(change) {
+            const info = document.getElementById('info');
+            if (!info || typeof info.animate !== 'function' || _dimbarFadeAnim
+                || parseFloat(getComputedStyle(info).opacity) < 0.5) { change(); return; }
+            const out = info.animate([{ opacity: 1 }, { opacity: 0 }], { duration: 70, easing: 'ease-in', fill: 'forwards' });
+            _dimbarFadeAnim = out;
+            const done = () => { _dimbarFadeAnim = null; };
+            out.oncancel = done;
+            out.onfinish = () => {
+                change();
+                out.oncancel = null;
+                out.cancel();
+                const back = info.animate([{ opacity: 0 }, { opacity: 1 }], { duration: 110, easing: 'ease-out' });
+                _dimbarFadeAnim = back;
+                back.onfinish = done;
+                back.oncancel = done;
+            };
+        }
+
+        /** Shift+A on an array without stored orientation: name the current
+         *  view and/or give the voxel size, e.g. "axial 1 1 3". */
+        async function _describeArrayOrientation() {
+            const dims = _cycleSpatialDims();
+            if (!dims) { showStatus('need three spatial dimensions'); return; }
+            const planes = _cyclePlanes();
+            const cur = _currentPlaneIndex(planes);
+            const curName = cur >= 0 ? (planes[cur].name || '') : '';
+            const sizes = dims.map(d => _voxelSizeOf(d));
+            const sizeText = sizes.every(v => v) ? sizes.map(v => String(+v.toFixed(4))).join(' ') : '';
+            const answer = await showInlinePrompt(
+                `Name this view (axial, coronal or sagittal) and/or the voxel size in mm along dims ${dims.join(', ')} — e.g. "axial 1 1 3". Empty clears both.`,
+                `${curName} ${sizeText}`.trim(),
+            );
+            if (answer === null) return;
+            const tokens = answer.trim().toLowerCase().split(/[\s,;×]+/).filter(Boolean);
+            const words = tokens.filter(t => /^[a-z]+$/.test(t));
+            const nums = tokens.filter(t => !/^[a-z]+$/.test(t)).map(Number);
+            if (nums.some(n => !Number.isFinite(n) || n <= 0) || ![0, 1, 3].includes(nums.length) || words.length > 1) {
+                showStatus('expected a view name and/or 1 or 3 positive numbers'); return;
+            }
+            let name = null;
+            if (words.length) {
+                name = _PLANE_NAMES.find(n => n.startsWith(words[0]));
+                if (!name) { showStatus('view name must be axial, coronal or sagittal'); return; }
+                if (cur < 0) { showStatus('show one of the three views first (Shift+P)'); return; }
+            }
+            if (!tokens.length) {
+                _userAnatomy = null; _userVoxelSizes = null;
+            } else {
+                if (name) {
+                    const sl = planes[cur].sliceDir;
+                    _userAnatomy = name === 'axial' ? { R: dim_x, A: dim_y, S: sl }
+                        : name === 'coronal' ? { R: dim_x, S: dim_y, A: sl }
+                        : { A: dim_x, S: dim_y, R: sl };
+                    // The other two views get the named layout afresh; this
+                    // one stays exactly as it is on screen.
+                    _viewMemory = { [sl]: { dimX: dim_x, dimY: dim_y, flipX: flip_x, flipY: flip_y } };
+                }
+                if (nums.length) {
+                    const v = nums.length === 1 ? [nums[0], nums[0], nums[0]] : nums;
+                    _userVoxelSizes = {};
+                    dims.forEach((d, i) => { _userVoxelSizes[d] = v[i]; });
+                }
+            }
+            ModeRegistry.scaleAll();
+            renderInfo(); saveState();
+            const parts = [];
+            if (!tokens.length) parts.push('view names and voxel size cleared');
+            if (name) parts.push(`this is the ${name} view`);
+            if (nums.length) parts.push(`voxel size ${dims.map(d => _userVoxelSizes[d]).join(' × ')} mm`);
+            showStatus(parts.join(' · '));
+        }
+
+        /** Layout size of a pane showing dimX × dimY in on-screen proportions.
+         *  With both voxel sizes known it is in units of the finest voxel of
+         *  the array, so panes laid out side by side share one mm-per-pixel
+         *  scale; otherwise it is the raw pixel size. */
+        function _physicalPaneSize(w, h, dimX, dimY) {
+            if (squareStretch) return { w, h };
+            const sx = _voxelSizeOf(dimX), sy = _voxelSizeOf(dimY);
+            if (!sx || !sy) return { w, h };
+            const known = [...Array(shape.length).keys()].map(_voxelSizeOf).filter(Boolean);
+            const ref = Math.min(...known);
+            const k = v => Math.max(0.05, Math.min(20, v / ref));
+            return { w: w * k(sx), h: h * k(sy) };
+        }
+
         /** x/y/z letter for one of the current multiview's 3 spatial dims,
          *  by its position in mvDims — a pane's two screen axes aren't always
          *  literally x/y (e.g. a sagittal pane is y/z). */
@@ -9150,6 +9376,7 @@
 
         function _calcSinglePaneViewportRect(w, h, zoom, immersive) {
             if (!w || !h) return null;
+            h = h * _pixelAspect(dim_x, dim_y);
             const immersivePad = 12;
             const sidePad = immersive ? immersivePad * 2 : NORMAL_SIDE_RESERVE;
             const bottomReserve = immersive ? 0 : NORMAL_BOTTOM_RESERVE;
@@ -9207,6 +9434,8 @@
         }
 
         function scaleCanvas(w, h) {
+            // Layout works in on-screen proportions: thick voxels draw taller.
+            h = h * _pixelAspect(dim_x, dim_y);
             const immersivePad = 12;
             const cP = _crossfadeCollapseP;
             const bottomReserve = _fullscreenActive ? 0 : NORMAL_BOTTOM_RESERVE * (1 - cP);
@@ -9309,7 +9538,10 @@
             const cbExtra = compareCenterCbReserve;
             const panePadY = (_fullscreenActive ? 0 : 12 * (1 - _crossfadeCollapseP)) + cbExtra;
             const fitSlack = 0.96 + 0.04 * (_fullscreenActive ? 1 : _crossfadeCollapseP);
-            const activeFrames = compareFrames.filter(Boolean);
+            // Layout-only sizes in on-screen proportions (thick voxels draw taller).
+            const _cmpAspect = _pixelAspect(dim_x, dim_y);
+            const activeFrames = compareFrames.filter(Boolean)
+                .map(f => _cmpAspect === 1 ? f : { ...f, height: f.height * _cmpAspect });
             const paneCount = activeFrames.length;
             if (!paneCount) return;
             const hasCenterPane = (diffMode > 0 || registrationMode || _wipeActive || _flickerActive || _checkerActive);
@@ -23079,6 +23311,9 @@
                 dim_z,
                 current_slice_dim,
                 activeDim,
+                viewMemory: { ..._viewMemory },
+                userAnatomy: _userAnatomy,
+                userVoxelSizes: _userVoxelSizes,
                 compareSid: detachedDimMode ? null : compareSid,
                 compareSidList: detachedDimMode ? [] : [...compareSidList],
                 compareName,
@@ -23158,6 +23393,27 @@
                 { const _dv = modeManager.getFocusedView() || modeManager.currentViews[0]; if (_dv) { _dv.displayState.vmin = manualVmin; _dv.displayState.vmax = manualVmax; } }
             }
 
+            {
+                const okDim = d => Number.isInteger(d) && d >= 0 && d < shape.length;
+                _viewMemory = {};
+                if (s.viewMemory && typeof s.viewMemory === 'object') {
+                    for (const [k, m] of Object.entries(s.viewMemory)) {
+                        if (m && okDim(Number(k)) && okDim(m.dimX) && okDim(m.dimY)) {
+                            _viewMemory[k] = { dimX: m.dimX, dimY: m.dimY, flipX: !!m.flipX, flipY: !!m.flipY };
+                        }
+                    }
+                }
+                const a = s.userAnatomy;
+                _userAnatomy = (a && okDim(a.R) && okDim(a.A) && okDim(a.S)) ? { R: a.R, A: a.A, S: a.S } : null;
+                _userVoxelSizes = null;
+                if (s.userVoxelSizes && typeof s.userVoxelSizes === 'object') {
+                    const vs = {};
+                    for (const [k, v] of Object.entries(s.userVoxelSizes)) {
+                        if (okDim(Number(k)) && Number.isFinite(v) && v > 0) vs[k] = v;
+                    }
+                    if (Object.keys(vs).length) _userVoxelSizes = vs;
+                }
+            }
             if (Number.isInteger(s.dim_x) && s.dim_x >= 0 && s.dim_x < shape.length) dim_x = s.dim_x;
             if (Number.isInteger(s.dim_y) && s.dim_y >= 0 && s.dim_y < shape.length) dim_y = s.dim_y;
             if (Number.isInteger(s.dim_z) && s.dim_z >= -1 && s.dim_z < shape.length) dim_z = s.dim_z;
@@ -26847,8 +27103,9 @@
             const vpW = vp ? vp.offsetWidth : cssW;
             const vpH = vp ? vp.offsetHeight : cssH;
             const selW = x1 - x0; // image pixels
-            const selH = y1 - y0;
-            const baseScale = getBaseScale(canvas.width, canvas.height);
+            const _selAspect = _pixelAspect(dim_x, dim_y);
+            const selH = (y1 - y0) * _selAspect;
+            const baseScale = getBaseScale(canvas.width, canvas.height * _selAspect);
             // fitZoom: scale that maps the selection to fill the viewport
             const fitZoom = Math.min(vpW / (selW * baseScale), vpH / (selH * baseScale));
             userZoom = Math.max(0.1, Math.min(10.0, fitZoom));
@@ -28026,18 +28283,16 @@
                 },
             },
             'nifti.toggleRasResample': {
-                title: 'Toggle explicit RAS conversion (NIfTI)',
+                title: 'Toggle explicit RAS conversion (NIfTI) / name view and voxel size (other arrays)',
                 when: [],
                 run: (ctx, e) => {
                     if (_rasResampleLoading) return;
+                    // Arrays with no stored orientation: describe it instead.
+                    if (!spatialMeta) { _describeArrayOrientation(); return; }
                     if (compareActive || qmriActive) {
                         showToast('RAS resample not supported in compare/qMRI mode');
                         return;
                     }
-                    if (!spatialMeta) {
-                        showToast('RAS resample: not a NIfTI scan');
-                        return;
-                    }
                     if (!spatialMeta.is_oblique && spatialMeta.is_canonical !== false) {
                         const labels = (spatialMeta.axis_labels || []).join('');
                         showToast(`already in canonical RAS (${labels || 'axis-aligned'}) — no resample needed`);
@@ -28124,6 +28379,19 @@
                     showToast(roundedPanes ? 'rounded panes: on' : 'rounded panes: off');
                 },
             },
+            'view.cyclePlane': {
+                title: 'Next view (axial / coronal / sagittal)',
+                when: [],
+                run: (ctx, e) => {
+                    if (multiViewActive || compareMvActive || qmriMvActive) { showStatus('views: the 3-plane view already shows all three'); return; }
+                    if (dim_z >= 0 || qmriMosaicActive || stackMosaicActive) { showStatus('views: leave the mosaic first'); return; }
+                    if (mipActive || cutawayActive) { showStatus('views: not available in 3-D view'); return; }
+                    if (rgbMode || hasVectorfield) { showStatus('views: not available for this array'); return; }
+                    const planes = _cyclePlanes();
+                    if (!planes) { showStatus('views: need three spatial dimensions'); return; }
+                    _fadeDimbarAround(() => _switchToNextPlane(planes));
+                },
+            },
             'view.transpose': {
                 title: 'Transpose x/y',
                 when: [],
@@ -29682,6 +29950,7 @@
             { key: 'T', command: 'theme.cycle' },
             { key: 'r', command: 'view.rotateOrFlip' },
             { key: 't', command: 'view.transpose' },
+            { key: 'P', shift: true, command: 'view.cyclePlane' },
             { key: 'b', command: 'borders.toggle' },
             { key: 'B', command: 'panes.rounded.toggle' },
             { key: 'a', command: 'view.toggleSquareStretch' },
@@ -29791,6 +30060,7 @@
                         entries: [
                             { key: '← → ↑ ↓', action: 'Step through slices' },
                             { key: 'x / y', action: 'Change viewing dimension', hint: 'choose which axes map to horizontal and vertical' },
+                            { key: 'Shift+P', action: 'Next view — axial → coronal → sagittal', hint: 'each view keeps its own r / t rotation and flip · NIfTI views are named; for other arrays Shift+A names the current view and sets the voxel size' },
                             { key: 'Shift+D', action: 'Toggle dimbar max indices' },
                             { key: 'z', action: 'Mosaic — tile all slices in a grid' },
                             { key: 'Shift+;', action: 'Stack mosaic — view N arrays at once', hint: 'asks for N · [ ] move the window · Enter opens a tile · Shift+U shows true physical size' },
@@ -37342,8 +37612,9 @@
                          - bottomPad * (1 - _crossfadeCollapseP);
             const absMaxScaleW = (window.innerWidth - sidePad - (cols - 1) * colGap) / cols;
             const absMaxScaleH = Math.max(10, totalH / rows);
+            const _cqAspect = _pixelAspect(dim_x, dim_y);
             const absMaxScale = Math.min(...ready.map(v =>
-                Math.min(absMaxScaleW / v.lastW, absMaxScaleH / v.lastH)));
+                Math.min(absMaxScaleW / v.lastW, absMaxScaleH / (v.lastH * _cqAspect))));
             const { capped: cappedScale, atMax: _cqAtMax } = _clampUniformZoom(absMaxScale);
             // Per-pane geometry routed through the shared _scalePane primitive.
             // compare-qMRI has no pan state and no per-pane viewport element —
@@ -37357,7 +37628,7 @@
             const _cqPanStub = { x: 0, y: 0, clamp: () => {}, apply: () => {} };
             for (const v of ready) {
                 const r = _scalePane(
-                    { canvas: v.canvas, w: v.lastW, h: v.lastH, pan: _cqPanStub },
+                    { canvas: v.canvas, w: v.lastW, h: v.lastH * _cqAspect, pan: _cqPanStub },
                     null,
                     {
                         maxW: Math.round(absMaxScaleW),
@@ -37966,12 +38237,13 @@
             const absMaxT = Math.max(10, Math.min(absMaxScaleW, absMaxScaleH));
             const { atMax: _cmvAtMax } = _clampUniformZoom(absMaxT);
             const T = Math.min(Math.max(10, Math.floor(absMaxT * userZoom)), absMaxT);
-            const maxSide = Math.max(...ready.map(v => Math.max(v.lastW, v.lastH)));
+            const _cmvSizes = new Map(ready.map(v => [v, _physicalPaneSize(v.lastW, v.lastH, v.dimX, v.dimY)]));
+            const maxSide = Math.max(...ready.map(v => Math.max(_cmvSizes.get(v).w, _cmvSizes.get(v).h)));
             const cmvBaseScale = absMaxT / maxSide;
             const _cmvPanStub = { x: 0, y: 0, clamp: () => {}, apply: () => {} };
             for (const v of ready) {
                 _scalePane(
-                    { canvas: v.canvas, w: v.lastW, h: v.lastH, pan: _cmvPanStub },
+                    { canvas: v.canvas, w: _cmvSizes.get(v).w, h: _cmvSizes.get(v).h, pan: _cmvPanStub },
                     null,
                     {
                         maxW: T,
@@ -38559,7 +38831,8 @@
             const absMaxT = Math.max(10, Math.min(absMaxScaleW, absMaxScaleH));
             const { atMax } = _clampUniformZoom(absMaxT);
             const T = Math.min(Math.max(10, Math.floor(absMaxT * userZoom)), absMaxT);
-            const maxSide = Math.max(...ready.map(v => Math.max(v.lastW, v.lastH)));
+            const _qmvSizes = new Map(ready.map(v => [v, _physicalPaneSize(v.lastW, v.lastH, v.dimX, v.dimY)]));
+            const maxSide = Math.max(...ready.map(v => Math.max(_qmvSizes.get(v).w, _qmvSizes.get(v).h)));
             const baseScale = absMaxT / maxSide;
             const panStub = { x: 0, y: 0, clamp: () => {}, apply: () => {} };
             for (const v of ready) {
@@ -38571,7 +38844,7 @@
                     v.clip.classList.toggle('qmv-br', qr === nRows - 1 && qc === 2);
                 }
                 _scalePane(
-                    { canvas: v.canvas, w: v.lastW, h: v.lastH, pan: panStub },
+                    { canvas: v.canvas, w: _qmvSizes.get(v).w, h: _qmvSizes.get(v).h, pan: panStub },
                     v.clip || null,
                     {
                         maxW: T, maxH: T,
@@ -38984,7 +39257,7 @@
             const layoutSizes = ready.map(v => ({
                 v,
                 w: Math.max(1, Number(shape[dim_x]) || v.lastW),
-                h: Math.max(1, Number(shape[dim_y]) || v.lastH),
+                h: Math.max(1, Number(shape[dim_y]) || v.lastH) * _pixelAspect(dim_x, dim_y),
             }));
             const absMaxScale = Math.min(...layoutSizes.map(({ w, h }) =>
                 Math.min(absMaxScaleW / w, absMaxScaleH / h)));
@@ -39986,9 +40259,10 @@
                     ready.forEach((v, i) => {
                         const rt = rects[i];
                         if (!rt || !rt.w || !rt.h) return;
-                        const fit = Math.min(rt.w / v.lastW, rt.h / v.lastH);
+                        const ps = _physicalPaneSize(v.lastW, v.lastH, v.dimX, v.dimY);
+                        const fit = Math.min(rt.w / ps.w, rt.h / ps.h);
                         _scalePane(
-                            { canvas: v.canvas, w: v.lastW, h: v.lastH, pan: _presetPanStub },
+                            { canvas: v.canvas, w: ps.w, h: ps.h, pan: _presetPanStub },
                             v.pane || null,
                             {
                                 maxW: rt.w, maxH: rt.h,
@@ -40059,13 +40333,14 @@
             // multi-view is already handled by the pre-loop overshoot clamp above, so
             // every pane is scaled with updateAutoFit:false / allowOverflowRecalc:false
             // (no reference pane is needed — nothing in the loop mutates userZoom).
-            const maxSide = Math.max(...ready.map(v => Math.max(v.lastW, v.lastH)));
+            const _mvSizes = new Map(ready.map(v => [v, _physicalPaneSize(v.lastW, v.lastH, v.dimX, v.dimY)]));
+            const maxSide = Math.max(...ready.map(v => Math.max(_mvSizes.get(v).w, _mvSizes.get(v).h)));
             const mvBaseScale = absMaxT / maxSide;
             const _mvPanStub = { x: 0, y: 0, clamp: () => {}, apply: () => {} };
             for (const v of ready) {
                 if (v.pane) v.pane.classList.remove('mv-small-pane');
                 _scalePane(
-                    { canvas: v.canvas, w: v.lastW, h: v.lastH, pan: _mvPanStub },
+                    { canvas: v.canvas, w: _mvSizes.get(v).w, h: _mvSizes.get(v).h, pan: _mvPanStub },
                     v.pane || null,
                     {
                         maxW: T,
@@ -41166,6 +41441,7 @@
         // were forImmersive. Mirrors the _autoFitPending branch in scaleCanvas.
         function _calcAutoFitZoom(w, h, forImmersive) {
             if (!w || !h) return 1;
+            h = h * _pixelAspect(dim_x, dim_y);
             if (compareActive) {
                 // In compare mode, compareScaleCanvases handles actual sizing.
                 // At userZoom=1.0 the base scale already fits each image in its pane,

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: arrayview
-Version: 0.48.2
+Version: 0.48.3
 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.2.dist-info → arrayview-0.48.3.dist-info}/RECORD

@@ -28,11 +28,11 @@ 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=HEA0okhZeiOADOEMdntOYe-mPMP2b_hfBBoAgiyQ-M4,22793
+arrayview/_routes_rendering.py,sha256=6DD8VxPglnPsG0rnE-qk6ogcNRe2S_KAh3K54QYUHFQ,23380
 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=78XmMyuD_-KjG5dHpzbhtN4dOa5m5BeyHfASAFYg85c,43552
+arrayview/_routes_websocket.py,sha256=zfwojLG-c6NaxZanZgmiPpoQUpCmQFqCOglaydjtzJ4,43675
 arrayview/_segmentation.py,sha256=aENWHmefrKDScXhcZL1X3KgYXE784dpMkmFFo83qnrw,7377
 arrayview/_server.py,sha256=Ejh-6rWpWo0luhBhtsVq1Z4RFIyOPVv5nzExHtXb7iA,23042
 arrayview/_session.py,sha256=D4I6FLazLEXbo0IdkyRrzhvMNhvAI6dSyYu5I3tMCaM,42137
@@ -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=KJecxCJXM-dVDb3df9BftEAxiKuiqKfksaWlnj6xHY4,2387023
+arrayview/_viewer.html,sha256=jKI9Ic8YwKYoIKhii_k019xb0ujcf-tgi8kkzfLyyl0,2402661
 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.2.dist-info/METADATA,sha256=iF32fWHFv__muQOvQPW_UDhkozFyTaaj4yGhot_ps3U,2288
-arrayview-0.48.2.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-arrayview-0.48.2.dist-info/entry_points.txt,sha256=-0s08axutXkTbINiKs0Q7iv-33aWuTaamUg2q2-NyQ4,60
-arrayview-0.48.2.dist-info/licenses/LICENSE,sha256=34OivjM9faB2QaPjZpMRTIiSx31V3U9cEyQ6F2k-bH0,1062
-arrayview-0.48.2.dist-info/RECORD,,
+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,,