arrayview 0.44.0__tar.gz → 0.45.1__tar.gz

{arrayview-0.44.0 → arrayview-0.45.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: arrayview
-Version: 0.44.0
+Version: 0.45.1
 Summary: Fast multi-dimensional array viewer
 Project-URL: Home, https://github.com/oscarvanderheide/arrayview
 Project-URL: Source, https://github.com/oscarvanderheide/arrayview
@@ -59,6 +59,14 @@ uvx arrayview path/to/dicom-series/
 Press `v` for the three-plane ortho view. `Shift+3` replaces the current slice,
 or all three ortho panes, with interactive 3D cutaway renders.
 Drop another file onto an open viewer to compare, open separately, or overlay it.
+Press `Shift+R` for ROI analysis: a compact HUD lists each region's mean and standard
+deviation. The HUD sits beside the image when space allows; drag its header
+to move it. Hover a row or region to highlight its counterpart, and use each
+row's trash icon to delete that region. Open the detailed analysis with the
+button beside the HUD's column headings.
+Hold a flood-fill seed and drag up/down to adjust sensitivity; a translucent tapered gauge
+at the starting point shows the current value and the 1%–100% range. The
+pointer hides while adjusting; only the gauge marker moves.
 
 
 Check the [docs](https://oscarvanderheide.github.io/arrayview/) to learn more. 

{arrayview-0.44.0 → arrayview-0.45.1}/README.md

@@ -22,6 +22,14 @@ uvx arrayview path/to/dicom-series/
 Press `v` for the three-plane ortho view. `Shift+3` replaces the current slice,
 or all three ortho panes, with interactive 3D cutaway renders.
 Drop another file onto an open viewer to compare, open separately, or overlay it.
+Press `Shift+R` for ROI analysis: a compact HUD lists each region's mean and standard
+deviation. The HUD sits beside the image when space allows; drag its header
+to move it. Hover a row or region to highlight its counterpart, and use each
+row's trash icon to delete that region. Open the detailed analysis with the
+button beside the HUD's column headings.
+Hold a flood-fill seed and drag up/down to adjust sensitivity; a translucent tapered gauge
+at the starting point shows the current value and the 1%–100% range. The
+pointer hides while adjusting; only the gauge marker moves.
 
 
 Check the [docs](https://oscarvanderheide.github.io/arrayview/) to learn more. 

{arrayview-0.44.0 → arrayview-0.45.1}/pyproject.toml

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

{arrayview-0.44.0 → arrayview-0.45.1}/src/arrayview/_analysis.py

@@ -70,6 +70,12 @@ def _build_metadata(session) -> dict:
             [list(shape) for shape in row]
             for row in session.data.ragged_spatial_shapes
         ]
+    case_voxel_spacings = getattr(session.data, "case_voxel_spacings", None)
+    if case_voxel_spacings:
+        meta["case_voxel_spacings"] = [
+            [list(spacing) for spacing in row]
+            for row in case_voxel_spacings
+        ]
     return meta
 
 

arrayview-0.45.1/src/arrayview/_bootstrap_app.py

@@ -0,0 +1,120 @@
+"""Answer the health check while the real server is still loading.
+
+A freshly spawned daemon binds its port within ~150 ms, but importing the web
+framework and the route modules takes another ~300-500 ms (more on a busy
+host). Nothing that arrives in that window can be served by the real app, and
+the launcher, the VS Code opener and the tunnel proxy all wait on ``/ping``
+before they will open a viewer tab.
+
+This tiny ASGI app is what uvicorn serves from the moment the socket is bound:
+
+* ``GET /ping`` is answered immediately with the daemon's real identity (the
+  same payload the real route returns, built from ``_session``), so the tab
+  can be opened while the framework is still importing;
+* every other request simply waits in line and is handed to the real app the
+  moment it is attached, so the page download overlaps the import instead of
+  starting after it;
+* if the real app fails to load, waiting requests get a 503 and the daemon
+  exits, which is what happened before too — just later.
+
+No ordering that the launch relies on changes: ``/ping`` still reports the
+identity that the registry record carries, and the viewer page still cannot
+arrive before the server that serves it exists.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import threading
+from typing import Awaitable, Callable
+
+Scope = dict
+Receive = Callable[[], Awaitable[dict]]
+Send = Callable[[dict], Awaitable[None]]
+
+
+class BootstrapApp:
+    """ASGI app that answers ``/ping`` itself until the real app is attached."""
+
+    def __init__(self) -> None:
+        self._app = None
+        self._error: BaseException | None = None
+        self._ready = threading.Event()
+
+    # ── wiring (called from whichever thread loads the real app) ──────────
+    def attach(self, app) -> None:
+        self._app = app
+        self._ready.set()
+
+    def fail(self, error: BaseException) -> None:
+        self._error = error
+        self._ready.set()
+
+    @property
+    def ready(self) -> bool:
+        return self._app is not None
+
+    # ── ASGI ──────────────────────────────────────────────────────────────
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        kind = scope.get("type")
+        if kind == "lifespan":
+            await self._lifespan(receive, send)
+            return
+        if (
+            self._app is None
+            and kind == "http"
+            and scope.get("method") == "GET"
+            and scope.get("path") == "/ping"
+        ):
+            await self._ping(send)
+            return
+        if not self._ready.is_set():
+            loop = asyncio.get_running_loop()
+            await loop.run_in_executor(None, self._ready.wait)
+        if self._app is None:
+            await self._unavailable(kind, send)
+            return
+        await self._app(scope, receive, send)
+
+    async def _lifespan(self, receive: Receive, send: Send) -> None:
+        # The real app registers no startup/shutdown hooks, so uvicorn's
+        # lifespan protocol is answered here and never forwarded.
+        while True:
+            message = await receive()
+            if message["type"] == "lifespan.startup":
+                await send({"type": "lifespan.startup.complete"})
+            elif message["type"] == "lifespan.shutdown":
+                await send({"type": "lifespan.shutdown.complete"})
+                return
+
+    async def _ping(self, send: Send) -> None:
+        import arrayview._session as _session_mod
+
+        payload = _session_mod.ping_payload(
+            active_sessions=len(_session_mod.SESSIONS)
+        )
+        await _send_json(send, 200, payload)
+
+    async def _unavailable(self, kind: str | None, send: Send) -> None:
+        detail = f"ArrayView server failed to start: {self._error!r}"
+        if kind == "websocket":
+            await send({"type": "websocket.close", "code": 1011, "reason": detail[:120]})
+            return
+        await _send_json(send, 503, {"error": detail, "type": "ServerStartupFailed"})
+
+
+async def _send_json(send: Send, status: int, payload: dict) -> None:
+    body = json.dumps(payload).encode("utf-8")
+    await send(
+        {
+            "type": "http.response.start",
+            "status": status,
+            "headers": [
+                (b"content-type", b"application/json"),
+                (b"content-length", str(len(body)).encode("ascii")),
+                (b"cache-control", b"no-store"),
+            ],
+        }
+    )
+    await send({"type": "http.response.body", "body": body})

{arrayview-0.44.0 → arrayview-0.45.1}/src/arrayview/_io.py

@@ -283,6 +283,11 @@ class _ProgressiveNiftiJob:
         if self.future is not None and self.future.cancel():
             self._finish(cancelled=True)
 
+    def has_plane(self, z_index) -> bool:
+        """True if *z_index* is already decoded (a non-blocking peek)."""
+        with self._condition:
+            return bool(self._decoded[z_index]) or self._done
+
     def plane(self, z_index):
         with self._condition:
             while not self._decoded[z_index] and not self._done:
@@ -442,7 +447,8 @@ class _ProgressiveNiftiSeriesMixin:
             return None
         with self._progressive_lock:
             job = self._progressive_jobs.get(cache_key)
-            if job is None:
+            is_new_job = job is None
+            if is_new_job:
                 spec = _progressive_nifti_spec(filepath)
                 if spec is None:
                     return None
@@ -471,7 +477,18 @@ class _ProgressiveNiftiSeriesMixin:
                     overlay_prefetch=overlay_prefetch
                 ).submit(job.run)
         try:
-            return job.plane(z_index)
+            # The request that starts the job waits on just the one plane, so
+            # the first frame of a fresh file shows up as soon as the decoder
+            # reaches it rather than waiting for the whole thing. Every later
+            # request for this same file instead waits for the whole volume
+            # (unless its plane is already decoded): scrolling through every
+            # plane that way finishes in less total time than paying a small
+            # wait on each individual plane (~200ms vs ~315ms measured on a
+            # 75-plane volume), so it also keeps later frames from feeling
+            # slower than the ones on the other two axes.
+            if is_new_job or job.has_plane(z_index):
+                return job.plane(z_index)
+            return job.volume()[:, :, z_index]
         except _ProgressiveLoadCancelled:
             raise
         except Exception:
@@ -491,11 +508,12 @@ class _NiftiSeries(_ProgressiveNiftiSeriesMixin):
 
     _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:
@@ -518,6 +536,10 @@ class _NiftiSeries(_ProgressiveNiftiSeriesMixin):
     def dtype(self):
         return self._dtype
 
+    @property
+    def case_voxel_spacings(self):
+        return self._spacing_matrix
+
     def _get_volume(self, p_idx, m_idx):
         cache_key = (p_idx, m_idx)
         with self._cache_lock:
@@ -711,7 +733,10 @@ class _RaggedFileSeries(_ProgressiveNiftiSeriesMixin):
     _av_lazy = True
     _av_ragged = True
 
-    def __init__(self, file_matrix, spatial_shapes, dtype, spatial_meta=None, all_nifti=False):
+    def __init__(
+        self, file_matrix, spatial_shapes, dtype, spatial_meta=None, all_nifti=False,
+        spacing_matrix=None,
+    ):
         self._file_matrix = file_matrix
         self._spatial_shapes = [
             [tuple(int(s) for s in shape) for shape in row]
@@ -719,6 +744,7 @@ class _RaggedFileSeries(_ProgressiveNiftiSeriesMixin):
         ]
         self._dtype = np.dtype(dtype)
         self._spatial_meta = spatial_meta
+        self._spacing_matrix = spacing_matrix
         self._all_nifti = bool(all_nifti)
         self._spatial_ndim = len(self._spatial_shapes[0][0])
         self._vol_shape = tuple(
@@ -755,6 +781,10 @@ class _RaggedFileSeries(_ProgressiveNiftiSeriesMixin):
     def ragged_spatial_shapes(self):
         return self._spatial_shapes
 
+    @property
+    def case_voxel_spacings(self):
+        return self._spacing_matrix
+
     def _normalize_collection_indices(self, idx_list):
         n_p = len(self._file_matrix)
         n_m = len(self._file_matrix[0]) if self._file_matrix else 0
@@ -992,12 +1022,14 @@ def _series_from_file_matrix(
 
     if all_nifti:
         spatial_shapes = []
+        voxel_sizes_list = []
         for fpath, img, item_meta in _iter_nifti_headers(
             all_paths, scan_progress=scan_progress, scan_label=scan_label
         ):
             shape = tuple(item_meta["canonical_shape"])
             dtype = img.get_data_dtype()
             spatial_shapes.append(shape)
+            voxel_sizes_list.append(tuple(item_meta["voxel_sizes"]))
             if ref_shape is None:
                 ref_shape = shape
                 ref_dtype = dtype
@@ -1013,16 +1045,21 @@ def _series_from_file_matrix(
                     f"{dtype}, expected {ref_dtype}."
                 )
         shape_matrix = []
+        spacing_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)
+                    row_spacings.append(voxel_sizes_list[0] if voxel_sizes_list else (1.0, 1.0, 1.0))
                 else:
                     row_shapes.append(spatial_shapes[pos])
+                    row_spacings.append(voxel_sizes_list[pos])
                     pos += 1
             shape_matrix.append(row_shapes)
+            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.")
@@ -1033,9 +1070,13 @@ def _series_from_file_matrix(
                     ref_dtype,
                     spatial_meta=spatial_meta,
                     all_nifti=True,
+                    spacing_matrix=spacing_matrix,
             )
         else:
-            series = _NiftiSeries(file_matrix, ref_shape, ref_dtype, spatial_meta)
+            series = _NiftiSeries(
+                file_matrix, ref_shape, ref_dtype, spatial_meta,
+                spacing_matrix=spacing_matrix,
+            )
         if load == "eager":
             for p, row in enumerate(file_matrix):
                 for m, path in enumerate(row):

{arrayview-0.44.0 → arrayview-0.45.1}/src/arrayview/_launch_plan.py

@@ -9,6 +9,7 @@ import os
 import socket
 import sys
 import time
+import urllib.error
 import urllib.request
 import uuid
 
@@ -710,6 +711,11 @@ def _ping_arrayview_server(port: int) -> dict | None:
                 payload = json.loads(resp.read().decode("utf-8"))
             if payload.get("ok") is True and payload.get("service") == "arrayview":
                 return payload
+        except urllib.error.URLError as exc:
+            # Nobody is listening on the port: retrying cannot change that,
+            # and the two 50 ms pauses were paid on every fresh launch.
+            if isinstance(exc.reason, ConnectionRefusedError):
+                return None
         except Exception:
             pass
         if attempt < 2:

{arrayview-0.44.0 → arrayview-0.45.1}/src/arrayview/_launcher.py

@@ -155,15 +155,17 @@ def _register_server_runtime(port: int, owner_mode: str):
         os.chmod(log_directory, 0o700)
     except OSError:
         pass
+    # Identity lives in _session, not _server, so registering does not pull in
+    # the web framework: the daemon can answer /ping before that import runs.
     record = InstanceRecord.create(
         port=port,
-        protocol_version=_server_mod().SERVER_PROTOCOL_VERSION,
+        protocol_version=_session_mod.SERVER_PROTOCOL_VERSION,
         package_version=__version__,
         owner_mode=owner_mode,
         log_path=str(log_directory / f"server-{os.getpid()}.log"),
     )
     registry.write(record)
-    _server_mod().configure_server_runtime(
+    _session_mod.configure_server_runtime(
         instance_id=record.instance_id,
         process_start=record.process_start,
         owner_mode=record.owner_mode,
@@ -4622,13 +4624,24 @@ def _serve_daemon(
         port=record.port,
     )
 
+    # Serve from the bootstrap app right away: /ping answers with this
+    # daemon's identity while the web framework is still importing, so the
+    # launcher and the opener can open the tab ~0.4 s sooner and the page
+    # download overlaps the import. Every other request waits in line and is
+    # served by the real app the moment it is attached.
+    from arrayview._bootstrap_app import BootstrapApp
+
+    bootstrap = BootstrapApp()
+    uvicorn_server: list = []
+
     def _run_uvicorn_on_socket():
         config = _uvicorn().Config(
-            _server_mod().app,
+            bootstrap,
             log_level="error",
             timeout_keep_alive=30,
         )
         server = _uvicorn().Server(config)
+        uvicorn_server.append(server)
         asyncio.run(server.serve(sockets=sock))
 
     # Start uvicorn immediately — the window can open before data is ready.
@@ -4638,14 +4651,43 @@ def _serve_daemon(
     ).start()
     _trace_launch_event("backend.http_thread_started", port=port)
 
-    # Pre-warm colormap LUTs in background (saves ~200 ms on first frame render).
-    def _warm_luts():
+    # Let the listener come up before any CPU-heavy import starts: with the
+    # framework import, the colormap warm-up and the data load all competing
+    # for the interpreter, uvicorn's own startup was measured taking ~0.6 s
+    # instead of ~0.03 s, which delayed the first /ping answer by the same.
+    serving_deadline = time.monotonic() + 5.0
+    while time.monotonic() < serving_deadline:
+        if uvicorn_server and getattr(uvicorn_server[0], "started", False):
+            break
+        time.sleep(0.002)
+    _trace_launch_event("backend.serving", port=port)
+
+    def _attach_full_app():
+        try:
+            bootstrap.attach(_server_mod().app)
+        except BaseException as exc:  # noqa: BLE001 — any failure here is fatal
+            bootstrap.fail(exc)
+            _trace_launch_event("daemon.exiting", reason="server_import_failed")
+            _vprint(f"[ArrayView] server failed to start: {exc!r}", flush=True)
+            try:
+                registry.remove(record.instance_id)
+            except Exception:
+                pass
+            _cleanup_source_staging_dirs(source_staging_dirs)
+            os._exit(1)
+        _trace_launch_event("backend.app_attached", port=port)
+        # Pre-warm colormap LUTs (the page and the first frame both need
+        # them). Sequenced after the framework import rather than alongside
+        # it: run together they contend for the interpreter and both finish
+        # later than they do one after the other.
         try:
             from arrayview._render import _init_luts
             _init_luts()
         except Exception:
             pass
-    threading.Thread(target=_warm_luts, daemon=True).start()
+        _trace_launch_event("backend.luts_ready", port=port)
+
+    threading.Thread(target=_attach_full_app, daemon=True).start()
 
     def _load():
         from arrayview._io import (

{arrayview-0.44.0 → arrayview-0.45.1}/src/arrayview/_platform.py

@@ -102,6 +102,12 @@ def _in_jupyter() -> bool:
     global _JUPYTER_CACHE
     if _JUPYTER_CACHE is not None:
         return _JUPYTER_CACHE
+    # A notebook kernel has IPython loaded before any user code runs, so a
+    # process without it cannot be one. Importing IPython just to ask costs
+    # ~250 ms on every terminal launch; skip it when it is not already there.
+    if "IPython" not in sys.modules:
+        _JUPYTER_CACHE = False
+        return False
     try:
         from IPython import get_ipython