Technical Review: MiniAn vs CaImAn

MiniAn 2.0.2 and CaImAn 1.13.2: Technical Comparison

Review date:July 8, 2026

Version anchors:MiniAn 2.0.2, released June 26, 2026; CaImAn 1.13.2, released July 28, 2026

Evidence base:the MiniAn and CaImAn primary papers, current official documentation, tagged source code, packaged notebooks, release notes, and published benchmark data.

Executive assessment

MiniAn and CaImAn are related but not equivalent calcium-imaging systems. MiniAn was explicitly inspired by CaImAn and MIN1PIPE, and it implements a CNMF-style one-photon miniscope workflow around labeled xarray objects, Dask execution, Zarr persistence, and interactive parameter exploration.[^1]CaImAn is a broader computational imaging platform that includes rigid and piecewise-rigid NoRMCorre, standard CNMF, one-photon CNMF-E, offline and online source extraction, deconvolution, component evaluation, memory-mapped processing, cross-session registration, and a separate voltage-imaging workflow through VolPy.[^2]

The original review was right to identify a difference in design emphasis:

-MiniAn puts interactive inspection and parameter exploration near the center of the ordinary workflow.

-CaImAn exposes a larger set of parameterized algorithms and result objects that are easier to embed in automated processing systems.

That distinction should not be stated as an absolute opposition. CaImAn also provides notebooks, diagnostics, plotting, and manual review. MiniAn can also be scripted and run without interactive plots after parameters have been selected. The more defensible formulation is thatMiniAn is notebook-centered and inspection-first, while CaImAn is platform-centered and automation-ready.

The direct published comparison is also narrower than the original review sometimes implies. In the 2022 MiniAn study, both pipelines performed strongly on author-tuned simulated recordings. On six experimental CA1 recordings, the reported F1 value of 0.73 +/- 0.03 measured agreement between MiniAn and CaImAn, not biological accuracy. The spatial and temporal correlations of matched components likewise measured agreement between two computational outputs.[^3]

No current benchmark establishes that MiniAn 2.0.2 or CaImAn 1.13.2 is universally more accurate. The choice should be made from the imaging modality, background structure, motion, hardware, need for online processing, desired level of automation, and willingness to inspect and curate intermediate results.

1. Product boundaries and version boundaries

MiniAn is specifically presented as a miniscope analysis and visualization pipeline. Its documented main interface is the packaged Jupyter pipeline notebook. Theminiancommand-line tool copies notebooks and manages demonstration data; it is not a complete headless batch-analysis command.[^4]MiniAn 2.0.2 requires Python 3.10 or later, is distributed through PyPI and conda-forge, and uses GPL-3.0-or-later licensing.[^5]

CaImAn has a wider product boundary. Its current documentation describes calcium and voltage imaging, one-photon and two-photon source extraction, rigid and piecewise-rigid motion correction, offline and online analysis, deconvolution, component evaluation, memory mapping, and multi-session registration.[^2]The main workflow remains Python API and notebook oriented. A graphical interface exists, but the documentation calls it experimental rather than a polished no-code application.[^6]

The comparison must also distinguish current software from publication-era software:

-The MiniAn paper was published in 2022, while MiniAn 2.0 introduced new packaging, bundled notebooks, updated dependencies, a rewritten motion path, and a reported approximately twelvefold speedup specifically for motion estimation. Version 2.0.2 then changed important storage and dtype behavior.[^7]

-The main CaImAn paper was published in 2019, while CaImAn 1.13.2 contains later changes to NumPy compatibility, motion-shift handling, component logic, visualization, and model infrastructure.[^8]

A historical benchmark should therefore be cited as evidence about the tested versions and settings, not automatically as a benchmark of the current releases.

One wording correction is also important: CNMF was not established by CaImAn. The CNMF method predates the CaImAn software platform. MiniAn inherits and reimplements ideas from the broader CNMF literature, with CaImAn and MIN1PIPE serving as important software and workflow influences.[^9]

2. Shared source-separation idea, different background models

Both systems estimate spatial and temporal components jointly. A useful high-level model is:

Y approximately equals A C + background + residual

Here,Yis the fluorescence movie,Acontains spatial footprints, andCcontains denoised temporal components. This is more than static ROI detection: spatially overlapping sources can be separated when their temporal activity differs.

