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

celldetective/gui/InitWindow.py

@@ -0,0 +1,400 @@
+from PyQt5.QtWidgets import QApplication, QMainWindow
+from celldetective.utils import get_software_location
+import os
+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):
+
+	"""
+	Initial window to set the experiment folder or create a new one.
+	"""
+
+	def __init__(self, parent_window=None):
+		super().__init__()
+
+		self.parent_window = parent_window
+		self.Styles = Styles()
+		self.init_styles()
+		self.setWindowTitle("celldetective")
+
+		self.n_threads = min([1,psutil.cpu_count()])
+
+		try:
+			subprocess.check_output('nvidia-smi')
+			print('NVIDIA GPU detected (activate or disable in Memory & Threads)...')
+			self.use_gpu = True
+		except Exception: # this command not being found can raise quite a few different errors depending on the configuration
+			print('No NVIDIA GPU detected...')
+			self.use_gpu = False
+			
+		self.soft_path = get_software_location()
+		self.onlyInt = QIntValidator()
+		self.setWindowIcon(QIcon(os.sep.join([self.soft_path,'celldetective','icons','logo.png'])))
+		center_window(self)
+		self._createActions()
+		self._createMenuBar()
+
+		app = QApplication.instance()
+		self.screen = app.primaryScreen()
+		self.geometry = self.screen.availableGeometry()
+		self.screen_width, self.screen_height = self.geometry.getRect()[-2:]
+
+		central_widget = QWidget()
+		self.vertical_layout = QVBoxLayout(central_widget)
+		self.vertical_layout.setContentsMargins(15,15,15,15)
+		self.vertical_layout.addWidget(QLabel("Experiment folder:"))
+		self.create_locate_exp_hbox()
+		self.create_buttons_hbox()
+		self.setCentralWidget(central_widget)
+		self.reload_previous_gpu_threads()
+		self.show()
+	
+	def closeEvent(self, event):
+		QApplication.closeAllWindows()
+		event.accept()
+		gc.collect()
+
+	def create_locate_exp_hbox(self):
+
+		self.locate_exp_layout = QHBoxLayout()
+		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()
+		self.experiment_path_selection.setPlaceholderText('/path/to/experiment/folder/')
+		self.locate_exp_layout.addWidget(self.experiment_path_selection, 90)
+
+		self.browse_button = QPushButton("Browse...")
+		self.browse_button.clicked.connect(self.browse_experiment_folder)
+		self.browse_button.setStyleSheet(self.button_style_sheet)
+		self.browse_button.setIcon(icon(MDI6.folder, color="white"))
+		self.locate_exp_layout.addWidget(self.browse_button, 10)
+		self.vertical_layout.addLayout(self.locate_exp_layout)
+
+
+	def _createMenuBar(self):
+
+		menuBar = self.menuBar()
+		menuBar.clear()
+		# Creating menus using a QMenu object
+
+		fileMenu = QMenu("File", self)
+		fileMenu.clear()
+		fileMenu.addAction(self.newExpAction)
+		fileMenu.addAction(self.openAction)
+
+		fileMenu.addMenu(self.OpenRecentAction)
+		self.OpenRecentAction.clear()
+		if len(self.recentFileActs)>0:
+			for i in range(len(self.recentFileActs)):
+				self.OpenRecentAction.addAction(self.recentFileActs[i])
+
+		fileMenu.addAction(self.openModels)
+		fileMenu.addSeparator()
+		fileMenu.addAction(self.exitAction)
+		menuBar.addMenu(fileMenu)
+
+		OptionsMenu = QMenu("Options", self)
+		OptionsMenu.addAction(self.MemoryAndThreadsAction)
+		menuBar.addMenu(OptionsMenu)
+
+		PluginsMenu = QMenu("Plugins", self)
+		PluginsMenu.addAction(self.CorrectAnnotationAction)
+		menuBar.addMenu(PluginsMenu)
+
+		helpMenu = QMenu("Help", self)
+		helpMenu.clear()
+		helpMenu.addAction(self.DocumentationAction)
+		helpMenu.addAction(self.SoftwareAction)
+		helpMenu.addSeparator()
+		helpMenu.addAction(self.AboutAction)
+		menuBar.addMenu(helpMenu)
+
+		#editMenu = menuBar.addMenu("&Edit")
+		#helpMenu = menuBar.addMenu("&Help")
+
+	def _createActions(self):
+		# Creating action using the first constructor
+		#self.newAction = QAction(self)
+		#self.newAction.setText("&New")
+		# Creating actions using the second constructor
+		self.openAction = QAction('Open...', self)
+		self.openAction.setShortcut("Ctrl+O")
+		self.openAction.setShortcutVisibleInContextMenu(True)
+
+		self.MemoryAndThreadsAction = QAction('Memory & Threads...')
+
+		self.CorrectAnnotationAction = QAction('Correct a segmentation annotation...')
+
+		self.newExpAction = QAction('New', self)
+		self.newExpAction.setShortcut("Ctrl+N")
+		self.newExpAction.setShortcutVisibleInContextMenu(True)
+		self.exitAction = QAction('Exit', self)
+
+		self.openModels = QAction('Open Models Location')
+		self.openModels.setShortcut("Ctrl+L")
+		self.openModels.setShortcutVisibleInContextMenu(True)
+
+		self.OpenRecentAction = QMenu('Open Recent')
+		self.reload_previous_experiments()
+
+		self.DocumentationAction = QAction("Documentation", self)
+		self.DocumentationAction.setShortcut("Ctrl+D")
+		self.DocumentationAction.setShortcutVisibleInContextMenu(True)
+
+		self.SoftwareAction = QAction("Software", self) #1st arg icon(MDI6.information)
+		self.AboutAction = QAction("About celldetective", self)
+
+		#self.DocumentationAction.triggered.connect(self.load_previous_config)
+		self.openAction.triggered.connect(self.open_experiment)
+		self.newExpAction.triggered.connect(self.create_new_experiment)
+		self.exitAction.triggered.connect(self.close)
+		self.openModels.triggered.connect(self.open_models_folder)
+		self.AboutAction.triggered.connect(self.open_about_window)
+		self.MemoryAndThreadsAction.triggered.connect(self.set_memory_and_threads)
+		self.CorrectAnnotationAction.triggered.connect(self.correct_seg_annotation)
+
+		self.DocumentationAction.triggered.connect(self.open_documentation)
+
+	def reload_previous_gpu_threads(self):
+
+		self.recentFileActs = []
+		self.threads_config_path = os.sep.join([self.soft_path,'celldetective','threads.json'])
+		print('Reading previous Memory & Threads settings...')
+		if os.path.exists(self.threads_config_path):
+			with open(self.threads_config_path, 'r') as f:
+				self.threads_config = json.load(f)
+			if 'use_gpu' in self.threads_config:
+				self.use_gpu = bool(self.threads_config['use_gpu'])
+				print(f'Use GPU: {self.use_gpu}...')
+			if 'n_threads' in self.threads_config:
+				self.n_threads = int(self.threads_config['n_threads'])
+				print(f'Number of threads: {self.n_threads}...')
+
+
+	def reload_previous_experiments(self):
+
+		recentExps = []
+		self.recentFileActs = []
+		if os.path.exists(os.sep.join([self.soft_path,'celldetective','recent.txt'])):
+			recentExps = open(os.sep.join([self.soft_path,'celldetective','recent.txt']), 'r')
+			recentExps = recentExps.readlines()
+			recentExps = [r.strip() for r in recentExps]
+			recentExps.reverse()
+			recentExps = list(dict.fromkeys(recentExps))
+			self.recentFileActs = [QAction(r,self) for r in recentExps]
+			for r in self.recentFileActs:
+				r.triggered.connect(lambda checked, item=r: self.load_recent_exp(item.text()))
+
+	def correct_seg_annotation(self):
+		
+		self.filename,_ = QFileDialog.getOpenFileName(self,"Open Image", "/home/", "TIF Files (*.tif)")
+		if self.filename!='':
+			print('Opening ',self.filename,' in napari...')
+			correct_annotation(self.filename)
+		else:
+			return None
+
+	def set_memory_and_threads(self):
+		
+		print('setting memory and threads')
+
+		self.ThreadsWidget = QWidget()
+		self.ThreadsWidget.setWindowTitle("Threads")
+		layout = QVBoxLayout()
+		self.ThreadsWidget.setLayout(layout)
+
+		self.threads_le = QLineEdit(str(self.n_threads))
+		self.threads_le.setValidator(self.onlyInt)
+
+		hbox = QHBoxLayout()
+		hbox.addWidget(QLabel('Parallel threads: '), 33)
+		hbox.addWidget(self.threads_le, 66)
+		layout.addLayout(hbox)
+
+		self.use_gpu_checkbox = QCheckBox()
+		hbox2 = QHBoxLayout()
+		hbox2.addWidget(QLabel('Use GPU: '), 33)
+		hbox2.addWidget(self.use_gpu_checkbox, 66)
+		layout.addLayout(hbox2)
+		if self.use_gpu:
+			self.use_gpu_checkbox.setChecked(True)
+
+		self.validateThreadBtn = QPushButton('Submit')
+		self.validateThreadBtn.setStyleSheet(self.button_style_sheet)
+		self.validateThreadBtn.clicked.connect(self.set_threads)
+		layout.addWidget(self.validateThreadBtn)
+		center_window(self.ThreadsWidget)
+		self.ThreadsWidget.show()
+
+	def set_threads(self):
+		self.n_threads = int(self.threads_le.text())
+		self.use_gpu = bool(self.use_gpu_checkbox.isChecked())
+		dico = {"use_gpu": self.use_gpu, "n_threads": self.n_threads}
+		with open(self.threads_config_path, 'w') as f:
+			json.dump(dico, f, indent=4)
+		self.ThreadsWidget.close()
+
+
+	def open_experiment(self):
+		print('ok')
+		self.browse_experiment_folder()
+		if self.experiment_path_selection.text()!='':
+			self.open_directory()
+
+	def load_recent_exp(self, path):
+		
+		self.experiment_path_selection.setText(path)
+		print(f'Attempt to load experiment folder: {path}...')
+		self.open_directory()
+
+	def open_about_window(self):
+		self.about_wdw = AboutWidget()
+		self.about_wdw.show()
+
+	def open_documentation(self):
+		doc_url = QUrl('https://celldetective.readthedocs.io/')
+		QDesktopServices.openUrl(doc_url)
+
+	def open_models_folder(self):
+		path = os.sep.join([self.soft_path,'celldetective','models',os.sep])
+		try:
+			subprocess.Popen(f'explorer {os.path.realpath(path)}')
+		except:
+
+			try:
+				os.system('xdg-open "%s"' % path)
+			except:
+				return None
+
+
+		#os.system(f'start {os.path.realpath(path)}')
+
+	def create_buttons_hbox(self):
+
+		self.buttons_layout = QHBoxLayout()
+		self.buttons_layout.setContentsMargins(30,15,30,5)
+		self.new_exp_button = QPushButton("New")
+		self.new_exp_button.clicked.connect(self.create_new_experiment)
+		self.new_exp_button.setStyleSheet(self.button_style_sheet_2)
+		self.buttons_layout.addWidget(self.new_exp_button, 50)
+
+		self.validate_button = QPushButton("Open")
+		self.validate_button.clicked.connect(self.open_directory)
+		self.validate_button.setStyleSheet(self.button_style_sheet)
+		self.validate_button.setEnabled(False)
+		self.validate_button.setShortcut("Return")
+		self.buttons_layout.addWidget(self.validate_button, 50)
+		self.vertical_layout.addLayout(self.buttons_layout)
+
+	def check_path_and_enable_opening(self):
+		
+		"""
+		Enable 'Open' button if the text is a valid path.
+		"""
+
+		text = self.experiment_path_selection.text()
+		if (os.path.exists(text)) and os.path.exists(os.sep.join([text,"config.ini"])):
+			self.validate_button.setEnabled(True)
+		else:
+			self.validate_button.setEnabled(False)
+
+	def init_styles(self):
+
+		"""
+		Initialize styles.
+		"""
+		
+		self.qtab_style = self.Styles.qtab_style
+		self.button_style_sheet = self.Styles.button_style_sheet
+		self.button_style_sheet_2 = self.Styles.button_style_sheet_2
+		self.button_style_sheet_2_not_done = self.Styles.button_style_sheet_2_not_done
+		self.button_style_sheet_3 = self.Styles.button_style_sheet_3
+		self.button_select_all = self.Styles.button_select_all
+
+	def set_experiment_path(self, path):
+		self.experiment_path_selection.setText(path)
+
+	def create_new_experiment(self):
+
+		print("Configuring new experiment...")
+		self.new_exp_window = ConfigNewExperiment(self)
+		self.new_exp_window.show()
+
+	def open_directory(self):
+
+		self.exp_dir = self.experiment_path_selection.text().replace('/', os.sep)
+		print(f"Setting current directory to {self.exp_dir}...")
+
+		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
+		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 = []
+			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}")
+			
+			with open(os.sep.join([self.soft_path,'celldetective','recent.txt']), 'a+') as f:
+				f.write(self.exp_dir+'\n')
+
+			self.control_panel = ControlPanel(self, self.exp_dir)
+			self.control_panel.show()
+
+			self.reload_previous_experiments()
+			self._createMenuBar()
+
+
+	def browse_experiment_folder(self):
+
+		"""
+		Locate an experiment folder. If no configuration file is in the experiment, display a warning.
+		"""
+
+		self.foldername = str(QFileDialog.getExistingDirectory(self, 'Select directory'))
+		if self.foldername!='':
+			self.experiment_path_selection.setText(self.foldername)
+		else:
+			return None
+		if not os.path.exists(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

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/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/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/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."
+          }
+        }
+      }
+    }
+  }
+}

