arrayview 0.48.1__tar.gz → 0.48.3__tar.gz

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

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

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

{arrayview-0.48.1 → arrayview-0.48.3}/src/arrayview/_diff.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import numpy as np
 
 from arrayview._render import (
+    lut_rgba,
     LUTS,
     _build_mosaic_grid,
     _compute_vmin_vmax,
@@ -192,7 +193,7 @@ def _render_diff_rgba(
         normalized = np.zeros_like(raw)
     _ensure_lut(colormap)
     lut = LUTS.get(colormap, LUTS["gray"])
-    rgba = lut[(normalized * 255).astype(np.uint8)]
+    rgba = lut_rgba(lut, (normalized * 255).astype(np.uint8))
     if nan_mask is not None and nan_mask.shape == rgba.shape[:2]:
         rgba[nan_mask] = [22, 22, 22, 255]
     return rgba

{arrayview-0.48.1 → arrayview-0.48.3}/src/arrayview/_render.py

@@ -190,11 +190,13 @@ def extract_slice(session, dim_x, dim_y, idx_list, progress=None):
     # slicer below, so the extracted data doesn't depend on them.
     key_idx = tuple(None if i in (dim_x, dim_y) else idx_list[i] for i in range(len(idx_list)))
     key = (dim_x, dim_y, key_idx)
-    with session._raw_lock:
-        if key in session.raw_cache:
-            session.raw_cache.move_to_end(key)
-            return session.raw_cache[key]
+    return _cache_once(
+        session, session._raw_lock, "raw_cache", "_raw_bytes", "RAW_CACHE_BYTES",
+        key, lambda: _read_slice(session, dim_x, dim_y, idx_list, progress),
+    )
+
 
+def _read_slice(session, dim_x, dim_y, idx_list, progress):
     slicer = [
         slice(None) if i in (dim_x, dim_y) else idx_list[i]
         for i in range(len(session.shape))
@@ -244,12 +246,6 @@ def extract_slice(session, dim_x, dim_y, idx_list, progress=None):
         # buffer as too small. Present the single axis as one row so that
         # invariant holds everywhere instead of at each call site.
         result = result.reshape(1, -1)
-
-    with session._raw_lock:
-        if key not in session.raw_cache:  # double-check: another worker may have populated it
-            session.raw_cache[key] = result
-            session._raw_bytes += result.nbytes
-            _evict_lru(session, "_raw_bytes", "raw_cache", "RAW_CACHE_BYTES")
     return result
 
 
@@ -274,11 +270,13 @@ def extract_projection(session, dim_x, dim_y, idx_list, proj_dim, proj_mode):
         for i in range(len(idx_list))
     )
     key = ("proj", dim_x, dim_y, key_idx, proj_dim, proj_mode)
-    with session._raw_lock:
-        if key in session.raw_cache:
-            session.raw_cache.move_to_end(key)
-            return session.raw_cache[key]
+    return _cache_once(
+        session, session._raw_lock, "raw_cache", "_raw_bytes", "RAW_CACHE_BYTES",
+        key, lambda: _compute_projection(session, dim_x, dim_y, idx_list, proj_dim, proj_mode),
+    )
 
+
+def _compute_projection(session, dim_x, dim_y, idx_list, proj_dim, proj_mode):
     # Build slicer: display dims + projection dim get slice(None), rest use idx
     slicer = []
     for i in range(len(session.shape)):
@@ -317,11 +315,6 @@ def extract_projection(session, dim_x, dim_y, idx_list, proj_dim, proj_mode):
         result = np.nan_to_num(result).astype(np.complex64)
     else:
         result = np.nan_to_num(result).astype(np.float32)
-    with session._raw_lock:
-        if key not in session.raw_cache:
-            session.raw_cache[key] = result
-            session._raw_bytes += result.nbytes
-            _evict_lru(session, "_raw_bytes", "raw_cache", "RAW_CACHE_BYTES")
     return result
 
 
@@ -358,6 +351,20 @@ def _prepare_display(
     return data, vmin, vmax
 
 
+def lut_rgba(lut: np.ndarray, indices: np.ndarray) -> np.ndarray:
+    """Return ``lut[indices]`` as (..., 4) uint8, gathering whole pixels.
+
+    Indexing the (256, 4) table copies four bytes one channel at a time; the
+    same table viewed as 256 uint32 gathers each pixel in one step, ~4x
+    faster on a large mosaic and byte-for-byte identical. The gather keeps
+    the index array's memory order, so a transposed slice is made C-order
+    first or the uint8 view cannot be taken.
+    """
+    table = np.ascontiguousarray(lut, dtype=np.uint8).view(np.uint32).reshape(-1)
+    indices = np.ascontiguousarray(indices)
+    return table[indices].view(np.uint8).reshape(*indices.shape, 4)
+
+
 def _ensure_lut(name: str) -> bool:
     """Ensure name is in LUTS. Returns True if valid."""
     _init_luts()
@@ -404,7 +411,7 @@ def apply_colormap_rgba(
         normalized = np.zeros_like(data)
     _ensure_lut(colormap)
     lut = LUTS.get(colormap, LUTS["gray"])
-    rgba = lut[(normalized * 255).astype(np.uint8)]
+    rgba = lut_rgba(lut, (normalized * 255).astype(np.uint8))
     alpha_on = getattr(session, "alpha_level", 0) > 0
     if alpha_on:
         if vmax > vmin:
@@ -835,15 +842,102 @@ def render_mosaic(
     vmin_override=None,
     vmax_override=None,
     progress=None,
+    fit=None,
 ):
+    """Render the mosaic grid of every slice along *dim_z*.
+
+    ``fit=(w, h)`` returns the grid already shrunk to the viewer's canvas
+    (as the live socket would before sending) and caches it that way, so a
+    grid warmed ahead of time is ready to send: the shrink of a 240-slice
+    grid costs as much as rendering it.
+    """
     idx_norm = list(idx_tuple)
     idx_norm[dim_z] = 0
     key = (dim_x, dim_y, dim_z, tuple(idx_norm), colormap, dr, complex_mode, log_scale, mosaic_cols, vmin_override, vmax_override)
-    with session._mosaic_lock:
-        if key in session.mosaic_cache:
-            session.mosaic_cache.move_to_end(key)
-            return session.mosaic_cache[key]
 
+    def build_full():
+        return _build_mosaic_rgba(
+            session, dim_x, dim_y, dim_z, idx_tuple, colormap, dr, complex_mode,
+            log_scale, mosaic_cols, vmin_override, vmax_override, progress,
+        )
+
+    full = lambda: _mosaic_once(session, key, build_full)
+    if not fit:
+        return full()
+    fit_w, fit_h = int(fit[0]), int(fit[1])
+    return _mosaic_once(session, key + (("fit", fit_w, fit_h),), lambda: fit_rgba(full(), fit_w, fit_h))
+
+
+def _mosaic_once(session, key, build):
+    return _cache_once(
+        session, session._mosaic_lock, "mosaic_cache", "_mosaic_bytes",
+        "MOSAIC_CACHE_BYTES", key, build,
+    )
+
+
+def _cache_once(session, lock, cache_attr, bytes_attr, budget_attr, key, build):
+    """Return session.<cache_attr>[key], building it once under concurrent asks.
+
+    Lookahead and the request it anticipated, a hedged duplicate request, or
+    several panes can ask for the same entry at the same moment; without this
+    each rebuilt (re-read from disk) what another was half-way through,
+    doubling the wait it was meant to hide. Later askers wait for the builder
+    and take its result; if the builder fails, the next one builds it itself.
+    """
+    cache = getattr(session, cache_attr)
+    while True:
+        with lock:
+            if key in cache:
+                cache.move_to_end(key)
+                return cache[key]
+            inflight_attr = f"_{cache_attr}_inflight"
+            inflight = getattr(session, inflight_attr, None)
+            if inflight is None:
+                inflight = {}
+                setattr(session, inflight_attr, inflight)
+            event = inflight.get(key)
+            owner = event is None
+            if owner:
+                event = inflight[key] = threading.Event()
+        if not owner:
+            event.wait()
+            if hasattr(event, "value"):
+                return event.value  # even if too big to have stayed cached
+            continue  # builder failed: build it here
+        try:
+            value = build()
+            event.value = value
+            with lock:
+                if key not in cache:
+                    cache[key] = value
+                    setattr(session, bytes_attr, getattr(session, bytes_attr) + value.nbytes)
+                    _evict_lru(session, bytes_attr, cache_attr, budget_attr)
+            return value
+        finally:
+            with lock:
+                inflight.pop(key, None)
+            event.set()
+
+
+def fit_rgba(rgba, canvas_w, canvas_h):
+    """Shrink an RGBA frame to fit the viewer's canvas; unchanged if it fits."""
+    h, w = rgba.shape[:2]
+    if not (canvas_w and canvas_h and (w > canvas_w or h > canvas_h)):
+        return rgba
+    from ._imaging import ensure_image
+
+    image_cls = ensure_image()
+    pil = image_cls.fromarray(
+        rgba.astype(np.uint8) if rgba.dtype != np.uint8 else rgba, mode="RGBA"
+    )
+    pil.thumbnail((canvas_w, canvas_h), image_cls.LANCZOS)
+    return np.array(pil)
+
+
+def _build_mosaic_rgba(
+    session, dim_x, dim_y, dim_z, idx_tuple, colormap, dr, complex_mode,
+    log_scale, mosaic_cols, vmin_override, vmax_override, progress,
+):
     n = session.shape[dim_z]
     # Reported per slice rather than estimated: each slice faults in roughly the
     # same number of pages, so slice i of n is an honest fraction of the wait.
@@ -873,30 +967,30 @@ def render_mosaic(
     elif complex_mode == 1 and np.iscomplexobj(session.data):
         vmin, vmax = -float(np.pi), float(np.pi)
     else:
-        vmin = float(np.percentile(all_data, 1))
-        vmax = float(np.percentile(all_data, 99))
+        # One call partitions once for both ends; two calls sorted the whole
+        # stack twice (~0.14 s of a 240-slice mosaic step).
+        vmin, vmax = (float(v) for v in np.percentile(all_data, [1, 99]))
 
     if mosaic_cols is not None:
         grid, rows, cols = _build_mosaic_grid(all_data, n, cols=mosaic_cols)
     else:
         grid, rows, cols = _build_mosaic_grid(all_data, n)
 
+    # Map to LUT indices in place: a mosaic is tens of millions of pixels, and
+    # each full-size temporary of the where/clip/divide chain cost ~50 ms.
     nan_mask = np.isnan(grid)
-    filled = np.where(nan_mask, vmin, grid)
     if vmax > vmin:
-        normalized = np.clip((filled - vmin) / (vmax - vmin), 0, 1)
+        grid -= vmin
+        grid *= 255.0 / (vmax - vmin)
+        np.clip(grid, 0, 255, out=grid)
+        grid[nan_mask] = 0
     else:
-        normalized = np.zeros_like(filled)
+        grid[:] = 0
 
     _ensure_lut(colormap)
     lut = LUTS.get(colormap, LUTS["gray"])
-    rgba = lut[(normalized * 255).astype(np.uint8)]
+    rgba = lut_rgba(lut, grid.astype(np.uint8))
     rgba[nan_mask] = [22, 22, 22, 255]
-    with session._mosaic_lock:
-        if key not in session.mosaic_cache:
-            session.mosaic_cache[key] = rgba
-            session._mosaic_bytes += rgba.nbytes
-            _evict_lru(session, "_mosaic_bytes", "mosaic_cache", "MOSAIC_CACHE_BYTES")
     return rgba
 
 

{arrayview-0.48.1 → arrayview-0.48.3}/src/arrayview/_routes_rendering.py

@@ -8,6 +8,7 @@ from fastapi.responses import JSONResponse
 from arrayview._diff import _compute_diff, _diff_histogram, _render_diff_rgba
 from arrayview._overlays import _composite_mosaic_overlays, _composite_overlays
 from arrayview._render import (
+    lut_rgba,
     LUTS,
     _build_mosaic_grid,
     _compute_vmin_vmax,
@@ -23,7 +24,12 @@ from arrayview._render import (
     render_rgb_rgba,
     render_rgba,
 )
-from arrayview._session import HEAVY_OP_LIMIT_BYTES, SESSIONS, _schedule_prefetch
+from arrayview._session import (
+    HEAVY_OP_LIMIT_BYTES,
+    SESSIONS,
+    _schedule_prefetch,
+    _schedule_projection_prefetch,
+)
 from arrayview._synthetic_mri import (
     _qmri_adjust_vmin_vmax,
     qmri_display_slice,
@@ -65,7 +71,7 @@ def render_rgba_from_data(data, colormap, vmin, vmax):
         normalized = np.zeros_like(data)
     _ensure_lut(colormap)
     lut = LUTS.get(colormap, LUTS["gray"])
-    return lut[(normalized * 255).astype(np.uint8)]
+    return lut_rgba(lut, (normalized * 255).astype(np.uint8))
 
 
 def register_rendering_routes(app, *, get_session_or_404) -> None:
@@ -220,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,
@@ -276,21 +292,17 @@ def register_rendering_routes(app, *, get_session_or_404) -> None:
                     mosaic_cols,
                 )
         render_ms = (time.perf_counter() - render_t0) * 1000.0
-        # This endpoint is what compare mode polls per scroll step (the live
-        # WS path has its own prefetch call). Without this, a second array
-        # open puts every pane on the request-then-wait path with nothing
-        # warmed ahead, which is a much bigger hit than the extra data alone.
-        # No per-request direction field here (stateless HTTP), so infer it
-        # from the index this session last rendered, mirroring the WS guard.
-        if slice_dim >= 0 and dim_z < 0:
-            prev_idx = getattr(session, "_http_prefetch_prev_idx", None)
-            direction = 1
-            if prev_idx is not None and len(prev_idx) == len(idx_tuple):
-                delta = idx_tuple[slice_dim] - prev_idx[slice_dim]
-                if delta:
-                    direction = 1 if delta > 0 else -1
-            session._http_prefetch_prev_idx = idx_tuple
-            _schedule_prefetch(session, dim_x, dim_y, list(idx_tuple), slice_dim, direction)
+        # This endpoint is what compare, qMRI and multiview panes poll per
+        # scroll step (the live WS path has its own prefetch call). No
+        # per-request direction field here (stateless HTTP), so the prefetch
+        # lane infers it from the position it last saw.
+        if projection_mode > 0 and projection_dim >= 0 and not synthetic_mri and session.rgb_axis is None:
+            _schedule_projection_prefetch(
+                session, dim_x, dim_y, list(idx_tuple), slice_dim,
+                projection_dim, projection_mode,
+            )
+        elif slice_dim >= 0 and dim_z < 0:
+            _schedule_prefetch(session, dim_x, dim_y, list(idx_tuple), slice_dim)
         encode_t0 = time.perf_counter()
         img = _pil_image().fromarray(rgba[:, :, :3], mode="RGB")
         buf = io.BytesIO()
@@ -504,7 +516,7 @@ def register_rendering_routes(app, *, get_session_or_404) -> None:
             normalized = np.clip((sampled - vmin) / (vmax - vmin), 0, 1)
         else:
             normalized = np.zeros_like(sampled)
-        rgba = lut[(normalized * 255).astype(np.uint8)]
+        rgba = lut_rgba(lut, (normalized * 255).astype(np.uint8))
 
         img = _pil_image().fromarray(rgba[:, :, :3], mode="RGB")
         if draft and (grid_w != size_w or grid_h != size_h):
@@ -578,7 +590,7 @@ def register_rendering_routes(app, *, get_session_or_404) -> None:
 
         _init_luts()
         lut = LUTS.get(colormap if colormap in LUTS else "gray", LUTS["gray"])
-        rgba = lut[(normalized * 255).astype(np.uint8)]
+        rgba = lut_rgba(lut, (normalized * 255).astype(np.uint8))
         rgba[nan_mask] = [22, 22, 22, 255]
         img = _pil_image().fromarray(rgba[:, :, :3], mode="RGB")
         buf = io.BytesIO()
@@ -639,7 +651,7 @@ def register_rendering_routes(app, *, get_session_or_404) -> None:
                 normalized = np.clip((frame - vmin) / (vmax - vmin), 0, 1)
             else:
                 normalized = np.zeros_like(frame)
-            rgba = lut[(normalized * 255).astype(np.uint8)]
+            rgba = lut_rgba(lut, (normalized * 255).astype(np.uint8))
             gif_frames.append(_pil_image().fromarray(rgba[:, :, :3], mode="RGB"))
 
         buf = io.BytesIO()

{arrayview-0.48.1 → arrayview-0.48.3}/src/arrayview/_routes_websocket.py

@@ -11,6 +11,8 @@ from arrayview._analysis import _build_metadata
 from arrayview._lifecycle import release_session
 from arrayview._overlays import _composite_mosaic_overlays, _composite_overlays
 from arrayview._render import (
+    fit_rgba,
+    lut_rgba,
     LUTS,
     _prepare_display,
     _ensure_lut,
@@ -26,7 +28,9 @@ from arrayview._session import (
     SHELL_SOCKETS,
     _render,
     _schedule_overlay_prefetch,
+    _schedule_mosaic_prefetch,
     _schedule_prefetch,
+    _schedule_projection_prefetch,
     _vprint,
     wait_for_session_ready,
 )
@@ -246,7 +250,7 @@ def _render_rgba_from_data(data, colormap, vmin, vmax):
         normalized = np.zeros_like(data)
     _ensure_lut(colormap)
     lut = LUTS.get(colormap, LUTS["gray"])
-    return lut[(normalized * 255).astype(np.uint8)]
+    return lut_rgba(lut, (normalized * 255).astype(np.uint8))
 
 
 def _render_qmri_rgba(
@@ -267,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(
@@ -281,13 +286,14 @@ 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:
         normalized = np.zeros_like(data)
     _ensure_lut(colormap)
     lut = LUTS.get(colormap, LUTS["gray"])
-    rgba = lut[(normalized * 255).astype(np.uint8)]
+    rgba = lut_rgba(lut, (normalized * 255).astype(np.uint8))
     alpha_on = getattr(session, "alpha_level", 0) > 0
     if alpha_on:
         if vmax > vmin:
@@ -297,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
 
 
@@ -485,7 +490,6 @@ def register_websocket_routes(app) -> None:
                 _vmax_ov = msg.get("vmax_override")
                 vmin_override = float(_vmin_ov) if _vmin_ov is not None else None
                 vmax_override = float(_vmax_ov) if _vmax_ov is not None else None
-                direction = int(msg.get("direction", 1))
                 slice_dim = int(msg.get("slice_dim", -1))
                 canvas_w = int(msg.get("canvas_w", 0))
                 canvas_h = int(msg.get("canvas_h", 0))
@@ -560,6 +564,13 @@ def register_websocket_routes(app) -> None:
                         )
                         h, w = rgba.shape[:2]
                     else:
+                        # Overlays are drawn onto the full-size grid, so only a
+                        # bare mosaic can come back already fitted to the canvas.
+                        mosaic_fit = (
+                            (canvas_w, canvas_h)
+                            if canvas_w and canvas_h and not msg.get("overlay_sid")
+                            else None
+                        )
                         rgba = await _render(
                             loop,
                             lambda: render_mosaic(
@@ -576,6 +587,7 @@ def register_websocket_routes(app) -> None:
                                 vmin_override=vmin_override,
                                 vmax_override=vmax_override,
                                 progress=_render_progress_reporter(loop, ws, label='Building mosaic'),
+                                fit=mosaic_fit,
                             ),
                         )
                         rgba = _composite_mosaic_overlays(
@@ -718,12 +730,7 @@ def register_websocket_routes(app) -> None:
                 header = np.array([seq, w, h], dtype=np.uint32).tobytes()
                 vminmax = np.array([vmin, vmax], dtype=np.float32).tobytes()
                 if canvas_w and canvas_h and (w > canvas_w or h > canvas_h):
-                    pil = _pil_image().fromarray(
-                        rgba.astype(np.uint8) if rgba.dtype != np.uint8 else rgba,
-                        mode="RGBA",
-                    )
-                    pil.thumbnail((canvas_w, canvas_h), _pil_image().LANCZOS)
-                    rgba = np.array(pil)
+                    rgba = fit_rgba(rgba, canvas_w, canvas_h)
                     h, w = rgba.shape[:2]
                     header = np.array([seq, w, h], dtype=np.uint32).tobytes()
                 payload = header + vminmax + rgba.tobytes()
@@ -764,9 +771,30 @@ def register_websocket_routes(app) -> None:
                         }
                     )
 
-                if slice_dim >= 0 and not (dim_z >= 0):
+                if (
+                    dim_z < 0 and projection_mode > 0 and projection_dim >= 0
+                    and not synthetic_mri and session.rgb_axis is None
+                ):
+                    _schedule_projection_prefetch(
+                        session, dim_x, dim_y, list(idx_tuple), slice_dim,
+                        projection_dim, projection_mode,
+                    )
+                elif slice_dim >= 0 and not (dim_z >= 0):
+                    # The lane infers direction from where it last was. Panes
+                    # that hard-code the message's direction (qMRI, compare
+                    # qMRI) would otherwise always read ahead forward.
                     _schedule_prefetch(
-                        session, dim_x, dim_y, list(idx_tuple), slice_dim, direction
+                        session, dim_x, dim_y, list(idx_tuple), slice_dim
+                    )
+                elif dim_z >= 0 and not qmri_role and not synthetic_mri and session.rgb_axis is None:
+                    _schedule_mosaic_prefetch(
+                        session, dim_x, dim_y, dim_z, list(idx_tuple), slice_dim,
+                        dict(
+                            colormap=colormap, dr=dr, complex_mode=complex_mode,
+                            log_scale=log_scale, mosaic_cols=mosaic_cols,
+                            vmin_override=vmin_override, vmax_override=vmax_override,
+                            fit=mosaic_fit,
+                        ),
                     )
                 stack_axes = tuple(getattr(session.data, "_stack_axes", ()))
                 if stack_axes: