celldetective 1.2.2__tar.gz → 1.2.2.post2__tar.gz

{celldetective-1.2.2 → celldetective-1.2.2.post2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: celldetective
-Version: 1.2.2
+Version: 1.2.2.post2
 Summary: description
 Home-page: http://github.com/remyeltorro/celldetective
 Author: Rémy Torro
@@ -37,6 +37,8 @@ Requires-Dist: superqt[cmap]
 Requires-Dist: setuptools
 Requires-Dist: matplotlib_scalebar
 Requires-Dist: numpy==1.26.4
+Requires-Dist: pytest
+Requires-Dist: pytest-qt
 
 # Celldetective
 
@@ -51,86 +53,41 @@ Requires-Dist: numpy==1.26.4
 ![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)
+![GitHub repo size](https://img.shields.io/github/repo-size/remyeltorro/celldetective)
+![GitHub License](https://img.shields.io/github/license/remyeltorro/celldetective?link=https%3A%2F%2Fgithub.com%2Fremyeltorro%2Fcelldetective%2Fblob%2Fmain%2FLICENSE)
 ![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
+Celldetective is a python package and graphical user interface 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>
+-  [Check the full documentation](https://celldetective.readthedocs.io)
+-  [Report a bug or request a new feature](https://github.com/remyeltorro/celldetective/issues/new/choose)
+-  [Explore the 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>
+![Pipeline](https://github.com/remyeltorro/celldetective/raw/main/docs/source/_static/celldetective-blocks.png)
 
-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>
+Celldetective was designed to analyze time-lapse microscopy images in difficult situations: mixed cell populations that are only separable through multimodal information. This software provides a toolkit for the analysis of cell population interactions. 
+
+
+**Key features**: 
+- Achieve single-cell description (segment / track / measure) for up to two populations of interest
+- Signal annotation and traditional or Deep learning automation
+- Mask annotation in napari[^5] and retraining of Deep learning models
+- Neighborhood linking within and across populations and interaction annotations
+- Everything is done graphically, no coding is required!
+  
+Check out the [highlights](https://celldetective.readthedocs.io/en/latest/overview.html#description) in the documentation! 
+
+Instead of reinventing the wheel and out of respect for the amazing work done by these teams, we chose to build around StarDist[^1] & Cellpose[^2][^3] (BSD-3 license) for the Deep-learning segmentation and the Bayesian tracker bTrack[^4] (MIT license) for tracking. If you use these models or methods in your Celldetective workflow, don't forget to cite the respective papers!
+
+**Target Audience**: The software is targeted to scientists who are interested in quantifying dynamically (or not) cell populations from microscopy images. Experimental scientists who produce such images can also analyze their data, thanks to the graphical interface, that completely removes the need for coding, and the many helper functions that guide the user in the analysis steps. Finally, the modular structure of Celldetective welcomes users with a partial need. 
+
+![Signal analysis](https://github.com/remyeltorro/celldetective/raw/main/docs/source/_static/signal-annotator.gif)
+
 
 # System requirements
 
@@ -146,28 +103,26 @@ 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
+will be longer). 
+
+A typical analysis of a single movie with a GPU takes
+between 3 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.
+Processing is performed frame by frame, therefore the memory requirement is extremely low. The main bottleneck is in the visualization of segmentation and tracking output. Whole stacks (typically 1-9 Gb) have to be loaded in memory at once to be viewed in napari. 
 
 ## 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
+It was tested on MacOS, but Tensorflow installation can require extra
 steps.
 
--   Linux: Ubuntu 20.04.6 LTS (Focal Fossa) (not tested on ulterior
-    versions)
+-   Linux: Ubuntu 20.04.6 LTS (Focal Fossa)
 -   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 and more recently 3.11.
+[Anaconda](https://www.anaconda.com/download). Celldetective is routinely tested on both Ubuntu and Windows for Python versions 3.9, 3.10 and 3.11.
 
 # Installation
 
@@ -197,58 +152,8 @@ environment):
 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
-
-# optional: create an environment
-conda create -n celldetective python=3.11 pyqt
-conda activate 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
+For more installation options, please check the [documentation](https://celldetective.readthedocs.io/en/latest/get-started.html#installation).
 
-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.11 pyqt
-conda activate celldetective
-pip install -r requirements.txt
-pip install -e .
-```
-
-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
 
@@ -256,14 +161,11 @@ You can launch the GUI by 1) opening a terminal and 2) typing the
 following:
 
 ``` bash
+# conda activate celldetective
 python -m celldetective
 ```
 
-# Documentation
-
-Read the tutorial here:
-
-<https://celldetective.readthedocs.io/>
+For more information about how to get started, please check the [documentation](https://celldetective.readthedocs.io/en/latest/get-started.html#launching-the-gui).
 
 # How to cite?
 

celldetective-1.2.2.post2/README.md

@@ -0,0 +1,173 @@
+# 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)
+![GitHub repo size](https://img.shields.io/github/repo-size/remyeltorro/celldetective)
+![GitHub License](https://img.shields.io/github/license/remyeltorro/celldetective?link=https%3A%2F%2Fgithub.com%2Fremyeltorro%2Fcelldetective%2Fblob%2Fmain%2FLICENSE)
+![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 graphical user interface to perform single-cell
+analysis on multimodal time lapse microscopy images.
+
+-  [Check the full documentation](https://celldetective.readthedocs.io)
+-  [Report a bug or request a new feature](https://github.com/remyeltorro/celldetective/issues/new/choose)
+-  [Explore the datasets, models and demos](https://zenodo.org/records/10650279)
+
+## Overview
+
+![Pipeline](https://github.com/remyeltorro/celldetective/raw/main/docs/source/_static/celldetective-blocks.png)
+
+
+Celldetective was designed to analyze time-lapse microscopy images in difficult situations: mixed cell populations that are only separable through multimodal information. This software provides a toolkit for the analysis of cell population interactions. 
+
+
+**Key features**: 
+- Achieve single-cell description (segment / track / measure) for up to two populations of interest
+- Signal annotation and traditional or Deep learning automation
+- Mask annotation in napari[^5] and retraining of Deep learning models
+- Neighborhood linking within and across populations and interaction annotations
+- Everything is done graphically, no coding is required!
+  
+Check out the [highlights](https://celldetective.readthedocs.io/en/latest/overview.html#description) in the documentation! 
+
+Instead of reinventing the wheel and out of respect for the amazing work done by these teams, we chose to build around StarDist[^1] & Cellpose[^2][^3] (BSD-3 license) for the Deep-learning segmentation and the Bayesian tracker bTrack[^4] (MIT license) for tracking. If you use these models or methods in your Celldetective workflow, don't forget to cite the respective papers!
+
+**Target Audience**: The software is targeted to scientists who are interested in quantifying dynamically (or not) cell populations from microscopy images. Experimental scientists who produce such images can also analyze their data, thanks to the graphical interface, that completely removes the need for coding, and the many helper functions that guide the user in the analysis steps. Finally, the modular structure of Celldetective welcomes users with a partial need. 
+
+![Signal analysis](https://github.com/remyeltorro/celldetective/raw/main/docs/source/_static/signal-annotator.gif)
+
+
+# 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 3 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.
+
+Processing is performed frame by frame, therefore the memory requirement is extremely low. The main bottleneck is in the visualization of segmentation and tracking output. Whole stacks (typically 1-9 Gb) have to be loaded in memory at once to be viewed in napari. 
+
+## Software requirements
+
+The software was developed simulateously on Ubuntu 20.04 and Windows 11.
+It was tested on MacOS, but Tensorflow installation can require extra
+steps.
+
+-   Linux: Ubuntu 20.04.6 LTS (Focal Fossa)
+-   Windows: Windows 11 Home 23H2
+
+To use the software, you must install python, *e.g.* through
+[Anaconda](https://www.anaconda.com/download). Celldetective is routinely tested on both Ubuntu and Windows for Python versions 3.9, 3.10 and 3.11.
+
+# Installation
+
+## Stable release
+
+Celldetective requires a version of Python between 3.9 and 3.11 (included). If your Python version is older or more recent, consider using `conda` to create an environment as described below.
+
+With the proper Python version, Celldetective can be directly installed with `pip`:
+
+``` bash
+pip install celldetective
+```
+
+We recommend that you create an environment to use Celldetective, to protect your package versions and fix the Python version *e.g.*
+with `conda`:
+
+``` bash
+conda create -n celldetective python=3.11 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
+```
+
+For more installation options, please check the [documentation](https://celldetective.readthedocs.io/en/latest/get-started.html#installation).
+
+
+# Quick start
+
+You can launch the GUI by 1) opening a terminal and 2) typing the
+following:
+
+``` bash
+# conda activate celldetective
+python -m celldetective
+```
+
+For more information about how to get started, please check the [documentation](https://celldetective.readthedocs.io/en/latest/get-started.html#launching-the-gui).
+
+# 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.2.2.post2/celldetective/__main__.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python3
+import sys
+from PyQt5.QtWidgets import QApplication, QSplashScreen
+from PyQt5.QtGui import QPixmap
+from os import sep
+from celldetective.utils import get_software_location
+from time import time, sleep
+#os.environ['QT_DEBUG_PLUGINS'] = '1'
+
+if __name__ == "__main__":
+
+	splash=True
+	print('Loading the libraries...')
+
+	App = QApplication(sys.argv)
+	App.setStyle("Fusion")
+
+	if splash:
+		start = time()
+		splash_pix = QPixmap(sep.join([get_software_location(),'celldetective','icons','splash.png']))
+		splash = QSplashScreen(splash_pix)
+		splash.setMask(splash_pix.mask())
+		splash.show()
+		#App.processEvents(QEventLoop.AllEvents, 300)
+		while time() - start < 1:
+			sleep(0.001)
+			App.processEvents()
+
+	from PyQt5.QtWidgets import QFileDialog, QWidget, QVBoxLayout, QCheckBox, QHBoxLayout, QLabel, QLineEdit, QPushButton, QMessageBox, QMenu, QAction
+	from PyQt5.QtGui import QIcon, QDesktopServices, QIntValidator
+	from celldetective.gui.InitWindow import AppInitWindow
+
+	print('Libraries successfully loaded...')
+
+	window = AppInitWindow(App)
+
+	if splash:
+		splash.finish(window)
+
+	sys.exit(App.exec())

celldetective-1.2.2/celldetective/__main__.py → celldetective-1.2.2.post2/celldetective/gui/InitWindow.py

@@ -1,13 +1,22 @@
-#!/usr/bin/env python3
-import sys
-from PyQt5.QtWidgets import QApplication, QSplashScreen, QMainWindow
-from PyQt5.QtGui import QPixmap
-from os import sep
+from PyQt5.QtWidgets import QApplication, QMainWindow
 from celldetective.utils import get_software_location
-#from PyQt5.QtCore import QEventLoop
-from time import time, sleep
 import os
-#os.environ['QT_DEBUG_PLUGINS'] = '1'
+from PyQt5.QtWidgets import QFileDialog, QWidget, QVBoxLayout, QCheckBox, QHBoxLayout, QLabel, QLineEdit, QPushButton, QMessageBox, QMenu, QAction
+from PyQt5.QtCore import Qt, QUrl
+from PyQt5.QtGui import QIcon, QDesktopServices, QIntValidator
+from glob import glob
+from superqt.fonticon import icon
+from fonticon_mdi6 import MDI6
+import gc
+from celldetective.gui import Styles, ControlPanel, ConfigNewExperiment
+from celldetective.gui.gui_utils import center_window
+import subprocess
+import os
+from celldetective.gui.about import AboutWidget
+from celldetective.io import correct_annotation
+import psutil
+import subprocess
+import json
 
 class AppInitWindow(QMainWindow):
 
@@ -389,54 +398,3 @@ class AppInitWindow(QMainWindow):
 			if returnValue == QMessageBox.Ok:
 				self.experiment_path_selection.setText('')
 				return None
-
-if __name__ == "__main__":
-
-	# import ctypes
-	# myappid = 'mycompany.myproduct.subproduct.version' # arbitrary string
-	# ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(myappid)
-	splash=True
-	print('Loading the libraries...')
-
-	App = QApplication(sys.argv)
-	#App.setWindowIcon(QIcon(os.sep.join([get_software_location(),'celldetective','icons','mexican-hat.png'])))
-	App.setStyle("Fusion")
-
-	if splash:
-		start = time()
-		splash_pix = QPixmap(sep.join([get_software_location(),'celldetective','icons','splash.png']))
-		splash = QSplashScreen(splash_pix)
-		splash.setMask(splash_pix.mask())
-		splash.show()
-		#App.processEvents(QEventLoop.AllEvents, 300)
-		while time() - start < 1:
-			sleep(0.001)
-			App.processEvents()
-
-	from PyQt5.QtWidgets import QFileDialog, QWidget, QVBoxLayout, QCheckBox, QHBoxLayout, QLabel, QLineEdit, QPushButton, QMessageBox, QMenu, QAction
-	from PyQt5.QtCore import Qt, QUrl
-	from PyQt5.QtGui import QIcon, QDesktopServices, QIntValidator
-	from glob import glob
-	from superqt.fonticon import icon
-	from fonticon_mdi6 import MDI6
-	import gc
-	from celldetective.gui import Styles, ControlPanel, ConfigNewExperiment
-	from celldetective.gui.gui_utils import center_window
-	import subprocess
-	import os
-	from celldetective.gui.about import AboutWidget
-	from celldetective.io import correct_annotation
-	import psutil
-	import subprocess
-	import json
-	# import matplotlib
-	# matplotlib.rcParams.update({'font.size': 8})
-
-	print('Libraries successfully loaded...')
-
-	window = AppInitWindow(App)
-
-	if splash:
-		splash.finish(window)
-
-	sys.exit(App.exec())

celldetective-1.2.2.post2/celldetective/gui/help/DL-segmentation-strategy.json

@@ -0,0 +1,41 @@
+{
+  "Blob-like cell": {
+    "yes": {
+      "Fluorescence image": {
+        "yes": {
+          "Mixture of population": {
+            "yes": "train custom StarDist model",
+            "no": {
+              "Cells can be identified from a single channel": {
+                "yes": "Use StarDist versatile fluorescence",
+                "no" : "train custom StarDist model"
+              }
+            }
+          }
+        },
+        "no": "train custom StarDist model"
+      }
+    },
+    "no": {
+      "Mixture of population": {
+        "yes": "train custom cellpose model",
+        "no": {
+          "Heterogeneity in cell sizes": {
+            "yes": "train custom cellpose model",
+            "no": {
+              "Cells can be identified from at most 2-channels (one cyto-like and one nucleus-like)": {
+                "yes": {
+                  "cyto-like channel is brightfield": {
+                    "yes": "cellpose livecell",
+                    "no" : "cellpose cyto3"
+                  }
+                },
+                "no": "train custom cellpose model"
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

celldetective-1.2.2.post2/celldetective/gui/help/Threshold-vs-DL.json

@@ -0,0 +1,26 @@
+{
+  "Cell masks can be extracted from a single channel": {
+    "yes": {
+      "Rare cell-cell contacts": {
+        "yes": {
+          "Non-cell objects easily separable": {
+            "yes": {
+              "Background heterogeneities": {
+                "yes": {
+                  "Correction possible": {
+                    "yes": "Threshold pipeline",
+                    "no" : "DL"
+                  }
+                },
+                "no": "Threshold pipeline"
+              }
+            },
+            "no": "DL"
+          }
+        },
+        "no": "DL"
+      }
+    },
+    "no": "DL"
+  }
+}

celldetective-1.2.2.post2/celldetective/gui/help/cell-populations.json

@@ -0,0 +1,11 @@
+{
+  "Do you have more than one cell population of interest in the images?": {
+    "yes": {
+      "Do you have more than two cell populations of interest?": {
+        "yes": "The study of interactions between more than two cell populations is not currently supported in celldetective. Either study the cell populations two-by-two or group several populations into one (e.g. all effector-like cells vs all target-like cells). You can use the classification tools of celldetective to decompose the responses per cell population at a later stage.",
+        "no": "Identify the effector-like population (effects some changes on the other population) and the target-like population. If this characterization is ill-defined, choose a convention and stick to it. Beware, the available non-generalist Deep-learning models differ slightly for the two populations."
+      }
+    },
+    "no": "Pass your cell population as either EFFECTORS or TARGETS and stick with the convention. Beware, the available non-generalist Deep-learning model differs slightly for the two populations."
+  }
+}

celldetective-1.2.2.post2/celldetective/gui/help/exp-structure.json

@@ -0,0 +1,36 @@
+{
+  "Did you test different biological conditions?": {
+    "yes": {
+      "Did you image several positions (tiles) per biological condition?": {
+        "yes": {
+          "Did you record a time-lapse?": {
+            "yes": "Set N wells for the N biological conditions. Set M positions per well. Put the respective time-lapse stack in each generated position folder.",
+            "no": "Set N wells for the N biological conditions. Set a single position per well. Assemble all the tiles into a single stack per condition."
+          }
+        },
+        "no": {
+          "Did you record a time-lapse?": {
+            "yes": "Set N wells for the N biological conditions. Set a single position per well. Put the respective time-lapse stack in each generated position folder.",
+            "no": "There is not enough data to create a valid stack. Consider merging different experiments to generate several positions."
+          }
+        }
+      }
+    },
+    "no": {
+      "Did you image several positions (tiles)?": {
+        "yes": {
+          "Did you record a time-lapse?": {
+            "yes": "Set a single well. Set N positions. Put the respective time-lapse stack in each generated position folder.",
+            "no": "Set a single well. Set a single position. Assemble all the tiles into a single stack and put it in this position folder."
+          }
+        },
+        "no": {
+          "Did you record a time-lapse?": {
+            "yes": "Set a single well and a single position. Put the time-lapse stack in the generated position folder.",
+            "no": "There is not enough data to create a valid stack. Consider merging different experiments to generate several positions."
+          }
+        }
+      }
+    }
+  }
+}