CaImAn island stable

This release captures the latest stable version of v1.1 before our next major release. Several bug fixes and improvements compared to v.1.1-alpha (e.g., faster motion correction, better handling of background in 1p data).

CaImAn island

CHECK THE NEW README FILE, UPDATED INSTALLATION INSTUCTIONS!!

New release that fixes a set of bugs and add new functionalities:
BUGS FIXED:

• MAC OS or LINUX processing getting stuck in multiprocessing or ipyparallel
• Online algorithm bug fixes
• Window support (a bit) more stable

New Features:

• installation with pip
• installation of demos examples movies and neural nets in a separate folder
• in place installation with pip
• CI for all the demos
• Use numpy's .tofile() method instead of managing files ourselves
• Added CNN for online calcium imaging analysis
• Online algorithm performance improved
• Online algorithm to run on Zebrafish data
• Code is more path aware
• Fixed tifffile compatibility
• Installation with packages from only conda-forge
• added support for non integere gSig
• enabling multiple new components per timestep in onacid
• Proofreading and killed deadcode
• more stable support for CNMF-E (endoscopic one photon data)

Latest stable 1.0

This release captures the last snapshot of CaImAn 1.0 that is stable and might be used for users not wanting to switch to the following release because of back compatibility issues

CaImAn 1.0

This release is to be considered stable and adds the following functionalities:

• Online analysis of calcium imaging data
• Scripts for the analysis of endoscopic data (1-photon imaging), CNMF-E
• New supervised and unsupervised classifiers that helps filtering out low quality components
• Speed up and memory efficiency improvements

CaImAn v0.8 The Long Cocodrilo

This release comes before major refactoring in CaImAn as a mean to support users that won't need new functionalities. It includes a stable version of CNMF and motion correction algorithms.

El cocodrilo

This release stabilizes the lat known version to humanity of calblitz and CNMF, that now have merged into CaImAn

0.4 El pirata

Handling large datasets and local feature equalization

In case something is not working perfectly, consider using the updated demo files:

https://github.com/agiovann/Constrained_NMF/blob/master/demo.py
https://github.com/agiovann/Constrained_NMF/blob/master/demo_patches.py
https://github.com/agiovann/Constrained_NMF/blob/master/demoCNMF.ipynb

New features

• The main new feature with this release is the ability to handle large datasets through memory mapping and partitioning the FOV in different spatially overlapping patches that are processed in parallel. For more details please read here. There is a new demo file (demo_patches.py) that illustrates the use of such tool. If you need also motion correction please check this repository and/or contact me.
• added travis/docker support (experimental)

Important functions that have been introduced are:

save_memmap: Save a tiff stack file as a matlab file that can be memory mapped. If the dataset is too large to load in memory, it can be read/saved in pieces. And of course the counterpart load_memmap.py. One can also decide to downsample and/or use portion of each of the files on the fly, thus allowing easily to have quick approximation of data analysis of very large files.

Another new feature is an unsupervised classifier that orders the component according to a metric that counts fluctuations in the traces that are statistically exceptional given an estimate of baseline and noise. Exceptional events are assumed to be spikes. The function implementing it is utilities.evaluate_components.

Deprecated functions

• The SPGL module has been deprecated and removed from the repository

Bug fixing

• the number of processes is decided at a single point in the code now
• the number of processes has been decreased because it seems to affect performance when more than 80% of cores where in use
• now the pfft is computed only on part of the data to speed up computation

Major speed and memory improvements

This release improves the speed performance of the code and introduces tools for interactive visualization. Major changes include:

• Use of the CVXPY library together with the ECOS and SCS solvers for fast updating of the temporal components. To use this solver set options['temporal_params']['method'] = 'cvxpy'. Installation of the CVXPY library is required.
• Manual component refinement through utilities.manually_refine_components. Allows the user to select additional components by clicking on a summary statistic image. A new component is then fit around that neighborhood.
• Setting the AR order p=0 through options['temporal_params']['p'] = 0 turns off deconvolution. Use this for fast updating of temporal components during first iteration and merging for speed improvements.
• Memory mapping for large data handling using little RAM. In the demo data is reshaped into a 2d array, then saved as numpy array that is used in a memory mapped form.
• Fixed a bug in utilities.order_components
• update_temporal_components also outputs the component-filtered noise statistic YrA. This can be used as an input to utilities.view_patches and utilities.view_patches_bar for faster visualization.
• General cleanup and code optimization.

0.1-beta

This release fixes a bug in initialization.greedyROI2d that was causing suboptimal identification of the weaker components.

It also introduces a new way for merging components that does not require the computation of the residual Y_res, yielding significant gains in speed and memory requirements. The choice for using fast merging can be tuned from the input fast_merge in merging.mergeROIS_parallel which is set by default to True. To enable this option the following changes have been made:

• merging.mergeROIS_parallel takes the input data Yr as its first input and not the residual Y_res
• temporal.update_temporal_components_parallel no longer produce the residual Y_res as an output.

0.04

Included automatic installation with conda and external demo files