arrayview 0.43.4__py3-none-any.whl → 0.45.0__py3-none-any.whl

arrayview/_analysis.py

@@ -42,6 +42,11 @@ def _build_metadata(session) -> dict:
             # Collection axes are appended after the image dimensions. They
             # select a case; they must not influence the startup plane.
             default_shape = target_shape[:spatial_ndim]
+            # NIfTI metadata identifies the first three axes as anatomical.
+            # Later axes may be echoes, parameters, or time points, so they
+            # must not change which anatomical plane opens first.
+            if getattr(session, "spatial_meta", None) is not None:
+                default_shape = default_shape[:3]
     default_dims = _session_mod._startup_dims_for_data(session.data, default_shape)
     if default_dims is not None:
         meta["default_dims"] = [int(default_dims[0]), int(default_dims[1])]
@@ -65,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/_io.py

@@ -172,7 +172,9 @@ def _nifti_header_with_meta(filepath, *, native=False):
         (abs(norm_rot[i, j]) for i in range(3) for j in range(3) if i != j),
         default=0.0,
     )
-    canonical_shape = tuple(int(img.shape[int(axis)]) for axis in transform[:, 0])
+    canonical_shape = tuple(
+        int(img.shape[int(axis)]) for axis in transform[:, 0]
+    ) + tuple(int(size) for size in img.shape[3:])
     meta = {
         "affine": original_affine,
         "affine_canonical": affine_canonical,
@@ -281,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:
@@ -440,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
@@ -469,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:
@@ -489,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:
@@ -516,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:
@@ -709,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]
@@ -717,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(
@@ -753,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
@@ -990,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
@@ -1011,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.")
@@ -1031,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/_routes_loading.py

@@ -401,148 +401,162 @@ def register_loading_routes(app, *, notify_shells, setup_rgb) -> None:
                 "pending": True,
             }
         signature_before_load = file_signature(abs_path) if not dir_patterns else None
+        # A collection scan+load runs synchronously on this request (no
+        # "background" fast path — see the `not dir_patterns` guard above),
+        # but the caller already navigates the browser to `requested_sid`
+        # before this returns. Without marking the sid pending here, the
+        # viewer's very first phase report can 404 (sid known to neither
+        # SESSIONS nor PENDING_SESSIONS yet) and the opener misreports launch
+        # as failed even though the load goes on to succeed.
+        dir_pending_sid = requested_sid if (dir_patterns and requested_sid) else None
+        if dir_pending_sid:
+            PENDING_SESSIONS.add(dir_pending_sid)
         try:
-            from ._io import load_data_with_meta, load_dir_collection, list_array_keys
-
-            # Multi-array .npz/.mat: if no key provided, return the key list so
-            # the client can show a picker instead of blocking on terminal input.
-            _key = body.get("key")
-            _array_keys = None
-            if dir_patterns:
-                data, spatial_meta, dir_overlay_items, summary = await asyncio.to_thread(
-                    load_dir_collection,
-                    list(dir_patterns),
-                    overlays=[tuple(item) for item in body.get("dir_overlay_specs", [])],
-                    case_regex=body.get("dir_case_regex"),
-                    exclude_cases=body.get("dir_exclude_cases", []),
-                    load=body.get("load", "lazy"),
-                    stack=body.get("stack", "auto"),
-                )
-            elif filepath.endswith(".npz") or filepath.endswith(".mat"):
-                _array_keys = await asyncio.to_thread(list_array_keys, filepath)
-                if len(_array_keys) > 1 and not _key:
-                    return {"array_keys": _array_keys, "filepath": filepath}
-                if len(_array_keys) == 1 and not _key:
-                    _key = _array_keys[0]["key"]
-
-            data, spatial_meta = await asyncio.to_thread(
-                load_data_with_meta,
-                filepath,
-                key=_key,
-                select=body.get("select"),
-            ) if not dir_patterns else (data, spatial_meta)
-        except Exception as e:
-            if staging_dir:
-                cleanup_staging_directory(staging_dir)
-            return {"error": str(e)}
-        try:
-            session = await asyncio.to_thread(
-                Session, data, filepath=None if dir_patterns else filepath, name=name
-            )
-        except Exception as e:
-            if staging_dir:
-                cleanup_staging_directory(staging_dir)
-            return {"error": str(e)}
-        if requested_sid:
-            session.sid = requested_sid
-        session.release_on_disconnect = bool(
-            body.get("release_on_disconnect", False)
-        )
-        session.related_release_sids = [
-            str(value) for value in body.get("related_sids", [])
-        ]
-        if staging_dir:
-            session._source_staging_dirs = [str(staging_dir)]
-        if not dir_patterns:
             try:
