arrayview 0.48.3__tar.gz → 0.49.0__tar.gz

{arrayview-0.48.3 → arrayview-0.49.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: arrayview
-Version: 0.48.3
+Version: 0.49.0
 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 → arrayview-0.49.0}/pyproject.toml

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

{arrayview-0.48.3 → arrayview-0.49.0}/src/arrayview/_analysis.py

@@ -60,6 +60,15 @@ def _build_metadata(session) -> dict:
     }
     if getattr(session, "initial_view", None):
         meta["initial_view"] = session.initial_view
+    if meta["has_source_file"]:
+        from arrayview._config import get_viewer_remember_view
+
+        if get_viewer_remember_view():
+            from arrayview._view_memory import remembered_view
+
+            remembered = remembered_view(session)
+            if remembered:
+                meta["remembered_view"] = remembered
     code_source = _code_source(session)
     if code_source is not None:
         meta["code_source"] = code_source

{arrayview-0.48.3 → arrayview-0.49.0}/src/arrayview/_config.py

@@ -39,6 +39,8 @@ BUILTIN_PREFERENCES = {
         "theme": "dark",
         "rounded_panes": True,
         "qmri_gapless": False,
+        "compare_gapless": False,
+        "remember_view": False,
         "ortho_layout": None,
         "dimbar_mode": "compact",
     },
@@ -49,6 +51,8 @@ PREFERENCE_SCHEMA = {
         "theme": sorted(_VALID_THEMES),
         "rounded_panes": "boolean",
         "qmri_gapless": "boolean",
+        "compare_gapless": "boolean",
+        "remember_view": "boolean",
         "colormaps": "non-empty list of names",
         "ortho_layout": sorted(_VALID_ORTHO_LAYOUTS),
         "dimbar_mode": sorted(_VALID_DIMBAR_MODES),
@@ -120,7 +124,7 @@ def _validate_preference(section: str, key: str, value):
         )
     if section == "viewer" and key == "theme":
         return _normalized_string(value, _VALID_THEMES, "viewer.theme")
-    if section == "viewer" and key in ("rounded_panes", "qmri_gapless"):
+    if section == "viewer" and key in ("rounded_panes", "qmri_gapless", "compare_gapless", "remember_view"):
         if not isinstance(value, bool):
             raise InvalidPreferenceError(f"viewer.{key} must be a boolean")
         return value
@@ -246,6 +250,20 @@ def get_viewer_qmri_gapless() -> bool:
     return isinstance(viewer_cfg, dict) and viewer_cfg.get("qmri_gapless") is True
 
 
+def get_viewer_compare_gapless() -> bool:
+    """Whether arrays compared side by side touch, with no space between them."""
+    viewer_cfg = load_config().get("viewer", {})
+    return isinstance(viewer_cfg, dict) and viewer_cfg.get("compare_gapless") is True
+
+
+def get_viewer_remember_view() -> bool:
+    """Whether reopening a file brings back the view it was last left in."""
+    viewer_cfg = load_config().get("viewer", {})
+    val = viewer_cfg.get("remember_view") if isinstance(viewer_cfg, dict) else None
+    # `arrayview config set` stores the word "true"; the Preferences menu a boolean.
+    return val is True or (isinstance(val, str) and val.strip().lower() in ("true", "1", "yes", "on"))
+
+
 def get_viewer_ortho_layout() -> str | None:
     """Return the preferred initial ortho-view layout."""
     viewer_cfg = load_config().get("viewer", {})

{arrayview-0.48.3 → arrayview-0.49.0}/src/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,
@@ -98,8 +135,13 @@ def _compute_diff(
     diff_mode,
     indices_a=None,
     indices_b=None,
+    stats_out=None,
 ):
-    """Return raw diff, display range, colormap, and optional separator mask."""
+    """Return raw diff, display range, colormap, and optional separator mask.
+
+    When *stats_out* is a dict it is filled with summary numbers for the
+    compared view (see `_diff_summary`).
+    """
     def _parse_indices(raw_indices):
         if raw_indices is None:
             return ()
@@ -114,71 +156,72 @@ 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 stats_out is not None:
+        stats_out.update(_diff_summary(a, b, nan_mask))
     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"
 
     return raw, vmin, vmax, colormap, nan_mask
 
 