The generic background term hides an important distinction.

MiniAn

MiniAn's standard notebook first applies explicit one-photon preprocessing, then estimates CNMF background terms during factorization. The current example configuration uses median denoising and morphological top-hat background removal before initialization. MiniAn also estimates spatial and temporal background variables during CNMF updates.[^10]

CaImAn standard CNMF

Standard CaImAn CNMF commonly represents background with low-rank spatial and temporal factors such asbandf. This is typically associated with two-photon or other relatively low-background recordings.

CaImAn CNMF-E

One-photon CNMF-E uses a specialized local background architecture. Current CaImAn guidance recommends one-photon settings such asmethod_init='corr_pnr',center_psf=True, and a ring-background configuration controlled by parameters includingring_size_factor.[^11]Current result objects can contain one-photon background quantities such asWandb0, which are not interchangeable with the ordinary low-rankb fterm.[^12]

The original review's contrast - MiniAn removes background before source extraction while CaImAn models it inside source extraction - captures a real difference in emphasis, but it is too binary. MiniAn also estimates CNMF background terms after preprocessing, and CaImAn one-photon workflows may use filtering during motion correction and initialization. The correct comparison is:

>MiniAn places more of the one-photon background correction in an explicit, inspectable preprocessing stage, while CNMF-E places more of it inside a specialized local generative model.

CNMF-E is the more elaborate statistical background model. That is a theoretical and architectural distinction, not proof that it produces more accurate neurons on every recording. A complex model can still be misspecified, and a simpler top-hat correction can work well when broad background is separable by spatial scale.

3. Preprocessing and parameter visibility

MiniAn's current example notebook exposes denoising and background-removal settings directly. The packaged defaults for the demonstration recording are median denoising with a kernel size of 7 and top-hat removal with a radius of 15 pixels.[^10]These are demonstration values, not general biological constants.

MiniAn's interactive visualizations make it easy to compare raw and processed frames and inspect the effect of a window size. This is valuable, but visual accessibility does not make a parameter objectively correct. A setting can produce a cleaner-looking image while suppressing weak cells, dendritic structures, vascular features, or legitimate spatial variation.

CaImAn provides substantial diagnostics and demonstration notebooks, but parameter exploration is less tightly integrated into one linear teaching notebook. Its users often configureCNMFParams, run a processing object, inspect summary images and component metrics, then revise the parameter set. This is still inspectable analysis, but the inspection model is more distributed across demos, API objects, plots, and saved results.

The practical difference is therefore one of workflow design:

-MiniAn makes parameter consequences visible before and during most major stages.

-CaImAn organizes a broader parameter surface into reusable processing objects.

Neither approach removes the need to define an analysis protocol and preserve the chosen values.

4. Motion correction

MiniAn

MiniAn 2.0.2 recursively combines frames or intermediate templates. In the ordinary rigid path, relative displacement is estimated with FFT-based phase correlation and subpixel refinement. The packaged pipeline invokes motion estimation without a mesh, so the documented standard path estimates one translational shift per frame.[^13]

The source also contains a B-spline mesh path. Supplyingmesh_sizeenables experimental non-rigid estimation. The current source explicitly calls this path experimental, notes that the packaged pipeline does not setmesh_size, and says the implementation is worth revisiting.[^14]

MiniAn should therefore be described as having:

-an established recursive rigid workflow in its main notebook;

-an experimental B-spline option that should not be treated as the default validated path.

CaImAn

NoRMCorre supports one global translation per frame in rigid mode and locally estimated translations over overlapping patches in piecewise-rigid mode.[^15]Piecewise-rigid NoRMCorre is more mature than MiniAn's experimental mesh path, but it is not an unrestricted elastic deformation model. It estimates and regularizes local translations rather than discovering an arbitrary biomechanical transformation.

For difficult one-photon recordings, CaImAn can spatially high-pass filter data for motion estimation and apply the resulting shifts to the original movie. This can help when broad background obscures cell-scale registration structure.[^11]

The original review's categorical conclusion that CaImAn is better for difficult motion is too strong. The defensible conclusion is:

>CaImAn offers the more established piecewise-rigid option for spatially nonuniform motion. Whether that produces more accurate motion or better downstream source recovery on a particular miniscope dataset still requires a controlled comparison.

