lbm_suite2p_python 3.0.0__tar.gz → 3.0.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lbm_suite2p_python
-Version: 3.0.0
+Version: 3.0.1
 Summary: Light Beads Microscopy Pipeline using Suite2p
 License-Expression: BSD-3-Clause
 Project-URL: homepage, https://github.com/MillerBrainObservatory/LBM-Suite2p-Python
@@ -11,18 +11,15 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Requires-Python: <3.14,>=3.12.7
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
-Requires-Dist: mbo_utilities>=2.7.7
+Requires-Dist: mbo_utilities>=3.0.0
 Requires-Dist: suite2p>=1.0.0.1
 Requires-Dist: setuptools<81
 Provides-Extra: rastermap
 Requires-Dist: rastermap; extra == "rastermap"
 Provides-Extra: cellpose
 Requires-Dist: cellpose>=4.0.6; extra == "cellpose"
-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,torch]; extra == "all"
+Requires-Dist: lbm_suite2p_python[cellpose,rastermap]; extra == "all"
 Dynamic: license-file
 
 <p align="center">

{lbm_suite2p_python-3.0.0 → lbm_suite2p_python-3.0.1}/lbm_suite2p_python/__init__.py

@@ -39,6 +39,8 @@ from lbm_suite2p_python.zplane import (
     plot_filtered_cells,
     plot_diameter_histogram,
     plot_projection,
+    plot_accepted_rejected_overlay,
+    plot_volume_accepted_rejected_overlay,
 )
 
 from lbm_suite2p_python.volume import (
@@ -151,4 +153,6 @@ __all__ = [
     "plot_volume_signal",
     "plot_volume_neuron_counts",
     "consolidate_volume",
+    "plot_accepted_rejected_overlay",
+    "plot_volume_accepted_rejected_overlay",
 ]

{lbm_suite2p_python-3.0.0 → lbm_suite2p_python-3.0.1}/lbm_suite2p_python/conversion.py

@@ -20,6 +20,8 @@ from pathlib import Path
 import numpy as np
 from mbo_utilities.file_io import load_npy
 
+from lbm_suite2p_python.db_settings import _ensure_diameter_array
+
 
 # file signatures for format detection
 SUITE2P_REQUIRED = ["stat.npy", "iscell.npy", "ops.npy"]
@@ -436,7 +438,7 @@ def cellpose_to_suite2p(
     meta_path = cellpose_dir / "cellpose_meta.npy"
     if meta_path.exists():
         cp_meta = np.load(meta_path, allow_pickle=True).item()
-        ops["diameter"] = cp_meta.get("diameter", ops.get("diameter"))
+        ops["diameter"] = _ensure_diameter_array(cp_meta.get("diameter", ops.get("diameter")))
         ops["cellprob_threshold"] = cp_meta.get("cellprob_threshold")
         ops["flow_threshold"] = cp_meta.get("flow_threshold")
 

{lbm_suite2p_python-3.0.0 → lbm_suite2p_python-3.0.1}/lbm_suite2p_python/db_settings.py

@@ -172,6 +172,20 @@ _FORK_TO_UPSTREAM_RENAMES: dict[str, str] = {
     "nbinned": "nbins",
     "high_pass": "highpass_time",
     "spatial_hp_cp": "highpass_spatial",
+    "pretrained_model": "cellpose_model",
+}
+
+# fork's anatomical_only int (1-4) selects which image cellpose runs on.
+# upstream replaced this with a string in cellpose_settings.img. mapping:
+#   1 -> 'max_proj / meanImg'  (log ratio)
+#   2 -> 'meanImg'
+#   3 -> enhanced_mean_img  (REMOVED upstream — no equivalent string;
+#                            falls through to max_proj branch)
+#   4 -> 'max_proj'  (anything not matching the two strings hits else: img=max_proj)
+_ANATOMICAL_ONLY_TO_IMG: dict[int, str] = {
+    1: "max_proj / meanImg",
+    2: "meanImg",
+    4: "max_proj",
 }
 _UPSTREAM_TO_FORK_RENAMES = {v: k for k, v in _FORK_TO_UPSTREAM_RENAMES.items()}
 
@@ -189,17 +203,24 @@ _BASELINE_UPSTREAM_TO_FORK = {
 }
 
 
-def _ensure_diameter_list(value: Any) -> list[float]:
-    """Upstream expects diameter as [dy, dx]. Fork may store a scalar int."""
+def _ensure_diameter_array(value: Any) -> np.ndarray:
+    """Coerce diameter to an `np.ndarray` of shape (2,), mirroring suite2p
+    `pipeline_s2p.py:150-160`: scalar -> [d, d]; list/tuple -> array; size-1
+    array -> [d, d]; size>=2 ndarray passes through. None falls back to
+    [6., 6.] (fork-only — upstream doesn't accept None at this point).
+    """
     if value is None:
-        return [12.0, 12.0]
+        return np.array([6.0, 6.0])
+    if not isinstance(value, (list, tuple, np.ndarray)):
+        return np.array([value, value])
     if isinstance(value, (list, tuple)):
         if len(value) == 0:
-            return [12.0, 12.0]
-        if len(value) == 1:
-            return [float(value[0]), float(value[0])]
-        return [float(value[0]), float(value[1])]
-    return [float(value), float(value)]
+            return np.array([6.0, 6.0])
+        value = np.array(value)
+    if value.size == 1:
+        v = value.item()
+        return np.array([v, v])
+    return value
 
 
 def _ensure_do_registration_int(value: Any) -> int:
@@ -255,7 +276,7 @@ def ops_to_db_settings(ops: dict) -> tuple[dict, dict]:
     for key in _SETTINGS_TOP_LEVEL:
         if key in lookup:
             if key == "diameter":
-                settings[key] = _ensure_diameter_list(lookup[key])
+                settings[key] = _ensure_diameter_array(lookup[key])
             else:
                 settings[key] = lookup[key]
 
@@ -319,6 +340,33 @@ def ops_to_db_settings(ops: dict) -> tuple[dict, dict]:
     for key in _DETECTION_CELLPOSE_KEYS:
         if key in lookup:
             cellpose[key] = lookup[key]
+
+    # fork's anatomical_only int picks which image cellpose runs on.
+    # upstream encodes this via cellpose_settings.img; without this
+    # mapping anatomical_only=4 silently degrades to anatomical_only=1
+    # (the upstream default 'max_proj / meanImg' = log ratio image)
+    # because the translator only sets algorithm='cellpose' otherwise.
+    anat = lookup.get("anatomical_only")
+    if anat and "img" not in cellpose:
+        try:
+            anat_int = int(anat)
+        except (TypeError, ValueError):
+            anat_int = None
+        if anat_int in _ANATOMICAL_ONLY_TO_IMG:
+            cellpose["img"] = _ANATOMICAL_ONLY_TO_IMG[anat_int]
+        elif anat_int == 3:
+            # upstream removed enhanced_mean_img — closest fallback is
+            # 'meanImg' (same source family, no median-ratio enhancement).
+            # warn the caller so they know something changed.
+            import warnings
+            warnings.warn(
+                "anatomical_only=3 (enhanced_mean_img) is no longer supported "
+                "upstream; falling back to cellpose_settings.img='meanImg'. "
+                "Use anatomical_only in {1, 2, 4} to avoid this fallback.",
+                stacklevel=2,
+            )
+            cellpose["img"] = "max_proj"
+
     if cellpose:
         detection["cellpose_settings"] = cellpose
 
@@ -348,16 +396,9 @@ def db_settings_to_ops(db: dict | None, settings: dict | None) -> dict:
         if key in settings:
             value = settings[key]
             if key == "diameter":
-                # fork's run_plane_bin / cellpose path / rigid reg assume a
-                # scalar diameter (e.g. `np.isnan(ops["diameter"])`), but
-                # upstream stores it as [dy, dx]. Collapse to a single
-                # value for fork consumers — use dy if equal, else the
-                # mean rounded to 1 decimal.
-                if isinstance(value, (list, tuple)) and len(value) >= 1:
-                    if len(value) >= 2 and float(value[0]) != float(value[1]):
-                        value = round((float(value[0]) + float(value[1])) / 2, 1)
-                    else:
-                        value = float(value[0])
+                # keep upstream's [dy, dx] np.ndarray shape — fork consumers
+                # that need a scalar should use np.mean / [0] explicitly.
+                value = _ensure_diameter_array(value)
             ops[key] = value
 
     # flat sections

{lbm_suite2p_python-3.0.0 → lbm_suite2p_python-3.0.1}/lbm_suite2p_python/default_ops.py

@@ -119,6 +119,14 @@ def s2p_ops():
             1.0,  # adjust the automatically determined threshold by this scalar multiplier
         "max_overlap":
             0.75,  # cells with more overlap than this get removed during triage, before refinement
+        # disable upstream's npix_norm filter (suite2p>=1.0.0.x) — its
+        # detect.py call site applies 0.0/100.0 if these aren't set, which
+        # culls 100x-median-sized ROIs. suite2p_mbo had no such filter and
+        # LBM cells at diameter=4 trip the upper bound when many small
+        # cells skew the median low. -1 / inf mirrors roi_stats's own
+        # function-level defaults (effectively off).
+        "npix_norm_min": -1.0,
+        "npix_norm_max": float("inf"),
         "high_pass":
             100,  # running mean subtraction across bins with a window of size "high_pass" (use low values for 1P)
         "spatial_hp_detect":
@@ -130,7 +138,7 @@ def s2p_ops():
             3,
         # run cellpose to get masks on 1: max_proj / mean_img; 2: mean_img; 3: mean_img enhanced, 4: max_proj
         "diameter": 4,  # LBM default cell diameter in pixels (cellpose estimates if 0)
-        "cellprob_threshold": 0,  # cellprob_threshold for cellpose (0 = upstream default)
+        "cellprob_threshold": -6,  # permissive LBM default for cellpose (upstream is 0.0)
         "flow_threshold": 0,  # flow_threshold for cellpose (0 = flow-check disabled)
         "spatial_hp_cp": 0.5,  # high-pass image spatially by a multiple of the diameter
         # cellpose model: 'cpsam' (default) or path to custom model trained with lsp.train_cellpose()
@@ -176,7 +184,7 @@ def default_ops(metadata=None, ops=None):
         anatomical_only=3
         diameter=4
         spatial_hp_cp=0.5
-        cellprob_threshold=0
+        cellprob_threshold=-6
         flow_threshold=0
         spatial_scale=1
         tau=1.3

{lbm_suite2p_python-3.0.0 → lbm_suite2p_python-3.0.1}/lbm_suite2p_python/postprocessing.py

@@ -166,7 +166,15 @@ def filter_by_diameter(
 
     radii = np.array([s["radius"] for s in stat])
     diameters_px = 2 * radii
-    median_diam = ops.get("diameter", np.median(diameters_px))
+    # ops["diameter"] is np.ndarray([dy, dx]) post-pipeline; collapse to scalar
+    # for the multiplier comparison below.
+    raw_diam = ops.get("diameter")
+    if raw_diam is None:
+        median_diam = float(np.median(diameters_px))
+    elif isinstance(raw_diam, (list, tuple, np.ndarray)) and np.size(raw_diam) >= 1:
+        median_diam = float(np.mean(raw_diam))
+    else:
+        median_diam = float(raw_diam)
     lower, upper = min_mult * median_diam, max_mult * median_diam
 
     valid = (diameters_px >= lower) & (diameters_px <= upper)

{lbm_suite2p_python-3.0.0 → lbm_suite2p_python-3.0.1}/lbm_suite2p_python/run_lsp.py

@@ -99,13 +99,10 @@ def _call_upstream_pipeline(ops, f_reg, f_raw, f_reg_chan2, f_raw_chan2,
         for k, v in reg_outputs.items():
             ops[k] = v
     if isinstance(detect_outputs, dict):
+        from lbm_suite2p_python.db_settings import _ensure_diameter_array
         for k, v in detect_outputs.items():
-            # don't clobber diameter — keep whatever was passed in unless upstream
-            # actually refined it (and collapse list to scalar for fork consumers)
             if k == "diameter" and v is not None:
-                if isinstance(v, (list, tuple)) and len(v) >= 1:
-                    v = float(v[0]) if len(v) < 2 or v[0] == v[1] else (float(v[0]) + float(v[1])) / 2
-                ops[k] = v
+                ops[k] = _ensure_diameter_array(v)
             elif k != "diameter":
                 ops[k] = v
     ops["plane_times"] = plane_times
@@ -420,6 +417,7 @@ from lbm_suite2p_python.zplane import (
     plot_filtered_cells,
     plot_filter_exclusions,
     plot_cell_filter_summary,
+    plot_volume_accepted_rejected_overlay,
 )
 
 DEFAULT_CELL_FILTERS = []
@@ -432,6 +430,43 @@ from mbo_utilities.metadata import (
 
 logger = get_logger("run_lsp")
 
+
+_external_logging_attached = False
+
+
+def _attach_external_loggers(level: int = logging.INFO) -> None:
+    """Surface suite2p / cellpose progress messages on stdout.
+
+    Mainline suite2p (`suite2p.detection.anatomical`,
+    `suite2p.registration.*`) and cellpose (`cellpose.models`) use plain
+    `logging.getLogger(__name__)` loggers with no handlers attached. Their
+    `logger.info(...)` calls — registration progress, ">>>> CELLPOSE finding
+    masks", median-diameter reports — propagate to root and get silently
+    dropped by the default WARNING-level lastResort handler. Without this
+    hookup the user can't tell whether detection is running or what params
+    cellpose actually picked. Idempotent, called once per pipeline entry.
+    """
+    global _external_logging_attached
+    if _external_logging_attached:
+        return
+    fmt = logging.Formatter("%(name)s: %(message)s")
+    for name in ("suite2p", "cellpose"):
+        lg = logging.getLogger(name)
+        if lg.level == logging.NOTSET or lg.level > level:
+            lg.setLevel(level)
+        has_stream = any(
+            isinstance(h, logging.StreamHandler) and not isinstance(h, logging.FileHandler)
+            for h in lg.handlers
+        )
+        if not has_stream:
+            h = logging.StreamHandler()
+            h.setFormatter(fmt)
+            h.setLevel(level)
+            lg.addHandler(h)
+        lg.propagate = False
+    _external_logging_attached = True
+
+
 from lbm_suite2p_python._benchmarking import get_cpu_percent, get_ram_used
 from lbm_suite2p_python.volume import (
     plot_volume_diagnostics,
@@ -644,6 +679,8 @@ def pipeline(
     from mbo_utilities import imread
     from mbo_utilities.arrays import supports_roi
 
+    _attach_external_loggers()
+
     # 1. Handle Deprecations
     if roi is not None:
         import warnings
@@ -1204,6 +1241,9 @@ def run_volume(
                 plot_3d_roi_map(
                     ops_files, save_path / "roi_map_3d_plane.png", color_by="plane"
                 )
+                plot_volume_accepted_rejected_overlay(
+                    ops_files, save_path / "volume_segmentation_overlay.png"
+                )
             except Exception as e:
                 print(f"Warning: Volume plots failed: {e}")
                 traceback.print_exc()
@@ -1445,12 +1485,31 @@ def run_plane_bin(ops) -> bool:
     n_func = ops.get("nframes_chan1") or ops.get("nframes") or ops.get("n_frames")
     if n_func is None:
         raise KeyError("Missing nframes_chan1 / nframes / n_frames in ops")
+
+    # Graceful fallback for "reload a completed plane" workflow:
+    # - keep_raw=False (default) deletes data_raw.bin after a run.
+    # - When the user reloads that plane_dir and clicks Run again, the
+    #   GUI hands us an ops where raw_file is missing but reg_file (the
+    #   registered data.bin) is present. Re-registration needs raw data,
+    #   but detection/extraction can still run against data.bin.
+    # - Instead of crashing, downgrade to detection-only and log why.
     if run_registration and raw_file is None:
-        raise KeyError(
-            "Missing raw_file in ops — required when do_registration=1. "
-            "Set do_registration=0 to run detection-only against an "
-            "existing data.bin."
-        )
+        _existing_reg = ops.get("reg_file")
+        if _existing_reg and Path(_existing_reg).exists():
+            print(
+                "NOTE: raw_file missing but reg_file exists — downgrading "
+                "do_registration=1 → 0 (detection/extraction only against "
+                f"{Path(_existing_reg).name}). Pass keep_raw=True on the "
+                "first run if you want to re-register a reloaded plane."
+            )
+            ops["do_registration"] = 0
+            run_registration = False
+        else:
+            raise KeyError(
+                "Missing raw_file in ops — required when do_registration=1. "
+                "Set do_registration=0 to run detection-only against an "
+                "existing data.bin."
+            )
     n_func = int(n_func)
 
     # reg_file may already point at a linked source binary; only pin it
@@ -1488,16 +1547,12 @@ def run_plane_bin(ops) -> bool:
         ops["nframes_chan2"] = n_align
 
     if "diameter" in ops:
-        # save user's input diameter before suite2p/cellpose overwrites it
-        # cellpose estimates actual cell diameters and saves median to ops["diameter"]
+        # save user's input diameter for provenance — cellpose later overwrites
+        # ops["diameter"] with the estimated median from detection.
+        # do not default/coerce here: db_settings._ensure_diameter_list
+        # converts to [dy, dx] at the upstream-pipeline boundary, and mainline
+        # suite2p / cellpose handle None / scalar / list / aspect-pair natively.
         ops["diameter_user"] = ops["diameter"]
-        if ops["diameter"] is not None and np.isnan(ops["diameter"]):
-            ops["diameter"] = 8
-            ops["diameter_user"] = 8
-        if (ops["diameter"] in (None, 0)) and ops.get("anatomical_only", 0) > 0:
-            ops["diameter"] = 8
-            ops["diameter_user"] = 8
-            print("Warning: diameter was not set, defaulting to 8.")
 
     # reset detection-derived parameters when re-running registration or detection
     # so compute_enhanced_mean_image() reinitializes them from diameter.
@@ -1506,8 +1561,16 @@ def run_plane_bin(ops) -> bool:
     # (run_registration / run_detection were resolved earlier, near the
     # raw_file check — keep them in scope here.)
     if run_registration:
-        # full reset: clear both registration and detection intermediates
-        for key in ["spatscale_pix", "Vcorr", "Vmax", "Vmap", "Vsplit", "ihop"]:
+        # full reset: clear both registration and detection intermediates.
+        # registration outputs (badframes/xoff/yoff/corrXY) are cleared too —
+        # otherwise a prior divergent run leaves badframes=True for most
+        # frames and detection silently excludes them on the rerun even
+        # though the new registration succeeded.
+        for key in [
+            "spatscale_pix", "Vcorr", "Vmax", "Vmap", "Vsplit", "ihop",
+            "badframes", "xoff", "yoff", "corrXY",
+            "xoff1", "yoff1", "corrXY1",
+        ]:
             if key in ops:
                 del ops[key]
     elif run_detection:
@@ -2102,10 +2165,29 @@ def run_plane(
             "data_path": str(input_path.resolve()),
         }
 
+        # auto-resolve source_mode based on user intent + disk state:
+        #
+        # - explicit `do_registration=0` from the user means "I'm reusing
+        #   the registered binary, just sweeping detection/extraction".
+        #   the safe + cheap mode here is `link` — zero copies, source
+        #   binary is read-only, and N sweeps over the same plane don't
+        #   produce N redundant copies of data.bin.
+        # - otherwise fall back to the original disk-based heuristic:
+        #   `copy` if raw exists (registration can proceed locally), else
+        #   `copy_reg` (no raw on disk, raw_file gets popped, downstream
+        #   gracefully downgrades to detection-only).
+        _effective_mode = source_mode
+        if _effective_mode == "auto":
+            if ops_user.get("do_registration", 1) == 0:
+                _effective_mode = "link"
+            else:
+                _effective_mode = (
+                    "copy" if (src_dir / "data_raw.bin").exists() else "copy_reg"
+                )
+
         # link mode can't safely co-exist with do_registration=1 because
         # registration would need to write the source data.bin. flip to
         # copy_reg and warn instead of corrupting the source binary.
-        _effective_mode = source_mode
         if _effective_mode == "link" and ops_user.get("do_registration", 1):
             logger.warning(
                 "source_mode='link' requires do_registration=0 (link mode "

{lbm_suite2p_python-3.0.0 → lbm_suite2p_python-3.0.1}/lbm_suite2p_python/volume.py

@@ -1068,13 +1068,13 @@ def plot_orthoslices(
     save_path: str | Path = None,
     figsize: tuple = (16, 6),
     use_mean: bool = True,
+    interpolate: bool = False,
 ) -> plt.Figure:
     """
     Generate orthogonal maximum intensity projections (XY, XZ, YZ) of the volume.
 
-    Creates a 3-panel figure showing the volume from three orthogonal views,
-    with proper interpolation to isotropic resolution. Axes are displayed
-    in micrometers using voxel size metadata.
+    Creates a 3-panel figure showing the volume from three orthogonal views.
+    Axes are displayed in micrometers using voxel size metadata.
 
     Parameters
     ----------
@@ -1086,13 +1086,17 @@ def plot_orthoslices(
         Figure size in inches.
     use_mean : bool, default True
         If True, use meanImg. If False, use refImg (registered reference).
+    interpolate : bool, default False
+        If True, resample the volume in Z to isotropic resolution and use
+        bilinear interpolation in the XZ/YZ panels. Off by default since
+        LBM volumes are typically very thin in Z (e.g. 14 planes), where
+        interpolation can be misleading.
 
     Returns
     -------
     fig : matplotlib.figure.Figure
         The generated figure object.
     """
-    from scipy.ndimage import zoom
     from lbm_suite2p_python.postprocessing import load_ops
 
     if not ops_files:
@@ -1159,15 +1163,21 @@ def plot_orthoslices(
     vol_y_um = ny * dy_um
     vol_z_um = (nz - 1) * dz_um if nz > 1 else dz_um
 
-    # interpolate volume to isotropic resolution for proper orthoslices
-    xy_res = (dx_um + dy_um) / 2
-    z_zoom = dz_um / xy_res if xy_res > 0 else 1.0
-    z_zoom = min(z_zoom, 10.0)  # cap to avoid memory issues
-    if z_zoom > 1.1:
-        volume_resampled = zoom(volume, (z_zoom, 1, 1), order=1)
+    # optionally resample volume in z to isotropic resolution
+    if interpolate:
+        from scipy.ndimage import zoom
+        xy_res = (dx_um + dy_um) / 2
+        z_zoom = dz_um / xy_res if xy_res > 0 else 1.0
+        z_zoom = min(z_zoom, 10.0)  # cap to avoid memory issues
+        if z_zoom > 1.1:
+            volume_resampled = zoom(volume, (z_zoom, 1, 1), order=1)
+        else:
+            volume_resampled = volume
     else:
         volume_resampled = volume
 
+    imshow_interp = "bilinear" if interpolate else "nearest"
+
     # compute projections
     xy_proj = np.max(volume, axis=0)
     xz_proj = np.max(volume_resampled, axis=1)
@@ -1199,7 +1209,7 @@ def plot_orthoslices(
     ax2.set_facecolor("black")
     im2 = ax2.imshow(xz_proj, cmap="magma", aspect="auto", extent=xz_extent,
                      vmin=np.percentile(xz_proj, 1), vmax=np.percentile(xz_proj, 99.5),
-                     interpolation="bilinear")
+                     interpolation=imshow_interp)
     ax2.set_xlabel("X (μm)", fontsize=10, fontweight="bold", color="white")
     ax2.set_ylabel("Z (μm)", fontsize=10, fontweight="bold", color="white")
     ax2.set_title("XZ Projection", fontsize=11, fontweight="bold", color="white")
@@ -1212,7 +1222,7 @@ def plot_orthoslices(
     ax3.set_facecolor("black")
     im3 = ax3.imshow(yz_proj.T, cmap="magma", aspect="auto", extent=yz_extent,
                      vmin=np.percentile(yz_proj, 1), vmax=np.percentile(yz_proj, 99.5),
-                     interpolation="bilinear")
+                     interpolation=imshow_interp)
     ax3.set_xlabel("Z (μm)", fontsize=10, fontweight="bold", color="white")
     ax3.set_ylabel("Y (μm)", fontsize=10, fontweight="bold", color="white")
     ax3.set_title("YZ Projection", fontsize=11, fontweight="bold", color="white")

{lbm_suite2p_python-3.0.0 → lbm_suite2p_python-3.0.1}/lbm_suite2p_python/zplane.py

@@ -946,6 +946,339 @@ def plot_masks(
         plt.show()
 
 
+def _build_accepted_rejected_canvas(
+        img: np.ndarray,
+        stat,
+        iscell_mask: np.ndarray,
+        *,
+        ops: dict = None,
+        proj_key: str = None,
+        accepted_color=(0.0, 1.0, 0.0),
+        rejected_color=(1.0, 0.0, 0.0),
+):
+    """
+    Build an RGB canvas of a projection with accepted/rejected ROIs blended
+    on top using suite2p ``lam`` weights — the same per-pixel opacity used
+    by :func:`plot_masks`.
+
+    Returns
+    -------
+    canvas : ndarray (Ly, Lx, 3)
+    n_accepted, n_rejected : int
+    """
+    stat_yoff = 0
+    stat_xoff = 0
+    if ops is not None and proj_key is not None:
+        img, stat_yoff, stat_xoff = _crop_projection_to_valid(ops, img, proj_key)
+
+    vmin = np.nanpercentile(img, 1)
+    vmax = np.nanpercentile(img, 99)
+    normalized = (img - vmin) / (vmax - vmin + 1e-6)
+    normalized = np.clip(normalized, 0, 1)
+    normalized = np.nan_to_num(normalized, nan=0.0)
+    canvas = np.tile(normalized, (3, 1, 1)).transpose(1, 2, 0).astype(np.float32)
+
+    Ly, Lx = img.shape[:2]
+    iscell_mask = np.asarray(iscell_mask, dtype=bool)
+
+    accepted_color = np.asarray(accepted_color, dtype=np.float32)
+    rejected_color = np.asarray(rejected_color, dtype=np.float32)
+
+    for n, s in enumerate(stat):
+        ypix = np.asarray(s.get("ypix", []), dtype=int) - stat_yoff
+        xpix = np.asarray(s.get("xpix", []), dtype=int) - stat_xoff
+        lam = np.asarray(s.get("lam", []), dtype=np.float32)
+        if ypix.size == 0:
+            continue
+        valid = (ypix >= 0) & (ypix < Ly) & (xpix >= 0) & (xpix < Lx)
+        if not np.any(valid):
+            continue
+        ypix, xpix, lam = ypix[valid], xpix[valid], lam[valid]
+        lam = lam / (lam.max() + 1e-10)
+        col = accepted_color if iscell_mask[n] else rejected_color
+        for k in range(3):
+            canvas[ypix, xpix, k] = (
+                0.5 * canvas[ypix, xpix, k] + 0.5 * col[k] * lam
+            )
+
+    n_accepted = int(iscell_mask.sum())
+    n_rejected = int((~iscell_mask).sum())
+    return canvas, n_accepted, n_rejected
+
+
+def plot_accepted_rejected_overlay(
+        img: np.ndarray,
+        stat,
+        iscell_mask: np.ndarray,
+        savepath: str | Path = None,
+        title: str = None,
+        *,
+        ops: dict = None,
+        proj_key: str = None,
+        figsize: tuple = (6, 6),
+        dpi: int = 300,
+):
+    """
+    Draw accepted (green) and rejected (red) ROI overlays on a projection.
+
+    Uses the same lam-weighted per-pixel opacity as :func:`plot_masks` so
+    feathering matches the rest of the segmentation figures. Adds dark
+    formatting and ``Accepted``/``Rejected`` count labels at the top.
+
+    Parameters
+    ----------
+    img : ndarray (Ly x Lx)
+        Background projection image.
+    stat : list[dict]
+        Suite2p ROI stat dictionaries (full-frame coordinates).
+    iscell_mask : ndarray[bool]
+        Boolean array, True for accepted ROIs.
+    savepath : str or Path, optional
+        Path to save the figure. If None, displays with plt.show().
+    title : str, optional
+        Projection-name title rendered above the count labels.
+    ops : dict, optional
+        Suite2p ops dictionary. With ``proj_key``, the image is cropped to
+        the valid (non-padded) region and stat coordinates are translated
+        accordingly.
+    proj_key : str, optional
+        Projection key matching ``img`` (e.g. ``"meanImg"``, ``"max_proj"``).
+    figsize : tuple, optional
+        Figure size. Default (6, 6) to match other segmentation figures.
+    dpi : int, optional
+        Output DPI. Default 300.
+    """
+    canvas, n_accepted, n_rejected = _build_accepted_rejected_canvas(
+        img, stat, iscell_mask, ops=ops, proj_key=proj_key,
+    )
+
+    fig, ax = plt.subplots(figsize=figsize, facecolor="black")
+    ax.set_facecolor("black")
+    ax.imshow(canvas, interpolation="nearest")
+
+    label_y = 1.02
+    if title:
+        ax.text(
+            0.5, 1.02, title,
+            transform=ax.transAxes,
+            fontsize=12, fontweight="bold", fontname="Courier New",
+            color="white", ha="center", va="bottom",
+        )
+        label_y = 1.10
+    ax.text(
+        0.37, label_y,
+        f"Accepted: {n_accepted:03d}",
+        transform=ax.transAxes,
+        fontsize=14, fontweight="bold", fontname="Courier New",
+        color="lime", ha="right", va="bottom",
+    )
+    ax.text(
+        0.63, label_y,
+        f"Rejected: {n_rejected:03d}",
+        transform=ax.transAxes,
+        fontsize=14, fontweight="bold", fontname="Courier New",
+        color="red", ha="left", va="bottom",
+    )
+    ax.set_xticks([])
+    ax.set_yticks([])
+    ax.axis("off")
+    plt.tight_layout()
+
+    if savepath:
+        if Path(savepath).is_dir():
+            raise ValueError("savepath must be a file path, not a directory.")
+        plt.savefig(savepath, dpi=dpi, facecolor="black")
+        plt.close(fig)
+    else:
+        plt.show()
+
+
+def plot_volume_accepted_rejected_overlay(
+        ops_files,
+        savepath: str | Path = None,
+        *,
+        ncols: int = None,
+        figsize: tuple = None,
+        dpi: int = 200,
+):
+    """
+    Volumetric version of :func:`plot_accepted_rejected_overlay`.
+
+    One subplot per z-plane showing the projection used by cellpose with
+    accepted ROIs in green and rejected in red. Uses the same lam-weighted
+    opacity as :func:`plot_masks`. Per-subplot titles show the plane's
+    ``Accepted: N`` (lime) and ``Rejected: N`` (red) counts; an overall
+    title at the very top reports total accepted/rejected across the volume.
+
+    Parameters
+    ----------
+    ops_files : list of str or Path
+        Paths to per-plane ``ops.npy`` files.
+    savepath : str or Path, optional
+        Where to save the figure. If None, calls plt.show().
+    ncols : int, optional
+        Number of columns in the subplot grid. Defaults to a near-square
+        layout.
+    figsize : tuple, optional
+        Figure size. Defaults based on the grid shape.
+    dpi : int, optional
+        Output DPI. Default 200.
+    """
+    ops_files = [Path(p) for p in ops_files]
+    n_planes = len(ops_files)
+    if n_planes == 0:
+        raise ValueError("ops_files is empty")
+
+    if ncols is None:
+        ncols = int(np.ceil(np.sqrt(n_planes)))
+    nrows = int(np.ceil(n_planes / ncols))
+    if figsize is None:
+        figsize = (4 * ncols, 4.4 * nrows)
+
+    proj_lookup = {
+        0: ("Vcorr", "Correlation Image"),
+        1: ("max_proj", "Max Projection"),
+        2: ("meanImg", "Mean Image"),
+        3: ("meanImgE", "Enhanced Mean Image"),
+        4: ("max_proj", "Max Projection"),
+    }
+    fallback_titles = {
+        "meanImg": "Mean Image",
+        "max_proj": "Max Projection",
+        "meanImgE": "Enhanced Mean Image",
+        "Vcorr": "Correlation Image",
+    }
+
+    def _is_valid_image(im):
+        if im is None:
+            return False
+        if isinstance(im, (int, float)) and im == 0:
+            return False
+        if isinstance(im, np.ndarray) and im.size == 0:
+            return False
+        return True
+
+    def _plane_num(ops, fallback):
+        raw = ops.get("plane", None)
+        if raw is None:
+            return fallback
+        if isinstance(raw, (int, np.integer)):
+            return int(raw)
+        digits = "".join(c for c in str(raw) if c.isdigit())
+        return int(digits) if digits else fallback
+
+    plane_entries = []
+    for i, ops_file in enumerate(ops_files):
+        try:
+            ops = load_ops(ops_file)
+        except Exception as e:
+            print(f"  Warning: could not load {ops_file}: {e}")
+            continue
+        try:
+            res = load_planar_results(ops)
+        except Exception as e:
+            print(f"  Warning: could not load planar results for {ops_file}: {e}")
+            continue
+
+        stat = res["stat"]
+        iscell_mask = res["iscell"][:, 0].astype(bool)
+
+        anatomical_only = int(ops.get("anatomical_only", 0) or 0)
+        proj_key, proj_title = proj_lookup.get(anatomical_only, ("meanImg", "Mean Image"))
+        img = ops.get(proj_key)
+        if not _is_valid_image(img):
+            for fk in ("meanImg", "max_proj", "meanImgE", "Vcorr"):
+                if _is_valid_image(ops.get(fk)):
+                    proj_key = fk
+                    proj_title = fallback_titles[fk]
+                    img = ops.get(fk)
+                    break
+        if not _is_valid_image(img):
+            continue
+
+        plane_entries.append({
+            "plane": _plane_num(ops, i),
+            "ops": ops,
+            "img": img,
+            "stat": stat,
+            "iscell_mask": iscell_mask,
+            "proj_key": proj_key,
+            "proj_title": proj_title,
+        })
+
+    if not plane_entries:
+        raise RuntimeError("No valid plane data found in ops_files")
+
+    plane_entries.sort(key=lambda e: e["plane"])
+
+    fig, axes = plt.subplots(nrows, ncols, figsize=figsize, facecolor="black")
+    axes = np.atleast_1d(axes).ravel()
+
+    total_accepted = 0
+    total_rejected = 0
+
+    for idx, ax in enumerate(axes):
+        ax.set_facecolor("black")
+        if idx >= len(plane_entries):
+            ax.axis("off")
+            continue
+        e = plane_entries[idx]
+        canvas, n_acc, n_rej = _build_accepted_rejected_canvas(
+            e["img"], e["stat"], e["iscell_mask"],
+            ops=e["ops"], proj_key=e["proj_key"],
+        )
+        total_accepted += n_acc
+        total_rejected += n_rej
+
+        ax.imshow(canvas, interpolation="nearest")
+        ax.set_xticks([])
+        ax.set_yticks([])
+        for spine in ax.spines.values():
+            spine.set_visible(False)
+
+        ax.text(
+            0.02, 1.10, f"plane {e['plane']:02d}",
+            transform=ax.transAxes,
+            fontsize=10, fontweight="bold", fontname="Courier New",
+            color="white", ha="left", va="bottom",
+        )
+        ax.text(
+            0.48, 1.10, f"Accepted: {n_acc:03d}",
+            transform=ax.transAxes,
+            fontsize=10, fontweight="bold", fontname="Courier New",
+            color="lime", ha="right", va="bottom",
+        )
+        ax.text(
+            0.52, 1.10, f"Rejected: {n_rej:03d}",
+            transform=ax.transAxes,
+            fontsize=10, fontweight="bold", fontname="Courier New",
+            color="red", ha="left", va="bottom",
+        )
+
+    fig.text(
+        0.49, 0.985,
+        f"Total Accepted: {total_accepted:04d}",
+        color="lime", fontsize=16, fontweight="bold", fontname="Courier New",
+        ha="right", va="top",
+    )
+    fig.text(
+        0.51, 0.985,
+        f"Total Rejected: {total_rejected:04d}",
+        color="red", fontsize=16, fontweight="bold", fontname="Courier New",
+        ha="left", va="top",
+    )
+
+    plt.tight_layout(rect=(0, 0, 1, 0.96))
+
+    if savepath:
+        if Path(savepath).is_dir():
+            raise ValueError("savepath must be a file path, not a directory.")
+        plt.savefig(savepath, dpi=dpi, facecolor="black")
+        plt.close(fig)
+    else:
+        plt.show()
+
+
 def plot_projection(
     ops,
     output_directory=None,
@@ -2873,6 +3206,8 @@ def plot_zplane_figures(
         "meanImg_segmentation": plane_dir / "03_mean_segmentation.png",
         "meanImgE": plane_dir / "04_mean_enhanced.png",
         "meanImgE_segmentation": plane_dir / "04_mean_enhanced_segmentation.png",
+        # rejected-cell overlay on the projection used for cellpose detection
+        "rejected_segmentation": plane_dir / "04b_rejected_segmentation.png",
         # Diagnostics and analysis
         "quality_diagnostics": plane_dir / "05_quality_diagnostics.png",
         "registration": plane_dir / "06_registration.png",
@@ -2910,6 +3245,7 @@ def plot_zplane_figures(
         "meanImg_segmentation",
         "meanImgE",
         "meanImgE_segmentation",
+        "rejected_segmentation",
         "quality_diagnostics",
         "registration",
         "traces_raw_20",
@@ -3004,6 +3340,52 @@ def plot_zplane_figures(
             except Exception as e:
                 print(f"  Warning: {img_key} segmentation failed: {e}")
 
+        # rejected-cell overlay on the projection actually used for cellpose
+        # detection. anatomical_only mapping (from default_ops.py):
+        #   0 -> Vcorr (functional sparse mode)
+        #   1 -> max_proj / meanImg (combined; we display max_proj as the
+        #        closest visualizable proxy since the ratio isn't stored)
+        #   2 -> meanImg
+        #   3 -> meanImgE
+        #   4 -> max_proj
+        try:
+            if n_rejected > 0:
+                anatomical_only = int(output_ops.get("anatomical_only", 0) or 0)
+                proj_lookup = {
+                    0: ("Vcorr", "Correlation Image"),
+                    1: ("max_proj", "Max Projection (max_proj / meanImg)"),
+                    2: ("meanImg", "Mean Image"),
+                    3: ("meanImgE", "Enhanced Mean Image"),
+                    4: ("max_proj", "Max Projection"),
+                }
+                rej_key, rej_title = proj_lookup.get(anatomical_only, ("meanImg", "Mean Image"))
+                rej_img = output_ops.get(rej_key)
+                # fallback chain if the chosen projection isn't available
+                if not _is_valid_image(rej_img):
+                    for fk in ("meanImg", "max_proj", "meanImgE", "Vcorr"):
+                        if _is_valid_image(output_ops.get(fk)):
+                            rej_key = fk
+                            rej_title = {
+                                "meanImg": "Mean Image",
+                                "max_proj": "Max Projection",
+                                "meanImgE": "Enhanced Mean Image",
+                                "Vcorr": "Correlation Image",
+                            }[fk]
+                            rej_img = output_ops.get(fk)
+                            break
+                if _is_valid_image(rej_img):
+                    plot_accepted_rejected_overlay(
+                        img=rej_img,
+                        stat=stat_full,
+                        iscell_mask=iscell_mask,
+                        savepath=expected_files["rejected_segmentation"],
+                        title=rej_title,
+                        ops=output_ops,
+                        proj_key=rej_key,
+                    )
+        except Exception as e:
+            print(f"  Warning: rejected segmentation failed: {e}")
+
         # correlation image (Vcorr) - cropped space. Render the no-mask
         # version through the cropping helper so it matches the mask
         # variant's extent.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lbm_suite2p_python
-Version: 3.0.0
+Version: 3.0.1
 Summary: Light Beads Microscopy Pipeline using Suite2p
 License-Expression: BSD-3-Clause
 Project-URL: homepage, https://github.com/MillerBrainObservatory/LBM-Suite2p-Python
@@ -11,18 +11,15 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Requires-Python: <3.14,>=3.12.7
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
-Requires-Dist: mbo_utilities>=2.7.7
+Requires-Dist: mbo_utilities>=3.0.0
 Requires-Dist: suite2p>=1.0.0.1
 Requires-Dist: setuptools<81
 Provides-Extra: rastermap
 Requires-Dist: rastermap; extra == "rastermap"
 Provides-Extra: cellpose
 Requires-Dist: cellpose>=4.0.6; extra == "cellpose"
-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,torch]; extra == "all"
+Requires-Dist: lbm_suite2p_python[cellpose,rastermap]; extra == "all"
 Dynamic: license-file
 
 <p align="center">

lbm_suite2p_python-3.0.1/lbm_suite2p_python.egg-info/requires.txt

@@ -0,0 +1,12 @@
+mbo_utilities>=3.0.0
+suite2p>=1.0.0.1
+setuptools<81
+
+[all]
+lbm_suite2p_python[cellpose,rastermap]
+
+[cellpose]
+cellpose>=4.0.6
+
+[rastermap]
+rastermap

{lbm_suite2p_python-3.0.0 → lbm_suite2p_python-3.0.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lbm_suite2p_python"
-version = "3.0.0"
+version = "3.0.1"
 description = "Light Beads Microscopy Pipeline using Suite2p"
 readme = "README.md"
 license = "BSD-3-Clause"
@@ -18,7 +18,7 @@ classifiers=[
 ]
 
 dependencies = [
-	"mbo_utilities>=2.7.7",
+	"mbo_utilities>=3.0.0",
 	"suite2p>=1.0.0.1",
 	"setuptools<81",
 ]
@@ -35,14 +35,9 @@ rastermap = [
 cellpose = [
 	"cellpose>=4.0.6",
 ]
-# PyTorch for neural network operations (Cellpose, etc.)
-torch = [
-	"torch>=2.7.0",
-	"torchvision>=0.22.0",
-]
 # All optional dependencies
 all = [
-	"lbm_suite2p_python[rastermap,cellpose,torch]",
+	"lbm_suite2p_python[rastermap,cellpose]",
 ]
 
 [dependency-groups]
@@ -70,7 +65,7 @@ docs = [
 	"scikit-image",
 	"scipy",
 	"pandas",
-	"suite2p_mbo",
+	"suite2p",
 ]
 
 # https://github.com/charliermarsh/ruff

lbm_suite2p_python-3.0.0/lbm_suite2p_python.egg-info/requires.txt

@@ -1,16 +0,0 @@
-mbo_utilities>=2.7.7
-suite2p>=1.0.0.1
-setuptools<81
-
-[all]
-lbm_suite2p_python[cellpose,rastermap,torch]
-
-[cellpose]
-cellpose>=4.0.6
-
-[rastermap]
-rastermap
-
-[torch]
-torch>=2.7.0
-torchvision>=0.22.0