+def _diff_summary(a: np.ndarray, b: np.ndarray, nan_mask: np.ndarray | None) -> dict[str, float]:
+    """RMS of A−B, largest |A−B|, and RMS of A−B relative to the RMS of A.
+
+    Pixels that are not finite in either array (or are mosaic separators)
+    are left out. Empty or all-zero inputs give NaN for what is undefined.
+    """
+    a = np.asarray(a, dtype=np.float64)
+    b = np.asarray(b, dtype=np.float64)
+    valid = np.isfinite(a) & np.isfinite(b)
+    if nan_mask is not None and nan_mask.shape == valid.shape:
+        valid &= ~nan_mask
+    if not valid.any():
+        return {"rmse": float("nan"), "max_abs": float("nan"), "rel": float("nan")}
+    d = a[valid] - b[valid]
+    rmse = float(np.sqrt(np.mean(d * d)))
+    rms_a = float(np.sqrt(np.mean(a[valid] ** 2)))
+    return {
+        "rmse": rmse,
+        "max_abs": float(np.max(np.abs(d))),
+        "rel": rmse / rms_a if rms_a > 0 else float("nan"),
+    }
+
+
 def _render_diff_rgba(
     raw: np.ndarray,
     vmin: float,
@@ -188,7 +231,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 +244,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-0.48.3 → arrayview-0.49.0}/src/arrayview/_io.py

@@ -1106,11 +1106,12 @@ class _FileSeries:
 
     _av_lazy = True
 
-    def __init__(self, file_matrix, vol_shape, dtype, spatial_meta=None):
+    def __init__(self, file_matrix, vol_shape, dtype, spatial_meta=None, spacing_matrix=None):
         self._file_matrix = file_matrix
         self._vol_shape = tuple(vol_shape)
         self._dtype = np.dtype(dtype)
         self._spatial_meta = spatial_meta
+        self._spacing_matrix = spacing_matrix
         n_patients = len(file_matrix)
         n_modalities = len(file_matrix[0]) if file_matrix else 0
         if n_modalities <= 1:
@@ -1126,6 +1127,10 @@ class _FileSeries:
         )
         self._cache_lock = threading.Lock()
 
+    @property
+    def case_voxel_spacings(self):
+        return self._spacing_matrix
+
     @property
     def dtype(self):
         return self._dtype
@@ -1378,6 +1383,11 @@ def _is_nifti_path(filepath):
     return filepath.endswith(".nii") or filepath.endswith(".nii.gz")
 
 
+def _is_gipl_path(filepath):
+    """True if *filepath* ends with .gipl or .gipl.gz."""
+    return filepath.lower().endswith((".gipl", ".gipl.gz"))
+
+
 def _get_ext(filepath):
     """Return the extension of *filepath*, normalising .nii.gz and .zarr.zip."""
     lower = filepath.lower()