A motion benchmark should use known translations and local displacements, report edge behavior and residual motion, and measure the effect on recovered cells and traces rather than relying only on image similarity.

5. Initialization and iterative source extraction

MiniAn current notebook

The current MiniAn notebook does not use a generic random-projection initialization as its standard path. It uses rolling temporal windows to generate candidate seeds, followed by peak-to-noise-ratio refinement, a Kolmogorov-Smirnov normality test, and distance-and-correlation-based seed merging.[^10]

MiniAn then initializes each spatial footprint from local pixel-trace correlation and estimates initial temporal components before alternating spatial and temporal CNMF updates. Current parameters expose spatial sparsity, temporal sparsity, autoregressive order, support size, merge thresholds, and several solver controls.[^16]

CaImAn

CaImAn provides different initialization methods for different data types. One-photon CNMF-E commonly uses correlation and peak-to-noise-ratio images throughcorr_pnr, while other workflows may use greedy ROI, sparse NMF, seeded components, or mode-specific initialization.[^11]

CaImAn can initialize and optimize components in overlapping patches and then refit them against the full field of view. Patch processing is both a computational strategy and a scientific choice: patch size, overlap, edge handling, background extent, and initial component count can affect which sources are proposed and retained.

The comparison should not be reduced to "MiniAn seeds" versus "CaImAn automatic CNMF." Both systems make explicit initialization choices. MiniAn makes its candidate sequence easier to inspect in the standard notebook. CaImAn offers more initialization modes and a more extensive batch-processing architecture.

6. Output semantics and deconvolution

The arrays produced by both packages are model estimates, not direct biological measurements.

MiniAn

-Ais a nonnegative fluorescence footprint, not a verified cell membrane.

-Cis an estimated calcium component, not raw fluorescence.

-Sis a deconvolved activity estimate under an autoregressive model and sparsity constraint, not an electrophysiological spike train.

-YrAis a residual-projection quantity combined with the previous temporal component in the current implementation; it should not be called simply raw signal.[^17]

CaImAn

-A,C,S,YrA, and background fields have related but workflow-dependent meanings.

-Current quality evaluation often usesC + YrArather thanCalone.

-Sis deconvolved neural activity, not measured action potentials.

-Standard two-photon and one-photon result objects can contain different background fields.

-Conventional DF/F is not always identifiable in one-photon data. Current CaImAn supports a detrend-only mode for one-photon processing because baseline fluorescence may not be recoverable reliably.[^12]

Both packages also have scale ambiguities between spatial and temporal factors. Rescaling a footprint and inversely rescaling its trace can preserve the reconstructed movie. Cross-cell or cross-pipeline comparisons of absolute amplitudes require a documented normalization convention.

The original review gave CaImAn a categorical deconvolution advantage because it includes OASIS. That is too broad. OASIS is a mature and efficient solver, but the scientific quality of inferred activity also depends on source separation, baseline handling, frame rate, indicator kinetics, noise, autoregressive order, and the output convention being compared. A modern benchmark should compare both calcium-trace reconstruction and activity recovery against common ground truth, with scale alignment where necessary.

7. Component quality control and human review

MiniAn's approach

MiniAn integrates inspection throughout the notebook. Users can visualize preprocessing, shifts, candidate seeds, spatial updates, temporal updates, merged components, and final activity. The current viewer stores curation information in component labels rather than silently overwriting the original numerical arrays.[^18]

That is good audit design, but it does not eliminate operator variability. The package does not automatically record a complete history of who reviewed a component, why it was rejected, or when a label changed. Two users can select different windows, thresholds, penalties, merges, and curation states.

CaImAn's approach

CaImAn evaluates components with temporal peak-SNR-like evidence and spatial consistency. For appropriate somatic workflows it can also use a pretrained CNN morphology classifier. Current source implements high and low thresholds: a component must exceed at least one upper threshold while avoiding rejection under all enabled lower thresholds.[^19]

A crucial correction is that the current source explicitly documents the CNN filter asnot for one-photon data.[^19]Therefore, a comparison between MiniAn and CaImAn CNMF-E should not cite the soma CNN as though it were a standard one-photon advantage. CaImAn still offers automated one-photon screening through spatial and temporal metrics, but the classifier boundary must remain visible.

