lbm_suite2p_python 3.0.1__tar.gz → 3.0.2__tar.gz

{lbm_suite2p_python-3.0.1/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.1
-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,7 +11,7 @@ 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>=3.0.0
+Requires-Dist: mbo_utilities>=3.0.1
 Requires-Dist: suite2p>=1.0.0.1
 Requires-Dist: setuptools<81
 Provides-Extra: rastermap

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

@@ -48,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,
@@ -149,6 +150,7 @@ __all__ = [
     "plot_orthoslices",
     "plot_3d_roi_map",
     "plot_3d_rastermap_clusters",
+    "plot_volume_trace_figures",
     "plot_projection",
     "plot_volume_signal",
     "plot_volume_neuron_counts",

{lbm_suite2p_python-3.0.1 → 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.1 → 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.1 → lbm_suite2p_python-3.0.2}/lbm_suite2p_python/conversion.py

@@ -746,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.1 → lbm_suite2p_python-3.0.2}/lbm_suite2p_python/db_settings.py

@@ -189,6 +189,31 @@ _ANATOMICAL_ONLY_TO_IMG: dict[int, str] = {
 }
 _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"
@@ -284,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):
@@ -316,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:
@@ -410,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
@@ -423,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.1 → 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
 

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

@@ -1,6 +1,5 @@
 import json
 from pathlib import Path
-from typing import Callable
 
 import numpy as np
 from scipy.ndimage import percentile_filter
@@ -514,6 +513,222 @@ def filter_by_eccentricity(
     }
 
 
