arrayview 0.17.0__tar.gz → 0.18.0__tar.gz

{arrayview-0.17.0 → arrayview-0.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arrayview
-Version: 0.17.0
+Version: 0.18.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.17.0 → arrayview-0.18.0}/pyproject.toml

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

{arrayview-0.17.0 → arrayview-0.18.0}/src/arrayview/_server.py

@@ -2130,21 +2130,24 @@ def get_volume_histogram(
     sid: str,
     dim_x: int,
     dim_y: int,
-    scroll_dim: int,
+    scroll_dim: int = -1,
+    scroll_dims: str = "",
     fixed_indices: str = "",
     complex_mode: int = 0,
     bins: int = 64,
     session: "Session" = Depends(get_session_or_404),
 ):
-    """Return a histogram sampled across the scroll dimension.
+    """Return a histogram sampled across one or more aggregation dims.
 
-    Subsamples up to 16 evenly-spaced slices along *scroll_dim*, merges
-    their pixel data, and returns a single histogram.  The result is
-    cached on the session so repeated requests are instant.
+    *scroll_dims* is a comma-separated list of dim indices to aggregate
+    over (in addition to *dim_x* / *dim_y*).  When unset, falls back to
+    the legacy single *scroll_dim* param.  The sampler enumerates index
+    combinations across all aggregation dims but caps total samples at
+    ~16 via stride-subsampling.
 
     *fixed_indices* is a comma-separated list of ``dim:idx`` pairs that
-    pin non-display, non-scroll dimensions (e.g. ``"3:0"`` to select the
-    first parameter map in qMRI mode).
+    pin non-display, non-aggregation dimensions (e.g. ``"3:0"`` to
+    select the first parameter map in qMRI mode).
     """
 
     # Parse fixed indices
@@ -2155,27 +2158,59 @@ def get_volume_histogram(
                 d, v = pair.split(":", 1)
                 fixed[int(d)] = int(v)
 
+    # Resolve aggregation dims: prefer scroll_dims, fall back to scroll_dim.
+    agg_dims: list[int] = []
+    if scroll_dims:
+        for tok in scroll_dims.split(","):
+            tok = tok.strip()
+            if not tok:
+                continue
+            try:
+                d = int(tok)
+            except ValueError:
+                continue
+            if 0 <= d < len(session.shape) and d != dim_x and d != dim_y and d not in agg_dims:
+                agg_dims.append(d)
+    if not agg_dims and scroll_dim >= 0 and scroll_dim != dim_x and scroll_dim != dim_y:
+        agg_dims = [scroll_dim]
+
     # Check cache
-    cache_key = (dim_x, dim_y, scroll_dim, tuple(sorted(fixed.items())), complex_mode)
+    cache_key = (dim_x, dim_y, tuple(agg_dims), tuple(sorted(fixed.items())), complex_mode)
     if not hasattr(session, "_volume_hist_cache"):
         session._volume_hist_cache = {}
     cached = session._volume_hist_cache.get(cache_key)
     if cached is not None and cached.get("_data_version") == session.data_version:
         return cached["result"]
 
-    # Sample slices along scroll_dim
-    n = session.shape[scroll_dim]
+    # Build sample index lists per aggregation dim, stride-subsampled so
+    # their Cartesian product stays around ~16 samples total.
     max_samples = 16
-    if n <= max_samples:
-        sample_indices = list(range(n))
+    if not agg_dims:
+        # No aggregation dims — use the current middle slice only.
+        sample_combos = [tuple()]
     else:
-        step = n / max_samples
-        sample_indices = [int(i * step) for i in range(max_samples)]
+        per_dim_counts = [session.shape[d] for d in agg_dims]
+        # Target roughly equal sample count per dim so the product ≈ max_samples.
+        # Ceil to avoid zero; clamp to dim size.
+        k = len(agg_dims)
+        per_dim_target = max(1, int(round(max_samples ** (1.0 / k))))
+        sample_per_dim: list[list[int]] = []
+        for n in per_dim_counts:
+            m = min(n, per_dim_target)
+            if n <= m:
+                sample_per_dim.append(list(range(n)))
+            else:
+                step = n / m
+                sample_per_dim.append([int(i * step) for i in range(m)])
+        # Cartesian product with a hard cap.
+        import itertools as _it
+        sample_combos = list(_it.islice(_it.product(*sample_per_dim), max_samples))
 
     pixels = []
-    for si in sample_indices:
+    for combo in sample_combos:
         idx_list = [s // 2 for s in session.shape]
-        idx_list[scroll_dim] = si
+        for d, si in zip(agg_dims, combo):
+            idx_list[d] = si
         for d, v in fixed.items():
             idx_list[d] = v
         raw = extract_slice(session, dim_x, dim_y, idx_list)

{arrayview-0.17.0 → arrayview-0.18.0}/src/arrayview/_stdio_server.py

@@ -12,6 +12,7 @@ The binary payload has the same format as the WebSocket binary response for
 slice requests, and is length-prefixed JSON for metadata/register/sessions.
 """
 