-                signature_after_load = file_signature(abs_path)
+                from ._io import load_data_with_meta, load_dir_collection, list_array_keys
+
+                # Multi-array .npz/.mat: if no key provided, return the key list so
+                # the client can show a picker instead of blocking on terminal input.
+                _key = body.get("key")
+                _array_keys = None
+                if dir_patterns:
+                    data, spatial_meta, dir_overlay_items, summary = await asyncio.to_thread(
+                        load_dir_collection,
+                        list(dir_patterns),
+                        overlays=[tuple(item) for item in body.get("dir_overlay_specs", [])],
+                        case_regex=body.get("dir_case_regex"),
+                        exclude_cases=body.get("dir_exclude_cases", []),
+                        load=body.get("load", "lazy"),
+                        stack=body.get("stack", "auto"),
+                    )
+                elif filepath.endswith(".npz") or filepath.endswith(".mat"):
+                    _array_keys = await asyncio.to_thread(list_array_keys, filepath)
+                    if len(_array_keys) > 1 and not _key:
+                        return {"array_keys": _array_keys, "filepath": filepath}
+                    if len(_array_keys) == 1 and not _key:
+                        _key = _array_keys[0]["key"]
+
+                data, spatial_meta = await asyncio.to_thread(
+                    load_data_with_meta,
+                    filepath,
+                    key=_key,
+                    select=body.get("select"),
+                ) if not dir_patterns else (data, spatial_meta)
             except Exception as e:
                 if staging_dir:
                     cleanup_staging_directory(staging_dir)
                 return {"error": str(e)}
-            if signature_before_load == signature_after_load:
-                session.file_signature = signature_after_load
-        if dir_patterns:
-            session.collection_spatial_ndim = len(summary["spatial_shape"])
-            session.collection_identity = collection_identity
-        if spatial_meta is not None:
-            session.spatial_meta = spatial_meta
-            session.original_volume = data
-        if _array_keys and len(_array_keys) > 1:
-            session.array_keys = _array_keys
-            session.array_filepath = filepath
-        if body.get("rgb"):
             try:
