lbm_suite2p_python 3.0.0__tar.gz → 3.0.2__tar.gz

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

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: lbm_suite2p_python
-Version: 3.0.0
-Summary: Light Beads Microscopy Pipeline using Suite2p
+Version: 3.0.2
+Summary: Calcium Imaging Pipeline built with Suite2p, Cellpose and Rastermap
 License-Expression: BSD-3-Clause
 Project-URL: homepage, https://github.com/MillerBrainObservatory/LBM-Suite2p-Python
 Keywords: Pipeline,Numpy,Microscopy,ScanImage,Suite2p,tiff
@@ -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.1
 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.2}/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 (
@@ -46,6 +48,7 @@ from lbm_suite2p_python.volume import (
     plot_orthoslices,
     plot_3d_roi_map,
     plot_3d_rastermap_clusters,
+    plot_volume_trace_figures,
     plot_volume_signal,
     plot_volume_neuron_counts,
     consolidate_volume,
@@ -147,8 +150,11 @@ __all__ = [
     "plot_orthoslices",
     "plot_3d_roi_map",
     "plot_3d_rastermap_clusters",
+    "plot_volume_trace_figures",
     "plot_projection",
     "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.2}/lbm_suite2p_python/cellpose.py

@@ -194,10 +194,8 @@ def _masks_to_stat(masks, img=None, compute_overlap=True):
 
     # Build pixel count map for overlap detection
     if compute_overlap and masks.ndim == 2:
-        # Count how many ROIs claim each pixel (for overlap computation)
-        # Since cellpose masks are non-overlapping by design, we check boundaries
-        from scipy import ndimage
-        # Dilate each mask slightly to find potential overlaps at boundaries
+        # cellpose masks are non-overlapping by construction; track per-pixel
+        # claim count so callers can detect dilated-boundary overlaps
         overlap_map = np.zeros(masks.shape, dtype=np.int32)
         for roi_id in range(1, n_rois + 1):
             roi_mask = masks == roi_id
@@ -1611,7 +1609,6 @@ def prepare_training_data(
     train_cellpose : Train model on prepared data
     save_gui_results : Save results in GUI-compatible format
     """
-    import shutil
     import tifffile
 
     output_dir = Path(output_dir)

{lbm_suite2p_python-3.0.0 → lbm_suite2p_python-3.0.2}/lbm_suite2p_python/cli.py

@@ -23,13 +23,10 @@ Examples:
 """
 
 import argparse
-import json
 import sys
 from pathlib import Path
 from typing import Any
 
-import numpy as np
-
 
 def _snake_to_kebab(name: str) -> str:
     """convert snake_case to kebab-case for CLI args."""
@@ -95,7 +92,6 @@ def _get_ops_help() -> dict[str, str]:
 def build_parser() -> argparse.ArgumentParser:
     """build the argument parser with all pipeline and ops parameters."""
     from lbm_suite2p_python.default_ops import s2p_ops
-    from lbm_suite2p_python import __version__
 
     parser = argparse.ArgumentParser(
         prog="lsp",
@@ -193,6 +189,11 @@ Examples:
         "--dff-smooth", type=int, dest="dff_smooth_window",
         help="smoothing window for dF/F"
     )
+    dff.add_argument(
+        "--correct-neuropil", dest="correct_neuropil",
+        action=argparse.BooleanOptionalAction, default=True,
+        help="subtract 0.7*Fneu before dF/F (default: on; use --no-correct-neuropil to disable)"
+    )
 
     # cell filter options
     filters = parser.add_argument_group("cell filter options")
@@ -491,7 +492,7 @@ def main():
 
     # run pipeline
     try:
-        results = lsp.pipeline(
+        lsp.pipeline(
             input_data=input_path,
             save_path=output_path,
             ops=ops,
@@ -505,6 +506,7 @@ def main():
             dff_window_size=args.dff_window_size,
             dff_percentile=args.dff_percentile,
             dff_smooth_window=args.dff_smooth_window,
+            correct_neuropil=args.correct_neuropil,
             cell_filters=cell_filters,
             accept_all_cells=args.accept_all_cells,
             save_json=args.save_json,

{lbm_suite2p_python-3.0.0 → lbm_suite2p_python-3.0.2}/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")
 
@@ -744,8 +746,6 @@ def compare_detections(path_a, path_b, iou_threshold=0.5):
     dict
         Comparison results with matched pairs and unique ROIs.
     """
-    from scipy.ndimage import label
-
     path_a, path_b = Path(path_a), Path(path_b)
 
     # load masks from both

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

@@ -172,9 +172,48 @@ _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()}
 
+# per-section flat-key disambiguation. Several upstream sections share
+# an upstream key. When flattened to ops, the second iteration clobbers
+# the first; on the reverse derivation, the surviving value gets fanned
+# back into BOTH sections — silently corrupting one of them.
+# This map gives the colliding (section, upstream_key) pair its own
+# distinct flat-ops key so the round-trip preserves both values.
+#
+# Discovered collisions (audit via _SETTINGS_SECTIONS + detection groups):
+#   "batch_size" — registration vs extraction.
+#                  registration keeps the legacy flat name "batch_size"
+#                  (matches the historical fork ops shape);
+#                  extraction gets "extract_batch_size".
+#   "block_size" — registration vs detection (suite2p uses the same
+#                  upstream key for the rigid-block geometry AND the
+#                  pca-denoise / sparsery block size).
+#                  registration keeps the legacy flat name "block_size";
+#                  detection gets "det_block_size".
+#
+# Both rename targets match the field names that mbo's GUI dataclass
+# already uses (`extract_batch_size`, `det_block_size_y/_x`).
+_SECTION_FLAT_RENAMES: dict[tuple[str, str], str] = {
+    ("extraction", "batch_size"): "extract_batch_size",
+    ("detection", "block_size"): "det_block_size",
+}
+
 # baseline values differ between fork and upstream:
 #   fork dcnv.preprocess branches on "maximin" / "constant" / "constant_prctile"
 #   upstream dcnv.preprocess branches on "maximin" / "constant" / "prctile"
@@ -189,17 +228,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 +301,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]
 
@@ -263,9 +309,15 @@ def ops_to_db_settings(ops: dict) -> tuple[dict, dict]:
     for section, keys in _SETTINGS_SECTIONS.items():
         bucket: dict[str, Any] = {}
         for key in keys:
-            if key not in lookup:
+            # per-section flat-key disambiguation. e.g. extraction reads
+            # its batch_size from ops["extract_batch_size"] (not
+            # ops["batch_size"]) so registration's batch_size doesn't get
+            # spread into both sections during the flat→structured
+            # derivation. Mirror of the write side in db_settings_to_ops.
+            flat_key = _SECTION_FLAT_RENAMES.get((section, key), key)
+            if flat_key not in lookup:
                 continue
-            value = lookup[key]
+            value = lookup[flat_key]
             if section == "run" and key == "do_registration":
                 value = _ensure_do_registration_int(value)
             if section == "registration" and key == "block_size" and isinstance(value, list):
@@ -295,11 +347,16 @@ def ops_to_db_settings(ops: dict) -> tuple[dict, dict]:
     for key in _DETECTION_TOP_KEYS:
         if key == "algorithm":
             continue
-        if key in lookup:
-            value = lookup[key]
-            if key == "block_size" and isinstance(value, list):
-                value = tuple(value)
-            detection[key] = value
+        # per-section flat-key disambiguation. detection.block_size reads
+        # from ops["det_block_size"] (not ops["block_size"], which holds
+        # the registration block size). Mirror of the write side.
+        flat_key = _SECTION_FLAT_RENAMES.get(("detection", key), key)
+        if flat_key not in lookup:
+            continue
+        value = lookup[flat_key]
+        if key == "block_size" and isinstance(value, list):
+            value = tuple(value)
+        detection[key] = value
 
     sparsery: dict[str, Any] = {}
     for key in _DETECTION_SPARSERY_KEYS:
@@ -319,6 +376,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 +432,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
@@ -369,7 +446,14 @@ def db_settings_to_ops(db: dict | None, settings: dict | None) -> dict:
             value = section_dict[key]
             if section == "dcnv_preprocess" and key == "baseline":
                 value = _BASELINE_UPSTREAM_TO_FORK.get(str(value), value)
-            target_name = _UPSTREAM_TO_FORK_RENAMES.get(key, key)
+            # per-section disambiguation first (e.g. extraction.batch_size
+            # → extract_batch_size to avoid colliding with
+            # registration.batch_size). Fall back to the global
+            # upstream→fork rename map.
+            target_name = _SECTION_FLAT_RENAMES.get(
+                (section, key),
+                _UPSTREAM_TO_FORK_RENAMES.get(key, key),
+            )
             ops[target_name] = value
 
     # mirror align_by_chan2 back to align_by_chan for fork consumers
@@ -382,7 +466,13 @@ def db_settings_to_ops(db: dict | None, settings: dict | None) -> dict:
     for key in _DETECTION_TOP_KEYS:
         if key in detection:
             value = detection[key]
-            target_name = _UPSTREAM_TO_FORK_RENAMES.get(key, key)
+            # per-section disambiguation first (e.g. detection.block_size
+            # → det_block_size to avoid colliding with
+            # registration.block_size).
+            target_name = _SECTION_FLAT_RENAMES.get(
+                ("detection", key),
+                _UPSTREAM_TO_FORK_RENAMES.get(key, key),
+            )
             ops[target_name] = value
 
     # reverse the algorithm → sparse_mode derivation for fork consumers

lbm_suite2p_python-3.0.2/lbm_suite2p_python/default_ops.py

@@ -0,0 +1,84 @@
+"""Default ops for the LBM pipeline.
+
+Historically this module hard-coded a flat ops dict whose values
+diverged from suite2p's own defaults in a handful of fields
+(`batch_size=500`, `chan2_thres=0.65`, `tau=1.3`, `diameter=4`, etc.).
+That divergence made the round-trip through `settings.npy` confusing —
+on-disk values that matched the lsp default were flagged as "modified"
+against suite2p's schema, and vice versa.
+
+This module now exposes exactly suite2p's defaults (the values from
+`suite2p.default_settings()` + `suite2p.default_db()`), flattened to the
+fork's flat-ops shape via the same `db_settings_to_ops` translation
+that the rest of lsp uses. There is now ONE source of truth for "what
+default means": suite2p's parameter schema. Any LBM-specific tweaks
+(diameter, tau, etc.) belong in user code, not in the default.
+"""
+
+from mbo_utilities.metadata import get_param, get_voxel_size
+
+
+def s2p_ops() -> dict:
+    """Suite2p's default ops in flat (fork-style) form.
+
+    Composed from `suite2p.default_settings()` + `suite2p.default_db()`
+    via `db_settings_to_ops`, so the rename map and per-section
+    flat-key disambiguation (e.g. extraction.batch_size →
+    extract_batch_size) are applied consistently.
+    """
+    from suite2p import default_settings, default_db
+    from lbm_suite2p_python.db_settings import db_settings_to_ops
+
+    return db_settings_to_ops(default_db(), default_settings())
+
+
+def default_ops(metadata: dict | None = None, ops: dict | None = None) -> dict:
+    """Return default ops for the LBM Suite2p pipeline.
+
+    Parameters
+    ----------
+    metadata : dict, optional
+        Source-data metadata. When provided, `fs` and the (`dx`, `dy`)
+        voxel-size pair are pulled in from the metadata and overlaid
+        onto the suite2p defaults.
+    ops : dict, optional
+        A user-supplied ops dict to start from. When None, starts from
+        `s2p_ops()` (suite2p's defaults).
+
+    Returns
+    -------
+    dict
+        Flat ops dict ready to be passed to `pipeline()` / `run_plane()`.
+
+    Notes
+    -----
+    `nplanes=1` and `nchannels=1` are forced at the end. The lsp
+    pipeline always processes one plane at a time, so these stay fixed
+    regardless of caller input.
+
+    Examples
+    --------
+    >>> import lbm_suite2p_python as lsp
+    >>> ops = lsp.default_ops()
+    >>> lsp.run_plane(
+    ...     ops=ops,
+    ...     input_tiff="D:/demo/raw_data/raw_file_00001.tif",
+    ...     save_path="D:/demo/results",
+    ...     save_folder="v1",
+    ... )
+    """
+    if ops is None:
+        ops = s2p_ops()
+
+    if metadata is not None:
+        fs = get_param(metadata, "fs")
+        if fs is not None:
+            ops["fs"] = fs
+        voxel = get_voxel_size(metadata)
+        if voxel.dx != 1.0 or voxel.dy != 1.0:
+            ops["dx"] = voxel.dx
+            ops["dy"] = voxel.dy
+
+    ops["nplanes"] = 1
+    ops["nchannels"] = 1
+    return ops

{lbm_suite2p_python-3.0.0 → lbm_suite2p_python-3.0.2}/lbm_suite2p_python/gui.py

@@ -9,7 +9,6 @@ Usage:
 """
 
 import argparse
-import sys
 import tempfile
 from pathlib import Path