lbm_suite2p_python 2.5.4__tar.gz → 3.0.0__tar.gz

{lbm_suite2p_python-2.5.4/lbm_suite2p_python.egg-info → lbm_suite2p_python-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lbm_suite2p_python
-Version: 2.5.4
+Version: 3.0.0
 Summary: Light Beads Microscopy Pipeline using Suite2p
 License-Expression: BSD-3-Clause
 Project-URL: homepage, https://github.com/MillerBrainObservatory/LBM-Suite2p-Python
@@ -8,12 +8,12 @@ Keywords: Pipeline,Numpy,Microscopy,ScanImage,Suite2p,tiff
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Science/Research
 Classifier: Programming Language :: Python :: 3 :: Only
-Requires-Python: <3.12.10,>=3.12.7
+Requires-Python: <3.14,>=3.12.7
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
-Requires-Dist: mbo_utilities>=2.6.0
-Provides-Extra: suite2p
-Requires-Dist: suite2p_mbo>=2.0.1; extra == "suite2p"
+Requires-Dist: mbo_utilities>=2.7.7
+Requires-Dist: suite2p>=1.0.0.1
+Requires-Dist: setuptools<81
 Provides-Extra: rastermap
 Requires-Dist: rastermap; extra == "rastermap"
 Provides-Extra: cellpose
@@ -22,7 +22,7 @@ Provides-Extra: torch
 Requires-Dist: torch>=2.7.0; extra == "torch"
 Requires-Dist: torchvision>=0.22.0; extra == "torch"
 Provides-Extra: all
-Requires-Dist: lbm_suite2p_python[cellpose,rastermap,suite2p,torch]; extra == "all"
+Requires-Dist: lbm_suite2p_python[cellpose,rastermap,torch]; extra == "all"
 Dynamic: license-file
 
 <p align="center">

lbm_suite2p_python-3.0.0/lbm_suite2p_python/_padding_shim.py

@@ -0,0 +1,140 @@
+"""
+Padding-aware extraction shim for upstream suite2p.
+
+Problem
+-------
+When LBM data is axially registered, mbo's writer zero-pads planes so every
+plane sits in a common (Ly, Lx) coordinate system. `ops["yrange"]` /
+`ops["xrange"]` mark the valid (non-padded) region.
+
+Upstream's `suite2p.detection.*` is yrange/xrange-aware: `bin_movie` crops
+before computing meanImg / max_proj / Vcorr / cellpose inputs, so padding
+never enters detection. Upstream's `suite2p.extraction.masks` is NOT:
+`create_cell_pix` allocates `np.zeros((Ly, Lx))`, and `create_neuropil_masks`
+treats any pixel with `cell_pix < 0.5` as a valid neuropil candidate. Zero-
+padded pixels satisfy that predicate, so neuropil donuts around
+boundary-adjacent ROIs grow into the padding and pull zeros into `Fneu`.
+The corrupted `Fneu` propagates into `F - neuropil_coefficient * Fneu` and
+every dF/F derived from it.
+
+Fix
+---
+Monkeypatch `suite2p.extraction.masks.create_cell_pix` inside a context
+manager scoped to the lbm call only. The replacement:
+
+  1. Calls upstream's real implementation to produce the cell-pixel mask.
+  2. Marks every pixel outside `ops["yrange"]` / `ops["xrange"]` as
+     "occupied" (True / 1.0), which makes `create_neuropil_masks`'s
+     `cell_pix[y,x] < 0.5` predicate return False for those pixels, so
+     donuts grow only into the valid region.
+
+The patch is applied *only* for the duration of the `with` block and
+restored on exit, regardless of whether the wrapped code succeeds or
+raises. External users of suite2p see no change; only our call path is
+affected.
+
+Why this rather than rebuilding neuropil_masks externally and passing
+them to `extraction_wrapper(neuropil_masks=...)`
+-------------------------------------------------------------------
+The external-build approach would require us to bypass upstream's
+`pipeline()` and re-orchestrate detection → classification → extraction →
+deconvolution ourselves, just to inject the `neuropil_masks=` kwarg.
+Monkeypatching a single leaf function is ~15 lines, keeps us on the
+upstream orchestration path, and is trivially reversible.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import numpy as np
+
+
+@contextlib.contextmanager
+def padding_aware_extraction(ops):
+    """
+    Context manager: inside the block, upstream's neuropil-mask builder
+    treats pixels outside ``ops["yrange"]`` / ``ops["xrange"]`` as
+    "occupied", preventing neuropil donuts from extending into the
+    zero-padded axial-alignment border.
+
+    Safe to call unconditionally: if no yrange/xrange are present on ops,
+    or if they cover the full frame, the patch is a no-op.
+
+    Parameters
+    ----------
+    ops : dict
+        Flat suite2p ops dict. Reads ``ops["yrange"]`` and
+        ``ops["xrange"]``; does not mutate.
+
+    Yields
+    ------
+    None
+
+    Examples
+    --------
+    >>> with padding_aware_extraction(ops):
+    ...     reg_outputs, detect_outputs, stat, F, Fneu, ... = pipeline(
+    ...         save_path=save_path, f_reg=f_reg, ..., settings=settings,
+    ...     )
+    """
+    yrange = ops.get("yrange")
+    xrange = ops.get("xrange")
+    if not yrange or not xrange:
+        # no crop information — nothing to protect against
+        yield
+        return
+
+    try:
+        y0, y1 = int(yrange[0]), int(yrange[1])
+        x0, x1 = int(xrange[0]), int(xrange[1])
+    except (TypeError, ValueError):
+        yield
+        return
+
+    # import here so a missing suite2p doesn't break import of this module
+    try:
+        from suite2p.extraction import masks as _m
+    except ImportError:
+        yield
+        return
+
+    original_create_cell_pix = getattr(_m, "create_cell_pix", None)
+    if original_create_cell_pix is None:
+        # upstream moved or inlined create_cell_pix — no safe patch point.
+        # fall through without modification rather than silently corrupting.
+        yield
+        return
+
+    def _padding_aware_create_cell_pix(stats, Ly, Lx, lam_percentile=50.0):
+        """Drop-in replacement that adds the padding mask to upstream's result."""
+        cell_pix = original_create_cell_pix(stats, Ly, Lx, lam_percentile)
+        # upstream returns either bool array or float >0.5 mask; normalize
+        # to a bool copy so our additions don't alter any internal cache.
+        cell_pix = np.asarray(cell_pix).copy()
+        if cell_pix.dtype != bool:
+            cell_pix = cell_pix > 0.5
+
+        # mark the region OUTSIDE the valid window as occupied so the
+        # neuropil donut never extends into zero-padded pixels.
+        _y0 = max(0, min(y0, Ly))
+        _y1 = max(_y0, min(y1, Ly))
+        _x0 = max(0, min(x0, Lx))
+        _x1 = max(_x0, min(x1, Lx))
+        if _y0 > 0:
+            cell_pix[:_y0, :] = True
+        if _y1 < Ly:
+            cell_pix[_y1:, :] = True
+        if _x0 > 0:
+            cell_pix[:, :_x0] = True
+        if _x1 < Lx:
+            cell_pix[:, _x1:] = True
+        return cell_pix
+
+    _m.create_cell_pix = _padding_aware_create_cell_pix
+    try:
+        yield
+    finally:
+        # always restore, even on exception, so external callers of
+        # suite2p.extraction.masks.create_cell_pix see the unpatched
+        # upstream function.
+        _m.create_cell_pix = original_create_cell_pix

{lbm_suite2p_python-2.5.4 → lbm_suite2p_python-3.0.0}/lbm_suite2p_python/cellpose.py

@@ -37,9 +37,10 @@ def _compute_projection(
     Parameters
     ----------
     arr : array-like
-        Input array (T, Y, X) for 3D or (T, Z, Y, X) for 4D.
+        Input array. mbo_utilities arrays are 5D TCZYX.
+        Legacy 4D TZYX and 3D TYX inputs are also supported.
     plane_idx : int, optional
-        For 4D arrays, which z-plane to extract (0-indexed).
+        For volumetric arrays, which z-plane to extract (0-indexed).
         If None, uses all planes for 3D segmentation.
     method : str
         Projection method: 'max', 'mean', 'std', or 'percentile'.
@@ -53,19 +54,23 @@ def _compute_projection(
     """
     ndim = len(arr.shape)
 
-    if ndim == 4:
-        # (T, Z, Y, X)
+    if ndim == 5:
+        # 5D TCZYX: use channel 0
+        if plane_idx is not None:
+            data = arr[:, 0, plane_idx, :, :]  # (T, Y, X)
+        else:
+            data = arr[:, 0, :, :, :]  # (T, Z, Y, X)
+    elif ndim == 4:
+        # legacy 4D TZYX
         if plane_idx is not None:
-            # extract single plane -> (T, Y, X)
             data = arr[:, plane_idx, :, :]
         else:
-            # keep all planes -> (T, Z, Y, X)
             data = arr[:]
     elif ndim == 3:
-        # (T, Y, X)
+        # legacy 3D TYX
         data = arr[:]
     else:
-        raise ValueError(f"Expected 3D or 4D array, got {ndim}D")
+        raise ValueError(f"Expected 3D, 4D, or 5D array, got {ndim}D")
 
     # convert to numpy if lazy
     if hasattr(data, "compute"):
@@ -577,18 +582,18 @@ def cellpose(
 
     # get array info
     shape = arr.shape
-    ndim = len(shape)
     num_planes = _get_num_planes(arr)
     num_frames = shape[0]
+    is_volumetric = num_planes > 1
 
     print(f"\nDataset info:")
     print(f"  Shape: {shape}")
     print(f"  Frames: {num_frames}")
     print(f"  Planes: {num_planes}")
-    print(f"  Data type: {'4D volumetric' if ndim == 4 else '3D planar'}")
+    print(f"  Data type: {'volumetric' if is_volumetric else 'planar'}")
 
     # normalize planes to 0-indexed list
-    if ndim == 4:
+    if is_volumetric:
         planes_to_process = _normalize_planes(planes, num_planes)
     else:
         planes_to_process = [None]  # single plane data