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

arrayview/_diff.py

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

arrayview/_render.py

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

arrayview/_routes_rendering.py

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

arrayview/_routes_websocket.py

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

arrayview/_session.py

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