CaImAn also supports manual inspection and plotting. Its risk is not absence of transparency, but automation bias: users may accept or reject components from a metric threshold without checking whether the metric transfers to a new microscope, indicator, morphology, or signal regime.

The more accurate contrast is:

-MiniAn gives manual parameter exploration and visual review a larger role in the ordinary workflow.

-CaImAn provides a stronger formal component-scoring framework, but some scoring methods are modality-specific and still require inspection.

8. Dask, memory mapping, patches, and current scaling evidence

MiniAn

MiniAn uses xarray and Dask to create labeled lazy arrays, change chunk orientation for different operations, and persist intermediate arrays in Zarr. Its 2022 paper reported comparatively stable peak memory as recording length increased under the tested synthetic configuration.[^20]

That result is important but should not be generalized into "constant memory" or "all operations are out of core." Current temporal optimization spans all frames for each component, some routines intentionally materialize selected intermediates, and successful runs may rely on Dask spilling data to disk. The current notebook's memory limit is per worker, not a pooled application limit. More workers can reduce runtime while increasing aggregate memory and I/O pressure.[^10]

MiniAn 2.0's reported approximately twelvefold speedup applies to motion estimation, not the whole pipeline.[^7]

CaImAn

CaImAn uses disk-backed memory maps, patch-based extraction, and multiprocessing or cluster backends. Memory mapping allows recordings larger than RAM to be processed without eagerly loading the entire movie, but individual stages still allocate substantial working arrays. CNMF-E background updates can be especially memory intensive.[^21]

Historical comparison

The MiniAn paper's runtime and memory comparison was valuable for the software versions, hardware, worker counts, and synthetic data used in 2022. It does not establish the same advantage between MiniAn 2.0.2 and CaImAn 1.13.2. Both codebases have changed materially.[^3]

The original review's statement that MiniAn is simply "best for limited RAM" should therefore be replaced with:

>MiniAn demonstrated a strong low-memory design in the published benchmark and gives users unusually explicit control over chunking and worker memory. A current limited-RAM deployment should still benchmark both packages on the target recording and storage hardware.

A fair systems comparison must report wall-clock time, peak resident memory, swap or spill volume, temporary storage, process count, BLAS/OpenMP settings, disk type, field dimensions, frame count, and extracted component count.

9. Online processing and modality breadth

MiniAn is primarily an offline miniscope pipeline. It does not provide an equivalent of frame-by-frame OnACID source discovery in its ordinary workflow.

CaImAn documents online processing for both two-photon OnACID and one-photon OnACID-E.[^2]The current general Getting Started page describes theonline_cnmfobject mainly in terms of two-photon OnACID, while the feature overview and dedicated demonstration material include the one-photon variant. Methods should state which online algorithm and demo path were used rather than reporting only "OnACID."[^22]

Online capability is not the same as a complete closed-loop experiment product. CaImAn does not, by itself, provide every camera-control, synchronization, buffering, dropped-frame, stimulation, and behavioral-state function required for a validated closed-loop system. The correct claim is that CaImAn offers online source-extraction algorithms that can be integrated into such a system.

CaImAn also includes VolPy for voltage imaging. That demonstrates platform breadth, but VolPy is a separate workflow and should not be used as evidence that a particular CNMF or CNMF-E result is more accurate.

Thus:

-CaImAn is the relevant starting point when online processing or several imaging modalities must be supported in one software ecosystem.

-MiniAn remains more tightly focused on offline one-photon miniscope analysis.

10. Data structures, persistence, and reproducibility

MiniAn

MiniAn uses named xarray dimensions, Dask chunk metadata, and Zarr stores. Named dimensions reduce axis ambiguity and make subsetting and alignment more explicit. They do not guarantee correctness: mismatched coordinates, stale chunk encoding, incompatible saved sessions, or inconsistent unit subsets can still produce padded, misaligned, or invalid arrays.[^23]

MiniAn's repeatedsave_miniancalls function as checkpoints. They do not automatically create a complete transaction log or immutable methods manifest. Notebook state, parameter dictionaries, chunk settings, manual labels, and overwritten arrays must be preserved deliberately.

CaImAn

