celldetective 1.3.0.post1__py3-none-any.whl → 1.3.1__py3-none-any.whl

celldetective/_version.py

@@ -1 +1 @@
-__version__ = "1.3.0.post1"
+__version__ = "1.3.1"

celldetective/events.py

@@ -1,7 +1,7 @@
 import numpy as np
 from lifelines import KaplanMeierFitter
 
-def switch_to_events(classes, event_times, max_times, origin_times=None, left_censored=True, FrameToMin=None):
+def switch_to_events(classes, event_times, max_times, origin_times=None, left_censored=True, FrameToMin=None, cut_observation_time=None):
 	
 
 	"""
@@ -29,6 +29,8 @@ def switch_to_events(classes, event_times, max_times, origin_times=None, left_ce
 	FrameToMin : float, optional
 		A conversion factor to transform survival times from frames (or any other unit) to minutes. If None, no conversion 
 		is applied (default is None).
+	cut_observation_time : float or None, optional
+		A cutoff time to artificially reduce the observation window and exclude late events. If None, uses all available data (default is None).
 
 	Returns
 	-------
@@ -70,13 +72,36 @@ def switch_to_events(classes, event_times, max_times, origin_times=None, left_ce
 			if ot>=0. and ot==ot:
 				# origin time is larger than zero, no censorship
 				if c==0 and t>0:
+					
 					delta_t = t - ot
-					if delta_t>0:
-						events.append(1)
-						survival_times.append(delta_t)
-					else:
-						# negative delta t, invalid cell
-						pass
+
+					# Special case: observation cut at arbitrary time
+					if cut_observation_time is not None:
+						if t>=cut_observation_time:
+							# event time larger than cut, becomes no event
+							delta_t = cut_observation_time - ot # new time
+							if delta_t > 0:
+								events.append(0)
+								survival_times.append(delta_t)
+							else:
+								# negative delta t, invalid cell
+								pass
+						else:
+							# still event
+							if delta_t > 0:
+								events.append(1)
+								survival_times.append(delta_t)	
+							else:
+								# negative delta t, invalid cell
+								pass				
+					else: 
+						# standard mode
+						if delta_t>0:
+							events.append(1)
+							survival_times.append(delta_t)
+						else:
+							# negative delta t, invalid cell
+							pass
 				elif c==1:
 					delta_t = mt - ot
 					if delta_t>0:
@@ -93,10 +118,20 @@ def switch_to_events(classes, event_times, max_times, origin_times=None, left_ce
 
 		else:
 			if c==0 and t>0:
-				events.append(1)
-				survival_times.append(t - ot)
+				if cut_observation_time is not None:
+					if t>cut_observation_time:
+						events.append(0)
+						survival_times.append(cut_observation_time - ot)
+					else:
+						events.append(1)
+						survival_times.append(t - ot)						
+				else:				
+					events.append(1)
+					survival_times.append(t - ot)
 			elif c==1:
 				events.append(0)
+				if cut_observation_time is not None:
+					mt = cut_observation_time
 				survival_times.append(mt - ot)
 			else:
 				pass
@@ -106,7 +141,47 @@ def switch_to_events(classes, event_times, max_times, origin_times=None, left_ce
 		survival_times = [s*FrameToMin for s in survival_times]
 	return events, survival_times
 
-def compute_survival(df, class_of_interest, t_event, t_reference=None, FrameToMin=1):
+def compute_survival(df, class_of_interest, t_event, t_reference=None, FrameToMin=1, cut_observation_time=None):
+
+	"""
+	Computes survival analysis for a specific class of interest within a dataset, returning a fitted Kaplan-Meier 
+	survival curve based on event and reference times.
+
+	Parameters
+	----------
+	df : pandas.DataFrame
+		The dataset containing tracking data, event times, and other relevant columns for survival analysis.
+	class_of_interest : str
+		The name of the column that specifies the class for which survival analysis is to be computed.
+	t_event : str
+		The column indicating the time of the event of interest (e.g., cell death or migration stop).
+	t_reference : str or None, optional
+		The reference column indicating the start or origin time for each track (e.g., detection time). If None, 
+		events are not left-censored (default is None).
+	FrameToMin : float, optional
+		Conversion factor to scale the frame time to minutes (default is 1, assuming no scaling).
+	cut_observation_time : float or None, optional
+		A cutoff time to artificially reduce the observation window and exclude late events. If None, uses all available data (default is None).
+	Returns
+	-------
+	ks : lifelines.KaplanMeierFitter or None
+		A fitted Kaplan-Meier estimator object. If there are no events, returns None.
+
+	Notes
+	-----
+	- The function groups the data by 'position' and 'TRACK_ID', extracting the minimum `class_of_interest` and `t_event` 
+	  values for each track.
+	- If `t_reference` is provided, the analysis assumes left-censoring and will use `t_reference` as the origin time for 
+	  each track.
+	- The function calls `switch_to_events` to determine the event occurrences and their associated survival times.
+	- A Kaplan-Meier estimator (`KaplanMeierFitter`) is fitted to the data to compute the survival curve.
+
+	Example
+	-------
+	>>> ks = compute_survival(df, class_of_interest="class_custom", t_event="time_custom", t_reference="t_firstdetection")
+	>>> ks.plot_survival_function()
+	
+	"""
 
 	cols = list(df.columns)
 	assert class_of_interest in cols,"The requested class cannot be found in the dataframe..."
@@ -127,7 +202,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(['position','TRACK_ID'])[t_reference].max().values
 	
-	events, survival_times = switch_to_events(classes, event_times, max_times, origin_times=first_detections, left_censored=left_censored, FrameToMin=FrameToMin)
+	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)
 	ks = KaplanMeierFitter()
 	if len(events)>0:
 		ks.fit(survival_times, event_observed=events)

celldetective/extra_properties.py

@@ -57,7 +57,11 @@ def intensity_median(regionmask, intensity_image):
 	return np.nanmedian(intensity_image[regionmask])
 
 def intensity_nanmean(regionmask, intensity_image):
-	return np.nanmean(intensity_image[regionmask])
+	
+	if np.all(intensity_image==0):
+		return np.nan
+	else:
+		return np.nanmean(intensity_image[regionmask])
 
 def intensity_centre_of_mass_displacement(regionmask, intensity_image):
 

celldetective/gui/InitWindow.py

@@ -1,5 +1,5 @@
 from PyQt5.QtWidgets import QApplication, QMainWindow
-from celldetective.utils import get_software_location
+from celldetective.utils import get_software_location, download_zenodo_file
 import os
 from PyQt5.QtWidgets import QFileDialog, QWidget, QVBoxLayout, QCheckBox, QHBoxLayout, QLabel, QLineEdit, QPushButton, QMessageBox, QMenu, QAction
 from PyQt5.QtCore import Qt, QUrl
@@ -108,6 +108,10 @@ class AppInitWindow(QMainWindow):
 			for i in range(len(self.recentFileActs)):
 				self.OpenRecentAction.addAction(self.recentFileActs[i])
 
+		fileMenu.addMenu(self.openDemo)
+		self.openDemo.addAction(self.openSpreadingAssayDemo)
+		self.openDemo.addAction(self.openCytotoxicityAssayDemo)
+
 		fileMenu.addAction(self.openModels)
 		fileMenu.addSeparator()
 		fileMenu.addAction(self.exitAction)
@@ -124,7 +128,7 @@ class AppInitWindow(QMainWindow):
 		helpMenu = QMenu("Help", self)
 		helpMenu.clear()
 		helpMenu.addAction(self.DocumentationAction)
-		helpMenu.addAction(self.SoftwareAction)
+		#helpMenu.addAction(self.SoftwareAction)
 		helpMenu.addSeparator()
 		helpMenu.addAction(self.AboutAction)
 		menuBar.addMenu(helpMenu)
@@ -137,13 +141,17 @@ class AppInitWindow(QMainWindow):
 		#self.newAction = QAction(self)
 		#self.newAction.setText("&New")
 		# Creating actions using the second constructor
-		self.openAction = QAction('Open...', self)
+		self.openAction = QAction('Open Project', self)
 		self.openAction.setShortcut("Ctrl+O")
 		self.openAction.setShortcutVisibleInContextMenu(True)
 
-		self.MemoryAndThreadsAction = QAction('Memory & Threads...')
+		self.openDemo = QMenu('Open Demo')
+		self.openSpreadingAssayDemo = QAction('Spreading Assay Demo', self)
+		self.openCytotoxicityAssayDemo = QAction('Cytotoxicity Assay Demo', self)
+
+		self.MemoryAndThreadsAction = QAction('Threads')
 
-		self.CorrectAnnotationAction = QAction('Correct a segmentation annotation...')
+		self.CorrectAnnotationAction = QAction('Correct a segmentation annotation')
 
 		self.newExpAction = QAction('New', self)
 		self.newExpAction.setShortcut("Ctrl+N")
@@ -154,14 +162,14 @@ class AppInitWindow(QMainWindow):
 		self.openModels.setShortcut("Ctrl+L")
 		self.openModels.setShortcutVisibleInContextMenu(True)
 
-		self.OpenRecentAction = QMenu('Open Recent')
+		self.OpenRecentAction = QMenu('Open Recent Project')
 		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.SoftwareAction = QAction("Software", self) #1st arg icon(MDI6.information)
 		self.AboutAction = QAction("About celldetective", self)
 
 		#self.DocumentationAction.triggered.connect(self.load_previous_config)
@@ -172,9 +180,27 @@ class AppInitWindow(QMainWindow):
 		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)
 
+		self.openSpreadingAssayDemo.triggered.connect(self.download_spreading_assay_demo)
+		self.openCytotoxicityAssayDemo.triggered.connect(self.download_cytotoxicity_assay_demo)
+
+	def download_spreading_assay_demo(self):
+		
+		self.target_dir = str(QFileDialog.getExistingDirectory(self, 'Select Folder for Download'))
+		if not os.path.exists(os.sep.join([self.target_dir,'demo_ricm'])):
+			download_zenodo_file('demo_ricm', self.target_dir)
+		self.experiment_path_selection.setText(os.sep.join([self.target_dir, 'demo_ricm']))
+		self.validate_button.click()
+
+	def download_cytotoxicity_assay_demo(self):
+		
+		self.target_dir = str(QFileDialog.getExistingDirectory(self, 'Select Folder for Download'))
+		if not os.path.exists(os.sep.join([self.target_dir,'demo_adcc'])):
+			download_zenodo_file('demo_adcc', self.target_dir)
+		self.experiment_path_selection.setText(os.sep.join([self.target_dir, 'demo_adcc']))
+		self.validate_button.click()
+
 	def reload_previous_gpu_threads(self):
 
 		self.recentFileActs = []
@@ -256,7 +282,7 @@ class AppInitWindow(QMainWindow):
 
 
 	def open_experiment(self):
-		print('ok')
+		
 		self.browse_experiment_folder()
 		if self.experiment_path_selection.text()!='':
 			self.open_directory()

celldetective/gui/classifier_widget.py

@@ -120,9 +120,11 @@ class ClassifierWidget(QWidget, Styles):
 		self.property_query_le = QLineEdit()
 		self.property_query_le.setPlaceholderText('classify points using a query such as: area > 100 or eccentricity > 0.95')
 		self.property_query_le.setToolTip('Classify points using a query on measurements.\nYou can use "and" and "or" conditions to combine\nmeasurements (e.g. "area > 100 or eccentricity > 0.95").')
+		self.property_query_le.textChanged.connect(self.activate_submit_btn)
 		hbox_classify.addWidget(self.property_query_le, 70)
 		self.submit_query_btn = QPushButton('Submit...')
 		self.submit_query_btn.clicked.connect(self.apply_property_query)
+		self.submit_query_btn.setEnabled(False)
 		hbox_classify.addWidget(self.submit_query_btn, 20)
 		layout.addLayout(hbox_classify)
 
@@ -182,15 +184,24 @@ class ClassifierWidget(QWidget, Styles):
 
 		layout.addWidget(QLabel())
 
-
 		self.submit_btn = QPushButton('apply')
 		self.submit_btn.setStyleSheet(self.button_style_sheet)
 		self.submit_btn.clicked.connect(self.submit_classification)
+		self.submit_btn.setEnabled(False)
 		layout.addWidget(self.submit_btn, 30)
 
 		self.frame_slider.valueChanged.connect(self.set_frame)
 		self.alpha_slider.valueChanged.connect(self.set_transparency)
 
+	def activate_submit_btn(self):
+
+		if self.property_query_le.text()=='':
+			self.submit_query_btn.setEnabled(False)
+			self.submit_btn.setEnabled(False)
+		else:
+			self.submit_query_btn.setEnabled(True)
+			self.submit_btn.setEnabled(True)
+
 	def activate_r2(self):
 		if self.irreversible_event_btn.isChecked() and self.time_corr.isChecked():
 			for wg in [self.r2_slider, self.r2_label]:
@@ -250,32 +261,32 @@ class ClassifierWidget(QWidget, Styles):
 				self.scat_props.set_offsets(self.df.loc[self.df['FRAME']==self.currentFrame,[self.features_cb[1].currentText(),self.features_cb[0].currentText()]].to_numpy())
 				colors = [color_from_status(c) for c in self.df.loc[self.df['FRAME']==self.currentFrame,class_name].to_numpy()]
 				self.scat_props.set_facecolor(colors)
-				self.scat_props.set_alpha(self.currentAlpha)
-				self.ax_props.set_xlabel(self.features_cb[1].currentText())
-				self.ax_props.set_ylabel(self.features_cb[0].currentText())
 			else:
 				self.scat_props.set_offsets(self.df[[self.features_cb[1].currentText(),self.features_cb[0].currentText()]].to_numpy())
 				colors = [color_from_status(c) for c in self.df[class_name].to_numpy()]
 				self.scat_props.set_facecolor(colors)
-				self.scat_props.set_alpha(self.currentAlpha)
+			
+			self.scat_props.set_alpha(self.currentAlpha)
+
+			if feature_changed:
+	
 				self.ax_props.set_xlabel(self.features_cb[1].currentText())
 				self.ax_props.set_ylabel(self.features_cb[0].currentText())
 
-
-			feat_x = self.features_cb[1].currentText()
-			feat_y = self.features_cb[0].currentText()
-			min_x = self.df.dropna(subset=feat_x)[feat_x].min()
-			max_x = self.df.dropna(subset=feat_x)[feat_x].max()
-			min_y = self.df.dropna(subset=feat_y)[feat_y].min()
-			max_y = self.df.dropna(subset=feat_y)[feat_y].max()
-
-			if min_x==min_x and max_x==max_x:
-				self.ax_props.set_xlim(min_x, max_x)
-			if min_y==min_y and max_y==max_y:
-				self.ax_props.set_ylim(min_y, max_y)
+				feat_x = self.features_cb[1].currentText()
+				feat_y = self.features_cb[0].currentText()
+				min_x = self.df.dropna(subset=feat_x)[feat_x].min()
+				max_x = self.df.dropna(subset=feat_x)[feat_x].max()
+				min_y = self.df.dropna(subset=feat_y)[feat_y].min()
+				max_y = self.df.dropna(subset=feat_y)[feat_y].max()
+
+				if min_x==min_x and max_x==max_x:
+					self.ax_props.set_xlim(min_x, max_x)
+				if min_y==min_y and max_y==max_y:
+					self.ax_props.set_ylim(min_y, max_y)
 			
-			if feature_changed:
 				self.propscanvas.canvas.toolbar.update()
+
 			self.propscanvas.canvas.draw_idle()
 		
 		except Exception as e:
@@ -284,7 +295,20 @@ class ClassifierWidget(QWidget, Styles):
 	def apply_property_query(self):
 		
 		query = self.property_query_le.text()
-		self.df = classify_cells_from_query(self.df, self.name_le.text(), query)
+		
+		try:
+			self.df = classify_cells_from_query(self.df, self.name_le.text(), query)
+		except Exception as e:
+			msgBox = QMessageBox()
+			msgBox.setIcon(QMessageBox.Warning)
+			msgBox.setText(f"The query could not be understood. No filtering was applied. {e}")
+			msgBox.setWindowTitle("Warning")
+			msgBox.setStandardButtons(QMessageBox.Ok)
+			returnValue = msgBox.exec()
+			if returnValue == QMessageBox.Ok:
+				self.auto_close = False
+				return None
+
 		self.class_name = "status_"+self.name_le.text()
 		if self.df is None:
 			msgBox = QMessageBox()
@@ -294,8 +318,10 @@ class ClassifierWidget(QWidget, Styles):
 			msgBox.setStandardButtons(QMessageBox.Ok)
 			returnValue = msgBox.exec()
 			if returnValue == QMessageBox.Ok:
+				self.auto_close = False
 				return None
-		self.update_props_scatter()
+
+		self.update_props_scatter(feature_changed=False)
 
 	def set_frame(self, value):
 		xlim=self.ax_props.get_xlim()
@@ -329,12 +355,14 @@ class ClassifierWidget(QWidget, Styles):
 			self.project_times_btn.setIcon(icon(MDI6.math_integral_box,color="black"))
 			self.project_times_btn.setIconSize(QSize(20, 20))
 			self.frame_slider.setEnabled(False)
-		self.update_props_scatter()
+		self.update_props_scatter(feature_changed=False)
 
 	def submit_classification(self):
 		
-		print('submit')
+		self.auto_close = True
 		self.apply_property_query()
+		if not self.auto_close:
+			return None
 
 		if self.time_corr.isChecked():
 			self.class_name_user = 'class_'+self.name_le.text()

celldetective/gui/layouts.py

@@ -8,7 +8,7 @@ from superqt import QLabeledRangeSlider, QLabeledDoubleSlider, QLabeledSlider, Q
 from superqt.fonticon import icon
 from fonticon_mdi6 import MDI6
 from celldetective.utils import _extract_channel_indices_from_config
-from celldetective.gui.viewers import ThresholdedStackVisualizer, CellEdgeVisualizer, StackVisualizer, CellSizeViewer
+from celldetective.gui.viewers import ThresholdedStackVisualizer, CellEdgeVisualizer, StackVisualizer, CellSizeViewer, ChannelOffsetViewer
 from celldetective.gui import Styles
 from celldetective.preprocessing import correct_background_model, correct_background_model_free, estimate_background_per_condition
 from functools import partial
@@ -535,7 +535,6 @@ class BackgroundFitCorrectionLayout(QGridLayout, Styles):
 		self.threshold_viewer_btn.clicked.connect(self.set_threshold_graphically)
 		self.threshold_viewer_btn.setToolTip('Set the threshold graphically.')
 
-
 		self.model_lbl = QLabel('Model: ')
 		self.model_lbl.setToolTip('2D model to fit the background with.')
 		self.models_cb = QComboBox()
@@ -560,6 +559,8 @@ class BackgroundFitCorrectionLayout(QGridLayout, Styles):
 																			   self.corrected_stack_viewer,
 																			   self.add_correction_btn
 																			   ])
+
+
 	def add_to_layout(self):
 		
 		channel_layout = QHBoxLayout()
@@ -572,6 +573,7 @@ class BackgroundFitCorrectionLayout(QGridLayout, Styles):
 		subthreshold_layout = QHBoxLayout()
 		subthreshold_layout.addWidget(self.threshold_le, 95)
 		subthreshold_layout.addWidget(self.threshold_viewer_btn, 5)
+
 		threshold_layout.addLayout(subthreshold_layout, 75)
 		self.addLayout(threshold_layout, 1, 0, 1, 3)
 
@@ -878,18 +880,26 @@ class ProtocolDesignerLayout(QVBoxLayout, Styles):
 
 	def generate_layout(self):
 
+		self.correction_layout = QVBoxLayout()
+
+		self.background_correction_layout = QVBoxLayout()
+		self.background_correction_layout.setContentsMargins(0,0,0,0)
 		self.title_layout = QHBoxLayout()
 		self.title_layout.addWidget(self.title_lbl, 100, alignment=Qt.AlignCenter)
+		self.background_correction_layout.addLayout(self.title_layout)
+		self.background_correction_layout.addWidget(self.tabs)
+		self.correction_layout.addLayout(self.background_correction_layout)
+		
+		self.addLayout(self.correction_layout)
 
-		self.addLayout(self.title_layout)
-		self.addWidget(self.tabs)
-
+		self.list_layout = QVBoxLayout()
 		list_header_layout = QHBoxLayout()
 		list_header_layout.addWidget(self.protocol_list_lbl)
 		list_header_layout.addWidget(self.delete_protocol_btn, alignment=Qt.AlignRight)
-		self.addLayout(list_header_layout)
+		self.list_layout.addLayout(list_header_layout)
+		self.list_layout.addWidget(self.protocol_list)
 
-		self.addWidget(self.protocol_list)
+		self.addLayout(self.list_layout)
 
 
 	def remove_protocol_from_list(self):
@@ -899,6 +909,117 @@ class ProtocolDesignerLayout(QVBoxLayout, Styles):
 			del self.protocols[current_item]
 			self.protocol_list.takeItem(current_item)
 
+class ChannelOffsetOptionsLayout(QVBoxLayout, Styles):
+	
+	def __init__(self, parent_window=None, *args, **kwargs):
+		
+		super().__init__(*args, **kwargs)
+
+		self.parent_window = parent_window
+		if hasattr(self.parent_window.parent_window, 'exp_config'):
+			self.attr_parent = self.parent_window.parent_window
+		else:
+			self.attr_parent = self.parent_window.parent_window.parent_window
+
+		self.channel_names = self.attr_parent.exp_channels
+
+		self.setContentsMargins(15,15,15,15)
+		self.generate_widgets()
+		self.add_to_layout()
+
+	def generate_widgets(self):
+		
+		self.channel_lbl = QLabel('Channel: ')
+		self.channels_cb = QComboBox()
+		self.channels_cb.addItems(self.channel_names)
+
+		self.shift_lbl = QLabel('Shift: ')
+		self.shift_h_lbl = QLabel('(h): ')
+		self.shift_v_lbl = QLabel('(v): ')
+
+		self.set_shift_btn = QPushButton()
+		self.set_shift_btn.setIcon(icon(MDI6.image_check, color="k"))
+		self.set_shift_btn.setStyleSheet(self.button_select_all)
+		self.set_shift_btn.setToolTip('Set the channel shift.')
+		self.set_shift_btn.clicked.connect(self.open_offset_viewer)
+		
+		self.add_correction_btn = QPushButton('Add correction')
+		self.add_correction_btn.setStyleSheet(self.button_style_sheet_2)
+		self.add_correction_btn.setIcon(icon(MDI6.plus, color="#1565c0"))
+		self.add_correction_btn.setToolTip('Add correction.')
+		self.add_correction_btn.setIconSize(QSize(25, 25))
+		self.add_correction_btn.clicked.connect(self.add_instructions_to_parent_list)
+
+		self.vertical_shift_le = ThresholdLineEdit(init_value=0, connected_buttons=[self.add_correction_btn],placeholder='vertical shift [pixels]', value_type='float')
+		self.horizontal_shift_le = ThresholdLineEdit(init_value=0, connected_buttons=[self.add_correction_btn],placeholder='vertical shift [pixels]', value_type='float')
+	
+	def add_to_layout(self):
+
+		channel_ch_hbox = QHBoxLayout()
+		channel_ch_hbox.addWidget(self.channel_lbl, 25)
+		channel_ch_hbox.addWidget(self.channels_cb, 75)
+		self.addLayout(channel_ch_hbox)
+
+		shift_hbox = QHBoxLayout()
+		shift_hbox.addWidget(self.shift_lbl, 25)
+		
+		shift_subhbox = QHBoxLayout()
+		shift_subhbox.addWidget(self.shift_h_lbl, 10)
+		shift_subhbox.addWidget(self.horizontal_shift_le, 75//2)
+		shift_subhbox.addWidget(self.shift_v_lbl, 10)
+		shift_subhbox.addWidget(self.vertical_shift_le, 75//2)	
+		shift_subhbox.addWidget(self.set_shift_btn, 5)
+
+		shift_hbox.addLayout(shift_subhbox, 75)
+		self.addLayout(shift_hbox)
+
+		btn_hbox = QHBoxLayout()
+		btn_hbox.addWidget(self.add_correction_btn, 95)
+		self.addLayout(btn_hbox)		
+
+	def add_instructions_to_parent_list(self):
+
+		self.generate_instructions()
+		self.parent_window.protocol_layout.protocols.append(self.instructions)
+		correction_description = ""
+		for index, (key, value) in enumerate(self.instructions.items()):
+			if index > 0:
+				correction_description += ", "
+			correction_description += str(key) + " : " + str(value)
+		self.parent_window.protocol_layout.protocol_list.addItem(correction_description)
+
+	def generate_instructions(self):
+
+		self.instructions = {
+					  "correction_type": "offset",
+					  "target_channel": self.channels_cb.currentText(),
+					  "correction_horizontal": self.horizontal_shift_le.get_threshold(),
+					  "correction_vertical": self.vertical_shift_le.get_threshold(),
+					 }
+
+
+	def set_target_channel(self):
+
+		channel_indices = _extract_channel_indices_from_config(self.attr_parent.exp_config, [self.channels_cb.currentText()])
+		self.target_channel = channel_indices[0]
+
+	def open_offset_viewer(self):
+		
+		self.attr_parent.locate_image()
+		self.set_target_channel()
+
+		if self.attr_parent.current_stack is not None:
+			self.viewer = ChannelOffsetViewer(
+											 parent_window = self,
+											 stack_path=self.attr_parent.current_stack,
+											 channel_names=self.attr_parent.exp_channels,
+											 n_channels=len(self.channel_names),
+											 channel_cb=True,
+											 target_channel=self.target_channel,
+											 window_title='offset viewer',
+											)
+			self.viewer.show()
+
 
 class BackgroundModelFreeCorrectionLayout(QGridLayout, Styles):
 	

celldetective/gui/measurement_options.py

@@ -154,7 +154,7 @@ class ConfigMeasurements(QMainWindow, Styles):
 
 		grid = QGridLayout(self.iso_frame)
 
-		self.iso_lbl = QLabel("ISOTROPIC MEASUREMENTS")
+		self.iso_lbl = QLabel("Position-based measurements".upper())
 		self.iso_lbl.setStyleSheet("""
 			font-weight: bold;
 			padding: 0px;
@@ -171,7 +171,7 @@ class ConfigMeasurements(QMainWindow, Styles):
 
 		grid = QGridLayout(self.features_frame)
 
-		self.feature_lbl = QLabel("FEATURES")
+		self.feature_lbl = QLabel("Mask-based measurements".upper())
 		self.feature_lbl.setStyleSheet("""
 			font-weight: bold;
 			padding: 0px;
@@ -262,7 +262,7 @@ class ConfigMeasurements(QMainWindow, Styles):
 		self.add_feature_btn.setToolTip("Add feature")
 		self.add_feature_btn.setIconSize(QSize(20, 20))
 
-		self.features_list = ListWidget(FeatureChoice, initial_features=['area', 'intensity_mean', ])
+		self.features_list = ListWidget(FeatureChoice, initial_features=['area', 'intensity_nanmean', ])
 
 		self.del_feature_btn.clicked.connect(self.features_list.removeSel)
 		self.add_feature_btn.clicked.connect(self.features_list.addItem)