celldetective 1.3.9.post5__tar.gz → 1.4.1__tar.gz

{celldetective-1.3.9.post5 → celldetective-1.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: celldetective
-Version: 1.3.9.post5
+Version: 1.4.1
 Summary: description
 Home-page: http://github.com/remyeltorro/celldetective
 Author: Rémy Torro
@@ -44,12 +44,17 @@ Requires-Dist: h5py
 Requires-Dist: cliffs_delta
 Requires-Dist: requests
 Requires-Dist: trackpy
+Requires-Dist: prettyprint
+Requires-Dist: pandas
+Requires-Dist: matplotlib
+Requires-Dist: prettytable
 Dynamic: author
 Dynamic: author-email
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: license
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: summary
 
@@ -183,26 +188,29 @@ For more information about how to get started, please check the [documentation](
 # 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.585250v3)
-paper (currently preprint):
+[Celldetective](https://elifesciences.org/reviewed-preprints/105302)
+paper (currently a reviewed preprint at eLife):
 
 ``` raw
-@article {Torro2024.03.15.585250,
-    author = {Torro, R{\'e}my and D{\'\i}az-Bello, Beatriz and Arawi, Dalia El and Dervanova, Ksenija and Ammer, Lorna and Dupuy, Florian and Chames, Patrick and Sengupta, Kheya and Limozin, Laurent},
-    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 challenge in bioimaging for immunology and immunotherapy research lies in analyzing multimodal and multidimensional data that capture dynamic interactions between diverse cell populations. Here, we introduce Celldetective, an open-source Python-based software designed for high-performance, end-to-end analysis of image-based in vitro immune and immunotherapy assays. Purpose-built for multicondition, 2D multichannel time-lapse microscopy of mixed cell populations, Celldetective is optimized for the needs of immunology assays. The software seamlessly integrates AI-based segmentation, Bayesian tracking, and automated single-cell event detection, all within an intuitive graphical interface that supports interactive visualization, annotation, and training capabilities. We demonstrate its utility with original data on immune effector cell interactions with an activating surface, mediated by bispecific antibodies, and further showcase its potential for analyzing extensive sets of pairwise interactions in antibody-dependent cell cytotoxicity events.Competing Interest StatementThe authors have declared no competing interest.},
-    URL = {https://www.biorxiv.org/content/early/2024/11/13/2024.03.15.585250},
-    eprint = {https://www.biorxiv.org/content/early/2024/11/13/2024.03.15.585250.full.pdf},
-    journal = {bioRxiv}
+@article{torroCelldetectiveAIenhancedImage2025,
+  title = {Celldetective: An {{AI-enhanced}} Image Analysis Tool for Unraveling Dynamic Cell Interactions},
+  shorttitle = {Celldetective},
+  author = {Torro, Rémy and Díaz-Bello, Beatriz and Arawi, Dalia El and Dervanova, Ksenija and Ammer, Lorna and Dupuy, Florian and Chames, Patrick and Sengupta, Kheya and Limozin, Laurent},
+  date = {2025-03-10},
+  journaltitle = {eLife},
+  volume = {14},
+  publisher = {eLife Sciences Publications Limited},
+  doi = {10.7554/eLife.105302.1},
+  url = {https://elifesciences.org/reviewed-preprints/105302},
+  urldate = {2025-03-20},
+  abstract = {A current challenge in bioimaging for immunology and immunotherapy research lies in analyzing multimodal and multidimensional data that capture dynamic interactions between diverse cell populations. Here, we introduce Celldetective, an open-source Python-based software designed for high-performance, end-to-end analysis of image-based in vitro immune and immunotherapy assays. Purpose-built for multicondition, 2D multichannel time-lapse microscopy of mixed cell populations, Celldetective is optimized for the needs of immunology assays. The software seamlessly integrates AI-based segmentation, Bayesian tracking, and automated single-cell event detection, all within an intuitive graphical interface that supports interactive visualization, annotation, and training capabilities. We demonstrate its utility with original data on immune effector cell interactions with an activating surface, mediated by bispecific antibodies, and further showcase its potential for analyzing extensive sets of pairwise interactions in antibody-dependent cell cytotoxicity events.},
+  langid = {english},
+  file = {/home/torro/Zotero/storage/VFYBBMQF/Torro et al. - 2025 - Celldetective an AI-enhanced image analysis tool .pdf;/home/torro/Zotero/storage/UGMCKKST/105302.html}
 }
 ```
 
 Make sure you to cite the papers of any segmentation model (StarDist,
-Cellpose) or tracker (bTrack) you used through Celldetective.
+Cellpose) or tracker (bTrack, TrackPy) you used through Celldetective.
 
 # Bibliography
 

{celldetective-1.3.9.post5 → celldetective-1.4.1}/README.md

@@ -128,26 +128,29 @@ For more information about how to get started, please check the [documentation](
 # 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.585250v3)
-paper (currently preprint):
+[Celldetective](https://elifesciences.org/reviewed-preprints/105302)
+paper (currently a reviewed preprint at eLife):
 
 ``` raw
-@article {Torro2024.03.15.585250,
-    author = {Torro, R{\'e}my and D{\'\i}az-Bello, Beatriz and Arawi, Dalia El and Dervanova, Ksenija and Ammer, Lorna and Dupuy, Florian and Chames, Patrick and Sengupta, Kheya and Limozin, Laurent},
-    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 challenge in bioimaging for immunology and immunotherapy research lies in analyzing multimodal and multidimensional data that capture dynamic interactions between diverse cell populations. Here, we introduce Celldetective, an open-source Python-based software designed for high-performance, end-to-end analysis of image-based in vitro immune and immunotherapy assays. Purpose-built for multicondition, 2D multichannel time-lapse microscopy of mixed cell populations, Celldetective is optimized for the needs of immunology assays. The software seamlessly integrates AI-based segmentation, Bayesian tracking, and automated single-cell event detection, all within an intuitive graphical interface that supports interactive visualization, annotation, and training capabilities. We demonstrate its utility with original data on immune effector cell interactions with an activating surface, mediated by bispecific antibodies, and further showcase its potential for analyzing extensive sets of pairwise interactions in antibody-dependent cell cytotoxicity events.Competing Interest StatementThe authors have declared no competing interest.},
-    URL = {https://www.biorxiv.org/content/early/2024/11/13/2024.03.15.585250},
-    eprint = {https://www.biorxiv.org/content/early/2024/11/13/2024.03.15.585250.full.pdf},
-    journal = {bioRxiv}
+@article{torroCelldetectiveAIenhancedImage2025,
+  title = {Celldetective: An {{AI-enhanced}} Image Analysis Tool for Unraveling Dynamic Cell Interactions},
+  shorttitle = {Celldetective},
+  author = {Torro, Rémy and Díaz-Bello, Beatriz and Arawi, Dalia El and Dervanova, Ksenija and Ammer, Lorna and Dupuy, Florian and Chames, Patrick and Sengupta, Kheya and Limozin, Laurent},
+  date = {2025-03-10},
+  journaltitle = {eLife},
+  volume = {14},
+  publisher = {eLife Sciences Publications Limited},
+  doi = {10.7554/eLife.105302.1},
+  url = {https://elifesciences.org/reviewed-preprints/105302},
+  urldate = {2025-03-20},
+  abstract = {A current challenge in bioimaging for immunology and immunotherapy research lies in analyzing multimodal and multidimensional data that capture dynamic interactions between diverse cell populations. Here, we introduce Celldetective, an open-source Python-based software designed for high-performance, end-to-end analysis of image-based in vitro immune and immunotherapy assays. Purpose-built for multicondition, 2D multichannel time-lapse microscopy of mixed cell populations, Celldetective is optimized for the needs of immunology assays. The software seamlessly integrates AI-based segmentation, Bayesian tracking, and automated single-cell event detection, all within an intuitive graphical interface that supports interactive visualization, annotation, and training capabilities. We demonstrate its utility with original data on immune effector cell interactions with an activating surface, mediated by bispecific antibodies, and further showcase its potential for analyzing extensive sets of pairwise interactions in antibody-dependent cell cytotoxicity events.},
+  langid = {english},
+  file = {/home/torro/Zotero/storage/VFYBBMQF/Torro et al. - 2025 - Celldetective an AI-enhanced image analysis tool .pdf;/home/torro/Zotero/storage/UGMCKKST/105302.html}
 }
 ```
 
 Make sure you to cite the papers of any segmentation model (StarDist,
-Cellpose) or tracker (bTrack) you used through Celldetective.
+Cellpose) or tracker (bTrack, TrackPy) you used through Celldetective.
 
 # Bibliography
 

celldetective-1.4.1/celldetective/__init__.py

@@ -0,0 +1 @@
+from ._version import __version__

celldetective-1.4.1/celldetective/_version.py

@@ -0,0 +1 @@
+__version__ = "1.4.1"

{celldetective-1.3.9.post5 → celldetective-1.4.1}/celldetective/events.py

@@ -52,7 +52,7 @@ def switch_to_events(classes, event_times, max_times, origin_times=None, left_ce
 	>>> event_times = [5, 10, 15]
 	>>> max_times = [20, 20, 20]
 	>>> origin_times = [0, 0, 5]
-	>>> events, survival_times = switch_to_events_v2(classes, event_times, max_times, origin_times, FrameToMin=0.5)
+	>>> events, survival_times = switch_to_events(classes, event_times, max_times, origin_times, FrameToMin=0.5)
 	# This would process the events considering left censorship and convert survival times to minutes.
 	
 	"""
@@ -189,6 +189,7 @@ def compute_survival(df, class_of_interest, t_event, t_reference=None, FrameToMi
 	assert class_of_interest in cols,"The requested class cannot be found in the dataframe..."
 	assert t_event in cols,"The event time cannot be found in the dataframe..."
 	left_censored = False
+	first_detections = None
 
 	if not pairs:
 		groupby_cols = ['position','TRACK_ID']
@@ -209,10 +210,7 @@ def compute_survival(df, class_of_interest, t_event, t_reference=None, FrameToMi
 		assert t_reference in cols,"The reference time cannot be found in the dataframe..."
 		first_detections = df.groupby(groupby_cols)[t_reference].max().values
 	
-
-	print(f"{classes=} {event_times=} {max_times=} {first_detections=}")
 	events, survival_times = switch_to_events(classes, event_times, max_times, origin_times=first_detections, left_censored=left_censored, FrameToMin=FrameToMin, cut_observation_time=cut_observation_time)
-	print(f"{events=} {survival_times=}")
 
 	ks = KaplanMeierFitter()
 	if len(events)>0:

celldetective-1.4.1/celldetective/exceptions.py

@@ -0,0 +1,11 @@
+class QueryError(Exception):
+    """Base class for query-related errors."""
+
+class EmptyQueryError(QueryError):
+    pass
+
+class MissingColumnsError(QueryError):
+    def __init__(self, missing_cols):
+        msg = f"The following columns are missing from the DataFrame: {missing_cols}"
+        super().__init__(msg)
+        self.missing_cols = missing_cols

{celldetective-1.3.9.post5 → celldetective-1.4.1}/celldetective/extra_properties.py

@@ -245,6 +245,138 @@ def fraction_of_area_dark_intensity(regionmask, intensity_image, target_channel=
 	return float(np.sum(subregion)) / float(np.sum(regionmask))
 
 
+def area_dark_intensity_nintyfive(regionmask, intensity_image, target_channel='adhesion_channel', fill_holes=True): #, target_channel='adhesion_channel'
+	
+	subregion = (intensity_image < 0.95)*regionmask # under one, under 0.8, under 0.6, whatever value!
+	if fill_holes:
+		subregion = skm.label(subregion, connectivity=2, background=0)
+		subregion = fill_label_holes(subregion)
+		subregion[subregion>0] = 1
+	
+	return float(np.sum(subregion))
+
+def area_dark_intensity_ninty(regionmask, intensity_image, target_channel='adhesion_channel', fill_holes=True): #, target_channel='adhesion_channel'
+	
+	subregion = (intensity_image < 0.90)*regionmask # under one, under 0.8, under 0.6, whatever value!
+	if fill_holes:
+		subregion = skm.label(subregion, connectivity=2, background=0)
+		subregion = fill_label_holes(subregion)
+		subregion[subregion>0] = 1
+	
+	return float(np.sum(subregion))
+
+def mean_dark_intensity_nintyfive(regionmask, intensity_image, target_channel='adhesion_channel', fill_holes=True):
+    """
+    Calculate the mean intensity in a dark subregion below 95, handling NaN values.
+    
+    """
+    subregion = (intensity_image < 0.95) * regionmask
+    
+    if fill_holes:
+        subregion = skm.label(subregion, connectivity=2, background=0)
+        subregion = fill_label_holes(subregion)
+        subregion[subregion > 0] = 1
+    
+    
+    masked_intensity = intensity_image[subregion == 1]
+    
+    return float(np.nanmean(masked_intensity))
+
+
+def mean_dark_intensity_nintyfive_fillhole_false(regionmask, intensity_image, target_channel='adhesion_channel'):
+    """
+    Calculate the mean intensity in a dark subregion below 95, handling NaN values.
+    """
+    subregion = (intensity_image < 0.95) * regionmask  # Select dark regions within the mask
+
+    masked_intensity = intensity_image[subregion == 1]  # Extract pixel values from the selected region
+
+    return float(np.nanmean(masked_intensity))  # Compute mean, ignoring NaNs
+
+def mean_dark_intensity_ninty_fillhole_false(regionmask, intensity_image, target_channel='adhesion_channel'):
+    """
+    Calculate the mean intensity in a dark subregion, handling NaN values.
+    """
+    subregion = (intensity_image < 0.90) * regionmask  # Select dark regions within the mask
+
+    masked_intensity = intensity_image[subregion == 1]  # Extract pixel values from the selected region
+
+    return float(np.nanmean(masked_intensity))  # Compute mean, ignoring NaNs
+
+
+def mean_dark_intensity_ninty(regionmask, intensity_image, target_channel='adhesion_channel', fill_holes=True):
+    """
+    Calculate the mean intensity in a dark subregion below 90, handling NaN values.
+    
+    """
+    subregion = (intensity_image < 0.90) * regionmask
+    
+    if fill_holes:
+        subregion = skm.label(subregion, connectivity=2, background=0)
+        subregion = fill_label_holes(subregion)
+        subregion[subregion > 0] = 1
+    
+    
+    masked_intensity = intensity_image[subregion == 1]
+    
+    return float(np.nanmean(masked_intensity))
+
+def mean_dark_intensity_eight_five(regionmask, intensity_image, target_channel='adhesion_channel', fill_holes=True):
+    """
+    Calculate the mean intensity in a dark subregion below 85, handling NaN values.
+    
+    """
+    subregion = (intensity_image < 0.85) * regionmask
+    
+    if fill_holes:
+        subregion = skm.label(subregion, connectivity=2, background=0)
+        subregion = fill_label_holes(subregion)
+        subregion[subregion > 0] = 1
+    
+    
+    masked_intensity = intensity_image[subregion == 1]
+    
+    return float(np.nanmean(masked_intensity))
+
+
+def mean_dark_intensity_eight_five_fillhole_false(regionmask, intensity_image, target_channel='adhesion_channel'):
+
+    subregion = (intensity_image < 0.85) * regionmask  # Select dark regions within the mask
+
+    masked_intensity = intensity_image[subregion == 1]  # Extract pixel values from the selected region
+
+    return float(np.nanmean(masked_intensity))  # Compute mean, ignoring NaNs
+
+def percentile_zero_one_dark_intensity_ninty(regionmask, intensity_image, target_channel='adhesion_channel'):
+
+    subregion = (intensity_image < 0.95) * regionmask
+    return float(np.nanpercentile(intensity_image[subregion],0.1))
+
+
+def percentile_one_dark_intensity_ninty(regionmask, intensity_image, target_channel='adhesion_channel'):
+
+    subregion = (intensity_image < 0.95) * regionmask
+    return float(np.nanpercentile(intensity_image[subregion],1))
+
+
+def percentile_five_dark_intensity_ninty(regionmask, intensity_image, target_channel='adhesion_channel'):
+
+    subregion = (intensity_image < 0.95) * regionmask
+    return float(np.nanpercentile(intensity_image[subregion],5))
+
+
+def percentile_ten_dark_intensity_ninty(regionmask, intensity_image, target_channel='adhesion_channel'):
+
+    subregion = (intensity_image < 0.95) * regionmask
+    return float(np.nanpercentile(intensity_image[subregion],10))
+
+
+def percentile_ninty_five_dark_intensity_ninty(regionmask, intensity_image, target_channel='adhesion_channel'):
+
+    subregion = (intensity_image < 0.95) * regionmask
+    return float(np.nanpercentile(intensity_image[subregion],95))
+   
+
 def intensity_percentile_ninety_nine(regionmask, intensity_image):
 	return np.nanpercentile(intensity_image[regionmask],99)
 

{celldetective-1.3.9.post5 → celldetective-1.4.1}/celldetective/filters.py

@@ -1,4 +1,5 @@
-from skimage.filters import difference_of_gaussians, threshold_otsu, threshold_local, threshold_niblack, threshold_sauvola
+from skimage.filters import difference_of_gaussians, threshold_multiotsu, threshold_otsu, threshold_local, \
+	threshold_niblack, threshold_sauvola
 from celldetective.utils import interpolate_nan
 import scipy.ndimage as snd
 import numpy as np
@@ -102,6 +103,11 @@ def otsu_filter(img, *kwargs):
 	binary = img >= thresh
 	return binary.astype(float)
 
+def multiotsu_filter(img, classes=3, *kwargs):
+	thresholds = threshold_multiotsu(img, classes=classes)
+	regions = np.digitize(img, bins=thresholds)
+	return regions.astype(float)
+	
 def local_filter(img, *kwargs):
 	thresh = threshold_local(img.astype(float), *kwargs)
 	binary = img >= thresh

{celldetective-1.3.9.post5 → celldetective-1.4.1}/celldetective/gui/InitWindow.py

@@ -1,29 +1,27 @@
+import gc
+import json
 import os
-
-from PyQt5.QtWidgets import QApplication, QMainWindow
-from PyQt5.QtWidgets import QFileDialog, QDialog, 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
-
-from celldetective.gui.about import AboutWidget
-from celldetective.io import correct_annotation
-from celldetective.utils import download_zenodo_file
-from celldetective.gui.gui_utils import center_window
-from celldetective.gui import Styles, ControlPanel, ConfigNewExperiment
+from subprocess import Popen, check_output
 
-import gc
-from subprocess import check_output, Popen
+from PyQt5.QtCore import QUrl, Qt
+from PyQt5.QtGui import QDesktopServices, QIntValidator
+from PyQt5.QtWidgets import QAction, QApplication, QCheckBox, QDialog, QFileDialog, QHBoxLayout, QLabel, QLineEdit, \
+	QMenu, QPushButton, QVBoxLayout
+from fonticon_mdi6 import MDI6
 from psutil import cpu_count
-import json
+from superqt.fonticon import icon
 
+from celldetective.gui import ConfigNewExperiment, ControlPanel, CelldetectiveMainWindow, CelldetectiveWidget
+from celldetective.gui.about import AboutWidget
+from celldetective.gui.gui_utils import center_window, generic_message
 from celldetective.gui.processes.downloader import DownloadProcess
 from celldetective.gui.workers import ProgressWindow
+from celldetective.io import correct_annotation, extract_well_name_and_number
+from celldetective.utils import download_zenodo_file, pretty_table
 
-class AppInitWindow(QMainWindow, Styles):
+
+class AppInitWindow(CelldetectiveMainWindow):
 
 	"""
 	Initial window to set the experiment folder or create a new one.
@@ -36,7 +34,7 @@ class AppInitWindow(QMainWindow, Styles):
 		self.parent_window = parent_window
 		self.setWindowTitle("celldetective")
 
-		self.n_threads = min([1,cpu_count()])
+		self.n_threads = min([1, cpu_count()])
 
 		try:
 			check_output('nvidia-smi')
@@ -48,7 +46,6 @@ class AppInitWindow(QMainWindow, Styles):
 
 		self.soft_path = software_location
 		self.onlyInt = QIntValidator()
-		self.setWindowIcon(QIcon(os.sep.join([self.soft_path,'celldetective','icons','logo.png'])))
 
 		self._createActions()
 		self._createMenuBar()
@@ -58,9 +55,9 @@ class AppInitWindow(QMainWindow, Styles):
 		self.geometry = self.screen.availableGeometry()
 		self.screen_width, self.screen_height = self.geometry.getRect()[-2:]
 
-		central_widget = QWidget()
+		central_widget = CelldetectiveWidget()
 		self.vertical_layout = QVBoxLayout(central_widget)
-		self.vertical_layout.setContentsMargins(15,15,15,15)
+		self.vertical_layout.setContentsMargins(15, 15, 15, 15)
 		self.vertical_layout.addWidget(QLabel("Experiment folder:"))
 		self.create_locate_exp_hbox()
 		self.create_buttons_hbox()
@@ -79,14 +76,17 @@ class AppInitWindow(QMainWindow, Styles):
 	def create_locate_exp_hbox(self):
 
 		self.locate_exp_layout = QHBoxLayout()
-		self.locate_exp_layout.setContentsMargins(0,5,0,0)
+		self.locate_exp_layout.setContentsMargins(0, 5, 0, 0)
 		self.experiment_path_selection = QLineEdit()
 		self.experiment_path_selection.setAlignment(Qt.AlignLeft)	
 		self.experiment_path_selection.setEnabled(True)
 		self.experiment_path_selection.setDragEnabled(True)
 		self.experiment_path_selection.setFixedWidth(430)
 		self.experiment_path_selection.textChanged[str].connect(self.check_path_and_enable_opening)
-		self.foldername = os.getcwd()
+		try:
+			self.foldername = os.getcwd()
+		except FileNotFoundError as e:
+			self.foldername = ""
 		self.experiment_path_selection.setPlaceholderText('/path/to/experiment/folder/')
 		self.locate_exp_layout.addWidget(self.experiment_path_selection, 90)
 
@@ -266,7 +266,7 @@ class AppInitWindow(QMainWindow, Styles):
 		
 		print('setting memory and threads')
 
-		self.ThreadsWidget = QWidget()
+		self.ThreadsWidget = CelldetectiveWidget()
 		self.ThreadsWidget.setWindowTitle("Threads")
 		layout = QVBoxLayout()
 		self.ThreadsWidget.setLayout(layout)
@@ -382,24 +382,21 @@ class AppInitWindow(QMainWindow, Styles):
 		wells = glob(os.sep.join([self.exp_dir,"W*"]))
 		self.number_of_wells = len(wells)
 		if self.number_of_wells==0:
-			msgBox = QMessageBox()
-			msgBox.setIcon(QMessageBox.Critical)
-			msgBox.setText("No well was found in the experiment folder.\nPlease respect the W*/ nomenclature...")
-			msgBox.setWindowTitle("Error")
-			msgBox.setStandardButtons(QMessageBox.Ok)
-			returnValue = msgBox.exec()
-			if returnValue == QMessageBox.Ok:
-				return None
+			generic_message("No well was found in the experiment folder.\nPlease respect the W*/ nomenclature...", msg_type="critical")
+			return None
 		else:
 			if self.number_of_wells==1:
 				print(f"Found {self.number_of_wells} well...")
 			elif self.number_of_wells>1:
 				print(f"Found {self.number_of_wells} wells...")
-			number_pos = []
+
+			number_pos = {}
 			for w in wells:
-				position_folders = glob(os.sep.join([w,f"{w.split(os.sep)[-1][1]}*", os.sep]))
-				number_pos.append(len(position_folders))
-			print(f"Number of positions per well: {number_pos}")
+				well_name, well_nbr = extract_well_name_and_number(w)
+				position_folders = glob(os.sep.join([w,f"{well_nbr}*", os.sep]))
+				number_pos.update({well_name: len(position_folders)})
+			print(f"Number of positions per well:")
+			pretty_table(number_pos)
 			
 			with open(os.sep.join([self.soft_path,'celldetective','recent.txt']), 'a+') as f:
 				f.write(self.exp_dir+'\n')
@@ -423,12 +420,6 @@ class AppInitWindow(QMainWindow, Styles):
 		else:
 			return None
 		if not os.path.exists(os.sep.join([self.foldername,"config.ini"])):
-			msgBox = QMessageBox()
-			msgBox.setIcon(QMessageBox.Warning)
-			msgBox.setText("No configuration can be found in the selected folder...")
-			msgBox.setWindowTitle("Warning")
-			msgBox.setStandardButtons(QMessageBox.Ok)
-			returnValue = msgBox.exec()
-			if returnValue == QMessageBox.Ok:
-				self.experiment_path_selection.setText('')
-				return None
+			generic_message("No configuration can be found in the selected folder...", msg_type="warning")
+			self.experiment_path_selection.setText('')
+			return None

{celldetective-1.3.9.post5 → celldetective-1.4.1}/celldetective/gui/__init__.py

@@ -1,21 +1,15 @@
 from .styles import Styles
-from .btrack_options import ConfigTracking
+from .base_components import CelldetectiveWidget, CelldetectiveMainWindow
 from .json_readers import ConfigEditor
 from .tableUI import TableUI
-from .measurement_options import ConfigMeasurements
-from .neighborhood_options import ConfigNeighborhoods
 from .classifier_widget import ClassifierWidget
 from .survival_ui import ConfigSurvival
 from .plot_signals_ui import ConfigSignalPlot
-from .signal_annotator_options import ConfigSignalAnnotator
-from .signal_annotator import SignalAnnotator
-from .signal_annotator2 import SignalAnnotator2
-from .retrain_signal_model_options import ConfigSignalModelTraining
-from .retrain_segmentation_model_options import ConfigSegmentationModelTraining
+from .event_annotator import EventAnnotator
+from .pair_event_annotator import PairEventAnnotator
 from .thresholds_gui import ThresholdConfigWizard
 from .seg_model_loader import SegmentationModelLoader
 from .process_block import ProcessPanel, NeighPanel, PreprocessingPanel
 from .analyze_block import AnalysisPanel
 from .control_panel import ControlPanel
 from .configure_new_exp import ConfigNewExperiment
-

{celldetective-1.3.9.post5 → celldetective-1.4.1}/celldetective/gui/about.py

@@ -1,44 +1,48 @@
-from PyQt5.QtWidgets import QWidget, QVBoxLayout, QLabel
+from PyQt5.QtWidgets import QVBoxLayout, QLabel
 from PyQt5.QtGui import QPixmap
 from PyQt5.QtCore import Qt
+
+from celldetective.gui import CelldetectiveWidget
 from celldetective.utils import get_software_location
 import os
 from celldetective.gui.gui_utils import center_window
 from celldetective._version import __version__
 
-class AboutWidget(QWidget):
 
+class AboutWidget(CelldetectiveWidget):
+	
 	def __init__(self):
-
 		super().__init__()
 		self.setWindowTitle("About celldetective")
-		self.setMinimumWidth(300)
+		self.setMaximumWidth(320)
 		center_window(self)
-		logo = QPixmap(os.sep.join([get_software_location(),'celldetective','icons','logo.png']))
-
+		
+		logo = QPixmap(self.celldetective_logo_path)
+		
 		# Create the layout
 		layout = QVBoxLayout(self)
 		img_label = QLabel('')
 		img_label.setPixmap(logo)
 		layout.addWidget(img_label, alignment=Qt.AlignCenter)
-
+		
 		self.soft_name = QLabel('celldetective')
 		self.soft_name.setStyleSheet("""font-weight: bold;
 										font-size: 18px;
 									""")
 		layout.addWidget(self.soft_name, alignment=Qt.AlignCenter)
-
-		self.version_lbl = QLabel(f"Version {__version__} <a href=\"https://github.com/remyeltorro/celldetective/releases\">(release notes)</a>")
+		
+		self.version_lbl = QLabel(f"Version {__version__} <a href=\"https://github.com/celldetective/celldetective"
+								  f"/releases\">(release notes)</a>")
 		self.version_lbl.setOpenExternalLinks(True)
 		layout.addWidget(self.version_lbl, alignment=Qt.AlignCenter)
-
+		
 		self.lab_lbl = QLabel("Developed at Laboratoire Adhésion et Inflammation (LAI) INSERM U1067 CNRS UMR 7333")
 		self.lab_lbl.setWordWrap(True)
 		layout.addWidget(self.lab_lbl, alignment=Qt.AlignCenter)
-
-		self.centuri_mention = QLabel("The project leading to this publication has received funding from France 2030, the French Government program managed by the French National Research Agency (ANR-16-CONV-0001) and from Excellence Initiative of Aix-Marseille University - A*MIDEX')")
+		
+		self.centuri_mention = QLabel(
+			"The project leading to this publication has received funding from France 2030, the French Government "
+			"program managed by the French National Research Agency (ANR-16-CONV-0001) and from Excellence Initiative "
+			"of Aix-Marseille University - A*MIDEX')")
 		self.centuri_mention.setWordWrap(True)
 		layout.addWidget(self.centuri_mention, alignment=Qt.AlignCenter)
-
-
-