CaImAn organizes configuration throughCNMFParamsand outputs throughEstimates, with memory maps for movies and HDF5 persistence for fitted result objects.[^24]This is a strong programmatic architecture for batch pipelines. The v1.13.1 release introduced the beginnings of operational provenance in saved CNMF and OnACID results, but it is not a complete audit trail.[^8]

A result object does not necessarily contain input hashes, every intermediate memory map, the full environment, thread settings, manual decisions, or downstream exports.

Reporting requirements for both

A reproducible comparison should preserve:

-package release and full Git commit;

-Python and dependency environment;

-input filenames, ordering, hashes, frame rate, dtype, dimensions, and downsampling;

-preprocessing and motion parameters;

-initialization method and random state where applicable;

-spatial, temporal, merge, background, and deconvolution settings;

-all quality thresholds and classifier identity;

-worker, process, thread, RAM, GPU, and storage configuration;

-intermediate and final component IDs;

-automated and manual rejection or merge decisions;

-registration settings and session order;

-exact definitions of exported traces and activity arrays.

Neither project currently turns all of these items into one immutable manifest automatically.

11. Cross-session registration

MiniAn's current cross-registration workflow aligns session-level fields, restricts analysis to a common window, computes component centroids, and matches cells from Euclidean centroid distance. Pairwise matching is based on mutual nearest neighbors, and multi-session conflicts are resolved through a graph procedure.[^25]

The currentresolve_mappingdefault ismode='majority'; strict removal of conflicting cells is optional.[^26]This differs from a simple description in which every conflict is always discarded. MiniAn's matching score does not currently combine footprint shape, activity, neighborhood topology, or calibrated identity probabilities.

CaImAn can align fields and compare footprints with an intersection-over-union-derived distance, apply centroid-distance constraints, and solve pairwise assignments with the Hungarian algorithm. Multi-session registration progressively adds unmatched components to an accumulated union, and optional optical-flow alignment can be used.[^27]

CaImAn's method uses richer spatial information than MiniAn's centroid-only score, but neither output is confirmed biological identity. Both produce hard assignments that depend on segmentation, alignment, thresholds, and session order. Neither supplies a calibrated posterior probability that two components are the same cell.

The defensible conclusion is:

>CaImAn has the more feature-rich footprint-based registration implementation. MiniAn has a simpler and more directly interpretable centroid workflow. Accuracy under rotation, depth change, local deformation, crowding, and changing footprint shape remains an empirical question.

12. What the published evidence actually shows

MiniAn simulated comparison

The 2022 study processed the same 512 x 512, 20,000-frame simulated recordings with MiniAn and CaImAn while varying signal level and cell count. The released source data show F1 values from approximately 0.925 to 0.995 for MiniAn and 0.910 to 1.000 for CaImAn across the reported conditions. Spatial-footprint correlations remained above approximately 0.986 for both. Temporal calcium-trace correlations decreased in the weakest conditions.[^28]

Both pipelines were tuned with access to the synthetic truth. The result demonstrates that both could recover the authors' modeled sources under the tested settings. It is not a blind default-parameter benchmark.

MiniAn experimental comparison

Six experimental CA1 recordings were processed with both systems. The paper reported:

-F1 agreement: 0.73 +/- 0.03 SEM;

-spatial correlation among matched components: 0.84 +/- 0.02;

-temporal correlation among matched components: 0.86 +/- 0.02.[^3]

These are substantial agreements, but they also imply material disagreement in component populations. The F1 value is not "MiniAn accuracy" or "CaImAn accuracy." Two pipelines can disagree when one is right, and they can agree on the same error.

The original review's statement that the packages produce "highly similar biological outputs" should therefore be narrowed to:

>The packages produced strongly correlated matched components and substantial, but incomplete, population agreement on the six tested CA1 recordings.

CaImAn's broader published record

CaImAn's 2019 study included a multi-laboratory two-photon consensus-annotation benchmark, a Python-versus-MATLAB CNMF-E comparison, online processing demonstrations, and scaling experiments.[^29]This is a broader published validation record than MiniAn's paper, not an independent proof that current CaImAn is universally superior.

The one-photon CNMF-E comparison measured agreement with another implementation rather than absolute biological truth. The consensus benchmark was primarily active soma-like two-photon data. Online and scaling demonstrations used specific hardware and problem sizes. Those boundaries should remain attached to the claims.

Current-version gap

There is no published same-data benchmark of MiniAn 2.0.2 against CaImAn 1.13.2. Current architecture, dependencies, motion code, storage behavior, model backends, and defaults differ from the publication-era versions. A current recommendation must therefore be based partly on software capabilities and deployment requirements, not a current accuracy ranking.

13. Use-case guidance without declaring a universal winner

These are starting points, not rules. A laboratory should run a representative pilot and inspect failure modes before committing a longitudinal study to one pipeline.

14. A decisive modern benchmark

A useful comparison should include both end-to-end and module-controlled conditions.

End-to-end condition

Each package should use its intended workflow, including its normal preprocessing, initialization, source extraction, quality control, and curation. This estimates what a competent user obtains from the complete system.

Module-controlled conditions

Where technically possible, both packages should receive:

-the same raw movie;

-the same externally motion-corrected movie;

-the same source masks or seed positions;

-the same evaluation denominator and matching rules.

This would separate differences caused by preprocessing, motion, initialization, factorization, filtering, and curation.

Data

The benchmark should combine:

-physically motivated synthetic recordings with known spatial, temporal, activity, and motion truth;

-experimentally recorded one-photon sessions with blinded expert-consensus annotations;

-several indicators, scopes, brain regions, frame rates, laboratories, cell densities, background levels, and motion regimes;

-short and long recordings that expose memory, I/O, and drift behavior.

Minisim can provide controlled synthetic cases, but conclusions must be checked against real recordings because simulator truth is exact only within the simulator's assumptions.

Metrics

At minimum, report:

-one-to-one ROI precision, recall, and F1;

-footprint overlap and shape similarity;

-calcium-trace correlation and contamination;

-activity recovery with scale alignment where needed;

-split, merge, and duplicate errors;

-motion-trajectory error and downstream recovery;

-rejected-component characteristics;

-runtime, peak RAM, swap or spill, temporary storage, and disk throughput;

-installation success and failure rate;

-operator time and manual curation time;

-sensitivity to reasonable parameter changes;

-agreement among independent operators;

-reproducibility from a saved manifest.

The comparison should use current tagged releases, identical hardware, fixed environments, and predeclared tuning rules. Otherwise an apparent software difference may simply reflect different operator effort.

Overall conclusion

MiniAn and CaImAn share a source-separation foundation but organize the scientific workflow differently.

MiniAn's strongest contribution is the integration of one-photon preprocessing, labeled arrays, Dask-backed computation, persistent intermediate states, and interactive parameter exploration in one annotated notebook-centered workflow. That transparency makes assumptions easier to inspect. It also makes operator decisions a major part of the method.

CaImAn's strongest contribution is breadth. NoRMCorre, standard CNMF, CNMF-E, OASIS, automated quality metrics, memory mapping, patch processing, online analysis, and registration form a large reusable platform. That automation and breadth are valuable, but the package's capabilities are modality-specific and its configuration surface is substantial.

The strongest correction to the original review is that the comparison should not be summarized as "MiniAn is transparent and CaImAn is accurate" or as a numerical score contest. The available evidence does not support that hierarchy.

The defensible conclusion is:

>MiniAn is the more deliberately transparent and miniscope-focused workflow. CaImAn is the broader and more automation-ready computational platform. Historical data show strong performance by both and substantial, incomplete agreement on experimental CA1 recordings. No current evidence establishes a universal source-recovery winner.

Primary references

[^1]: MiniAn project and PyPI description: https://github.com/miniscope/minian and https://pypi.org/project/minian/

[^2]: CaImAn 1.13.2 feature overview: https://caiman.readthedocs.io/en/dev/CaImAn_features_and_references.html

[^3]: Dong Z, Mau W, Feng Y, et al.Minian, an open-source miniscope analysis pipeline. eLife. 2022;11:e70661. https://elifesciences.org/articles/70661

[^4]: MiniAn pipeline and CLI documentation: https://minian.readthedocs.io/en/v2.0.2/pipeline/index.html and https://minian.readthedocs.io/en/v2.0.2/start_guide/install.html

[^5]: MiniAn 2.0.2 PyPI metadata: https://pypi.org/project/minian/

[^6]: CaImAn graphical-interface documentation: https://caiman.readthedocs.io/en/dev/GUI.html

[^7]: MiniAn 2.0 release notes and 2.0.2 changelog: https://minian.readthedocs.io/en/v2.0.2/start_guide/changelog.html

[^8]: CaImAn v1.13.2 and v1.13.1 release notes: https://github.com/flatironinstitute/CaImAn/releases/tag/v1.13.2 and https://github.com/flatironinstitute/CaImAn/releases/tag/v1.13.1

[^9]: MiniAn paper, overview of related CNMF software: https://elifesciences.org/articles/70661

[^10]: MiniAn 2.0.2 packaged pipeline notebook: https://raw.githubusercontent.com/miniscope/minian/v2.0.2/minian/notebooks/pipeline/pipeline.ipynb

[^11]: CaImAn one-photon processing guidance: https://caiman.readthedocs.io/en/dev/CaImAn_Tips.html

[^12]: CaImAn 1.13.2Estimatessource and one-photon output definitions: https://raw.githubusercontent.com/flatironinstitute/CaImAn/v1.13.2/caiman/source_extraction/cnmf/estimates.py

[^13]: MiniAn 2.0.2 motion-estimation source: https://minian.readthedocs.io/en/v2.0.2/_modules/minian/motion_correction.html

[^14]: MiniAn 2.0.2mesh_sizedocumentation and experimental B-spline path: https://minian.readthedocs.io/en/v2.0.2/_modules/minian/motion_correction.html

[^15]: CaImAn documentation and NoRMCorre references: https://caiman.readthedocs.io/en/dev/CaImAn_features_and_references.html

[^16]: MiniAn 2.0.2 initialization and CNMF source: https://github.com/miniscope/minian/blob/v2.0.2/minian/initialization.py and https://github.com/miniscope/minian/blob/v2.0.2/minian/cnmf.py

[^17]: MiniAn 2.0.2compute_traceand temporal-update source: https://github.com/miniscope/minian/blob/v2.0.2/minian/cnmf.py

[^18]: MiniAn 2.0.2CNMFViewerand pipeline curation behavior: https://github.com/miniscope/minian/blob/v2.0.2/minian/visualization.py and https://raw.githubusercontent.com/miniscope/minian/v2.0.2/minian/notebooks/pipeline/pipeline.ipynb

[^19]: CaImAn 1.13.2 component-evaluation source, including threshold logic and the one-photon CNN caveat: https://raw.githubusercontent.com/flatironinstitute/CaImAn/v1.13.2/caiman/components_evaluation.py

[^20]: MiniAn paper, computational benchmark figures and source data: https://elifesciences.org/articles/70661/figures

[^21]: Giovannucci A, Friedrich J, Gunn P, et al.CaImAn: An open source tool for scalable calcium imaging data analysis. eLife. 2019;8:e38173. https://elifesciences.org/articles/38173

[^22]: CaImAn Getting Started and feature documentation: https://caiman.readthedocs.io/en/dev/Getting_Started.html and https://caiman.readthedocs.io/en/dev/CaImAn_features_and_references.html

[^23]: MiniAn variable and persistence guidance: https://minian.readthedocs.io/en/v2.0.2/tips/variables.html

[^24]: CaImAn 1.13.2 Getting Started and result-object architecture: https://caiman.readthedocs.io/en/dev/Getting_Started.html

[^25]: MiniAn 2.0.2 cross-registration notebook and source: https://raw.githubusercontent.com/miniscope/minian/v2.0.2/minian/notebooks/cross_registration/cross-registration.ipynb and https://minian.readthedocs.io/en/v2.0.2/_modules/minian/cross_registration.html

[^26]: MiniAn 2.0.2resolve_mappingsource: https://minian.readthedocs.io/en/v2.0.2/_modules/minian/cross_registration.html

[^27]: CaImAn ROI-registration source and documentation: https://github.com/flatironinstitute/CaImAn/blob/v1.13.2/caiman/base/rois.py and https://caiman.readthedocs.io/en/dev/core_functions.html

[^28]: MiniAn eLife Figure 15 and source data: https://elifesciences.org/articles/70661/figures and https://cdn.elifesciences.org/articles/70661/elife-70661-fig15-data1-v2.csv

[^29]: CaImAn 2019 primary paper: https://elifesciences.org/articles/38173