celldetective/gui/help/feature-btrack.json

@@ -0,0 +1,11 @@
+{
+  "Are morphological, tonal or textural features critical to follow the cells of interest?": {
+    "yes": {
+      "Are the values of these features constant or slowly changing?": {
+        "yes": "You may pass features to bTrack. Both motion and feature information will be combined to perform tracking.",
+        "no": "Abrupt transitions in the features may perturb bTrack's performance and truncate trajectories prematurely. Avoid passing features. "
+      }
+    },
+    "no": "No need to pass features. The tracking will rely exclusively on the cell positions. Skip this step."
+  }
+}

celldetective/gui/help/neighborhood.json

@@ -0,0 +1,16 @@
+{
+  "Do you want to relate target and effector populations?": {
+    "yes": {
+      "Do you have the complete cell shape for both populations of interest?": {
+        "yes": "You may compute a mask-contact neighborhood. Set the reference and neighbor populations. Use the tolerance parameter to be more or less sensitive about the reference-cell / neighbor-cell contact.",
+        "no": "You may use an isotropic distance threshold. Set the reference and neighbor populations. Use a radius r > (R_ref + 1/2 * R_neigh) with R_ref the average reference cell radius and R_neigh the average neighbor cell radius."
+      }
+    },
+    "no": {
+      "Do you have the complete cell shape for the population of interest?": {
+        "yes": "You may compute a mask-contact neighborhood. Set the same reference and neighbor population. Use the tolerance parameter to be more or less sensitive about the cell-cell contact.",
+        "no": "You may use an isotropic distance threshold. Set the same reference and neighbor population. Use a radius r > 1.5*R with R the average cell radius."
+      }
+    }
+  }
+}

celldetective/gui/help/prefilter-for-segmentation.json

@@ -0,0 +1,16 @@
+{
+  "Cells are either brighter or darker than background": {
+    "yes": {
+      "Background is heterogeneous": {
+        "yes": "prefilter"         ,
+        "no" : "threshold directly"
+      }
+    },
+    "no": {
+      "Background is perfectly homogeneous (same value everywhere on the image)": {
+        "yes": "subtract the background value (subtract_filter) and take the absolute value (abs_filter) for all the pixels of the image. You may add a slight Gaussian blur after these operations",
+        "no": "use a Gaussian blur and apply a standard-deviation filter (or variance filter)"
+      }
+    }
+  }
+}

celldetective/gui/help/preprocessing.json

@@ -0,0 +1,51 @@
+{
+  "Is the background spatially invariant (within a well)?": {
+    "yes": {
+      "Do your stacks represent timeseries?": {
+        "yes": {
+          "Does your background add to the signal (typical of fluorescence)?": {
+            "yes": "You may perform a model-free background correction. Set the channel(s) of interest and specify that you have timeseries. Estimate the frame range over which you have the best estimate of the background (typically before cell arrival, when applicable). Carefully tune the threshold to exclude all non-background objects. If the background intensity values fluctuate slightly from one frame to the next or one position to the next, activate the optimization option. Since your background is additive, you may subtract it from the images. ",
+            "no": "You may perform a model-free background correction. Set the channel(s) of interest and specify that you have timeseries. Estimate the frame range over which you have the best estimate of the background (typically before cell arrival, when applicable). Carefully tune the threshold to exclude all non-background objects. If the background intensity values fluctuate slightly from one frame to the next or one position to the next, activate the optimization option. Since your background is not additive, you may divide it from the images to express the intensities as relative to the background."
+          }
+        },
+        "no": {
+          "Does your background add to the signal (typical of fluorescence)?": {
+            "yes": "You may perform a model-free background correction. Set the channel(s) of interest and specify that you have tiles. Carefully tune the threshold to exclude all non-background objects. If the background intensity values fluctuate slightly from one position to the next, activate the optimization option. Since your background is additive, you may subtract it from the images. ",
+            "no": "You may perform a model-free background correction. Set the channel(s) of interest and specify that you have tiles. Carefully tune the threshold to exclude all non-background objects. If the background intensity values fluctuate slightly from one position to the next, activate the optimization option. Since your background is not additive, you may divide it from the images to express the intensities as relative to the background."
+          }
+        }
+      }
+    },
+    "no": {
+      "Is the background brighter at the center than at the edges?": {
+        "yes": {
+          "Is the background correction critical to segment the cells? It is often the case when you use a traditional segmentation pipeline.": {
+            "yes": {
+              "Does your background add to the signal (typical of fluorescence)?": {
+                "yes": "You may perform a model-based (fit) correction. Set the channel(s) of interest and carefully tune the threshold to exclude all non-background objects. Choose a paraboloid model and subtract.",
+                "no": "You may perform a model-based (fit) correction. Set the channel(s) of interest and carefully tune the threshold to exclude all non-background objects. Choose a paraboloid model and divide to express the intensities as relative to the background."
+              }
+            },
+            "no": "You can skip the image preprocessing step to save a considerable amount of storage. You will have the option to perform this preprocessing on-the-fly in the measurement module, which may be preferable. See <a href='https://celldetective.readthedocs.io/en/latest/measure.html#background-correction'>the documentation</a>."
+          }
+        },
+        "no": {
+          "Is the background a constant value?": {
+            "yes": {
+              "Is the background correction critical to segment the cells? It is often the case when you use a traditional segmentation pipeline.": {
+                "yes": {
+                  "Does your background add to the signal (typical of fluorescence)?": {
+                    "yes": "You may perform a model-based (fit) correction. Set the channel(s) of interest and carefully tune the threshold to exclude all non-background objects. Choose a plane model and subtract.",
+                    "no": "You may perform a model-based (fit) correction. Set the channel(s) of interest and carefully tune the threshold to exclude all non-background objects. Choose a plane model and divide to express the intensities as relative to the background."
+                  }
+                },
+                "no": "You can skip the image preprocessing step to save a considerable amount of storage. You will have the option to perform this preprocessing on-the-fly in the measurement module, which may be preferable. See <a href='https://celldetective.readthedocs.io/en/latest/measure.html#background-correction'>the documentation</a>."
+              }
+            },
+            "no": "For a complex background pattern it is preferable to not perform a correction at this stage. We recommend exploring the local cell correction available in the measurement module. See <a href='https://celldetective.readthedocs.io/en/latest/measure.html#background-correction'>the documentation</a>."
+          }
+        }
+      }
+    }
+  }
+}

celldetective/gui/help/propagate-classification.json

@@ -0,0 +1,16 @@
+{
+  "Do you want to exploit the instantaneous classification to interpret cell tracks as a whole?": {
+    "yes": {
+      "Do the cells exhibit irreversible transitions between the negative and positive state?": {
+        "yes": "Tick the 'irreversible event' option. This will generate a class of either 0 (an observed transition), 1 (no observed transition) or 2 (a left-censored transition) for your cells. In case of doubt, transitioning cells (class 0) will be assigned to class 2. Lower the R² threshold if too many transitions are misidentified.",
+        "no": {
+          "Do the cells have a unique state from the beginning to the end of the movie?": {
+            "yes": "Tick the 'unique state' option. This will generate a class of either 1 (always negative) or 2 (always positive) for your cells.",
+            "no": "No model of propagation fit for your data is currently available in celldetective. Do not hesitate to formulate a <a href='https://github.com/remyeltorro/celldetective/issues/new?assignees=&labels=&projects=&template=%E2%AD%90-feature-request.md&title=%5BFEATURE%5D'>request</a>."
+          }
+        }
+      }
+    },
+    "no": "Then you do not need to tick the 'Time correlated' option. Each cell at each time point is classified independently."
+  }
+}