celldetective 1.0.2.post1__py3-none-any.whl → 1.1.1__py3-none-any.whl

celldetective-1.1.1.dist-info/METADATA

@@ -0,0 +1,305 @@
+Metadata-Version: 2.1
+Name: celldetective
+Version: 1.1.1
+Summary: description
+Home-page: http://github.com/remyeltorro/celldetective
+Author: Rémy Torro
+Author-email: remy.torro@inserm.fr
+License: GPL-3.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: wheel
+Requires-Dist: nbsphinx
+Requires-Dist: nbsphinx-link
+Requires-Dist: sphinx-rtd-theme
+Requires-Dist: sphinx ==5.0.2
+Requires-Dist: jinja2 <3.1
+Requires-Dist: ipykernel
+Requires-Dist: stardist
+Requires-Dist: cellpose <3
+Requires-Dist: scikit-learn
+Requires-Dist: btrack
+Requires-Dist: tensorflow <=2.12.1
+Requires-Dist: napari
+Requires-Dist: tqdm
+Requires-Dist: mahotas
+Requires-Dist: fonticon-materialdesignicons6
+Requires-Dist: art
+Requires-Dist: lifelines
+Requires-Dist: setuptools
+Requires-Dist: scipy
+Requires-Dist: seaborn
+Requires-Dist: opencv-python-headless ==4.7.0.72
+Requires-Dist: liblapack
+Requires-Dist: gputools
+Requires-Dist: lmfit ~=1.2.2
+Requires-Dist: superqt[cmap] >=0.6.1
+Requires-Dist: matplotlib-scalebar
+
+# Celldetective
+
+<embed>
+    <p align="center">
+    <img src="https://github.com/remyeltorro/celldetective/blob/main/celldetective/icons/logo-large.png" width="33%" />
+    </p>
+</embed>
+
+![ico1](https://img.shields.io/readthedocs/celldetective?link=https%3A%2F%2Fcelldetective.readthedocs.io%2Fen%2Flatest%2Findex.html)
+![ico17](https://github.com/remyeltorro/celldetective/actions/workflows/test.yml/badge.svg)
+![ico4](https://img.shields.io/pypi/v/celldetective)
+![ico6](https://img.shields.io/github/downloads/remyeltorro/celldetective/total)
+![ico5](https://img.shields.io/pypi/dm/celldetective)
+![ico2](https://img.shields.io/github/forks/remyeltorro/celldetective?link=https%3A%2F%2Fgithub.com%2Fremyeltorro%2Fcelldetective%2Fforks)
+![ico3](https://img.shields.io/github/stars/remyeltorro/celldetective?link=https%3A%2F%2Fgithub.com%2Fremyeltorro%2Fcelldetective%2Fstargazers)
+
+Celldetective is a python package and software to perform single-cell
+analysis on multimodal time lapse microscopy images.
+
+-   **Documentation:** <https://celldetective.readthedocs.io>
+-   **Source code:** <https://github.com/remyeltorro/celldetective>
+-   **Bug reports:**
+    <https://github.com/remyeltorro/celldetective/issues/new/choose>
+-   **Datasets, models and demos:**
+    <https://zenodo.org/records/10650279>
+
+## Overview
+
+<embed>
+    <p align="center">
+    <img src="https://github.com/remyeltorro/celldetective/blob/main/docs/source/_static/celldetective-blocks.png" width="90%" />
+    </p>
+</embed>
+
+Despite notable efforts in the development of user-friendly softwares
+that integrate state-of-the-art solutions to perform single cell
+analysis, very few are designed for time-lapse data and even less for
+multimodal problems where cells populations are mixed and can only be
+separated through the use of multimodal information. Few software
+solutions provide, to our knowledge, the extraction of response
+functions from single cell events such as the dynamic survival of a
+population directly in the GUI, as coding skills are usually required to
+do so. We want to study complex data which is often multimodal time
+lapse microscopy images of interacting cell populations, without loss of
+generality. With a high need for an easy-to-use,
+no-coding-skill-required software adapted to images and intended for
+biologists, we introduce **Celldetective**, an open-source python-based
+software with the following highlight features:
+
+-   **Comprehensive single-cell image analysis** : Celldetective ships
+    segmentation, tracking, and measurement modules, as well as event
+    detection from single-cell signals, for up to two populations of
+    interest.
+-   **Integration of state-of-the-art solutions** : Celldetective
+    harnesses state-of-the-art segmentation techniques (StarDist[^1],
+    Cellpose[^2] ,[^3]) and tracking algorithm (bTrack[^4]), as well as
+    the napari viewer[^5] where applicable. These algorithms are
+    interfaced to be well integrated and accessible for the target
+    audience, in the context of complex biological applications.
+-   **A framework for event description and annotations** : we propose a
+    broad and intuitive framework to annotate and automate the detection
+    of events from single-cell signals through Deep Learning signal
+    classification and regression. The event formulation is directly
+    exploited to define population survival responses.
+-   **A neighborhood scheme to study cell-cell interactions** : we
+    introduce a neighborhood scheme to relate the spatio-temporal
+    distribution and measurements of two cell populations, allowing the
+    study of how cell-cell interactions affect single-cell and
+    population responses.
+-   **Deep Learning customization in GUI** : Celldetective facilitates
+    the specialization of Deep Learning models or the creation of new
+    ones adapted to user data, by facilitating the creation of training
+    sets and the training of such models, without having to write a
+    single line of code.
+-   **In-software analysis** : Celldetective ships visualization tools
+    to collapse single-cell signals with respect to an event, build
+    survival curves, compare measurement distributions across biological
+    conditions.
+-   **A library of segmentation and signal models**: we created specific
+    models to investigate a co-culture of MCF-7 cells and primary NK
+    cells, that are available directly is the software with a large
+    collection of generalist models developed by the StarDist and
+    Cellpose teams, which are a perfect starting point to segment single
+    cells in a new biological system.
+-   **Accessible and open source** : Celldetective does not require any
+    coding skills. The software, its models and datasets are made fully
+    open source to encourage transparency and reproducibility.
+
+<embed>
+    <p align="center">
+    <img src="https://github.com/remyeltorro/celldetective/blob/main/docs/source/_static/signal-annotator.gif" width="90%" />
+    </p>
+</embed>
+
+# System requirements
+
+## Hardware requirements
+
+The software was tested on several machines, including:
+
+-   An Intel(R) Core(TM) i9-10850K CPU @ 3.60GHz, with a single NVIDIA
+    GeForce RTX 3070 (8 Gb of memory) and 16 Gb of memory
+-   An Intel(R) Core(TM) i7-9750H CPU @ 2.60 GHz, with 16 Gb of memory
+
+In GPU mode, succesive segmentation and DL signal analysis could be
+performed without saturating the GPU memory thanks to the subprocess
+formulation for the different modules. The GPU can be disabled in the
+startup window. The software does not require a GPU (but model inference
+will be longer). A typical analysis of a single movie with a GPU takes
+between 5 to 15 minutes. Depending on the number of cells and frames on
+the images, this computation time can increase to the order of half an
+hour on a CPU.
+
+The memory must be sufficient to load a movie stack at once in order to
+visualize it in napari. Otherwise, processing is performed frame by
+frame, therefore the memory required is extremely low.
+
+## Software requirements
+
+The software was developed simulateously on Ubuntu 20.04 and Windows 11.
+It was tested on MacOS, but Tensorflow installation can rquire extra
+steps.
+
+-   Linux: Ubuntu 20.04.6 LTS (Focal Fossa) (not tested on ulterior
+    versions)
+-   Windows: Windows 11 Home 23H2
+
+To use the software, you must install python, *e.g.* through
+[Anaconda](https://www.anaconda.com/download). We developed and tested
+the software in Python 3.9.18.
+
+# Installation
+
+## Stable release
+
+Celldetective can be installed with `pip`:
+
+``` bash
+pip install celldetective
+```
+
+We recommend that you create an environment to use Celldetective, *e.g.*
+with `conda`:
+
+``` bash
+conda create -n celldetective python=3.9.18 pyqt
+conda activate celldetective
+pip install celldetective
+```
+
+Need an update? Simply type the following in the terminal (in your
+environment):
+
+``` bash
+pip install --upgrade celldetective
+```
+
+## Development version
+
+### From GitHub
+
+If you want to run the latest development version, you can clone the
+repository to your local machine and install Celldetective in
+"development" mode. This means that any changes to the cloned repository
+will be immediately available in the python environment:
+
+``` bash
+# creates "celldetective" folder
+git clone git://github.com/remyeltorro/celldetective.git
+cd celldetective
+
+# install the celldetective package in editable/development mode
+pip install -r requirements.txt
+pip install -e .
+```
+
+To run the latest development version without cloning the repository,
+you can also use this line:
+
+``` bash
+pip install git+https//github.com/remyeltorro/celldetective.git
+```
+
+### From a zip file
+
+You can also download the repository as a compressed file. Unzip the
+file and open a terminal at the root of the folder (same level as the
+file requirements.txt). We recommend that you create a python
+environment as Celldetective relies on many packages that may interfere
+with package requirements for other projects. Run the following lines to
+create an environment named \"celldetective\":
+
+``` bash
+conda create -n celldetective python=3.9.18 pyqt
+conda activate celldetective
+pip install -r requirements.txt
+pip install .
+```
+
+The installation of the dependencies will take a few minutes (up to half
+an hour if the network is bad). The Celldetective package itself is
+light and installs in a few seconds.
+
+Before launching the software, move to a different directory as running
+the package locally can create some bugs when locating the models.
+
+# Quick start
+
+You can launch the GUI by 1) opening a terminal and 2) typing the
+following:
+
+``` bash
+python -m celldetective
+```
+
+# Documentation
+
+Read the tutorial here:
+
+<https://celldetective.readthedocs.io/>
+
+# How to cite?
+
+If you use this software in your research, please cite the
+[Celldetective](https://www.biorxiv.org/content/10.1101/2024.03.15.585250v1)
+paper (currently preprint):
+
+``` raw
+@article {Torro2024.03.15.585250,
+    author = {R{\'e}my Torro and Beatriz D{\`\i}az-Bello and Dalia El Arawi and Lorna Ammer and Patrick Chames and Kheya Sengupta and Laurent Limozin},
+    title = {Celldetective: an AI-enhanced image analysis tool for unraveling dynamic cell interactions},
+    elocation-id = {2024.03.15.585250},
+    year = {2024},
+    doi = {10.1101/2024.03.15.585250},
+    publisher = {Cold Spring Harbor Laboratory},
+    abstract = {A current key challenge in bioimaging is the analysis of multimodal and multidimensional data reporting dynamic interactions between diverse cell populations. We developed Celldetective, a software that integrates AI-based segmentation and tracking algorithms and automated signal analysis into a user-friendly graphical interface. It offers complete interactive visualization, annotation, and training capabilities. We demonstrate it by analyzing original experimental data of spreading immune effector cells as well as antibody-dependent cell cytotoxicity events using multimodal fluorescence microscopy.Competing Interest StatementThe authors have declared no competing interest.},
+    URL = {https://www.biorxiv.org/content/early/2024/03/17/2024.03.15.585250},
+    eprint = {https://www.biorxiv.org/content/early/2024/03/17/2024.03.15.585250.full.pdf},
+    journal = {bioRxiv}
+}
+```
+
+Make sure you to cite the papers of any segmentation model (StarDist,
+Cellpose) or tracker (bTrack) you used through Celldetective.
+
+# Bibliography
+
+[^1]: Schmidt, U., Weigert, M., Broaddus, C. & Myers, G. Cell Detection
+    with Star-Convex Polygons. in Medical Image Computing and Computer
+    Assisted Intervention -- MICCAI 2018 (eds. Frangi, A. F., Schnabel,
+    J. A., Davatzikos, C., Alberola-López, C. & Fichtinger, G.) 265--273
+    (Springer International Publishing, Cham, 2018).
+    <doi:10.1007/978-3-030-00934-2_30>.
+
+[^2]: Stringer, C., Wang, T., Michaelos, M. & Pachitariu, M. Cellpose: a
+    generalist algorithm for cellular segmentation. Nat Methods 18,
+    100--106 (2021).
+
+[^3]: Pachitariu, M. & Stringer, C. Cellpose 2.0: how to train your own
+    model. Nat Methods 19, 1634--1641 (2022).
+
+[^4]: Ulicna, K., Vallardi, G., Charras, G. & Lowe, A. R. Automated Deep
+    Lineage Tree Analysis Using a Bayesian Single Cell Tracking
+    Approach. Frontiers in Computer Science 3, (2021).
+
+[^5]: Ahlers, J. et al. napari: a multi-dimensional image viewer for
+    Python. Zenodo <https://doi.org/10.5281/zenodo.8115575> (2023).

celldetective-1.1.1.dist-info/RECORD

@@ -0,0 +1,84 @@
+celldetective/__init__.py,sha256=FEZpJKcskBH2IginYzeqPWoR1lVGuyYCXhv7Hnlkoo8,49
+celldetective/__main__.py,sha256=XFAkq_2cBEkWAVXDGSNFagoQBglyl0Y-GOO3KFc8UqM,13888
+celldetective/events.py,sha256=s2pWnR3Z1fcB15sET5WsF2Pi6v6qv16hks_m3WiklNs,3658
+celldetective/extra_properties.py,sha256=y2SkixGxTOaTz_ghl6RoRnb646t09cgKjB6Pqree0w0,4163
+celldetective/filters.py,sha256=i-XN6psgdaG_w6gjK2Qvb1OshspQaDsV_PF1WTyo2Sw,2704
+celldetective/io.py,sha256=UW0AfnQDLIxfiZ5igk-MoWCYR0N6ePuAsEY-kTOvj58,80460
+celldetective/measure.py,sha256=HDQZfSRx3daOCV5Snu1paYU5JYkwu8engO2qZqhTAUo,48089
+celldetective/neighborhood.py,sha256=QCuhesMHGyr3c3ys9wWcNR1HM6CHdHe51R8upoolgPw,49514
+celldetective/preprocessing.py,sha256=psCs4CAI7gG3YlKvxkXKnpClFL4SjWm5TToXq2ZwL-s,37137
+celldetective/segmentation.py,sha256=2w1OZBg9Ij9C05EMrGVsCpheI2PcykIArFQbxIBIGIM,28978
+celldetective/signals.py,sha256=P7eiDZGGIAYCFBKjGCBi8gMBvJYywxlxZNzyGgw-26Y,102783
+celldetective/tracking.py,sha256=A0mhdF4uq4m8OX1-rhtuhG69rlh_6Pb34Aebu7hIeKM,37601
+celldetective/utils.py,sha256=JQDbZB_VLyVkXfqbROe-m4XjXpkhljYLWMnQf3gbqlU,77509
+celldetective/datasets/segmentation_annotations/blank,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+celldetective/datasets/signal_annotations/blank,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+celldetective/gui/__init__.py,sha256=y2dvrUdJi17QMgPjl8WN3XFHYzJpu2ul4_8y7MQV1Bk,941
+celldetective/gui/about.py,sha256=i-y54Opb10pKTVNUEcJC-D6Cbiqud2EJ3ZLayXqhdqc,1715
+celldetective/gui/analyze_block.py,sha256=WD3JQQylx_dVozFCvNqrOyR6LcNHV7R1_gGh7XqOVeI,25423
+celldetective/gui/btrack_options.py,sha256=eQEf63yTUsPCN-d1LqgAMmUQpfv2FH85FqnOSaR-9Q8,35575
+celldetective/gui/classifier_widget.py,sha256=qvRl6svlelGsi-IRa7MrCGXrx4sRI8egl5xdGLH3r1A,15341
+celldetective/gui/configure_new_exp.py,sha256=ANJ-Zn4sjBphtj_aoJu6m1PFEKyv9gxeh9XqS6xOGjk,18969
+celldetective/gui/control_panel.py,sha256=wcDqe4XaDJRMmPmWKJpxd0D9V4_DrdRGnEH6D7B_IK0,17557
+celldetective/gui/gui_utils.py,sha256=PidFfdc8XASeIzZO5pfKgwqe4vROG7-KpYMcBZ42jdw,22673
+celldetective/gui/json_readers.py,sha256=fTrNrlxv9NCae8ZJexBEHxI3yCLRqt6F0Yo1OeDycfA,3686
+celldetective/gui/layouts.py,sha256=qotn6r2feFqc0gZx95ssjxYoxOqms0ZcSWApBrBWYEM,26938
+celldetective/gui/measurement_options.py,sha256=i0CdAfupHJAqhOT7RsufEK919sAzQnFBkQO4IAMYZL0,47704
+celldetective/gui/neighborhood_options.py,sha256=sdKxVRliZtuKSpcPfnFxqkW4V8rN2tzjhDxOPVmElyE,20191
+celldetective/gui/plot_measurements.py,sha256=xUoGxV6uXcen-t4yWtAmcGTUayICI-FxTVKPrWMNlfg,51799
+celldetective/gui/plot_signals_ui.py,sha256=TwWU2u3_mkRNsM8er0kI_kwr5EoZ29YEzlr0cQzyW4A,43732
+celldetective/gui/process_block.py,sha256=7n9glZ1ojEi1bObqwIj4giNhrteT69X1EPMQ1hK63aU,53565
+celldetective/gui/retrain_segmentation_model_options.py,sha256=-rkuUzI_vFFlZC3LAAYEELoJUKcz6PmkpCrxKZindhg,27218
+celldetective/gui/retrain_signal_model_options.py,sha256=uHZy3FGsGMHfZL_nYnuFiXF57XaAMVzjYxVF2OXhYnY,24184
+celldetective/gui/seg_model_loader.py,sha256=uKp8oab-4QdTGqb-tb6bOD-FLD_154GOvgWFYz97BwY,17350
+celldetective/gui/signal_annotator.py,sha256=4ymMpo_GjSBsJSRkyNKrWRLy0EFXHINbFtp9ykDqfGE,84864
+celldetective/gui/signal_annotator_options.py,sha256=-Q7f8eCwniqbgLJqMCa91Wc-V3VHAZidwt7LPd4Z5yU,10879
+celldetective/gui/styles.py,sha256=Vw4wr6MQ4iBwhOY-ZWAxFDZZ3CNohmEnuPPazwhJaho,4129
+celldetective/gui/survival_ui.py,sha256=2JGLC5m6D_gVLwnBAM7uEvuCKw1Cli8nM9i5s7TIpGg,33612
+celldetective/gui/tableUI.py,sha256=fOJXWakqZPQOUp5VydCteg5nrV9DHX24Rq1uoE3mT7Q,31717
+celldetective/gui/thresholds_gui.py,sha256=xVbGw6R9yojZ4iffzM6uR2lMojqVJjoGviCmxzlnEeY,47979
+celldetective/gui/viewers.py,sha256=G8uNb0U_4tJiZkcAWX9BbCSBIUbF4tjedZD-5o4WKxY,27734
+celldetective/icons/logo-large.png,sha256=FXSwV3u6zEKcfpuSn4unnqB0oUnN9cHqQ9BCKWytrpg,36631
+celldetective/icons/logo.png,sha256=wV2OS8_dU5Td5cgdPbCOU3JpMpTwNuYLnfVcnQX0tJA,2437
+celldetective/icons/signals_icon.png,sha256=vEiKoqWTtN0-uJgVqtAlwCuP-f4QeWYOlO3sdp2tg2w,3969
+celldetective/icons/splash-test.png,sha256=W9smcuuwJUF9DU-rz4aACx7_rCmGRsxYUGPBDlDnrJk,17523
+celldetective/icons/splash.png,sha256=J_1jPJylxwHGzGF1xCGocc-BmylHtHTII9VJSLKnezY,17895
+celldetective/icons/splash0.png,sha256=qVXsrYUinm5g6-vbHcqwyjh8SIqs9lEqPWnPa1WijaQ,14233
+celldetective/icons/survival2.png,sha256=8zsualD7d9VPAecoFA4Om9TFARErqpJzMg6U7XANXf4,4479
+celldetective/icons/vignette_signals2.png,sha256=hsVOdQDpEfMGM45aaSeacEm3lvxbquRKKYutiS9qoS0,20743
+celldetective/icons/vignette_signals2.svg,sha256=muGNcQudV1jG-bmFd9FwV-Wb8PcrRV5osdZ7pHR7Ekk,5947
+celldetective/links/zenodo.json,sha256=7WKRuZY7MHTR-IChWBbU0i47H_479NtlxsCGaJn9-xM,22728
+celldetective/models/segmentation_effectors/blank,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+celldetective/models/segmentation_effectors/primNK_cfse/config_input.json,sha256=gwEGP5wc6iVcwLrR5IbEb-9lTbdQuPyLLFYXh00374U,509
+celldetective/models/segmentation_effectors/primNK_cfse/cp-cfse-transfer,sha256=ps4BAzGxr2i2R0uBGJqfF9wjg5bIeSeBGQb0YcUChhY,26559970
+celldetective/models/segmentation_effectors/primNK_cfse/training_instructions.json,sha256=DqEO4_oQuQmJkZiefREXz8ts60svoqxIQB-LMScuCnc,909
+celldetective/models/segmentation_generic/blank,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+celldetective/models/segmentation_targets/blank,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+celldetective/models/signal_detection/blank,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+celldetective/models/tracking_configs/mcf7.json,sha256=iDjb8i6yxs0GleW39dvY3Ld5bZJatlXJrwI8PG3vCT0,1780
+celldetective/models/tracking_configs/ricm.json,sha256=L-vmwCR1f89U-qnH2Ms0cBfPFR_dxIWoe2ccH8V-QBA,2727
+celldetective/models/tracking_configs/ricm2.json,sha256=DDjJ6ScYcDWvlsy7ujPID8v8H28vcNcMuZmNR8XmGxo,2718
+celldetective/scripts/analyze_signals.py,sha256=23TXGNw-j5xT3ss4mXlnKdBgFLnQ50JUEQOC6_H7Q_0,2203
+celldetective/scripts/measure_cells.py,sha256=4uRG6Dg0WsO-N8ZaBJ4loWOvX6FdHaCblIFXq6Dtirc,11000
+celldetective/scripts/segment_cells.py,sha256=XbWi2EyhH7vUbUhVR1IPILN2jy5q2AA8T4x44AjTMFE,7874
+celldetective/scripts/segment_cells_thresholds.py,sha256=GbWXa6xoO8s4PinJPZIxAuosw4vpzyJ7FiFYpSURojk,4998
+celldetective/scripts/track_cells.py,sha256=AaNiYEW4osYKKR2kbdVLOUnQEBbcZIA-D0mkhcxPWTY,7985
+celldetective/scripts/train_segmentation_model.py,sha256=UY493QK7_FhS9uHYl2eeEYx7t0kw1jhvc0YMY12YZpI,8614
+celldetective/scripts/train_signal_model.py,sha256=9-dmPCLKJ9ypjsV9AwFd-Sb6B6YaHS0QGT218H5hUPo,1861
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/test_events.py,sha256=eLFwwEEJfQAdwhews3-fn1HSvzozcNNFN_Qn0gOvQkE,685
+tests/test_filters.py,sha256=iJksl_HgquqGzPPv46qpNtlD4rkBpZ5eVtIotgZ7LDs,656
+tests/test_io.py,sha256=gk5FmoI7ANEczUtNXYRxc48KzkfYzemwS_eYaLq4_NI,2093
+tests/test_measure.py,sha256=FEUAs1rVHylvIvubCb0bJDNGZLVmkgXNgI3NaGQ1dA8,4542
+tests/test_neighborhood.py,sha256=gk5FmoI7ANEczUtNXYRxc48KzkfYzemwS_eYaLq4_NI,2093
+tests/test_preprocessing.py,sha256=FI-Wk-kc4wWmOQg_NLCUIZC1oti396wr5cC-BauBai0,1436
+tests/test_segmentation.py,sha256=-3b7o_fUVMYxfVwX5VHFqRF0dDXObSTtylf5XQGcq1A,3493
+tests/test_signals.py,sha256=No4cah6KxplhDcKXnU8RrA7eDla4hWw6ccf7xGnBokU,3599
+tests/test_tracking.py,sha256=8hebWSqEIuttD1ABn-6dKCT7EXKRR7-4RwyFWi1WPFo,8800
+tests/test_utils.py,sha256=NKRCAC1d89aBK5cWjTb7-pInYow901RrT-uBlIdz4KI,3692
+celldetective-1.1.1.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+celldetective-1.1.1.dist-info/METADATA,sha256=oPVbQsTELvlHqiLkqJuE2A6slkrZ5Zimq6rMPNty740,12412
+celldetective-1.1.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+celldetective-1.1.1.dist-info/entry_points.txt,sha256=2NU6_EOByvPxqBbCvjwxlVlvnQreqZ3BKRCVIKEv3dg,62
+celldetective-1.1.1.dist-info/top_level.txt,sha256=6rsIKKfGMKgud7HPuATcpq6EhdXwcg_yknBVWn9x4C4,20
+celldetective-1.1.1.dist-info/RECORD,,

{celldetective-1.0.2.post1.dist-info → celldetective-1.1.1.dist-info}/top_level.txt

@@ -1 +1,2 @@
 celldetective
+tests

tests/test_events.py

@@ -0,0 +1,28 @@
+import unittest
+from celldetective.events import switch_to_events
+
+class TestEventSwitch(unittest.TestCase):
+
+	@classmethod
+	def setUpClass(self):
+		self.classes = [0,0,1,1,2]
+		self.event_times = [5.,8.5,-1,-1,-1]
+		self.max_times = [10,10,10,10,10]
+		self.origin_times = [0,3,2,1,0]
+
+		self.expected_events = [1,1,0,0]
+		self.expected_times = [5.,5.5,8,9]
+
+	def test_expected_events(self):
+		events, times = switch_to_events(
+										self.classes,
+										self.event_times,
+										self.max_times,
+										self.origin_times
+										)
+		self.assertEqual(events, self.expected_events)
+		self.assertEqual(times, self.expected_times)
+
+
+if __name__=="__main__":
+	unittest.main()

tests/test_filters.py

@@ -0,0 +1,24 @@
+import unittest
+import numpy as np
+from celldetective.filters import gauss_filter, abs_filter
+
+
+class TestFilters(unittest.TestCase):
+
+	@classmethod
+	def setUpClass(self):
+		self.img = np.ones((256,256),dtype=int)
+		self.img[100:110,100:110] = 0
+		self.gauss_sigma = 1.6
+
+	def test_gauss_filter_is_float(self):
+		self.assertIsInstance(gauss_filter(self.img, self.gauss_sigma)[0,0], float)
+	
+	def test_gauss_filter_has_same_shape(self):
+		self.assertEqual(gauss_filter(self.img, self.gauss_sigma).shape, self.img.shape)
+
+	def test_abs_filter_is_positive(self):
+		self.assertTrue(np.all(abs_filter(self.img) >= 0.))
+
+if __name__=="__main__":
+	unittest.main()

tests/test_io.py

@@ -0,0 +1,70 @@
+import unittest
+import matplotlib.pyplot as plt
+import numpy as np
+import os
+
+# class TestPatchMask(unittest.TestCase):
+
+# 	@classmethod
+# 	def setUpClass(self):
+# 		self.radius = 3
+
+# 	def test_correct_shape(self):
+# 		self.patch = create_patch_mask(self.radius, self.radius)
+# 		self.assertEqual(self.patch.shape,(3,3))
+
+# 	def test_correct_ring(self):
+# 		self.patch = create_patch_mask(5, 5,radius=[1,2])
+# 		self.assertFalse(self.patch[2,2])
+
+# class TestRemoveRedundantFeatures(unittest.TestCase):
+
+# 	@classmethod
+# 	def setUpClass(self):
+# 		self.list_a = ['feat1','feat2','feat3','feat4','intensity_mean']
+# 		self.list_b = ['feat5','feat2','feat1','feat6','test_channel_mean']
+# 		self.expected = ['feat3','feat4']
+
+# 	def test_remove_red_features(self):
+# 		self.assertEqual(remove_redundant_features(self.list_a, self.list_b, channel_names=['test_channel']), self.expected)
+
+
+# class TestExtractChannelIndices(unittest.TestCase):
+
+# 	@classmethod
+# 	def setUpClass(self):
+# 		self.channels = ['ch1','ch2','ch3','ch4']
+# 		self.required_channels = ['ch4','ch2']
+# 		self.expected_indices = [3,1]
+
+# 	def test_extracted_channels_are_correct(self):
+# 		self.assertEqual(list(_extract_channel_indices(self.channels, self.required_channels)), self.expected_indices)
+
+
+# class TestImgIndexPerChannel(unittest.TestCase):
+
+# 	@classmethod
+# 	def setUpClass(self):
+# 		self.channels_indices = [1]
+# 		self.len_movie = 5
+# 		self.nbr_channels = 3
+# 		self.expected_indices = [1,4,7,10,13]
+
+# 	def test_index_sequence_is_correct(self):
+# 		self.assertEqual(list(_get_img_num_per_channel(self.channels_indices, self.len_movie, self.nbr_channels)[0]), self.expected_indices)
+
+
+# class TestSplitArrayByRatio(unittest.TestCase):
+
+# 	@classmethod
+# 	def setUpClass(self):
+# 		self.array_length = 100
+# 		self.array = np.ones(self.array_length)
+
+# 	def test_ratio_split_is_correct(self):
+# 		split_array = split_by_ratio(self.array,0.5,0.25,0.1)
+# 		self.assertTrue(np.all([len(split_array[0])==50, len(split_array[1])==25, len(split_array[2])==10]))
+
+
+# if __name__=="__main__":
+# 	unittest.main()

tests/test_measure.py

@@ -0,0 +1,141 @@
+import unittest
+import pandas as pd
+import numpy as np
+from celldetective.measure import measure_features, measure_isotropic_intensity, drop_tonal_features
+
+class TestFeatureMeasurement(unittest.TestCase):
+
+	"""
+	To do: test spot detection, fluo normalization and peripheral measurements
+	"""
+
+	@classmethod
+	def setUpClass(self):
+
+		# Simple mock data, 100px*100px, one channel, value is one, uniform
+		# Two objects in labels map
+
+		self.frame = np.ones((100,100,1), dtype=float)
+		self.labels = np.zeros((100,100), dtype=int)
+		self.labels[50:55,50:55] = 1
+		self.labels[0:10,0:10] = 2
+
+		self.feature_measurements = measure_features(
+												self.frame, 
+												self.labels, 
+												features=['intensity_mean','area',],
+												channels=['test_channel']
+												)
+
+		self.feature_measurements_no_image = measure_features(
+															None, 
+															self.labels, 
+															features=['intensity_mean','area',],
+															channels=None
+															)
+
+		self.feature_measurements_no_features = measure_features(
+															self.frame, 
+															self.labels, 
+															features=None,
+															channels=['test_channel'],
+															)
+
+	# With image
+	def test_measure_yields_table(self):
+		self.assertIsInstance(self.feature_measurements, pd.DataFrame)
+
+	def test_two_objects(self):
+		self.assertEqual(len(self.feature_measurements),2)
+
+	def test_channel_named_correctly(self):
+		self.assertIn('test_channel_mean',list(self.feature_measurements.columns))
+
+	def test_intensity_is_one(self):
+		self.assertTrue(np.all([v==1.0 for v in self.feature_measurements['test_channel_mean'].values]))
+
+	def test_area_first_is_twenty_five(self):
+		self.assertEqual(self.feature_measurements['area'].values[0],25)
+
+	def test_area_second_is_hundred(self):
+		self.assertEqual(self.feature_measurements['area'].values[1],100)
+
+	# Without image
+	def test_measure_yields_table(self):
+		self.assertIsInstance(self.feature_measurements_no_image, pd.DataFrame)
+
+	def test_two_objects(self):
+		self.assertEqual(len(self.feature_measurements_no_image),2)
+
+	def test_channel_not_in_table(self):
+		self.assertNotIn('test_channel_mean',list(self.feature_measurements_no_image.columns))
+
+	# With no features
+	def test_only_one_measurement(self):
+		cols = list(self.feature_measurements_no_features.columns)
+		assert 'class_id' in cols and len(cols)==1
+
+
+class TestIsotropicMeasurement(unittest.TestCase):
+
+	"""
+	
+	Test that isotropic intensity measurements behave as expected on fake image
+
+	"""
+
+	@classmethod
+	def setUpClass(self):
+
+		# Simple mock data, 100px*100px, one channel, value is one
+		# Square (21*21px) of value 0. in middle
+		# Two objects in labels map
+
+		self.frame = np.ones((100,100,1), dtype=float)
+		self.frame[40:61,40:61,0] = 0.
+		self.positions = pd.DataFrame([{'TRACK_ID': 0, 'POSITION_X': 50, 'POSITION_Y': 50, 'FRAME': 0, 'class_id': 0}])
+		
+		self.inner_radius = 9
+		self.upper_radius = 20
+		self.safe_upper_radius = int(21//2*np.sqrt(2))+2
+
+		self.iso_measurements = measure_isotropic_intensity(self.positions,
+															self.frame,
+															channels=['test_channel'],
+															intensity_measurement_radii=[self.inner_radius, self.upper_radius],
+															operations = ['mean'],
+															)
+		self.iso_measurements_ring = measure_isotropic_intensity(
+															self.positions,
+															self.frame,
+															channels=['test_channel'],
+															intensity_measurement_radii=[[self.safe_upper_radius, self.safe_upper_radius+3]],
+															operations = ['mean'],
+															)
+
+
+	def test_measure_yields_table(self):
+	 	self.assertIsInstance(self.iso_measurements, pd.DataFrame)
+
+	def test_intensity_zero_in_small_circle(self):
+		self.assertEqual(self.iso_measurements[f'test_channel_circle_{self.inner_radius}_mean'].values[0],0.)
+
+	def test_intensity_greater_than_zero_in_intermediate_circle(self):
+		self.assertGreater(self.iso_measurements[f'test_channel_circle_{self.upper_radius}_mean'].values[0],0.)
+	
+	def test_ring_measurement_avoids_zero(self):
+		self.assertEqual(self.iso_measurements[f'test_channel_ring_{self.safe_upper_radius}_{self.safe_upper_radius+3}_mean'].values[0],1.0)
+
+class TestDropTonal(unittest.TestCase):
+
+	@classmethod
+	def setUpClass(self):
+		self.features = ['area', 'intensity_mean', 'intensity_max']
+
+	def test_drop_tonal(self):
+		self.features_processed = drop_tonal_features(self.features)
+		self.assertEqual(self.features_processed,['area'])
+
+
+if __name__=="__main__":
+	unittest.main()