celldetective 1.3.9.post4__py3-none-any.whl → 1.4.0__py3-none-any.whl

celldetective/__init__.py

@@ -1,4 +1 @@
 from ._version import __version__
-#from .tracking import track, clean_trajectories
-#from .measure import contour_of_instance_segmentation
-

celldetective/_version.py

@@ -1 +1 @@
-__version__ = "1.3.9.post4"
+__version__ = "1.4.0"

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/extra_properties.py

@@ -1,23 +1,45 @@
 """
-Copyright © 2022 Laboratoire Adhesion et Inflammation, Authored by Remy Torro, 
-Ksenija Dervanova.
-
-Add extra properties to measure using regionprops (measure_features). 
-The functions must take "regionmask" as the first argument, corresponding
-to the binary mask of each cell of interest generated by regionprops 
-and an optional "intensity_image" second argument, i.e. the associated 
-multichannel image crop. The measurement will be named after the function
-name. If a function function() has several outputs (e.g. due to a multichannel image),
-they will be labelled with an index as function-0, function-1... A routine 
-automatically replacements keywords "intensity-0", "intensity-1" and so on,
-with the actual name of the intensity channel (e.g. "intensity-0" -> 
-"brightfield_channel"). Due to this indexing behavior, avoid using digits 
-in the function names and prefer text instead: "intensity-99()" --> 
-"intensity-ninety-nine()".
-
-New functions appear automatically in the ConfigMeasurements widget of the
-GUI.
-
+Copyright © 2022 Laboratoire Adhesion et Inflammation  
+Authored by R. Torro, K. Dervanova, L. Limozin
+
+This module defines additional measurement functions for use with `regionprops` via `measure_features`.  
+
+Usage
+-----
+Each function must follow these conventions:
+
+- **First argument:** `regionmask` (numpy array)  
+  A binary mask of the cell of interest, as provided by `regionprops`.
+- **Optional second argument:** `intensity_image` (numpy array)  
+  An image crop/bounding box associated with the cell (single-channel at a time).  
+
+Unlike the default `regionprops` from `scikit-image`, the cell image is **not** masked with zeros outside its boundaries.  
+This allows thresholding techniques to be used in measurements.  
+
+Naming Conventions & Indexing
+------------------------------
+- The measurement name is derived from the function name.  
+- If a function returns multiple values (e.g., for multichannel images), outputs are labeled sequentially:  
+  `function-0`, `function-1`, etc.  
+- To rename these outputs, use `rename_intensity_column` from `celldetective.utils`.  
+- `"intensity"` in function names is automatically replaced with the actual channel name:  
+  - Example: `"intensity-0"` → `"brightfield_channel"`.  
+- **Avoid digits smaller than the number of channels in function names** to prevent indexing conflicts.  
+  Prefer text-based names instead:  
+
+  .. code-block:: python
+
+	  # Bad practice:
+	  def intensity2(regionmask, intensity_image):
+		  pass
+
+	  # Recommended:
+	  def intensity_two(regionmask, intensity_image):
+		  pass
+
+GUI Integration
+---------------
+New functions are **automatically** added to the list of available measurements in the graphical interface.  
 """
 
 import warnings
@@ -97,6 +119,45 @@ def fraction_of_area_detected_in_intensity(regionmask, intensity_image, target_c
 
 def area_detected_in_intensity(regionmask, intensity_image, target_channel='adhesion_channel'):
 
+	"""
+	Computes the detected area within the regionmask based on threshold-based segmentation.
+
+	The function applies a predefined filtering and thresholding pipeline to the intensity image (normalized adhesion channel)
+	to detect significant regions. The resulting segmented regions are restricted to the 
+	`regionmask`, ensuring that only the relevant area is measured.
+
+	Parameters
+	----------
+	regionmask : ndarray
+		A binary mask (2D array) where nonzero values define the region of interest.
+	intensity_image : ndarray
+		A 2D array of the same shape as `regionmask`, representing the intensity 
+		values associated with the region.
+	target_channel : str, optional
+		Name of the intensity channel used for measurement. Defaults to `'adhesion_channel'`.
+
+	Returns
+	-------
+	detected_area : float
+		The total area (number of pixels) detected based on intensity-based segmentation.
+
+	Notes
+	-----
+	- The segmentation is performed using `segment_frame_from_thresholds()` with predefined parameters:
+	  
+	  - Thresholding range: `[0.02, 1000]`
+	  - Filters applied in sequence:
+
+		- `"subtract"` with value `1` (subtract 1 from intensity values)
+		- `"abs"` (take absolute value of intensities)
+		- `"gauss"` with sigma `0.8` (apply Gauss filter with sigma `0.8`)
+
+	- The segmentation includes hole filling.
+	- The detected regions are converted to a binary mask (`lbl > 0`).
+	- Any pixels outside the `regionmask` are excluded from the measurement.
+
+	"""
+
 	instructions = {
 		"thresholds": [
 			0.02,
@@ -125,9 +186,46 @@ def area_detected_in_intensity(regionmask, intensity_image, target_channel='adhe
 	return float(np.sum(lbl))
 
 
-def area_dark_intensity(regionmask, intensity_image, target_channel='adhesion_channel', fill_holes=True): #, target_channel='adhesion_channel'
+def area_dark_intensity(regionmask, intensity_image, target_channel='adhesion_channel', fill_holes=True, threshold=0.95): #, target_channel='adhesion_channel'
 	
-	subregion = (intensity_image < 0.95)*regionmask # under one, under 0.8, under 0.6, whatever value!
+	"""
+	Computes the absolute area within the regionmask where the intensity is below a given threshold.
+
+	This function identifies pixels in the region where the intensity is lower than `threshold`. 
+	If `fill_holes` is `True`, small enclosed holes in the detected dark regions are filled before 
+	computing the total area.
+
+	Parameters
+	----------
+	regionmask : ndarray
+		A binary mask (2D array) where nonzero values define the region of interest.
+	intensity_image : ndarray
+		A 2D array of the same shape as `regionmask`, representing the intensity 
+		values associated with the region.
+	target_channel : str, optional
+		Name of the intensity channel used for measurement. Defaults to `'adhesion_channel'`.
+	fill_holes : bool, optional
+		If `True`, fills enclosed holes in the detected dark intensity regions before computing 
+		the area. Defaults to `True`.
+	threshold : float, optional
+		Intensity threshold below which a pixel is considered part of a dark region. 
+		Defaults to `0.95`.
+
+	Returns
+	-------
+	dark_area : float
+		The absolute area (number of pixels) where intensity values are below `threshold`, within the regionmask.
+
+	Notes
+	-----
+	- The default threshold for defining "dark" intensity regions is `0.95`, but it can be adjusted.
+	- If `fill_holes` is `True`, the function applies hole-filling to the detected dark regions
+	  using `skimage.measure.label` and `fill_label_holes()`.
+	- The `target_channel` parameter tells regionprops to only measure this channel.
+
+	"""
+
+	subregion = (intensity_image < threshold)*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)
@@ -136,9 +234,9 @@ def area_dark_intensity(regionmask, intensity_image, target_channel='adhesion_ch
 	return float(np.sum(subregion))
 
 
-def fraction_of_area_dark_intensity(regionmask, intensity_image, target_channel='adhesion_channel', fill_holes=True): #, target_channel='adhesion_channel'
+def fraction_of_area_dark_intensity(regionmask, intensity_image, target_channel='adhesion_channel', fill_holes=True, threshold=0.95): #, target_channel='adhesion_channel'
 	
-	subregion = (intensity_image < 0.95)*regionmask # under one, under 0.8, under 0.6, whatever value!
+	subregion = (intensity_image < threshold)*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)
@@ -147,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)
 
@@ -183,6 +413,38 @@ def intensity_nanmean(regionmask, intensity_image):
 
 def intensity_center_of_mass_displacement(regionmask, intensity_image):
 
+	"""
+	Computes the displacement between the geometric centroid and the 
+	intensity-weighted center of mass of a region.
+
+	Parameters
+	----------
+	regionmask : ndarray
+		A binary mask (2D array) where nonzero values indicate the region of interest.
+	intensity_image : ndarray
+		A 2D array of the same shape as `regionmask`, representing the intensity 
+		values associated with the region.
+
+	Returns
+	-------
+	distance : float
+		Euclidean distance between the geometric centroid and the intensity-weighted center of mass.
+	direction_arctan : float
+		Angle (in degrees) of displacement from the geometric centroid to the intensity-weighted center of mass,
+		computed using `arctan2(delta_y, delta_x)`.
+	delta_x : float
+		Difference in x-coordinates (intensity-weighted centroid - geometric centroid).
+	delta_y : float
+		Difference in y-coordinates (intensity-weighted centroid - geometric centroid).
+
+	Notes
+	-----
+	- If the `intensity_image` contains NaN values, it is first processed using `interpolate_nan()`.
+	- Negative intensity values are set to zero to prevent misbehavior in center of mass calculation.
+	- If the intensity image is entirely zero, all outputs are `NaN`.
+
+	"""
+
 	if np.any(intensity_image!=intensity_image):
 		intensity_image = interpolate_nan(intensity_image.copy())
 
@@ -247,7 +509,41 @@ def intensity_center_of_mass_displacement_edge(regionmask, intensity_image):
 def intensity_radial_gradient(regionmask, intensity_image):
 
 	"""
-	Determine if intensities are following a linear gradient from center to edge of the cell.
+	Determines whether the intensity follows a radial gradient from the center to the edge of the cell.
+
+	The function fits a linear model to the intensity values as a function of distance from the center
+	(computed via the Euclidean distance transform). The slope of the fitted line indicates whether 
+	the intensity is higher at the center or at the edges.
+
+	Parameters
+	----------
+	regionmask : ndarray
+		A binary mask (2D array) where nonzero values define the region of interest.
+	intensity_image : ndarray
+		A 2D array of the same shape as `regionmask`, representing the intensity 
+		values associated with the region.
+
+	Returns
+	-------
+	slope : float
+		Slope of the fitted linear model.  
+
+		- If `slope > 0`: Intensity increases towards the edge.  
+		- If `slope < 0`: Intensity is higher at the center.  
+
+	intercept : float
+		Intercept of the fitted linear model.
+	r2 : float
+		Coefficient of determination (R²), indicating how well the linear model fits the intensity profile.
+
+	Notes
+	-----
+	- If the `intensity_image` contains NaN values, they are interpolated using `interpolate_nan()`.
+	- The Euclidean distance transform (`distance_transform_edt`) is used to compute the distance 
+	  of each pixel from the edge.
+	- The x-values for the linear fit are reversed so that the origin is at the center.
+	- A warning suppression is applied to ignore messages about poorly conditioned polynomial fits.
+
 	"""
 	
 	if np.any(intensity_image!=intensity_image):

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,7 +76,7 @@ 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)
@@ -266,7 +263,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 +379,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 +417,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/gui/__init__.py

@@ -1,4 +1,5 @@
 from .styles import Styles
+from .base_components import CelldetectiveWidget, CelldetectiveMainWindow
 from .btrack_options import ConfigTracking
 from .json_readers import ConfigEditor
 from .tableUI import TableUI

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(os.sep.join([get_software_location(), 'celldetective', 'icons', 'logo.png']))
+		
 		# 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/remyeltorro/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)
-
-
-