+import concurrent.futures as _futures
 import json
 import io
 import arrayview._session as _session_mod
@@ -798,13 +799,35 @@ def _handle_fetch_proxy(msg: dict) -> None:
         _write_error(f"unsupported endpoint: {endpoint}")
 
 
-def _handle_slice(msg: dict) -> None:
-    """Render a slice and write the binary response."""
+# Slice render pool: renders multi-pane modes (qMRI, multiview, compare) in
+# parallel instead of serializing on the stdin read loop.  Responses are still
+# written to stdout in arrival order by the caller.  Per-cache locks on the
+# Session protect raw/rgba/mosaic caches from concurrent access.
+_SLICE_POOL: _futures.ThreadPoolExecutor | None = None
+
+
+def _get_slice_pool() -> _futures.ThreadPoolExecutor:
+    global _SLICE_POOL
+    if _SLICE_POOL is None:
+        from arrayview._session import _RENDER_WORKERS
+        _SLICE_POOL = _futures.ThreadPoolExecutor(
+            max_workers=_RENDER_WORKERS,
+            thread_name_prefix="arrayview-stdio-render",
+        )
+    return _SLICE_POOL
+
+
+def _build_slice_payload(msg: dict) -> bytes:
+    """Render a slice and return its binary payload.
+
+    Raises on missing session / bad input; does NOT write to stdout so this is
+    safe to call from a thread pool.  The caller is responsible for writing
+    the returned bytes (or the error) in arrival order.
+    """
     sid = msg["sid"]
     session = SESSIONS.get(sid)
     if not session:
-        _write_error("session not found")
-        return
+        raise RuntimeError("session not found")
 
     seq = int(msg.get("seq", 0))
     dim_x = int(msg["dim_x"])
@@ -908,7 +931,12 @@ def _handle_slice(msg: dict) -> None:
             ).tobytes()
             payload += vf_hdr + vf_scale + arrows.tobytes()
 
-    _write_response(payload)
+    return payload
+
+
+def _handle_slice(msg: dict) -> None:
+    """Render a slice and write the binary response (single-slice path)."""
+    _write_response(_build_slice_payload(msg))
 
 
 def _handle_get_viewer_html(msg: dict) -> None:
@@ -1085,17 +1113,33 @@ def run_stdio_server() -> None:
                 pane_key = (s.get("dim_x", -1), s.get("dim_y", -1))
                 latest_for_pane[pane_key] = i
 
-            # Process in arrival order: skip stale same-pane dups, render the rest
+            # Submit non-stale renders to the thread pool so multi-pane modes
+            # (qMRI, multiview, compare) don't serialize on the read loop.
+            # Per-cache locks on the Session make concurrent renders safe.
+            pool = _get_slice_pool() if len(pending_slices) > 1 else None
+            payload_futures: dict[int, _futures.Future] = {}
+            for i, s in enumerate(pending_slices):
+                pane_key = (s.get("dim_x", -1), s.get("dim_y", -1))
+                if latest_for_pane[pane_key] != i:
+                    continue
+                payload_futures[i] = (
+                    pool.submit(_build_slice_payload, s) if pool is not None else None
+                )
+
+            # Write responses in arrival order to match the extension's FIFO
+            # callback matching.
             for i, s in enumerate(pending_slices):
                 pane_key = (s.get("dim_x", -1), s.get("dim_y", -1))
                 if latest_for_pane[pane_key] != i:
                     _write_skip_response(s)
-                else:
-                    try:
-                        _handle_slice(s)
-                    except Exception as e:
-                        traceback.print_exc(file=sys.stderr)
-                        _write_error(str(e))
+                    continue
+                try:
+                    fut = payload_futures.get(i)
+                    payload = fut.result() if fut is not None else _build_slice_payload(s)
+                    _write_response(payload)
+                except Exception as e:
+                    traceback.print_exc(file=sys.stderr)
+                    _write_error(str(e))
 
             for def_type, def_msg in deferred:
                 try: