MiniAn 2.0.2: Technical Review and Current Assessment
Review date:July 12, 2026
Version anchor:MiniAn 2.0.2, released June 26, 2026
Evidence base:the 2022 eLife paper, MiniAn 2.0.2 documentation, the tagged 2.0.2 source, packaged pipeline and cross-registration notebooks, release notes, and the current PyPI metadata.
Executive assessment
MiniAn is an open-source analysis pipeline for single-photon miniscope recordings. Its central contribution is not a wholly new source-separation algorithm. It is the integration of preprocessing, motion correction, seed initialization, constrained nonnegative matrix factorization (CNMF), interactive parameter exploration, persistent labeled data, manual review, and cross-session matching into a notebook-centered workflow.[^1]
That framing remains accurate in 2026. The current package still emphasizes inspectability: users can view the consequences of denoising, background removal, motion correction, seed thresholds, spatial penalties, temporal penalties, and manual labels before treating the resulting components as a neuronal dataset. The 2022 paper made transparency, modest memory requirements, and accessibility the main design goals rather than presenting MiniAn as a fully automatic black box.[^2]
Several claims in the original review nevertheless need qualification. The 2022 paper and MiniAn 2.0.2 are not identical systems. The current package uses a modernized Python stack, ships its notebooks inside the installed package, retrieves checksum-verified demo data, defaults to rolling-window rather than randomized seed generation in the main notebook, includes a substantially optimized motion implementation, and supplies a Minisim-based ground-truth training notebook.[^3]
The current software is also more nuanced than the phrase "out-of-core pipeline" can imply. Dask and Zarr allow many operations to be lazy, chunked, and disk-backed, but some routines compute whole-axis intermediates, some explicitly callcompute(), and the temporal optimization for a cell still spans all frames. The strongest defensible statement is that MiniAn has a carefully designed Dask-backed workflow that can reduce peak memory and process recordings larger than RAM under suitable chunking and storage conditions. It is not a guarantee that every operation has constant memory use on every dataset.[^4]
The scientific validation remains meaningful but bounded. In the published simulations, MiniAn and CaImAn both achieved F1 and spatial-footprint correlations above 0.95 across the tested conditions, but both pipelines were tuned with knowledge of the simulated truth. On six experimental CA1 recordings, MiniAn and CaImAn showed an average F1 agreement of 0.73, spatial correlation of 0.84, and temporal correlation of 0.86. Those experimental values measure agreement between two algorithms, not absolute cell-detection accuracy.[^5]
MiniAn is therefore best described as a mature, actively maintained scientific workflow for transparent miniscope analysis. Its main strength is that important choices are visible and editable. Its main scientific risk is that those choices can vary across operators and datasets. Its main engineering risk is the interaction among Dask scheduling, chunk layout, on-disk coordinates, notebook state, optimization routines, and memory limits.
1. What the current package actually provides
MiniAn 2.0.2 is published on PyPI and conda-forge, requires Python 3.10 or later, uses GPL-3.0-or-later licensing, and requires FFmpeg andffprobefor video input. The recommended workflow is to install the package, copy the bundled pipeline notebook with theminiancommand, and run that notebook in Jupyter.[^6]
The public command-line interface should not be described as a headless batch-analysis engine. Its documented command groups manage bundled notebooks and demo datasets. The actual analysis remains centered on editable notebooks or direct Python API calls.[^7]
The current pipeline notebook divides analysis into five broad sections:
1.setup and data loading;
2.preprocessing;
3.motion correction;
4.initialization;
5.iterative CNMF spatial and temporal updates followed by visualization and saving.[^8]
The current notebook also states that basic familiarity with Python strings, lists, tuples, and dictionaries is recommended. MiniAn can be approachable to users with limited programming experience, but "no programming required" would be too strong. Users still edit parameter dictionaries, paths, metadata conventions, and notebook cells.[^9]
2. The version boundary matters
The 2022 paper describes the scientific architecture and the evidence available at publication. MiniAn 2.0.2 is the current implementation. These should be discussed separately whenever behavior changed.
Version 2.0 modernized installation and documentation, bundled the notebooks, moved demo data to checksum-verified downloads, consolidated video input, and reported roughly a twelve-fold speed improvement in motion estimation through Dask task de-duplication and a cheaper registration and warp kernel. That performance claim applies to motion estimation, not to the complete analysis pipeline.[^10]
Version 2.0.2 then changed the main data path fromfloat64tofloat32, fixed asave_minianfailure caused by stale xarray chunk encoding, exposed the rechunker memory limit in the pipeline notebook, and corrected several visualization issues.[^11]
As a result, historical benchmark numbers cannot be assumed to validate every current implementation detail. The underlying workflow is recognizably the same, but motion code, storage behavior, dependency versions, default notebook parameters, and some merging and registration semantics have changed.
3. Data model and source-separation model
MiniAn represents data with xarray objects, usually backed by Dask arrays and persisted in Zarr. Typical dimensions are semantically named rather than carried only by position:
-movie:(frame, height, width);
-spatial componentsA:(unit_id, height, width);
-temporal componentsC:(unit_id, frame);
-deconvolved activityS:(unit_id, frame).
This is a genuine engineering strength. Named dimensions and coordinates reduce ambiguity when arrays are subset, aligned, saved, reopened, or combined across sessions.
The CNMF model is more accurately written as
Y approximately equals A C + b f + residualwhereYis the movie,Acontains spatial footprints,Ccontains denoised calcium dynamics, andbandfdescribe spatial and temporal background terms. MiniAn does not identify a neuron solely because a region is bright; it estimates spatial and temporal components that jointly explain the movie.[^12]
The outputs need careful interpretation:
-Ais an estimated fluorescence footprint, not a binary anatomical boundary.
-Cis a model-derived calcium component, not raw fluorescence.
-Sis a deconvolved activity estimate under an autoregressive calcium model and an L1 sparsity penalty. It is not a direct electrophysiological spike train.
-YrAis not merely raw signal. Current source computes it as the previous temporal component plus a normalized residual projection after background subtraction and cross-talk adjustment, clipped to nonnegative values.[^13]
The paper itself describes the deconvolved output as a per-frame activity measure scaled by an unknown factor. Absolute amplitudes should therefore not be treated as directly comparable spike counts unless a separate calibration supports that interpretation.[^14]
Spatial normalization creates another scale consideration. The spatial update can normalize each footprint to unit sum and return a factor used to rescale temporal variables. Equivalent reconstructions can therefore distribute amplitude differently betweenAandC. Methods sections should report normalization settings before comparing component amplitudes across analyses.[^15]
4. Preprocessing
MiniAn currently supports median, Gaussian, bilateral, and anisotropic denoising. Background removal can use either a uniform filter or a morphological top-hat operation. For top-hat removal, thewndparameter is the radius of a disk structuring element; for uniform removal, it is the box-kernel size.[^16]
The main 2.0.2 demo notebook uses median denoising with kernel size 7 and top-hat background removal with a disk radius of 15 pixels. These are example parameters for the bundled recording, not universal recommendations.[^17]
The review's broader scientific point is valid: spatial scale is consequential. A top-hat radius that is too small can suppress cellular structure, while one that is too large can leave broad background. However, "the kernel must be larger than a neuron" should be presented as a practical heuristic to explore, not as an enforced MiniAn rule.
Preprocessing is evaluated lazily where possible, with computation commonly triggered when results are saved. That supports quick parameter previews, but it does not mean every preview or helper is free of materialization. Interactive tools can load subsets, and some current routines callcompute()internally.
5. Motion correction
MiniAn's current motion estimator recursively groups frames or templates and estimates their relative displacement. In the standard rigid path it uses FFT-based phase correlation and subpixel peak refinement. The main notebook callsestimate_motionalong the frame dimension without enabling a mesh, so its ordinary demonstrated path is rigid translation.[^18]
MiniAn 2.0.2 also contains an experimental non-rigid path. Supplyingmesh_sizeenables a B-spline control mesh with gradient-based optimization. It should be described as an experimental option rather than as the normal validated behavior of the main notebook.[^19]
The recursive architecture is useful because long recordings are not forced to register every frame directly to one immutable reference. Local templates are aggregated and then aligned through a hierarchy. Nevertheless, recursive registration can propagate a poor local template, an incorrect shift, or edge artifacts. Motion quality needs independent inspection through templates, shift traces, overlays, corrected videos, and downstream component stability.
The 2.0 release's reported twelve-fold improvement refers specifically to motion estimation. It should not be generalized to a twelve-fold improvement in total MiniAn runtime.[^10]
6. Seed generation and refinement
MiniAn generates an overcomplete candidate set by finding local maxima in maximum projections of frame subsets. The currentseeds_initAPI offers two methods:
-rolling, the default, uses overlapping windows across the recording;
-randomsamples random sets of frames.[^20]
The 2.0.2 pipeline notebook uses rolling windows, with a 1,000-frame window and a 500-frame step for the bundled demo. A review should therefore not describe current MiniAn initialization as inherently randomized. Random sampling remains available, but it is no longer the default demonstrated path.[^17]
The standard current notebook refines candidates in three steps:
1.peak-to-noise ratio filtering;
2.a Kolmogorov-Smirnov normality test;
3.distance-and-correlation-based seed merging.[^21]
MiniAn still contains GMM and intensity-based refinement functions, but the packaged 2.0.2 pipeline imports them without invoking them in the standard execution sequence. GMM filtering should therefore be described as an available alternative or an internal option, not as an invariant stage of current MiniAn.[^21]
Peak-to-noise refinement compares a robust peak-to-peak range with a high-pass-filtered noise range. It can use a fixed threshold or fit a two-component GMM whenthres="auto". The KS stage keeps seeds whose traces reject a normal-distribution null at the selected significance threshold. One sentence in the currentks_refinedocstring incorrectly says such seeds are discarded, but the code, notebook explanation, and returned mask retain them. That is a documentation inconsistency rather than a change in the executed logic.[^22]
There is also a source-level edge case worth noting. Bothpnr_refineandks_refinederive an internal chunk size withint(len(seeds) / 128). When fewer than 128 seeds are supplied, the visible expression can evaluate to zero before it is used in integer division. Sparse recordings should therefore be tested carefully, and the implementation would benefit from an explicit minimum chunk size of one.[^23]
Seed merging links nearby candidates whose temporal traces exceed a correlation threshold, then retains the brightest seed in each connected group. Because the grouping is transitive, two seeds can be merged through an intermediate neighbor even if the first and last are not directly similar enough to meet both criteria.[^24]
7. CNMF initialization and iterative refinement
For each retained seed, MiniAn initializes a spatial footprint from the temporal correlation between the seed trace and nearby pixels. The initial temporal matrix is then estimated with a least-squares projection from the movie and initialized footprints.[^25]
The spatial CNMF update solves nonnegative, sparsity-penalized regressions on a per-pixel basis. It limits candidate components at a pixel using a dilation of the previous footprints. Highersparse_penalvalues yield sparser spatial footprints, whilesize_threscan remove components whose nonzero area falls outside an allowed range.[^15]
These parameters are scientific as well as computational. A narrow dilation window can prevent a footprint from expanding to its true support. A high penalty can shrink weak cells, while a low penalty can let components absorb diffuse signal. Size filtering changes the final population and should be reported explicitly.
The temporal update estimates autoregressive coefficients and noise fromYrA, then solves an optimization problem with nonnegativity and sparsity constraints. Current source supports AR order, baseline segmentation, smoothing for AR estimation, warm starts, solver fallbacks, normalization, and post-hoc scaling.[^26]
The pipeline alternates spatial and temporal updates and performs component merging between iterations. Different iteration counts, merge thresholds, penalties, AR order, baseline handling, and solver behavior can all change the retained population.
8. Component merging and manual curation
Automatic unit merging considers components with overlapping nonzero footprints and sufficiently correlated temporal signals. Current 2.0.2 source combines both the spatial and temporal arrays by taking the mean across units in a merge group.[^27]
This differs from the 2022 paper's description, which states that merged spatial footprints are summed while temporal traces are averaged. Methods should therefore identify the software version rather than assuming the paper's wording exactly describes current behavior.[^28]
The manualCNMFViewershows spatial footprints, selected-cell activity, the original movie,C, andS. It lets the user label units as discarded or assign several units the same label to represent a merge. Current source stores those decisions in aunit_labelsarray:-1means discarded, and duplicated labels indicate a merge.[^29]
The main notebook then attaches these labels as coordinates to final arrays and saves the arrays. The underlying numerical components are not automatically re-estimated after a manual label change. Downstream analysis must apply the labels consistently and define how manually grouped signals are combined.[^30]
This non-destructive approach is good provenance practice, but the provenance is incomplete unless the analysis also records the reviewer, review date, curation criteria, and any later changes.
9. Dask, memory, and persistence
MiniAn's Dask architecture is one of its strongest contributions. Frame-wise operations can be partitioned temporally, spatial regressions can be partitioned spatially, and large arrays can be stored in chunked Zarr representations. The paper demonstrated mostly constant peak memory as frame count increased under its tested synthetic benchmark, while runtime grew approximately linearly.[^31]
That result should not be converted into a universal constant-memory guarantee. The paper explicitly notes that temporal optimization spans all frames for each cell, even though it can be partitioned across cells. Current source also computes some spatial matrices and residual terms, while functions such as PNR refinement and cross-registration intentionally callcompute()on selected intermediates.[^4]
The current notebook configures four Dask workers with a 4 GB per-worker limit for a nominal 16 GB laptop, sets a separate rechunking memory cap, and disables Dask's default worker termination at 95 percent of the limit so large operations spill to disk instead of killing workers. This is a practical engineering choice, but it means slow disk-backed spilling may be part of successful execution.[^17]
Worker count also changes total memory use. A4GBlimit is per worker, not pooled. More workers can improve throughput while increasing aggregate memory and I/O pressure. Storage location, chunk shape, scheduler overhead, component count, and field-of-view size all matter.
MiniAn uses explicitsave_miniancalls as checkpoints. Intermediate arrays are saved repeatedly and can be reopened withopen_minian. This is restartable, but it is not a transaction manager that automatically records a complete pipeline state. Users need to preserve the corresponding chunk dictionary, unit labels, parameters, and valid coordinate subsets when restarting.[^32]
The current documentation warns that incompatible coordinates from different sessions stored together can cause NaN padding or errors, and that spatial and temporal arrays must be subset consistently after stages that remove units. A Zarr store can open successfully while still containing mismatched scientific coordinates if files from different runs are mixed.[^32]
Version 2.0.2 fixed a crash caused by stale xarray chunk encodings during saving and changed the main data path tofloat32. Those changes are relevant when reproducing results made with older releases.[^11]
10. Cross-session registration
MiniAn's cross-registration notebook first aligns session-level maximum projections using translational motion estimation. It then keeps the common field-of-view region, shifts the spatial footprints, computes one centroid per component, and performs matching from centroid distances.[^33]
The notebook states explicitly that centroid location is the only component-level information used for identity matching. Footprint overlap, shape, local neighborhood structure, activity similarity, and probabilistic confidence are not part of the current matching score.[^34]
Pairwise mappings use a mutual-nearest-neighbor rule after a distance threshold. For multi-session extension,resolve_mappingconstructs a graph of pairwise matches and resolves conflicts.[^35]
A current documentation inconsistency matters here. The notebook says that conflicting mappings are dropped, echoing the conservative procedure described in the 2022 paper. However, the notebook callsresolve_mapping(mappings)without specifying a mode, and the current function defaults tomode="majority". In that mode, the most frequently mapped cell in a conflicting session is kept; all conflicting cells are dropped only instrictmode.[^36]
Thus, the paper-era and current default behavior differ:
-2022 paper: conflicts are discarded conservatively;
-2.0.2 default function call: majority resolution, with strict behavior available as an option.
Registration remains useful and interpretable, but it produces hard mappings rather than calibrated biological-identity probabilities. It is vulnerable to residual translation error, rotation, local deformation, depth change, dense neighbors, segmentation differences, and incomplete field overlap. Longitudinal studies should preserve the alignment templates, shifts, common window, distance threshold, conflict mode, unmatched units, and manual corrections.
11. Validation and what it establishes
Published simulated-data comparison
The 2022 paper generated 512 x 512 synthetic movies with 20,000 frames while varying cell number and signal level. MiniAn and CaImAn were both tuned with access to simulated ground truth. Under those conditions, both achieved F1 scores and spatial-footprint correlations above 0.95, while temporal correlation decreased at the lowest signal level.[^37]
This is useful controlled evidence. It does not show that either pipeline achieves that accuracy on unobserved experimental recordings, and it does not constitute a blind benchmark because ground truth informed parameter selection.
Experimental agreement with CaImAn
Six 20-minute CA1 recordings at 608 x 608 pixels and 30 fps were processed with both systems. The reported mean F1 agreement was 0.73 +/- 0.03 SEM, mean spatial correlation was 0.84 +/- 0.02, and mean temporal correlation was 0.86 +/- 0.02.[^5]
These results show substantial pipeline agreement. CaImAn is not biological ground truth, so the F1 value is not MiniAn's absolute precision-recall score. Disagreement near the field edge could reflect errors in either pipeline, different preprocessing assumptions, or genuinely ambiguous low-signal components.
Deconvolution and biological validation
The simulated activity comparison showed that MiniAn's continuous deconvolved output became strongly correlated with binned simulated spikes at higher signal levels. The paper correctly noted that amplitude remained influenced by background and noise.[^37]
The place-cell analysis then showed that MiniAn outputs and cross-session mappings could reproduce expected two-day place-field stability in CA1. This is meaningful biological plausibility evidence, but it remains indirect: a pipeline can preserve a population-level phenomenon while still making individual segmentation, event, or identity errors.[^38]
Current ground-truth notebook
MiniAn 2.0.1 added a bundled training notebook that runs the pipeline on Minisim recordings and scores motion, footprints, traces, and activity against known synthetic truth. The notebook explicitly shows that easy presets can be recovered well while realistic dense presets are only partially recovered with the example parameters.[^39]
This is a valuable current testing and teaching addition. It is not an independent peer-reviewed validation of MiniAn 2.0.2, and Minisim accuracy remains conditional on how well the simulator represents real recordings.
12. Software engineering and reproducibility
MiniAn 2.0.2 has a substantially more modern software foundation than the original review implied. It is installable from PyPI or conda-forge, uses versioned releases and tagged source, requires Python 3.10 or later, supplies packaged notebooks and checksum-verified demos, and includes unit and notebook-oriented tests.[^6]
The package metadata labels the project "Production/Stable." That is a packaging classifier, not proof that every analysis setting is scientifically validated for every preparation.[^6]
The current tests include a Minisim-based motion test and notebook execution guards, and the project describes end-to-end notebook runs as important integration coverage. This is stronger than a notebook with no automated execution, but it should not be equated with a comprehensive biological regression suite.[^11]
A reproducible MiniAn methods record should include at least:
-MiniAn release and full Git commit;
-Python and dependency environment;
-FFmpeg version and video-decoding command or input hashes;
-source filenames, ordering, frame rate, dtype, and downsampling;
-Dask worker count, threads, memory limit, and relevant thread settings;
-chunk dictionary and rechunking memory limit;
-preprocessing methods and parameters;
-motion method, template settings, mesh settings if used, and shift outputs;
-seed initialization method, window or random-sampling settings, and random seed where applicable;
-PNR, KS, GMM, intensity, and seed-merge settings actually used;
-every spatial and temporal CNMF parameter;
-solver status and warnings;
-all intermediate and final unit IDs;
-automated and manual merge decisions;
-unit_labelsand the criteria used for curation;
-cross-registration distance threshold and conflict-resolution mode;
-software runtime, peak memory, and storage location;
-final exported arrays and any downstream transformations.
MiniAn does not currently produce one immutable manifest containing all of this information. Notebook cells and saved arrays provide many ingredients, but a laboratory still needs a deliberate provenance policy.
Overall assessment
MiniAn's strongest idea is not simply "CNMF in Python." It is the proposition that calcium-imaging analysis should remain inspectable while it is being constructed. The current package makes preprocessing, motion, initialization, spatial updates, temporal updates, curation, storage, and registration visible within one coherent notebook-centered workflow.
That transparency is scientifically valuable because MiniAn contains many consequential choices. The pipeline does not eliminate judgment; it gives the researcher tools to see what that judgment changes. The price is operator variability, notebook-state complexity, and a large provenance burden.
MiniAn 2.0.2 should be regarded as active and technically mature scientific software, not as a frozen 2022 prototype. It has modern installation, tagged releases, improved motion performance, explicit memory controls, packaged notebooks, and a new ground-truth training workflow. At the same time, its published accuracy evidence is historical, its experimental F1 value is agreement with CaImAn rather than absolute truth, its memory behavior remains workload-dependent, and its cross-session identity model is deliberately simple.
The most defensible conclusion is:
>MiniAn is a strong platform for transparent, configurable miniscope analysis. Its results are most trustworthy when the operator preserves the complete parameter and curation history, validates intermediate outputs, and tests the chosen configuration on representative experimental and synthetic data rather than relying on package defaults or one historical benchmark.
References
[^1]: MiniAn 2.0.2 pipeline documentation: https://minian.readthedocs.io/en/stable/pipeline/index.html
[^2]: Dong Z, Mau W, Feng Y, et al.Minian, an open-source miniscope analysis pipeline. eLife. 2022;11:e70661. https://elifesciences.org/articles/70661
[^3]: MiniAn 2.0.2 changelog: https://minian.readthedocs.io/en/v2.0.2/start_guide/changelog.html
[^4]: eLife paper, Appendix 1, "Parallel and out-of-core computation with Dask": https://elifesciences.org/articles/70661#appendix-1
[^5]: eLife paper, experimental validation results: https://elifesciences.org/articles/70661#s4-3
[^6]: MiniAn 2.0.2 PyPI metadata and release files: https://pypi.org/project/minian/
[^7]: MiniAn command-line interface documentation: https://minian.readthedocs.io/en/stable/start_guide/cli.html
[^8]: MiniAn 2.0.2 packaged pipeline notebook: https://github.com/miniscope/minian/blob/v2.0.2/minian/notebooks/pipeline/pipeline.ipynb
[^9]: MiniAn 2.0.2 pipeline preface: https://raw.githubusercontent.com/miniscope/minian/v2.0.2/minian/notebooks/pipeline/pipeline.ipynb
[^10]: MiniAn 2.0.0 release notes: https://github.com/miniscope/minian/releases/tag/v2.0.0
[^11]: MiniAn 2.0.2 and 2.0.1 release notes: https://github.com/miniscope/minian/releases
[^12]: eLife paper, CNMF description and MiniAn workflow: https://elifesciences.org/articles/70661
[^13]: MiniAn 2.0.2compute_tracesource: https://github.com/miniscope/minian/blob/v2.0.2/minian/cnmf.py
[^14]: eLife paper, temporal-update interpretation: https://elifesciences.org/articles/70661#s3-6
[^15]: MiniAn 2.0.2update_spatialsource and API documentation: https://github.com/miniscope/minian/blob/v2.0.2/minian/cnmf.py
[^16]: MiniAn 2.0.2 preprocessing source: https://github.com/miniscope/minian/blob/v2.0.2/minian/preprocessing.py
[^17]: MiniAn 2.0.2 packaged pipeline parameter cell: https://raw.githubusercontent.com/miniscope/minian/v2.0.2/minian/notebooks/pipeline/pipeline.ipynb
[^18]: MiniAn 2.0.2 motion source and main pipeline notebook: https://github.com/miniscope/minian/blob/v2.0.2/minian/motion_correction.py
[^19]: MiniAn 2.0.2estimate_motiondocumentation, experimental non-rigidmesh_sizepath: https://minian.readthedocs.io/en/v2.0.2/_modules/minian/motion_correction.html
[^20]: MiniAn 2.0.2seeds_initsource: https://github.com/miniscope/minian/blob/v2.0.2/minian/initialization.py
[^21]: MiniAn 2.0.2 packaged pipeline, initialization section: https://github.com/miniscope/minian/blob/v2.0.2/minian/notebooks/pipeline/pipeline.ipynb
[^22]: MiniAn 2.0.2pnr_refineandks_refinesource: https://github.com/miniscope/minian/blob/v2.0.2/minian/initialization.py
[^23]: MiniAn 2.0.2initialization.py, seed-subset chunk calculations: https://raw.githubusercontent.com/miniscope/minian/v2.0.2/minian/initialization.py
[^24]: MiniAn 2.0.2seeds_mergesource: https://github.com/miniscope/minian/blob/v2.0.2/minian/initialization.py
[^25]: MiniAn 2.0.2initAandinitCsource: https://github.com/miniscope/minian/blob/v2.0.2/minian/initialization.py
[^26]: MiniAn 2.0.2update_temporalsource: https://github.com/miniscope/minian/blob/v2.0.2/minian/cnmf.py
[^27]: MiniAn 2.0.2unit_mergesource: https://github.com/miniscope/minian/blob/v2.0.2/minian/cnmf.py
[^28]: eLife paper, component merging: https://elifesciences.org/articles/70661#s3-7
[^29]: MiniAn 2.0.2CNMFViewersource: https://github.com/miniscope/minian/blob/v2.0.2/minian/visualization.py
[^30]: MiniAn 2.0.2 pipeline, manual labels and final save: https://github.com/miniscope/minian/blob/v2.0.2/minian/notebooks/pipeline/pipeline.ipynb
[^31]: eLife paper, computational performance benchmark: https://elifesciences.org/articles/70661#s4-4
[^32]: MiniAn documentation, working with variables and persistence: https://minian.readthedocs.io/en/stable/tips/variables.html
[^33]: MiniAn 2.0.2 cross-registration notebook: https://github.com/miniscope/minian/blob/v2.0.2/minian/notebooks/cross_registration/cross-registration.ipynb
[^34]: MiniAn 2.0.2 cross-registration notebook, centroid-only identity statement: https://raw.githubusercontent.com/miniscope/minian/v2.0.2/minian/notebooks/cross_registration/cross-registration.ipynb
[^35]: MiniAn 2.0.2 cross-registration source: https://github.com/miniscope/minian/blob/v2.0.2/minian/cross_registration.py
[^36]: MiniAn 2.0.2resolve_mappingdefault and cross-registration notebook call: https://github.com/miniscope/minian/blob/v2.0.2/minian/cross_registration.py
[^37]: eLife paper, simulated-data and deconvolution validation: https://elifesciences.org/articles/70661#s4-2
[^38]: eLife paper, CA1 place-cell validation: https://elifesciences.org/articles/70661#s4-5
[^39]: MiniAn 2.0.2 Minisim ground-truth notebook: https://github.com/miniscope/minian/blob/v2.0.2/minian/notebooks/pipeline_groundtruth/pipeline_groundtruth.ipynb