-                await asyncio.to_thread(setup_rgb, session)
-            except ValueError as e:
-                if staging_dir:
-                    cleanup_staging_directory(staging_dir)
-                return {"error": str(e)}
-        overlay_sids = []
-        overlay_names = []
-        overlay_sessions = []
-        for item in dir_overlay_items if dir_patterns else []:
-            try:
-                overlay_session = await asyncio.to_thread(
-                    Session, item["data"], filepath=None, name=item["name"]
+                session = await asyncio.to_thread(
+                    Session, data, filepath=None if dir_patterns else filepath, name=name
                 )
             except Exception as e:
                 if staging_dir:
                     cleanup_staging_directory(staging_dir)
                 return {"error": str(e)}
-            overlay_sessions.append(overlay_session)
-            overlay_sids.append(overlay_session.sid)
-            overlay_names.append(item["name"])
-        if dir_patterns:
-            session.collection_overlay_sids = list(overlay_sids)
-            session.collection_overlay_names = list(overlay_names)
-        if requested_sid:
-            if not commit_session_group_unless_cancelled(
-                session.sid,
-                [session, *overlay_sessions],
-            ):
-                CANCELLED_PENDING_SESSIONS.discard(session.sid)
-                if staging_dir:
-                    cleanup_staging_directory(staging_dir)
-                return {"error": "load request was cancelled"}
-        else:
-            SESSIONS[session.sid] = session
-            for overlay_session in overlay_sessions:
-                SESSIONS[overlay_session.sid] = overlay_session
-        if body.get("watch"):
-            import arrayview._session as _session_mod
-            from ._watch import attach_file_watch
-
-            attach_file_watch(session, filepath, _session_mod.SERVER_PORT or 8000)
-        notified = False
-        if notify:
-            tab_url = None
-            if body.get("compare_sids"):
-                tab_url = (
-                    f"/?sid={session.sid}"
-                    f"&compare_sid={body['compare_sid']}"
-                    f"&compare_sids={body['compare_sids']}"
-                )
-            if overlay_sids:
-                tab_url = (
-                    f"/?sid={session.sid}"
-                    f"&overlay_sid={','.join(overlay_sids)}"
-                    f"&overlay_names={urllib.parse.quote(','.join(overlay_names))}"
-                )
-            if native_request_id:
-                tab_url = tab_url or f"/?sid={session.sid}"
-                tab_url += (
-                    "&native_request_id="
-                    + urllib.parse.quote(native_request_id)
-                )
-            notified = await notify_shells(session.sid, name, url=tab_url, wait=False)
-        return {
-            "sid": session.sid,
-            "name": name,
-            "notified": notified,
-            "overlay_sids": overlay_sids,
-            "overlay_names": overlay_names,
-        }
+            if requested_sid:
+                session.sid = requested_sid
+            session.release_on_disconnect = bool(
+                body.get("release_on_disconnect", False)
+            )
+            session.related_release_sids = [
+                str(value) for value in body.get("related_sids", [])
+            ]
+            if staging_dir:
+                session._source_staging_dirs = [str(staging_dir)]
+            if not dir_patterns:
+                try:
+                    signature_after_load = file_signature(abs_path)
+                except Exception as e:
+                    if staging_dir:
+                        cleanup_staging_directory(staging_dir)
+                    return {"error": str(e)}
+                if signature_before_load == signature_after_load:
+                    session.file_signature = signature_after_load
+            if dir_patterns:
+                session.collection_spatial_ndim = len(summary["spatial_shape"])
+                session.collection_identity = collection_identity
+            if spatial_meta is not None:
+                session.spatial_meta = spatial_meta
+                session.original_volume = data
+            if _array_keys and len(_array_keys) > 1:
+                session.array_keys = _array_keys
+                session.array_filepath = filepath
+            if body.get("rgb"):
+                try:
+                    await asyncio.to_thread(setup_rgb, session)
+                except ValueError as e:
+                    if staging_dir:
+                        cleanup_staging_directory(staging_dir)
+                    return {"error": str(e)}
+            overlay_sids = []
+            overlay_names = []
+            overlay_sessions = []
+            for item in dir_overlay_items if dir_patterns else []:
+                try:
+                    overlay_session = await asyncio.to_thread(
+                        Session, item["data"], filepath=None, name=item["name"]
+                    )
+                except Exception as e:
+                    if staging_dir:
+                        cleanup_staging_directory(staging_dir)
+                    return {"error": str(e)}
+                overlay_sessions.append(overlay_session)
+                overlay_sids.append(overlay_session.sid)
+                overlay_names.append(item["name"])
+            if dir_patterns:
+                session.collection_overlay_sids = list(overlay_sids)
+                session.collection_overlay_names = list(overlay_names)
+            if requested_sid:
+                if not commit_session_group_unless_cancelled(
+                    session.sid,
+                    [session, *overlay_sessions],
+                ):
+                    CANCELLED_PENDING_SESSIONS.discard(session.sid)
+                    if staging_dir:
+                        cleanup_staging_directory(staging_dir)
+                    return {"error": "load request was cancelled"}
+            else:
+                SESSIONS[session.sid] = session
+                for overlay_session in overlay_sessions:
+                    SESSIONS[overlay_session.sid] = overlay_session
+            if body.get("watch"):
+                import arrayview._session as _session_mod
+                from ._watch import attach_file_watch
+
+                attach_file_watch(session, filepath, _session_mod.SERVER_PORT or 8000)
+            notified = False
+            if notify:
+                tab_url = None
+                if body.get("compare_sids"):
+                    tab_url = (
+                        f"/?sid={session.sid}"
+                        f"&compare_sid={body['compare_sid']}"
+                        f"&compare_sids={body['compare_sids']}"
+                    )
+                if overlay_sids:
+                    tab_url = (
+                        f"/?sid={session.sid}"
+                        f"&overlay_sid={','.join(overlay_sids)}"
+                        f"&overlay_names={urllib.parse.quote(','.join(overlay_names))}"
+                    )
+                if native_request_id:
+                    tab_url = tab_url or f"/?sid={session.sid}"
+                    tab_url += (
+                        "&native_request_id="
+                        + urllib.parse.quote(native_request_id)
+                    )
+                notified = await notify_shells(session.sid, name, url=tab_url, wait=False)
+            return {
+                "sid": session.sid,
+                "name": name,
+                "notified": notified,
+                "overlay_sids": overlay_sids,
+                "overlay_names": overlay_names,
+            }
+        finally:
+            if dir_pending_sid:
+                PENDING_SESSIONS.discard(dir_pending_sid)
 
     @app.post("/notify/{sid}")
     async def notify_existing_session(sid: str, request: Request):