@@ -1596,11 +1606,15 @@ def _series_from_file_matrix(
         return series, spatial_meta
 
     spatial_shapes = []
+    # GIPL headers carry a voxel size; use it when every file has one.
+    gipl_metas = [] if all(_is_gipl_path(path) for path in all_paths) else None
     for fpath in all_paths:
         arr = load_data(fpath)
         shape = arr.shape
         dtype = arr.dtype
         spatial_shapes.append(shape)
+        if gipl_metas is not None:
+            gipl_metas.append(_gipl_spatial_meta(fpath, arr))
         if ref_shape is None:
             ref_shape = shape
             ref_dtype = dtype
@@ -1616,30 +1630,47 @@ def _series_from_file_matrix(
             )
         if scan_progress is not None:
             scan_progress(scan_label, fpath)
+    spacing_matrix = None
+    if gipl_metas and all(meta is not None for meta in gipl_metas):
+        spatial_meta = gipl_metas[0]
+        spacing_matrix = []
     shape_matrix = []
     pos = 0
     for row in file_matrix:
         row_shapes = []
+        row_spacings = []
         for path in row:
             if path is None:
                 row_shapes.append(ref_shape)
+                if spacing_matrix is not None:
+                    row_spacings.append(gipl_metas[0]["voxel_sizes"])
             else:
                 row_shapes.append(spatial_shapes[pos])
+                if spacing_matrix is not None:
+                    row_spacings.append(gipl_metas[pos]["voxel_sizes"])
                 pos += 1
         shape_matrix.append(row_shapes)
+        if spacing_matrix is not None:
+            spacing_matrix.append(row_spacings)
     shapes_differ = any(shape != ref_shape for shape in spatial_shapes)
     if stack == "dense" and shapes_differ:
         raise ValueError("Dense stacking requires every file to have the same shape.")
     if stack == "ragged" or shapes_differ:
-        series = _RaggedFileSeries(file_matrix, shape_matrix, ref_dtype, spatial_meta=None)
+        series = _RaggedFileSeries(
+            file_matrix, shape_matrix, ref_dtype,
+            spatial_meta=spatial_meta, spacing_matrix=spacing_matrix,
+        )
     else:
-        series = _FileSeries(file_matrix, ref_shape, ref_dtype, spatial_meta=None)
+        series = _FileSeries(
+            file_matrix, ref_shape, ref_dtype,
+            spatial_meta=spatial_meta, spacing_matrix=spacing_matrix,
+        )
     if load == "eager":
         for p, row in enumerate(file_matrix):
             for m, path in enumerate(row):
                 if path is not None:
                     series._get_volume(p, m)
-    return series, None
+    return series, spatial_meta
 
 
 def _collection_scan_workers():
@@ -2350,6 +2381,9 @@ def load_data_with_meta(filepath, key=None, *, load="lazy", stack="auto", select
         return _load_file_series(filepath, load=load, stack=stack)
     if filepath.endswith(".nii") or filepath.endswith(".nii.gz"):
         return _load_nifti_with_meta(filepath)
+    if filepath.lower().endswith((".gipl", ".gipl.gz")):
+        arr = _load_gipl(filepath)
+        return arr, _gipl_spatial_meta(filepath, arr)
     return load_data(
         filepath, key=key, progress=progress, fast_first_frame=fast_first_frame
     ), None
@@ -2546,6 +2580,31 @@ def _load_gipl(filepath):
     return np.ascontiguousarray(arr)
 
 
+def _gipl_spatial_meta(filepath, arr):
+    """Voxel sizes from a GIPL header, so the viewer shows true proportions.
+
+    GIPL stores no orientation, so axis labels stay empty. Returns None when
+    the header has no usable voxel sizes.
+    """
+    import gzip
+
+    opener = gzip.open if filepath.lower().endswith(".gz") else open
+    with opener(filepath, "rb") as f:
+        header = f.read(_GIPL_HEADER_SIZE)
+    pixdim = np.frombuffer(header, ">f4", count=4, offset=10).astype(float)
+    n = min(arr.ndim, 3)
+    voxel_sizes = tuple(float(v) for v in pixdim[:n])
+    if not all(np.isfinite(v) and v > 0 for v in voxel_sizes):
+        return None
+    return {
+        "voxel_sizes": voxel_sizes,
+        "axis_labels": (),
+        "is_oblique": False,
+        "is_canonical": True,
+        "spatial_shape": tuple(int(v) for v in arr.shape[:n]),
+    }
+
+
 def _tensor_to_numpy(obj, source="object"):
     """Convert a tensor-like object (PyTorch, etc.) to a numpy array."""
     if isinstance(obj, np.ndarray):

{arrayview-0.48.3 → arrayview-0.49.0}/src/arrayview/_launcher.py

@@ -3539,11 +3539,12 @@ def view(
     vmax: float | None = None,
     log: bool = False,
     complex: str | None = None,
+    voxel_size=None,
 ):
     """
     Launch the viewer. Does not block the main Python process.
 
-    Accepts one to four arrays::
+    Accepts one to six arrays (the same limit as the command line)::
 
         handle = arrayview.view(a)
         ha, hb = arrayview.view(a, b)
@@ -3588,6 +3589,10 @@ def view(
     ``"imag"`` (``"mag"`` shows the absolute value of real data). Pressing
     ``E`` in the viewer copies the current view as such a call.
 
+    ``voxel_size`` — physical size of one step along each dimension, e.g.
+    ``(1, 1, 2)`` for 1 mm pixels and 2 mm slices. Slices then show their
+    true proportions. Leading dimensions only; later ones keep size 1.
+
     Returns a ``ViewHandle`` for a single array, or a tuple of ``ViewHandle``
     objects for multiple arrays (one per array). In inline/Jupyter mode with
     multiple arrays, the IFrame is displayed automatically and a uniform tuple
@@ -3601,9 +3606,14 @@ def view(
 
     _initial_view = _session_mod.initial_view_spec(
         mode=mode, dims=dims, index=index, cmap=cmap, vmin=vmin, vmax=vmax, log=log,
-        complex=complex,
+        complex=complex, voxel_size=voxel_size,
     )
     _code_name = _caller_variable_name(arrays[0]) if arrays else None
+    # Several arrays side by side need telling apart; the caller's variable
+    # names do that better than identical "Array (shape)" labels.
+    _var_names = (
+        [_caller_variable_name(arr) for arr in arrays] if len(arrays) > 1 else []
+    )
 
     height = _normalize_inline_height(height)
     _inline_mode_heights = _normalize_inline_mode_heights(mode_heights)
@@ -3612,8 +3622,8 @@ def view(
     n_arrays = len(arrays)
     if n_arrays == 0:
         raise ValueError("view() requires at least one array.")
-    if n_arrays > 4:
-        raise ValueError(f"view() accepts at most 4 arrays, got {n_arrays}.")
+    if n_arrays > 6:
+        raise ValueError(f"view() accepts at most 6 arrays, got {n_arrays}.")
 
     # --- Normalise per-array kwargs (name, rgb) ---
     if isinstance(name, list):
@@ -3664,6 +3674,8 @@ def view(
     arrays = tuple(_convert_array(arr) for arr in arrays)
 
     # --- Apply name defaults after conversion (shape is available now) ---
+    if len(set(filter(None, _var_names))) == n_arrays:
+        names = [names[i] if names[i] is not None else _var_names[i] for i in range(n_arrays)]
     names = [
         (f"Array {getattr(arrays[i], 'shape', '?')}" if names[i] is None else names[i])
         for i in range(n_arrays)
@@ -3680,6 +3692,13 @@ def view(
                 f"index has {len(_initial_view['index'])} entries but the array "
                 f"has {_ndim} dimensions"
             )
+    if _initial_view and "voxel_size" in _initial_view:
+        _ndim = len(getattr(data, "shape", ()))
+        if len(_initial_view["voxel_size"]) > _ndim:
+            raise ValueError(
+                f"voxel_size has {len(_initial_view['voxel_size'])} entries but the "
+                f"array has {_ndim} dimensions"
+            )
 
     # --- Normalise string window modes ---
     _raw_window = window

{arrayview-0.48.3 → arrayview-0.49.0}/src/arrayview/_platform.py

@@ -452,8 +452,17 @@ def _has_vscode_window_registration() -> bool:
 def _process_is_alive(pid: object) -> bool:
     try:
         numeric_pid = int(pid)
+    except (TypeError, ValueError):
+        return False
+    if os.name == "nt":
+        # Signal 0 is CTRL_C_EVENT on Windows: os.kill would try to interrupt
+        # a console process group rather than test whether the pid exists.
+        from arrayview._instance_registry import process_start_identity
+
+        return process_start_identity(numeric_pid) is not None
+    try:
         os.kill(numeric_pid, 0)
-    except (OSError, TypeError, ValueError):
+    except OSError:
         return False
     if sys.platform.startswith("linux"):
         try:

{arrayview-0.48.3 → arrayview-0.49.0}/src/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-0.48.3 → arrayview-0.49.0}/src/arrayview/_routes_preferences.py

@@ -68,6 +68,28 @@ def register_preferences_routes(app) -> None:
             return JSONResponse({"error": "session_not_found"}, status_code=404)
         return _response_payload()
 
+    @app.post("/view-memory/{sid}")
+    async def view_memory_post(sid: str, request: Request):
+        """Store the view a file was left in (Preferences → Reopen where you left off)."""
+        session = SESSIONS.get(sid)
+        if session is None:
+            return JSONResponse({"error": "session_not_found"}, status_code=404)
+        from arrayview._config import get_viewer_remember_view
+        from arrayview._view_memory import remember_view
+
+        if not get_viewer_remember_view():
+            return {"saved": False}
+        try:
+            body = await request.json()
+        except Exception:
+            return JSONResponse({"error": "invalid_json"}, status_code=400)
+        view = body.get("view") if isinstance(body, dict) else None
+        try:
+            saved = remember_view(session, view)
+        except OSError:
+            saved = False
+        return {"saved": saved}
+
     @app.patch("/preferences/{sid}")
     async def preferences_patch(sid: str, request: Request):
         if SESSIONS.get(sid) is None: