lbm_suite2p_python 2.0.2__tar.gz → 2.0.4__tar.gz

{lbm_suite2p_python-2.0.2/lbm_suite2p_python.egg-info → lbm_suite2p_python-2.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lbm_suite2p_python
-Version: 2.0.2
+Version: 2.0.4
 Summary: Light Beads Microscopy Pipeline using Suite2p
 License-Expression: BSD-3-Clause
 Project-URL: homepage, https://github.com/MillerBrainObservatory/LBM-Suite2p-Python
@@ -11,7 +11,7 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Requires-Python: <3.12.10,>=3.12.7
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
-Requires-Dist: mbo_utilities>=2.0.2
+Requires-Dist: mbo_utilities>=2.0.4
 Provides-Extra: cpsam
 Requires-Dist: cellpose==4.0.6; extra == "cpsam"
 Requires-Dist: pytorch; extra == "cpsam"

{lbm_suite2p_python-2.0.2 → lbm_suite2p_python-2.0.4}/lbm_suite2p_python/postprocessing.py

@@ -13,6 +13,7 @@ def _normalize_iscell(iscell):
         iscell = iscell[:, 0]
     return iscell.astype(bool)
 
+
 def filter_by_diameter(iscell, stat, ops, min_mult=0.3, max_mult=3.0):
     """
     Set iscell=False for ROIs whose radius is out of range relative to ops['diameter'].
@@ -97,6 +98,7 @@ def mode_robust(x):
             j = i
     return mode_robust(x[j:j+N+1])
 
+
 def compute_event_exceptionality(traces, N=5, robust_std=False):
     """
     traces: ndarray (n_cells x T)
@@ -430,3 +432,43 @@ def load_ops(ops_input: str | Path | list[str | Path]) -> dict:
     return {}
 
 
+def load_traces(ops):
+    """
+    Load fluorescence traces and related data from an ops file directory and return valid cells.
+
+    This function loads the raw fluorescence traces, neuropil traces, and spike data from the directory
+    specified in the ops dictionary. It also loads the 'iscell' file and returns only the traces corresponding
+    to valid cells (i.e. where iscell is True).
+
+    Parameters
+    ----------
+    ops : dict
+        Dictionary containing at least the key 'save_path', which specifies the directory where the following
+        files are stored: 'F.npy', 'Fneu.npy', 'spks.npy', and 'iscell.npy'.
+
+    Returns
+    -------
+    F_valid : ndarray
+        Array of fluorescence traces for valid cells (n_valid x n_timepoints).
+    Fneu_valid : ndarray
+        Array of neuropil fluorescence traces for valid cells (n_valid x n_timepoints).
+    spks_valid : ndarray
+        Array of spike data for valid cells (n_valid x n_timepoints).
+
+    Notes
+    -----
+    The 'iscell.npy' file is expected to be an array where the first column (iscell[:, 0]) contains
+    boolean values indicating valid cells.
+    """
+    save_path = Path(ops['save_path'])
+    F = np.load(save_path.joinpath('F.npy'))
+    Fneu = np.load(save_path.joinpath('Fneu.npy'))
+    spks = np.load(save_path.joinpath('spks.npy'))
+    iscell = np.load(save_path.joinpath('iscell.npy'), allow_pickle=True)[:, 0].astype(bool)
+
+    F_valid = F[iscell]
+    Fneu_valid = Fneu[iscell]
+    spks_valid = spks[iscell]
+
+    return F_valid, Fneu_valid, spks_valid
+

{lbm_suite2p_python-2.0.2 → lbm_suite2p_python-2.0.4}/lbm_suite2p_python/run_lsp.py

@@ -18,10 +18,7 @@ from lbm_suite2p_python.postprocessing import (
 )
 from mbo_utilities.log import get as get_logger
 
-from lbm_suite2p_python.zplane import (
-    save_pc_panels_and_metrics,
-    plot_zplane_figures
-)
+from lbm_suite2p_python.zplane import save_pc_panels_and_metrics, plot_zplane_figures
 
 logger = get_logger("run_lsp")
 
@@ -31,7 +28,9 @@ from lbm_suite2p_python.volume import (
     plot_volume_neuron_counts,
     get_volume_stats,
 )
-from mbo_utilities.file_io import get_plane_from_filename, get_files # derive_tag_from_filename, PIPELINE_TAGS
+from mbo_utilities.file_io import (
+    get_plane_from_filename,
+)  # derive_tag_from_filename, PIPELINE_TAGS
 
 PIPELINE_TAGS = ("plane", "roi", "z", "plane_", "roi_", "z_")
 
@@ -160,6 +159,7 @@ def run_volume(
     - Optional rastermap clustering results
     """
     from mbo_utilities.file_io import get_files, get_plane_from_filename
+
     start = time.time()
     if save_path is None:
         save_path = Path(input_files[0]).parent
@@ -204,6 +204,7 @@ def run_volume(
     if "roi" in Path(input_files[0]).stem.lower():
         print("Detected mROI data, merging ROIs for each z-plane...")
         from .merging import merge_mrois
+
         merged_savepath = save_path.joinpath("merged_mrois")
         merge_mrois(save_path, merged_savepath)
         save_path = merged_savepath
@@ -271,90 +272,144 @@ def run_volume(
 
 def _should_write_bin(ops_path: Path, force: bool = False) -> bool:
     """
-    Decide whether a data_raw.bin should be re-written.
-
-    Conditions that trigger re-write:
-      - force=True
-      - bin file missing
-      - ops.npy missing
-      - mismatch between ops metadata (Ly, Lx, nframes) and bin file size
-      - bin file cannot be read or has wrong shape
+    Return True if data_raw.bin should be re-written.
     """
     if force:
         return True
+
     ops_path = Path(ops_path)
     if not ops_path.is_file():
         return True
 
-    bin_path = ops_path.parent / "data.bin"
-    tiff_path = ops_path.parent / "reg_tif"
+    raw_path = ops_path.parent / "data_raw.bin"
+    chan2_path = ops_path.parent / "data_chan2.bin"
 
-    if not bin_path.is_file() and not tiff_path.is_dir():
+    # no raw data at all
+    if not raw_path.is_file() and not chan2_path.is_file():
         return True
 
     try:
         ops = np.load(ops_path, allow_pickle=True).item()
-        Ly, Lx = ops.get("Ly"), ops.get("Lx")
-        nframes = ops.get("nframes", ops.get("n_frames"))
 
-        if None in (Ly, Lx, nframes):
-            return True
+        for bin_path in (raw_path, chan2_path):
+            if not bin_path.is_file():
+                continue
 
-        expected_size = nframes * Ly * Lx * np.dtype(np.int16).itemsize
-        actual_size = bin_path.stat().st_size
+            if "chan2" in bin_path.name:
+                nframes = ops.get("nframes_chan2")
+            else:
+                nframes = (
+                    ops.get("nframes_chan1")
+                    or ops.get("nframes")
+                    or ops.get("num_frames")
+                )
 
-        if actual_size != expected_size:
-            return True
+            Ly, Lx = ops.get("Ly"), ops.get("Lx")
+            if None in (Ly, Lx, nframes):
+                return True
 
-        # Try opening first few frames to verify integrity
-        arr = np.memmap(bin_path, dtype=np.int16, mode="r", shape=(nframes, Ly, Lx))
-        _ = arr[0].sum()  # touch data
-        del arr
+            expected_size = nframes * Ly * Lx * np.dtype(np.int16).itemsize
+            actual_size = bin_path.stat().st_size
+            if actual_size != expected_size:
+                return True
+
+            # lightweight validation read
+            arr = np.memmap(bin_path, dtype=np.int16, mode="r", shape=(nframes, Ly, Lx))
+            _ = arr[0, 0, 0]
+            del arr
 
         return False  # all checks passed
+
     except Exception as e:
-        print(f"Bin validation failed: {e}")
+        print(f"Bin validation failed for {ops_path.parent}: {e}")
         return True
 
 
+def _should_register(ops_path: str | Path) -> bool:
+    """
+    Determine whether Suite2p registration still needs to be performed.
+
+    Registration is considered complete if any of the following hold:
+      - A reference image (refImg) exists and is a valid ndarray
+      - meanImg exists (Suite2p always produces it post-registration)
+      - Valid registration offsets (xoff/yoff) are present
+
+    Returns True if registration *should* be run, False otherwise.
+    """
+    ops = load_ops(ops_path)
+
+    has_ref = isinstance(ops.get("refImg"), np.ndarray)
+    has_mean = isinstance(ops.get("meanImg"), np.ndarray)
+    has_offsets = ("xoff" in ops and np.any(np.isfinite(ops["xoff"]))) or (
+        "yoff" in ops and np.any(np.isfinite(ops["yoff"]))
+    )
+    has_metrics = any(k in ops for k in ("regDX", "regPC", "regPC1", "regDX1"))
+
+    # registration done if any of these are true
+    registration_done = has_ref or has_mean or has_offsets or has_metrics
+    return not registration_done
+
+
 def run_plane_bin(ops) -> bool:
-    from suite2p.io.binary import BinaryFile
+    from mbo_utilities._binary import BinaryFile
     from suite2p.run_s2p import pipeline
+    from contextlib import nullcontext
+
     ops = load_ops(ops)
-    if "nframes" in ops and "n_frames" not in ops:
-        ops["n_frames"] = ops["nframes"]
-    if "n_frames" not in ops:
-        raise KeyError("run_plane_bin: missing frame count (nframes or n_frames)")
-    n_frames = ops["n_frames"]
     Ly, Lx = ops["Ly"], ops["Lx"]
 
-    # make sure diam is not nan
-    if ops["diameter"] is not None and np.isnan(ops["diameter"]):
-        ops["diameter"] = 8
-    if ops["diameter"] is None or ops["diameter"] == 0 and ops["anatomical_only"] > 0:
-        ops["diameter"] = 8
-        print("Warning: diameter was not set, defaulting to 8."
-              "Cellpose-SAM currently does not estimate diameter.")
-    with (
+    # input functional channel (unregistered)
+    raw_file = ops.get("raw_file")
+    nframes_chan1 = (
+        ops.get("nframes_chan1") or ops.get("nframes") or ops.get("n_frames")
+    )
+    if raw_file is None or nframes_chan1 is None:
+        raise KeyError("Missing raw_file or nframes_chan1")
+
+    # optional structural channel
+    chan2_file = ops.get("chan2_file", "")
+    nframes_chan2 = ops.get("nframes_chan2", 0)
+
+    ops_parent = Path(ops.get("ops_path")).parent
+    ops["save_path"] = ops_parent
 
+    align_structural = ops.get("align_by_chan", 1) == 2
+    ops["align_structural"] = align_structural
+
+    reg_file = ops_parent / "data.bin"
+    ops["reg_file"] = str(reg_file)
+
+    # sanity fix for diameter
+    if "diameter" in ops:
+        if ops["diameter"] is not None and np.isnan(ops["diameter"]):
+            ops["diameter"] = 8
+        if (ops["diameter"] is None or ops["diameter"] == 0) and ops.get(
+            "anatomical_only", 0
+        ) > 0:
+            ops["diameter"] = 8
+            print("Warning: diameter was not set, defaulting to 8.")
+
+    with (
         BinaryFile(
-            Ly=Ly, Lx=Lx, filename=ops["reg_file"], n_frames=n_frames
+            Ly=Ly, Lx=Lx, filename=str(reg_file), n_frames=nframes_chan1
         ) as f_reg,
+        BinaryFile(Ly=Ly, Lx=Lx, filename=raw_file, n_frames=nframes_chan1) as f_raw,
         (
-            BinaryFile(
-                Ly=Ly, Lx=Lx, filename=ops["raw_file"], n_frames=n_frames
-            )
-            if "raw_file" in ops and ops["raw_file"] is not None
+            BinaryFile(Ly=Ly, Lx=Lx, filename=chan2_file, n_frames=nframes_chan2)
+            if align_structural
             else nullcontext()
-        ) as f_raw,
+        ) as f_reg_chan2,
     ):
         ops = pipeline(
-            f_reg, f_raw, None, None, ops["do_registration"], ops, stat=None
+            f_reg=f_reg,
+            f_raw=f_raw,
+            f_reg_chan2=f_reg_chan2,
+            f_raw_chan2=f_reg_chan2 if align_structural else None,
+            run_registration=ops.get("do_registration", True),
+            ops=ops,
+            stat=None,
         )
-
     np.save(ops["ops_path"], ops)
-    del f_reg, f_raw, ops
-
     return True
 
 
@@ -441,18 +496,18 @@ def run_plane(
         logger.setLevel(logging.DEBUG)
         logger.info("Debug mode enabled.")
 
-    assert isinstance(input_path, (Path, str)), (
-        f"input_path should be a pathlib.Path or string, not: {type(input_path)}"
-    )
+    assert isinstance(
+        input_path, (Path, str)
+    ), f"input_path should be a pathlib.Path or string, not: {type(input_path)}"
     input_path = Path(input_path)
     if not input_path.is_file():
         if input_path.suffix != ".zarr":
             raise ValueError(f"Input file does not exist: {input_path}")
     input_parent = input_path.parent
 
-    assert isinstance(save_path, (Path, str, type(None))), (
-        f"save_path should be a pathlib.Path or string, not: {type(save_path)}"
-    )
+    assert isinstance(
+        save_path, (Path, str, type(None))
+    ), f"save_path should be a pathlib.Path or string, not: {type(save_path)}"
     if save_path is None:
         logger.debug(f"save_path is None, using parent of input file: {input_parent}")
         save_path = input_parent
@@ -469,8 +524,11 @@ def run_plane(
     ops = {**ops_default, **ops_user, "data_path": str(input_path.resolve())}
 
     # suite2p diameter handling
-    if isinstance(ops["diameter"], list) and len(
-            ops["diameter"]) > 1 and ops["aspect"] == 1.0:
+    if (
+        isinstance(ops["diameter"], list)
+        and len(ops["diameter"]) > 1
+        and ops["aspect"] == 1.0
+    ):
         ops["aspect"] = ops["diameter"][0] / ops["diameter"][1]  # noqa
 
     file = imread(input_path)
@@ -519,7 +577,8 @@ def run_plane(
         else:
             print(
                 f"ops['roidetect'] is True with no stat.npy file present, "
-                f"proceeding with segmentation/detection for plane {plane}.")
+                f"proceeding with segmentation/detection for plane {plane}."
+            )
             needs_detect = True
     elif (plane_dir / "stat.npy").is_file():
         # check contents of stat.npy
@@ -532,8 +591,6 @@ def run_plane(
             needs_detect = True
 
     ops_file = plane_dir / "ops.npy"
-    reg_data_file = plane_dir / "data.bin"
-    reg_data_file_tiff = plane_dir / "reg_tif"
 
     if _should_write_bin(ops_file, force=kwargs.get("force_save", False)):
         md_combined = {**metadata, **ops}
@@ -549,17 +606,13 @@ def run_plane(
         else {}
     )
 
-    exists = False
-    if reg_data_file.exists():
-        exists = True
-    if reg_data_file_tiff.exists():
-        exists = True
     if force_reg:
         needs_reg = True
     else:
-        # if either reg data file exists, we assume registration is done
-        needs_reg = not exists
-
+        if not ops_file.exists():
+            needs_reg = True
+        else:
+            needs_reg = _should_register(ops_file)
     ops = {
         **ops_default,
         **ops_outpath,
@@ -598,11 +651,13 @@ def run_plane(
         print(f"Skipping {ops_file.name}, processing was not completed.")
         return ops_file
 
-    # cleanup ourselves
-    if not keep_raw:
-        (plane_dir / "data_raw.bin").unlink(missing_ok=True)
-    if not keep_reg:
-        (plane_dir / "data.bin").unlink(missing_ok=True)
+    raw_file = Path(ops.get("raw_file", plane_dir / "data_raw.bin"))
+    reg_file = Path(ops.get("reg_file", plane_dir / "data.bin"))
+
+    if not keep_raw and raw_file.exists():
+        raw_file.unlink(missing_ok=True)
+    if not keep_reg and reg_file.exists():
+        reg_file.unlink(missing_ok=True)
 
     save_pc_panels_and_metrics(ops_file, plane_dir / "pc_metrics")
 
@@ -623,6 +678,8 @@ def run_grid_search(
     grid_search_dict: dict,
     input_file: Path | str,
     save_root: Path | str,
+    force_reg: bool,
+    force_detect: bool,
 ):
     """
     Run a grid search over all combinations of the input suite2p parameters.
@@ -643,6 +700,12 @@ def run_grid_search(
         Root directory where each parameter combination's output will be saved.
         A subdirectory will be created for each run using a short parameter tag.
 
+    force_reg : bool
+        Whether to force suite2p registration.
+
+    force_detect : bool
+        Whether to force suite2p detection.
+
     Notes
     -----
     - Subfolder names for each parameter are abbreviated to 3-character keys and truncated/rounded values.
@@ -695,16 +758,22 @@ def run_grid_search(
             for k, v in combo_dict.items()
         ]
         tag = "_".join(tag_parts)
+        save_path = save_root / tag
+        print(f"\nRunning grid search combination: {tag}")
 
-        print(f"Running grid search in: {save_root.joinpath(tag)}")
+        ops_file = save_path / "ops.npy"
+
+        # Skip runs that are already registered
+        if ops_file.exists() and not force_reg and not _should_register(ops_file):
+            print(f"Skipping {tag}: registration already complete.")
+            continue
 
-        save_path = save_root / tag
         run_plane(
             input_path=input_file,
             save_path=save_path,
             ops=ops,
             keep_reg=True,
             keep_raw=True,
-            force_reg=True,
-            force_detect=True,
+            force_reg=force_reg,
+            force_detect=force_detect,
         )

{lbm_suite2p_python-2.0.2 → lbm_suite2p_python-2.0.4/lbm_suite2p_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lbm_suite2p_python
-Version: 2.0.2
+Version: 2.0.4
 Summary: Light Beads Microscopy Pipeline using Suite2p
 License-Expression: BSD-3-Clause
 Project-URL: homepage, https://github.com/MillerBrainObservatory/LBM-Suite2p-Python
@@ -11,7 +11,7 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Requires-Python: <3.12.10,>=3.12.7
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
-Requires-Dist: mbo_utilities>=2.0.2
+Requires-Dist: mbo_utilities>=2.0.4
 Provides-Extra: cpsam
 Requires-Dist: cellpose==4.0.6; extra == "cpsam"
 Requires-Dist: pytorch; extra == "cpsam"

{lbm_suite2p_python-2.0.2 → lbm_suite2p_python-2.0.4}/lbm_suite2p_python.egg-info/requires.txt

@@ -1,4 +1,4 @@
-mbo_utilities>=2.0.2
+mbo_utilities>=2.0.4
 
 [cpsam]
 cellpose==4.0.6

{lbm_suite2p_python-2.0.2 → lbm_suite2p_python-2.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lbm_suite2p_python"
-version = "2.0.2"
+version = "2.0.4"
 description = "Light Beads Microscopy Pipeline using Suite2p"
 readme = "README.md"
 license = "BSD-3-Clause"
@@ -18,7 +18,7 @@ classifiers=[
 	"Programming Language :: Python :: 3 :: Only",
 ]
 dependencies = [
-	"mbo_utilities>=2.0.2",
+	"mbo_utilities>=2.0.4",
 ]
 
 [project.optional-dependencies]