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

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/_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/_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:
@@ -276,21 +282,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 +506,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 +580,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 +641,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/_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(
@@ -287,7 +291,7 @@ def _render_qmri_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:
@@ -485,7 +489,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 +563,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 +586,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 +729,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 +770,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:

arrayview/_session.py

@@ -294,53 +294,197 @@ def _get_overlay_prefetch_pool():
         return _OVERLAY_PREFETCH_POOL
 
 
-def _schedule_prefetch(session, dim_x, dim_y, idx_list, slice_dim, direction):
+def _prefetch_lane_step(session, lane, current, direction):
+    """Record that *lane* is now at *current*; return (lanes, generation, direction).
+
+    Panes at the same position in a lane share one generation; moving the
+    lane to a new position starts a new one, which stale queued jobs check.
+    ``direction=None`` infers it from the previous position, keeping the last
+    known direction when sibling panes re-request the same position.
+    """
+    lanes = getattr(session, "_prefetch_lanes", None)
+    if lanes is None:
+        lanes = {}
+        session._prefetch_lanes = lanes
+    state = lanes.get(lane)
+    if direction is None:
+        if state is None:
+            direction = 1
+        elif current != state["pos"]:
+            direction = 1 if current > state["pos"] else -1
+        else:
+            direction = state["dir"]
+    if state is None or current != state["pos"]:
+        now = _time.monotonic()
+        state = {
+            "gen": (state["gen"] + 1) if state else 1,
+            "pos": current,
+            "moved_at": now,
+            "interval": (now - state["moved_at"]) if state else None,
+            "queued": state["queued"] if state else set(),
+        }
+        lanes[lane] = state
+    state["dir"] = direction
+    return lanes, state["gen"], direction
+
+
+def _schedule_prefetch(session, dim_x, dim_y, idx_list, slice_dim, direction=None):
     """Warm raw_cache for the next PREFETCH_NEIGHBORS slices in *direction*.
 
     Runs in a low-priority background thread so it never blocks WS responses.
     Skips prefetch when the estimated byte cost exceeds PREFETCH_BUDGET_BYTES.
+
+    Lookahead is tracked per lane (display dims + scrolled dim), not per
+    session. qMRI maps and multiview planes are several panes of one session;
+    a single session-wide generation let each pane's request cancel the
+    lookahead its siblings had just queued, so only the last pane was ever
+    warmed. Panes at the same position in a lane now share one generation,
+    and only moving the lane to a new position supersedes queued work.
+    ``direction=None`` infers it from the lane's previous position (stateless
+    HTTP callers), keeping the last known direction when sibling panes
+    re-request the same position.
     """
     # Import here to avoid circular dependency — extract_slice lives in _render
     from arrayview._render import extract_slice
 
+    current = idx_list[slice_dim]
+    lane = (dim_x, dim_y, slice_dim)
+    lanes, _generation, direction = _prefetch_lane_step(session, lane, current, direction)
+    state = lanes[lane]
+
     n = session.shape[slice_dim]
     # A neighboring collection index can mean decompressing an entire .nii.gz
     # volume, not reading another small slice. Keep that work conservative.
     stack_axes = tuple(getattr(session.data, "_stack_axes", ()))
-    neighbor_count = 1 if slice_dim in stack_axes else PREFETCH_NEIGHBORS
-    slice_bytes = session.shape[dim_y] * session.shape[dim_x] * 4  # float32
-    if slice_bytes * neighbor_count > PREFETCH_BUDGET_BYTES:
-        return  # data too large; skip prefetch to avoid memory pressure
-
-    current = idx_list[slice_dim]
-    targets = []
-    for step in range(1, neighbor_count + 1):
-        nxt = current + direction * step
-        if 0 <= nxt < n:
-            targets.append(nxt)
-
-    if not targets:
+    if slice_dim in stack_axes:
+        neighbor_count = 1
+    elif state.get("interval") is not None and state["interval"] < FAST_SCROLL_INTERVAL_S:
+        # A held key outruns a 3-slice window on a slow drive: every step
+        # landed on a slice whose read had only just started.
+        neighbor_count = FAST_PREFETCH_NEIGHBORS
+    else:
+        neighbor_count = PREFETCH_NEIGHBORS
+    itemsize = 8 if np.iscomplexobj(np.empty(0, getattr(session.data, "dtype", np.float32))) else 4
+    slice_bytes = session.shape[dim_y] * session.shape[dim_x] * itemsize
+    # Big images look fewer slices ahead rather than none: switching lookahead
+    # off left every step of a 2k x 2k stack waiting on its own read. Only a
+    # slice that would crowd the raw cache is never warmed.
+    neighbor_count = min(neighbor_count, max(1, PREFETCH_BUDGET_BYTES // slice_bytes))
+    if slice_bytes > getattr(session, "RAW_CACHE_BYTES", 4 * PREFETCH_BUDGET_BYTES) // 4:
         return
 
-    # Supersede queued work from older scroll positions. A gzip operation that
-    # is already running cannot be cancelled safely, but stale queued jobs now
-    # return without touching disk.
-    generation = getattr(session, "_prefetch_generation", 0) + 1
-    session._prefetch_generation = generation
+    def _key(t):
+        idx = list(idx_list)
+        idx[slice_dim] = t
+        return idx, (dim_x, dim_y, tuple(None if i in (dim_x, dim_y) else idx[i] for i in range(len(idx))))
 
-    def _warm():
-        for t in targets:
-            if generation != getattr(session, "_prefetch_generation", 0):
+    # One job per slice so several reads are in flight (a network drive
+    # serves parallel readers ~2x faster). A queued job is dropped once the
+    # lane has moved past it or turned around; jobs still ahead survive new
+    # steps instead of being cancelled and requeued on every key repeat.
+    def _warm(t, key, idx):
+        try:
+            live = lanes[lane]
+            if (t - live["pos"]) * live["dir"] <= 0:
+                return
+            if abs(t - live["pos"]) > FAST_PREFETCH_NEIGHBORS:
                 return
-            idx = list(idx_list)
-            idx[slice_dim] = t
-            key_idx = tuple(None if i in (dim_x, dim_y) else idx[i] for i in range(len(idx)))
-            key = (dim_x, dim_y, key_idx)
             if key not in session.raw_cache:
                 try:
                     extract_slice(session, dim_x, dim_y, idx)
                 except Exception:
                     pass  # prefetch errors are silent
+        finally:
+            state["queued"].discard(key)
+
+    pool = None
+    for step in range(1, neighbor_count + 1):
+        t = current + direction * step
+        if not 0 <= t < n:
+            break
+        idx, key = _key(t)
+        if key in session.raw_cache or key in state["queued"]:
+            continue
+        state["queued"].add(key)
+        try:
+            pool = pool or _get_prefetch_pool()
+            pool.submit(_warm, t, key, idx)
+        except RuntimeError:
+            state["queued"].discard(key)
+            return  # pool shutting down
+
+
+def _schedule_mosaic_prefetch(session, dim_x, dim_y, dim_z, idx_list, slice_dim, render_args):
+    """Render the next mosaic along *slice_dim* into mosaic_cache.
+
+    A mosaic step re-reads and re-colours every slice along *dim_z*, which
+    for a large volume is far slower than the hand scrolling it, and the
+    slice lookahead does not apply (it warms single slices, not grids).
+    One step ahead only: each grid is tens of MB and a CPU-heavy render.
+    ``render_args`` are render_mosaic's remaining positional/keyword inputs
+    (colormap, dr, complex_mode, log_scale, mosaic_cols, vmin/vmax overrides)
+    so the warmed grid hits the same cache key as the real request.
+    """
+    if slice_dim < 0 or slice_dim == dim_z:
+        return
+    current = idx_list[slice_dim]
+    lane = ("mosaic", dim_x, dim_y, dim_z, slice_dim)
+    lanes, generation, direction = _prefetch_lane_step(session, lane, current, None)
+    target = current + direction
+    if not 0 <= target < session.shape[slice_dim]:
+        return
+    frames = session.shape[dim_z]
+    grid_bytes = frames * session.shape[dim_x] * session.shape[dim_y] * 4
+    # Never let the warmed grid push the one on screen out of the cache.
+    if 2 * grid_bytes > getattr(session, "MOSAIC_CACHE_BYTES", 0):
+        return
+
+    def _warm():
+        if generation != lanes[lane]["gen"]:
+            return
+        idx = list(idx_list)
+        idx[slice_dim] = target
+        try:
+            from arrayview._render import render_mosaic
+
+            render_mosaic(session, dim_x, dim_y, dim_z, tuple(idx), **render_args)
+        except Exception:
+            pass  # prefetch errors are silent
+
+    try:
+        _get_prefetch_pool().submit(_warm)
+    except RuntimeError:
+        pass  # pool shutting down
+
+
+def _schedule_projection_prefetch(session, dim_x, dim_y, idx_list, slice_dim, proj_dim, proj_mode):
+    """Compute the next projection along *slice_dim* into raw_cache.
+
+    A projection collapses a whole sub-volume, so on a lazily read file each
+    step waits for a volume read; single-slice lookahead neither predicts it
+    nor helps (scrolling the projected dim does not change the picture).
+    One step ahead: each costs a full sub-volume read.
+    """
+    if slice_dim < 0 or slice_dim in (dim_x, dim_y, proj_dim):
+        return
+    current = idx_list[slice_dim]
+    lane = ("proj", dim_x, dim_y, slice_dim, proj_dim, proj_mode)
+    lanes, generation, direction = _prefetch_lane_step(session, lane, current, None)
+    target = current + direction
+    if not 0 <= target < session.shape[slice_dim]:
+        return
+
+    def _warm():
+        if generation != lanes[lane]["gen"]:
+            return
+        idx = list(idx_list)
+        idx[slice_dim] = target
+        try:
+            from arrayview._render import extract_projection
+
+            extract_projection(session, dim_x, dim_y, idx, proj_dim, proj_mode)
+        except Exception:
+            pass  # prefetch errors are silent
 
     try:
         _get_prefetch_pool().submit(_warm)
@@ -814,6 +958,8 @@ ZARR_T_DEPTH = 2  # T-frames per chunk for 4D+ arrays
 # Neighbor prefetch (Phase 3)
 # ---------------------------------------------------------------------------
 PREFETCH_NEIGHBORS = 3  # slices to prefetch in the scroll direction
+FAST_PREFETCH_NEIGHBORS = 8  # ... while steps come faster than the interval below
+FAST_SCROLL_INTERVAL_S = 0.15
 PREFETCH_BUDGET_BYTES = 16 * 1024 * 1024  # 16 MB max prefetch per request
 
 # ---------------------------------------------------------------------------

arrayview/_synthetic_mri.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import numpy as np
 
-from arrayview._render import LUTS, _build_mosaic_grid, _ensure_lut, apply_complex_mode, extract_slice
+from arrayview._render import LUTS, lut_rgba, _build_mosaic_grid, _ensure_lut, apply_complex_mode, extract_slice
 
 
 QMRI_ROLE_ORDER: dict[int, list[str]] = {
@@ -202,6 +202,6 @@ def render_qmri_mosaic_rgba(
         normalized = np.zeros_like(filled)
     _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))
     rgba[nan_mask] = [22, 22, 22, 255]
     return rgba, vmin, vmax

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

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

@@ -7,7 +7,7 @@ arrayview/_bootstrap_app.py,sha256=ljiZ0o5D3nkJqEGcyyVF06dFWxXujBufQjbcn50QzXM,4
 arrayview/_config.py,sha256=5ovQTO2I-j3fxCxEKcZKE2pqiahLESGTGS24nQdP61I,13493
 arrayview/_diagnostics.py,sha256=XB0rCoDn3cpfhz4H-ayLktOgCMIoVJ0wM9N0ep_kKkQ,11018
 arrayview/_dicom.py,sha256=tNY353MNWTvcXavHeIkqj3242dbgfH_ctwcx9NDee-E,19607
-arrayview/_diff.py,sha256=oOwomSxq_xtPEyH1j31N2V-ukUY4CA6ywOQ3iKmOoP4,5802
+arrayview/_diff.py,sha256=10Uqvccr7Ocouphl14dMJzLMUHPhsD81LkM1IbsmLqg,5826
 arrayview/_extra_ports.py,sha256=MZcx04NI9Eg4coydb-yPIHp7uJbE6UscyYGnw8fxid0,11125
 arrayview/_icon.png,sha256=a8RTAbvweLhh3hzD5eGg76Peq-KSDcS6YrCphRb_HEs,2748
 arrayview/_imaging.py,sha256=MQX1uy4m1lofOeoLDhCp6cHO5p_V5fXm4qlSu9Ykn-c,534
@@ -19,7 +19,7 @@ arrayview/_launcher.py,sha256=Hljfeq4AmxVTDiDgYyMtHT5eiatgFdrvcr6bq75onZY,243267
 arrayview/_lifecycle.py,sha256=bqG0oKr-e-5S1ssCTlGmF-yBE47ilrpO1S_Owfjs9Z8,5365
 arrayview/_overlays.py,sha256=CksypG9rWfCz_3RRGIeyaKeXse17AFxvkEjmYyXnIIE,5399
 arrayview/_platform.py,sha256=qSWjRcx9rLIdLvKrRArSueFnbyn5GPKfTEMOc5mCIUs,29970
-arrayview/_render.py,sha256=aymnz7v9VgfLRRaGrsLpuqjTbP5nzOXzxyFa1ybP5ME,34845
+arrayview/_render.py,sha256=W2FyrBYNt2dwim_CjYMM5U_Dq_vL5DEU4PL6_ybxIZ8,38564
 arrayview/_routes_analysis.py,sha256=Xz9Ysr04u07pzSRB4Fzmcl6XwVxyaG6xCWxGwYZi_80,33085
 arrayview/_routes_drop.py,sha256=FC4e7STdCo3hYIA0C4Yy9Ka2UKFx7nLDU5dkujmc1Vo,12477
 arrayview/_routes_export.py,sha256=Ha8mMO2E9TlRL5x25-ADV8_8xUiC-jRz9N1oWwgKOsg,3898
@@ -28,18 +28,18 @@ 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=EQq2QzdtUS_pv35k7prLdlRdO5nByIlQ_Eu0nhVsn1Y,22970
+arrayview/_routes_rendering.py,sha256=HEA0okhZeiOADOEMdntOYe-mPMP2b_hfBBoAgiyQ-M4,22793
 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=CADgPfAsYWfB7IA75_qJ4voL8dQ3y4RjfzPO0vahIkc,42093
+arrayview/_routes_websocket.py,sha256=78XmMyuD_-KjG5dHpzbhtN4dOa5m5BeyHfASAFYg85c,43552
 arrayview/_segmentation.py,sha256=aENWHmefrKDScXhcZL1X3KgYXE784dpMkmFFo83qnrw,7377
 arrayview/_server.py,sha256=Ejh-6rWpWo0luhBhtsVq1Z4RFIyOPVv5nzExHtXb7iA,23042
-arrayview/_session.py,sha256=jDOERph1hRzqLr9_uzy4Yi0AlLYLD4Y8JJD8bM8r56M,35867
+arrayview/_session.py,sha256=D4I6FLazLEXbo0IdkyRrzhvMNhvAI6dSyYu5I3tMCaM,42137
 arrayview/_session_spec.py,sha256=mKDfMRsPYQdEmN9hLXmDU_9N7etiDyBXr8mz-fB8QBo,6825
 arrayview/_shell.html,sha256=vNa2Kiwx_eoB5H329jolYafLhwJDCH9DsJafBqvVMWU,13194
 arrayview/_source_safety.py,sha256=cI7JAL7DWYuxuB_LnYExvJZaICX2R2qJEJWD1M0z_gg,27664
-arrayview/_synthetic_mri.py,sha256=CNL-2WC835i6WCqkvmWBCO6WQ5w7HE5trNb8OyEfe64,7365
+arrayview/_synthetic_mri.py,sha256=KcSYC26dgjBH25bUoqHT0IgJIzOxgXCSLkWr-ZnFq08,7385
 arrayview/_torch.py,sha256=13sqIMCUu_-b9SQ9KfDCExDz2UMStL87EDVjnbJxAEo,7536
 arrayview/_tutorial.py,sha256=2zZHJGJDa4n30GE1-9ADjKFAifGBH9vvHXP4uDt7BaA,19547
 arrayview/_vectorfield.py,sha256=eDqMCMEGjO8Jdt-6Auh01cz3WD9dbF7xYUWD9xHAf1E,8115
@@ -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.1.dist-info/METADATA,sha256=CFJ0u2vmhoO0Aha0UjUmknepEdM3A1GiEd6D7aRaJhE,2288
-arrayview-0.48.1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-arrayview-0.48.1.dist-info/entry_points.txt,sha256=-0s08axutXkTbINiKs0Q7iv-33aWuTaamUg2q2-NyQ4,60
-arrayview-0.48.1.dist-info/licenses/LICENSE,sha256=34OivjM9faB2QaPjZpMRTIiSx31V3U9cEyQ6F2k-bH0,1062
-arrayview-0.48.1.dist-info/RECORD,,
+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,,