celldetective 1.2.2.post1__py3-none-any.whl → 1.2.2.post2__py3-none-any.whl

celldetective/gui/help/track-postprocessing.json

@@ -0,0 +1,46 @@
+{
+  "Are you interested in transient cells (existing on the image for only a short amount of time)?": {
+    "yes": {
+      "Are all the cells of interest visible (and segmented) on the last frame of the movie?": {
+        "yes": {
+          "Are the cells quasi-static?": {
+            "yes": "Set a low minimum tracklength to keep transient tracks. If you are confident that all the cells of interest are visible and properly segmented on the last image, you may tick the option to 'remove the tracks that do not end at the end'. With quasi-static cells, you may tick the option to 'sustain the first position from the beginning of the movie', to start measuring intensities before cell arrival, giving a contrast on the signals. Tick the option to 'interpolate missed detections within tracks'.",
+            "no": "Set a low minimum tracklength to keep transient tracks. If you are confident that all the cells of interest are visible and properly segmented on the last image, you may tick the option to 'remove the tracks that do not end at the end'. Tick the option to 'interpolate missed detections within tracks'."
+          }
+        },
+        "no": {
+          "Are the cells quasi-static?": {
+            "yes": "Set a low minimum tracklength to keep transient tracks. Tick the option to 'interpolate missed detections within tracks'.",
+            "no": "Set a low minimum tracklength to keep transient tracks. Tick the option to 'interpolate missed detections within tracks'."
+          }
+        }
+      }
+    },
+    "no": {
+      "Are all the cells of interest visible (and segmented) on the first frame of the movie?": {
+        "yes": {
+          "Are the cells quasi-static?": {
+            "yes": "Set a high minimum tracklength to filter out most false positive tracks. If you are confident that all the cells of interest are visible and properly segmented on the first frame, you may tick the option to 'remove the tracks that do not start at the beginning'. With quasi-static cells, you may tick the option to 'sustain the last position until the end of the movie', to continue measuring intensities locally when cell track is interrupted. Tick the option to 'interpolate missed detections within tracks'.",
+            "no": "Set a high minimum tracklength to filter out most false positive tracks. If you are confident that all the cells of interest are visible and properly segmented on the first frame, you may tick the option to 'remove the tracks that do not start at the beginning'. Tick the option to 'interpolate missed detections within tracks'."
+          }
+        },
+        "no": {
+          "Are all the cells of interest visible (and segmented) on the last frame of the movie?": {
+            "yes": {
+              "Are the cells quasi-static?": {
+                "yes": "Set a moderate minimum tracklength to filter out false positive tracks. If you are confident that all the cells of interest are visible and properly segmented on the last image, you may tick the option to 'remove the tracks that do not end at the end'. With quasi-static cells, you may tick the option to 'sustain the first position from the beginning of the movie', to start measuring intensities before cell arrival, giving a contrast on the signals. Tick the option to 'interpolate missed detections within tracks'.",
+                "no": "Set a moderate minimum tracklength to filter out false positive tracks. Tick the option to 'interpolate missed detections within tracks'."
+              }
+            },
+            "no": {
+              "Are the cells quasi-static?": {
+                "yes": "Set a moderate minimum tracklength to filter out false positive tracks. Tick the option to 'interpolate missed detections within tracks'.",
+                "no": "Set a moderate minimum tracklength to filter out false positive tracks. Tick the option to 'interpolate missed detections within tracks'."
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

celldetective/gui/help/tracking.json

@@ -0,0 +1,11 @@
+{
+  "Is the time resolution high enough to unambiguously identify visually cells from one frame to the next?": {
+    "yes": {
+      "Did you successfully segment the vast majority of the cells of interest?": {
+        "yes": "You should be able to track your cells. Do not forget to tune the tracking parameters for your cell population for optimal performance.",
+        "no": "With a non-negligible segmentation miss rate, tracking can be much noisier. If possible, try to improve the segmentation by using a different model or performing manual corrections. Otherwise, consider skipping the tracking and signal analysis steps and measure directly the cells."
+      }
+    },
+    "no": "Skip the tracking and signal analysis steps. Proceed directly with measurements."
+  }
+}

celldetective/io.py

@@ -22,6 +22,7 @@ from celldetective.utils import _estimate_scale_factor, _extract_channel_indices
 from celldetective.utils import interpolate_nan
 import concurrent.futures
 from tifffile import imwrite
+from stardist import fill_label_holes
 
 def get_experiment_wells(experiment):
 	
@@ -1069,8 +1070,8 @@ def get_pair_signal_models_list(return_path=False):
 	available_models = glob(modelpath + f'*{os.sep}')
 	available_models = [m.replace('\\', '/').split('/')[-2] for m in available_models]
 	#for rm in repository_models:
-	#	if rm not in available_models:
-	#		available_models.append(rm)
+	#   if rm not in available_models:
+	#       available_models.append(rm)
 
 	if not return_path:
 		return available_models
@@ -1276,7 +1277,7 @@ def view_on_napari_btrack(data, properties, graph, stack=None, labels=None, rela
 	if data.shape[1]==4:
 		viewer.add_tracks(data, properties=properties, graph=graph, name='tracks')
 	else:
-		viewer.add_tracks(data[:,[0,1,3,4]], properties=properties, graph=graph, name='tracks')		
+		viewer.add_tracks(data[:,[0,1,3,4]], properties=properties, graph=graph, name='tracks')     
 	viewer.show(block=True)
 
 	if flush_memory:
@@ -1347,47 +1348,63 @@ def load_napari_data(position, prefix="Aligned", population="target", return_sta
 from skimage.measure import label
 
 
-def auto_correct_masks(masks):
+def auto_correct_masks(masks, bbox_factor = 1.75, min_area=9, fill_labels=False):
 
 	"""
-	Automatically corrects segmentation masks by splitting disconnected objects sharing the same label.
+	Correct segmentation masks to ensure consistency and remove anomalies.
 
-	This function examines each labeled object in the input masks and splits objects whose bounding box
-	area is significantly larger than their actual area, indicating potential merging of multiple objects.
-	It uses geometric properties to identify such cases and applies a relabeling to separate merged objects.
+	This function processes a labeled mask image to correct anomalies and reassign labels. 
+	It performs the following operations:
+	
+	1. Corrects negative mask values by taking their absolute values.
+	2. Identifies and corrects segmented objects with a bounding box area that is disproportionately 
+	   larger than the actual object area. This indicates potential segmentation errors where separate objects 
+	   share the same label.
+	3. Removes small objects that are considered noise (default threshold is an area of less than 9 pixels).
+	4. Reorders the labels so they are consecutive from 1 up to the number of remaining objects (to avoid encoding errors).
 
 	Parameters
 	----------
-	masks : ndarray
-		A 2D numpy array representing the segmentation masks, where each object is labeled with a unique integer.
+	masks : np.ndarray
+		A 2D array representing the segmented mask image with labeled regions. Each unique value 
+		in the array represents a different object or cell.
 
 	Returns
 	-------
-	ndarray
-		A 2D numpy array of the corrected segmentation masks with potentially merged objects separated and
-		relabeled.
+	clean_labels : np.ndarray
+		A corrected version of the input mask, with anomalies corrected, small objects removed, 
+		and labels reordered to be consecutive integers.
 
 	Notes
 	-----
-	- The function uses bounding box area and actual object area to identify potentially merged objects.
-	  Objects are considered potentially merged if their bounding box area is more than twice their actual area.
-	- Relabeling of objects is done sequentially, adding to the maximum label number found in the original
-	  masks to ensure new labels do not overlap with existing ones.
-	- This function relies on `skimage.measure.label` for relabeling and `skimage.measure.regionprops_table`
-	  for calculating object properties.
+	- This function is useful for post-processing segmentation outputs to ensure high-quality 
+	  object detection, particularly in applications such as cell segmentation in microscopy images.
+	- The function assumes that the input masks contain integer labels and that the background 
+	  is represented by 0.
 
+	Examples
+	--------
+	>>> masks = np.array([[0, 0, 1, 1], [0, 2, 2, 1], [0, 2, 0, 0]])
+	>>> corrected_masks = auto_correct_masks(masks)
+	>>> corrected_masks
+	array([[0, 0, 1, 1],
+		   [0, 2, 2, 1],
+		   [0, 2, 0, 0]])
 	"""
 
+	# Avoid negative mask values
+	masks[masks<0] = np.abs(masks[masks<0])
+	
 	props = pd.DataFrame(regionprops_table(masks, properties=('label', 'area', 'area_bbox')))
 	max_lbl = props['label'].max()
-	corrected_lbl = masks.copy().astype(int)
+	corrected_lbl = masks.copy() #.astype(int)
 
 	for cell in props['label'].unique():
 
 		bbox_area = props.loc[props['label'] == cell, 'area_bbox'].values
 		area = props.loc[props['label'] == cell, 'area'].values
 
-		if bbox_area > 1.75 * area:  # condition for anomaly
+		if bbox_area > bbox_factor * area:  # condition for anomaly
 
 			lbl = masks == cell
 			lbl = lbl.astype(int)
@@ -1400,7 +1417,27 @@ def auto_correct_masks(masks):
 
 		max_lbl = np.amax(corrected_lbl)
 
-	return corrected_lbl
+	# Second routine to eliminate objects too small
+	props2 = pd.DataFrame(regionprops_table(corrected_lbl, properties=('label', 'area', 'area_bbox')))
+	for cell in props2['label'].unique():
+		area = props2.loc[props2['label'] == cell, 'area'].values
+		lbl = corrected_lbl == cell
+		if area < min_area:
+			corrected_lbl[lbl] = 0
+
+	# Additionnal routine to reorder labels from 1 to number of cells
+	label_ids = np.unique(corrected_lbl)[1:]
+	clean_labels = corrected_lbl.copy()
+
+	for k,lbl in enumerate(label_ids):
+		clean_labels[corrected_lbl==lbl] = k+1
+
+	clean_labels = clean_labels.astype(int)
+
+	if fill_labels:
+		clean_labels = fill_label_holes(clean_labels)
+
+	return clean_labels
 
 
 
@@ -1529,7 +1566,7 @@ def control_segmentation_napari(position, prefix='Aligned', population="target",
 					multichannel.append(frame)
 				except:
 					pass
-			multichannel = np.array(multichannel)		
+			multichannel = np.array(multichannel)       
 			save_tiff_imagej_compatible(annotation_folder + f"{exp_name}_{position.split(os.sep)[-2]}_{str(t).zfill(4)}_labelled.tif", labels_layer, axes='YX')
 			save_tiff_imagej_compatible(annotation_folder + f"{exp_name}_{position.split(os.sep)[-2]}_{str(t).zfill(4)}.tif", multichannel, axes='CYX')
 			info = {"spatial_calibration": spatial_calibration, "channels": list(channel_names), 'cell_type': ct, 'antibody': ab, 'concentration': conc, 'pharmaceutical_agent': pa}

celldetective/utils.py

@@ -1961,7 +1961,7 @@ def noise(x, apply_probability=0.5, clip_option=False):
 
 
 def augmenter(x, y, flip=True, gauss_blur=True, noise_option=True, shift=True, 
-	channel_extinction=False, extinction_probability=0.1, clip=False, max_sigma_blur=4, 
+	channel_extinction=True, extinction_probability=0.1, clip=False, max_sigma_blur=4, 
 	apply_noise_probability=0.5, augment_probability=0.9):
 
 	"""
@@ -2023,6 +2023,7 @@ def augmenter(x, y, flip=True, gauss_blur=True, noise_option=True, shift=True,
 	>>> y = np.random.randint(2, size=(128, 128))  # Sample binary mask
 	>>> x_aug, y_aug = augmenter(x, y)
 	# The returned `x_aug` and `y_aug` are augmented versions of `x` and `y`.
+	
 	"""
 
 	r = random.random()
@@ -2042,9 +2043,9 @@ def augmenter(x, y, flip=True, gauss_blur=True, noise_option=True, shift=True,
 	  
 		if channel_extinction:
 			assert extinction_probability <= 1.,'The extinction probability must be a number between 0 and 1.'
-			for i in range(x.shape[-1]):
-				if np.random.random() > (1 - extinction_probability):
-					x[:,:,i] = 0.
+			channel_off = [np.random.random() < extinction_probability for i in range(x.shape[-1])]
+			if not np.all(channel_off):
+				x[:,:,np.array(channel_off, dtype=bool)] = 0.
 
 	return x, y
 

celldetective-1.2.2.post2.dist-info/METADATA

@@ -0,0 +1,214 @@
+Metadata-Version: 2.1
+Name: celldetective
+Version: 1.2.2.post2
+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
+Requires-Dist: jinja2
+Requires-Dist: ipykernel
+Requires-Dist: stardist
+Requires-Dist: cellpose<3
+Requires-Dist: scikit-learn
+Requires-Dist: btrack
+Requires-Dist: tensorflow~=2.15.0
+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
+Requires-Dist: superqt[cmap]
+Requires-Dist: matplotlib-scalebar
+Requires-Dist: numpy==1.26.4
+Requires-Dist: pytest
+Requires-Dist: pytest-qt
+
+# 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.post1.dist-info → celldetective-1.2.2.post2.dist-info}/RECORD

@@ -1,9 +1,9 @@
 celldetective/__init__.py,sha256=PH25g2_AZt7N5Jg1KB3YT9wFvfMr9lIb2WxYzmDqlX4,105
-celldetective/__main__.py,sha256=Ua_3mAlW5Y53ih3rkZrAeYfvOc8-Xz6sZosyUCFtTZI,14842
+celldetective/__main__.py,sha256=_H9B620ntENFx9RBvlV6ybxpvtHzCbv5NnIPmDBr9Z0,1127
 celldetective/events.py,sha256=D07LyzBerq4QkXKRhMj0ZChzNkqBrW45E9TgBtEa3tk,4735
 celldetective/extra_properties.py,sha256=8DkxTvVs7gASsnnGurVZ3_zt6uR0pvvJhBKO2LC6hGk,5118
 celldetective/filters.py,sha256=b0qKwHor1fvNA_dHovP17nQz8EsW5YlyhT2TJnayn08,3615
-celldetective/io.py,sha256=ZenCko4gdyJE0hwdTb2DWEXhUJRoF5FwAcpgZRdZtAo,85024
+celldetective/io.py,sha256=Jld2Nt1cRZyJxUz2wdX-izrd0mp4DJ2P_AMwCDOLUfs,86273
 celldetective/measure.py,sha256=7bfCUdLfJbGmFWWwhu_C9-l1buj_-We7izBaFWTe4ok,54910
 celldetective/neighborhood.py,sha256=GjF_fTmtcU8jq5XZT-DnDSp28VDTrsaHjIGJG7W2Ppk,52799
 celldetective/preprocessing.py,sha256=iV5or20s8XPJXQZDsWzis7OBaqzPDyAo_cwcDVDuX5A,38188
@@ -11,9 +11,10 @@ celldetective/relative_measurements.py,sha256=qPHC6gtUaICNGKh6Qfh8y6NA4OUJauGcaj
 celldetective/segmentation.py,sha256=H_6BH_RKaG6injUPZ3gQzQ112pMyzQ33u5GEpLE9dsQ,30426
 celldetective/signals.py,sha256=485axzJwE3xsSsN4AmBQlZ2at7uWu9QRg0XrUHvLBUE,120552
 celldetective/tracking.py,sha256=HGeOtfQ-nmpaea9_Q-sq2WcwZfdPXRH028JyFlt6eUs,37901
-celldetective/utils.py,sha256=UkRHPHWZixj8HOI8pc79jgsRjWvpCkF-2lfJ9JfddgA,86311
+celldetective/utils.py,sha256=yuPsRGsw2tYE1IApGulC83dtHOhsIhbts-46b6V83QA,86375
 celldetective/datasets/segmentation_annotations/blank,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 celldetective/datasets/signal_annotations/blank,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+celldetective/gui/InitWindow.py,sha256=M0v58BmOuZ05em2WSXHpDar3tp2AeS6pr44ZBtiYz-4,13683
 celldetective/gui/__init__.py,sha256=2_r2xfOj4_2xj0yBkCTIfzlF94AHKm-j6Pvpd7DddQc,989
 celldetective/gui/about.py,sha256=fed6nh-WwKy6bEbavy6L62P0CQB8VsOO0PajOjHsnFk,1694
 celldetective/gui/analyze_block.py,sha256=sat8RECEeZxlaconZZIxI0IrIjwJo121PcBXqJmA1-o,24756
@@ -41,6 +42,17 @@ celldetective/gui/survival_ui.py,sha256=tzvtI0eC0bgd7Lfm20HqU7rfCJ60gy9a_Sc9cZLS
 celldetective/gui/tableUI.py,sha256=9yJ4CjeNAQoYdHXfsVvD0qr_IdYWuQwIBhvfU3QoNtc,40602
 celldetective/gui/thresholds_gui.py,sha256=t1hTDdaJTJWHBt9vtRCE4B1TsVHhobQwCpKfntVgaQI,50510
 celldetective/gui/viewers.py,sha256=mCyE9DaUX2rGq65oYEwyEfNtEUPrHdoFNg2MRp1kXs4,27701
+celldetective/gui/help/DL-segmentation-strategy.json,sha256=59jVtn8pECbCqPQwJifgViVYTF1AxLQDIkNJMS7CJuk,1143
+celldetective/gui/help/Threshold-vs-DL.json,sha256=SELQk3qF8xcwmkX686Bqrr7i5KiXqN7r4jbUydCLRDU,603
+celldetective/gui/help/cell-populations.json,sha256=wP0ekhokb9oHE3XqOQrC5ARewNgOlv0GJrQeVQyMJzg,1075
+celldetective/gui/help/exp-structure.json,sha256=Q3z9-76VkQK77qxHRt2nUzE-nnM3yCKFXK3RMcjkeSI,1737
+celldetective/gui/help/feature-btrack.json,sha256=2uU5R8HAvXfqjTieTwl3VzUb8Y5UGO3Qsb3_6UoUbs0,589
+celldetective/gui/help/neighborhood.json,sha256=aSGMwK3ZeGGXcoAgvmJMs9RpUWXOdxws2ajJ4MdQBOM,1096
+celldetective/gui/help/prefilter-for-segmentation.json,sha256=1-hgr3H5Sr91bL-3o_dQKFibmxfTFuO6btkNhAS6MGY,610
+celldetective/gui/help/preprocessing.json,sha256=k4gWxCIE9CMXtBQl9W0ZrbQwhPF1QIxJdnDqtTiYN-c,5252
+celldetective/gui/help/propagate-classification.json,sha256=cnZpY7iVFZzbHy1uIxWwtL-hnUEBV4JibVbQG5Zu66o,1285
+celldetective/gui/help/track-postprocessing.json,sha256=VaGd8EEkA33OL-EI3NXWZ8yHeWWyUeImDF5yAjsVYGA,3990
+celldetective/gui/help/tracking.json,sha256=yIAoOToqCSQ_XF4gwEZCcyXcvQ3mROju263ZPDvlUyY,776
 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
@@ -74,13 +86,14 @@ 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_qt.py,sha256=eYqOoff-vfvZAZM6H_IY19IqK7qzyETcyj54f9T0bQA,3906
 tests/test_segmentation.py,sha256=_HB8CCq-Ci6amf0xAmDIUuwtBUU_EGpgqLvcvSHrGug,3427
 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.2.2.post1.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-celldetective-1.2.2.post1.dist-info/METADATA,sha256=TUIJ7f5xLHoW8DMdQYzA3TQjU6fIm83Xo8DHV-99-QA,12839
-celldetective-1.2.2.post1.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-celldetective-1.2.2.post1.dist-info/entry_points.txt,sha256=2NU6_EOByvPxqBbCvjwxlVlvnQreqZ3BKRCVIKEv3dg,62
-celldetective-1.2.2.post1.dist-info/top_level.txt,sha256=6rsIKKfGMKgud7HPuATcpq6EhdXwcg_yknBVWn9x4C4,20
-celldetective-1.2.2.post1.dist-info/RECORD,,
+celldetective-1.2.2.post2.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+celldetective-1.2.2.post2.dist-info/METADATA,sha256=WT8GY_72_xK3YgqdZ97FwTWh857CGSzzNPJLKBJRIhI,9923
+celldetective-1.2.2.post2.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+celldetective-1.2.2.post2.dist-info/entry_points.txt,sha256=2NU6_EOByvPxqBbCvjwxlVlvnQreqZ3BKRCVIKEv3dg,62
+celldetective-1.2.2.post2.dist-info/top_level.txt,sha256=6rsIKKfGMKgud7HPuATcpq6EhdXwcg_yknBVWn9x4C4,20
+celldetective-1.2.2.post2.dist-info/RECORD,,

tests/test_qt.py

@@ -0,0 +1,101 @@
+import pytest
+from PyQt5 import QtCore
+from celldetective.gui.InitWindow import AppInitWindow
+import time
+import os
+
+abs_path = os.sep.join([os.path.split(os.path.dirname(os.path.realpath(__file__)))[0]])
+print(abs_path)
+
+@pytest.fixture
+def app(qtbot):
+	test_app = AppInitWindow()
+	qtbot.addWidget(test_app)
+	return test_app
+
+# def test_launch_demo(app, qtbot):
+# 	app.experiment_path_selection.setText(abs_path + os.sep + 'examples/demo')
+# 	qtbot.mouseClick(app.validate_button, QtCore.Qt.LeftButton)
+
+# def test_preprocessing_panel(app, qtbot):
+
+# 	app.experiment_path_selection.setText(abs_path + os.sep + 'examples/demo')
+# 	qtbot.mouseClick(app.validate_button, QtCore.Qt.LeftButton)
+
+# 	qtbot.mouseClick(app.control_panel.PreprocessingPanel.collapse_btn, QtCore.Qt.LeftButton)
+# 	qtbot.mouseClick(app.control_panel.PreprocessingPanel.fit_correction_layout.add_correction_btn, QtCore.Qt.LeftButton)
+# 	qtbot.mouseClick(app.control_panel.PreprocessingPanel.collapse_btn, QtCore.Qt.LeftButton)
+
+def test_app(app, qtbot):
+
+	# Set an experiment folder and open
+	app.experiment_path_selection.setText(os.sep.join([abs_path,'examples','demo']))
+	qtbot.mouseClick(app.validate_button, QtCore.Qt.LeftButton)
+
+	# Set a position
+	app.control_panel.position_list.setCurrentIndex(1)
+	app.control_panel.update_position_options()
+
+	# View stacl
+	qtbot.mouseClick(app.control_panel.view_stack_btn, QtCore.Qt.LeftButton)
+	#qtbot.wait(1000)
+	app.control_panel.viewer.close()
+
+	# Expand process block
+	qtbot.mouseClick(app.control_panel.ProcessEffectors.collapse_btn, QtCore.Qt.LeftButton)
+
+	# Use Threshold Config Wizard
+	qtbot.mouseClick(app.control_panel.ProcessEffectors.upload_model_btn, QtCore.Qt.LeftButton)
+	qtbot.wait(1000)
+	qtbot.mouseClick(app.control_panel.ProcessEffectors.SegModelLoader.threshold_config_button, QtCore.Qt.LeftButton)
+	app.control_panel.ProcessEffectors.SegModelLoader.ThreshWizard.close()
+	app.control_panel.ProcessEffectors.SegModelLoader.close()
+
+	# Check segmentation with napari
+	#qtbot.mouseClick(app.control_panel.ProcessEffectors.check_seg_btn, QtCore.Qt.LeftButton)
+	# close napari?
+
+	# Train model
+	qtbot.mouseClick(app.control_panel.ProcessEffectors.train_btn, QtCore.Qt.LeftButton)
+	qtbot.wait(1000)
+	app.control_panel.ProcessEffectors.ConfigSegmentationTrain.close()
+
+	# Config tracking
+	qtbot.mouseClick(app.control_panel.ProcessEffectors.track_config_btn, QtCore.Qt.LeftButton)
+	qtbot.wait(1000)
+	app.control_panel.ProcessEffectors.ConfigTracking.close()
+
+	# Config measurements
+	qtbot.mouseClick(app.control_panel.ProcessEffectors.measurements_config_btn, QtCore.Qt.LeftButton)
+	qtbot.wait(1000)
+	app.control_panel.ProcessEffectors.ConfigMeasurements.close()
+
+	# Classifier widget
+	qtbot.mouseClick(app.control_panel.ProcessEffectors.classify_btn, QtCore.Qt.LeftButton)
+	qtbot.wait(1000)
+	app.control_panel.ProcessEffectors.ClassifierWidget.close()
+
+	# Config signal annotator
+	qtbot.mouseClick(app.control_panel.ProcessEffectors.config_signal_annotator_btn, QtCore.Qt.LeftButton)
+	qtbot.mouseClick(app.control_panel.ProcessEffectors.ConfigSignalAnnotator.rgb_btn, QtCore.Qt.LeftButton)
+	qtbot.wait(1000)
+	app.control_panel.ProcessEffectors.ConfigSignalAnnotator.close()
+
+	# Signal annotator widget
+	qtbot.mouseClick(app.control_panel.ProcessEffectors.check_signals_btn, QtCore.Qt.LeftButton)
+	qtbot.wait(1000)
+	app.control_panel.ProcessEffectors.SignalAnnotator.close()
+
+	# Table widget
+	qtbot.mouseClick(app.control_panel.ProcessEffectors.view_tab_btn, QtCore.Qt.LeftButton)
+	qtbot.wait(1000)
+	app.control_panel.ProcessEffectors.tab_ui.close()
+
+	#qtbot.mouseClick(app.control_panel.PreprocessingPanel.fit_correction_layout.add_correction_btn, QtCore.Qt.LeftButton)
+	qtbot.mouseClick(app.control_panel.ProcessEffectors.collapse_btn, QtCore.Qt.LeftButton)
+
+
+
+# def test_click(app, qtbot):
+# 	qtbot.mouseClick(app.new_exp_button, QtCore.Qt.LeftButton)
+#	qtbot.wait(10000)