+def _load_F_Fneu(plane_dir, F, Fneu):
+    """Load F.npy / Fneu.npy from plane_dir if not already provided."""
+    if F is None and plane_dir is not None:
+        f_path = plane_dir / "F.npy"
+        if f_path.exists():
+            F = np.load(f_path, allow_pickle=True)
+    if Fneu is None and plane_dir is not None:
+        fn_path = plane_dir / "Fneu.npy"
+        if fn_path.exists():
+            Fneu = np.load(fn_path, allow_pickle=True)
+    return F, Fneu
+
+
+def _resolve_dff_window(window_size, ops):
+    """Same auto-window rule that dff_rolling_percentile uses."""
+    if window_size is not None:
+        return max(3, int(window_size))
+    fs = float((ops or {}).get("fs", 0) or 0)
+    tau = float((ops or {}).get("tau", 0) or 0)
+    w = int(10 * tau * fs) if (fs > 0 and tau > 0) else 300
+    return max(3, w)
+
+
+def _compute_dff_baseline(F, Fneu, correct_neuropil, neuropil_coef, percentile, window_size):
+    """
+    Compute the rolling-percentile baseline that dff_rolling_percentile
+    will see, given the neuropil-correction toggle. Returns the per-cell
+    f0 array (same shape as F).
+    """
+    if correct_neuropil:
+        if Fneu is None:
+            raise ValueError("correct_neuropil=True requires Fneu")
+        f_in = F - neuropil_coef * Fneu
+    else:
+        f_in = F
+    return np.array(
+        [percentile_filter(f, percentile, size=window_size, mode="nearest") for f in f_in]
+    )
+
+
+def filter_by_negative_baseline(
+    plane_dir=None,
+    iscell=None,
+    stat=None,
+    ops=None,
+    F=None,
+    Fneu=None,
+    correct_neuropil: bool = True,
+    neuropil_coef: float = 0.7,
+    percentile: int = 20,
+    window_size: int = None,
+    save: bool = False,
+):
+    """
+    Reject ROIs whose rolling-percentile baseline ever goes negative.
+
+    Real fluorescence is nonnegative. A negative rolling baseline means the
+    trace dropped below zero somewhere — usually neuropil over-subtraction
+    or registration drop-out. These cells produce divide-by-near-zero
+    blowups in dF/F.
+
+    Parameters mirror :func:`dff_rolling_percentile` so the baseline matches
+    what the dF/F plotting will see. Returns the standard
+    ``(iscell_filtered, removed_mask, info)`` triple.
+    """
+    iscell, stat, ops, plane_dir = _load_plane_data(plane_dir, iscell, stat, ops)
+    iscell_orig = _normalize_iscell(iscell)
+    F, Fneu = _load_F_Fneu(plane_dir, F, Fneu)
+    if F is None:
+        raise ValueError("filter_by_negative_baseline requires F (pass F or plane_dir with F.npy)")
+
+    window_size = _resolve_dff_window(window_size, ops)
+    f0 = _compute_dff_baseline(F, Fneu, correct_neuropil, neuropil_coef, percentile, window_size)
+    f0_min = f0.min(axis=1)
+
+    valid = f0_min >= 0
+    removed_mask = ~valid & iscell_orig
+    iscell_filtered = iscell_orig & valid
+    n_removed = int(removed_mask.sum())
+
+    if n_removed > 0:
+        print(f"filter_by_negative_baseline: removed {n_removed} ROIs (rolling p{percentile} F0 < 0)")
+
+    if save and plane_dir is not None:
+        _save_filtered_iscell(plane_dir, iscell_filtered, iscell_orig)
+
+    return iscell_filtered, removed_mask, {
+        "f0_min": f0_min,
+        "window_size": int(window_size),
+        "percentile": int(percentile),
+        "correct_neuropil": bool(correct_neuropil),
+        "neuropil_coef": float(neuropil_coef) if correct_neuropil else 0.0,
+        "n_removed": n_removed,
+    }
+
+
+def filter_by_min_baseline_abs(
+    plane_dir=None,
+    iscell=None,
+    stat=None,
+    ops=None,
+    F=None,
+    Fneu=None,
+    correct_neuropil: bool = True,
+    neuropil_coef: float = 0.7,
+    percentile: int = 20,
+    window_size: int = None,
+    min_F0_abs: float = 1.0,
+    save: bool = False,
+):
+    """
+    Reject ROIs whose median rolling baseline is below an absolute floor.
+
+    Catches very dim cells where any small fluctuation dominates dF/F.
+    The threshold is in raw photon-count units (same units as F.npy).
+
+    Parameters
+    ----------
+    min_F0_abs : float, default 1.0
+        Reject cells whose median(rolling p-th percentile baseline) is
+        below this value.
+    """
+    iscell, stat, ops, plane_dir = _load_plane_data(plane_dir, iscell, stat, ops)
+    iscell_orig = _normalize_iscell(iscell)
+    F, Fneu = _load_F_Fneu(plane_dir, F, Fneu)
+    if F is None:
+        raise ValueError("filter_by_min_baseline_abs requires F (pass F or plane_dir with F.npy)")
+
+    window_size = _resolve_dff_window(window_size, ops)
+    f0 = _compute_dff_baseline(F, Fneu, correct_neuropil, neuropil_coef, percentile, window_size)
+    f0_median = np.median(f0, axis=1)
+
+    valid = f0_median >= min_F0_abs
+    removed_mask = ~valid & iscell_orig
+    iscell_filtered = iscell_orig & valid
+    n_removed = int(removed_mask.sum())
+
+    if n_removed > 0:
+        print(f"filter_by_min_baseline_abs: removed {n_removed} ROIs (median F0 < {min_F0_abs:g})")
+
+    if save and plane_dir is not None:
+        _save_filtered_iscell(plane_dir, iscell_filtered, iscell_orig)
+
+    return iscell_filtered, removed_mask, {
+        "f0_median": f0_median,
+        "min_F0_abs": float(min_F0_abs),
+        "window_size": int(window_size),
+        "percentile": int(percentile),
+        "correct_neuropil": bool(correct_neuropil),
+        "neuropil_coef": float(neuropil_coef) if correct_neuropil else 0.0,
+        "n_removed": n_removed,
+    }
+
+
+def filter_by_min_baseline_rel(
+    plane_dir=None,
+    iscell=None,
+    stat=None,
+    ops=None,
+    F=None,
+    Fneu=None,
+    correct_neuropil: bool = True,
+    neuropil_coef: float = 0.7,
+    percentile: int = 20,
+    window_size: int = None,
+    min_F0_rel: float = 0.05,
+    save: bool = False,
+):
+    """
+    Reject ROIs whose minimum rolling baseline collapses far below the
+    cell's own typical raw brightness.
+
+    Catches transient baseline drop-outs (e.g. registration / motion
+    artifacts) that don't manifest as a low median baseline but still
+    cause dF/F spikes when the divisor briefly approaches zero.
+
+    Parameters
+    ----------
+    min_F0_rel : float, default 0.05
+        Reject cells whose ``min(rolling baseline) < min_F0_rel * median(F_raw)``.
+    """
+    iscell, stat, ops, plane_dir = _load_plane_data(plane_dir, iscell, stat, ops)
+    iscell_orig = _normalize_iscell(iscell)
+    F, Fneu = _load_F_Fneu(plane_dir, F, Fneu)
+    if F is None:
+        raise ValueError("filter_by_min_baseline_rel requires F (pass F or plane_dir with F.npy)")
+
+    window_size = _resolve_dff_window(window_size, ops)
+    f0 = _compute_dff_baseline(F, Fneu, correct_neuropil, neuropil_coef, percentile, window_size)
+    f0_min = f0.min(axis=1)
+    f_raw_median = np.median(F, axis=1)
+    threshold = min_F0_rel * f_raw_median
+
+    valid = f0_min >= threshold
+    removed_mask = ~valid & iscell_orig
+    iscell_filtered = iscell_orig & valid
+    n_removed = int(removed_mask.sum())
+
+    if n_removed > 0:
+        print(f"filter_by_min_baseline_rel: removed {n_removed} ROIs (min F0 < {min_F0_rel:g} * median(F_raw))")
+
+    if save and plane_dir is not None:
+        _save_filtered_iscell(plane_dir, iscell_filtered, iscell_orig)
+
+    return iscell_filtered, removed_mask, {
+        "f0_min": f0_min,
+        "f_raw_median": f_raw_median,
+        "min_F0_rel": float(min_F0_rel),
+        "window_size": int(window_size),
+        "percentile": int(percentile),
+        "correct_neuropil": bool(correct_neuropil),
+        "neuropil_coef": float(neuropil_coef) if correct_neuropil else 0.0,
+        "n_removed": n_removed,
+    }
+
+
 def apply_filters(
     plane_dir=None,
     iscell=None,
@@ -540,7 +755,7 @@ def apply_filters(
         Suite2p ops dictionary.
     filters : list of dict
         List of filter configurations. Each dict must have:
-        - 'name': str - filter function name (e.g., 'max_diameter', 'area', 'eccentricity')
+        - 'name': str - filter function name (e.g., 'max_diameter', 'area', 'eccentricity', 'baseline')
         - Additional keys are passed as kwargs to the filter function.
 
         Available filters:
@@ -548,6 +763,9 @@ def apply_filters(
         - 'max_diameter': filter_by_max_diameter (max_diameter_um, max_diameter_px, min_diameter_um, min_diameter_px)
         - 'area': filter_by_area (min_area_px, max_area_px, min_mult, max_mult)
         - 'eccentricity': filter_by_eccentricity (max_ratio, min_ratio)
+        - 'negative_baseline': filter_by_negative_baseline (correct_neuropil, percentile, window_size, neuropil_coef)
+        - 'min_baseline_abs': filter_by_min_baseline_abs (min_F0_abs, correct_neuropil, percentile, window_size, neuropil_coef)
+        - 'min_baseline_rel': filter_by_min_baseline_rel (min_F0_rel, correct_neuropil, percentile, window_size, neuropil_coef)
 
     save : bool, default False
         If True, save final filtered iscell.npy to plane_dir.
@@ -586,6 +804,9 @@ def apply_filters(
         "max_diameter": filter_by_max_diameter,
         "area": filter_by_area,
         "eccentricity": filter_by_eccentricity,
+        "negative_baseline": filter_by_negative_baseline,
+        "min_baseline_abs": filter_by_min_baseline_abs,
+        "min_baseline_rel": filter_by_min_baseline_rel,
     }
 
     iscell, stat, ops, plane_dir = _load_plane_data(plane_dir, iscell, stat, ops)
@@ -613,8 +834,10 @@ def apply_filters(
         # Don't save intermediate results, only final
         config["save"] = False
 
-        # Apply filter
+        # Apply filter — pass plane_dir so filters that need extra files
+        # (e.g. F.npy / Fneu.npy for baseline) can find them.
         iscell_current, removed, info = filter_fn(
+            plane_dir=plane_dir,
             iscell=iscell_current,
             stat=stat,
             ops=ops,
@@ -1049,8 +1272,6 @@ def compute_trace_quality_score(
     if weights is None:
         weights = {'snr': 1.0, 'skewness': 0.8, 'shot_noise': 0.5}
 
-    n_neurons = F.shape[0]
-
     # neuropil correction and rectification
     if Fneu is not None:
         F_corr = F - 0.7 * Fneu