celldetective 1.1.0__py3-none-any.whl → 1.1.1.post1__py3-none-any.whl

celldetective/__main__.py

@@ -54,6 +54,11 @@ class AppInitWindow(QMainWindow):
 		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):
 
@@ -365,25 +370,6 @@ class AppInitWindow(QMainWindow):
 			if returnValue == QMessageBox.Ok:
 				self.experiment_path_selection.setText('')
 				return None
-	
-	def closeEvent(self, event):
-
-		"""
-		Close child windows if closed.
-		"""
-		
-		try:
-			if self.control_panel:
-				self.control_panel.close()
-		except:
-			pass
-		try:
-			if self.new_exp_window:
-				self.new_exp_window.close()
-		except:
-			pass
-
-		gc.collect()
 
 if __name__ == "__main__":
 

celldetective/extra_properties.py

@@ -7,7 +7,7 @@ If intensity is in function name, it will be replaced by the name of the channel
 import warnings
 
 import numpy as np
-from scipy.ndimage import distance_transform_edt
+from scipy.ndimage import distance_transform_edt, center_of_mass
 from scipy.spatial.distance import euclidean
 
 
@@ -34,67 +34,77 @@ def intensity_percentile_twenty_five(regionmask, intensity_image):
 # STD
 
 def intensity_std(regionmask, intensity_image):
-    return np.nanstd(intensity_image[regionmask])
+	return np.nanstd(intensity_image[regionmask])
 
 
 def intensity_median(regionmask, intensity_image):
-    return np.nanmedian(intensity_image[regionmask])
+	return np.nanmedian(intensity_image[regionmask])
 
+def intensity_nanmean(regionmask, intensity_image):
+	return np.nanmean(intensity_image[regionmask])
 
 def intensity_centre_of_mass_displacement(regionmask, intensity_image):
-    y, x = np.mgrid[:regionmask.shape[0], :regionmask.shape[1]]
-    xtemp = x.copy()
-    ytemp = y.copy()
-
-    centroid_x = np.sum(xtemp * intensity_image) / np.sum(intensity_image)
-    centroid_y = np.sum(ytemp * intensity_image) / np.sum(intensity_image)
-    geometric_centroid_x = np.sum(xtemp * regionmask) / np.sum(regionmask)
-    geometric_centroid_y = np.sum(ytemp * regionmask) / np.sum(regionmask)
-    distance = euclidean(np.array((geometric_centroid_y, geometric_centroid_x)), np.array((centroid_y, centroid_x)))
-    delta_x = geometric_centroid_x - centroid_x
-    delta_y = geometric_centroid_y - centroid_y
-    direction_arctan = np.arctan2(delta_x, delta_y) * 180 / np.pi
-    return distance, direction_arctan
-
+	y, x = np.mgrid[:regionmask.shape[0], :regionmask.shape[1]]
+	xtemp = x.copy()
+	ytemp = y.copy()
+	intensity_weighted_center = center_of_mass(intensity_image, regionmask)
+	centroid_x = intensity_weighted_center[1]
+	centroid_y = intensity_weighted_center[0]
+
+	geometric_centroid_x = np.sum(xtemp * regionmask) / np.sum(regionmask)
+	geometric_centroid_y = np.sum(ytemp * regionmask) / np.sum(regionmask)
+	distance = euclidean(np.array((geometric_centroid_y, geometric_centroid_x)), np.array((centroid_y, centroid_x)))
+	delta_x = geometric_centroid_x - centroid_x
+	delta_y = geometric_centroid_y - centroid_y
+	direction_arctan = np.arctan2(delta_y, delta_x) * 180 / np.pi
+	if direction_arctan < 0:
+		direction_arctan += 360
+	return distance, direction_arctan
 
 def intensity_radial_gradient(regionmask, intensity_image):
-    warnings.filterwarnings('ignore', message="Polyfit may be poorly conditioned")
-    cell_mask = regionmask.copy()
-    intensity = intensity_image.copy()
-    y = intensity[cell_mask].flatten()
-    x = distance_transform_edt(cell_mask)
-    x = x[cell_mask].flatten()
-    params = np.polyfit(x, y, 1)
-    line = np.poly1d(params)
+	warnings.filterwarnings('ignore', message="Polyfit may be poorly conditioned")
+	cell_mask = regionmask.copy()
+	intensity = intensity_image.copy()
+	y = intensity[cell_mask].flatten()
+	x = distance_transform_edt(cell_mask)
+	x = x[cell_mask].flatten()
+	params = np.polyfit(x, y, 1)
+	line = np.poly1d(params)
 
-    return line.coefficients[0], line.coefficients[1]
+	return line.coefficients[0], line.coefficients[1]
 
 
 def intensity_centre_of_mass_displacement_edge(regionmask, intensity_image):
-    edt = distance_transform_edt(regionmask)
-    min_distance = 0
-    max_distance = 0.1*edt.max()
-    thresholded = (edt <= max_distance) * (edt > min_distance)
-    edge_mask = np.copy(regionmask)
-    edge_mask[np.where(thresholded == 0)] = 0
-    y, x = np.mgrid[:edge_mask.shape[0], :edge_mask.shape[1]]
-    xtemp = x.copy()
-    ytemp = y.copy()
-    intensity_edge = intensity_image.copy()
-    intensity_edge[np.where(edge_mask == 0)] = 0.
-    sum_intensity_edge = np.sum(intensity_edge)
-    sum_regionmask = np.sum(regionmask)
-
-    if sum_intensity_edge != 0 and sum_regionmask != 0:
-        centroid_x = np.sum(xtemp * intensity_edge) / sum_intensity_edge
-        centroid_y = np.sum(ytemp * intensity_edge) / sum_intensity_edge
-        geometric_centroid_x = np.sum(xtemp * regionmask) / sum_regionmask
-        geometric_centroid_y = np.sum(ytemp * regionmask) / sum_regionmask
-
-        distance = euclidean((geometric_centroid_y, geometric_centroid_x), (centroid_y, centroid_x))
-        delta_x = geometric_centroid_x - centroid_x
-        delta_y = geometric_centroid_y - centroid_y
-        direction_arctan = np.arctan2(delta_y, delta_x) * 180 / np.pi
-        return distance, direction_arctan
-    else:
-        return np.nan, np.nan
+	edt = distance_transform_edt(regionmask)
+	min_distance = 0
+	max_distance = 0.1*edt.max()
+	thresholded = (edt <= max_distance) * (edt > min_distance)
+	edge_mask = np.copy(regionmask)
+	edge_mask[np.where(thresholded == 0)] = 0
+	y, x = np.mgrid[:edge_mask.shape[0], :edge_mask.shape[1]]
+	xtemp = x.copy()
+	ytemp = y.copy()
+	intensity_edge = intensity_image.copy()
+	intensity_edge[np.where(edge_mask == 0)] = 0.
+	sum_intensity_edge = np.sum(intensity_edge)
+	sum_regionmask = np.sum(regionmask)
+
+	if sum_intensity_edge != 0 and sum_regionmask != 0:
+		y, x = np.mgrid[:regionmask.shape[0], :regionmask.shape[1]]
+		xtemp = x.copy()
+		ytemp = y.copy()
+		intensity_weighted_center = center_of_mass(intensity_image, regionmask)
+		centroid_x = intensity_weighted_center[1]
+		centroid_y = intensity_weighted_center[0]
+
+		geometric_centroid_x = np.sum(xtemp * regionmask) / np.sum(regionmask)
+		geometric_centroid_y = np.sum(ytemp * regionmask) / np.sum(regionmask)
+		distance = euclidean(np.array((geometric_centroid_y, geometric_centroid_x)), np.array((centroid_y, centroid_x)))
+		delta_x = geometric_centroid_x - centroid_x
+		delta_y = geometric_centroid_y - centroid_y
+		direction_arctan = np.arctan2(delta_y, delta_x) * 180 / np.pi
+		if direction_arctan < 0:
+			direction_arctan += 360
+		return distance, direction_arctan
+	else:
+		return np.nan, np.nan

celldetective/filters.py

@@ -1,21 +1,36 @@
 from skimage.filters import difference_of_gaussians, threshold_otsu, threshold_local, threshold_niblack, threshold_sauvola
+from celldetective.utils import interpolate_nan
 import scipy.ndimage as snd
 import numpy as np
 
-def gauss_filter(img, sigma, *kwargs):
+def gauss_filter(img, sigma, interpolate=True, *kwargs):
+	if interpolate:
+		img = interpolate_nan(img.astype(float))
 	return snd.gaussian_filter(img.astype(float), sigma, *kwargs)
 
-def median_filter(img, size, *kwargs):
+def median_filter(img, size, interpolate=True, *kwargs):
+	if interpolate:
+		img = interpolate_nan(img.astype(float))
+
 	size = int(size)
 	return snd.median_filter(img, size, *kwargs)
 
-def maximum_filter(img, size, *kwargs):
+def maximum_filter(img, size, interpolate=True, *kwargs):
+	if interpolate:
+		img = interpolate_nan(img.astype(float))
+
 	return snd.maximum_filter(img.astype(float), size, *kwargs)
 
-def minimum_filter(img, size, *kwargs):
+def minimum_filter(img, size, interpolate=True, *kwargs):
+	if interpolate:
+		img = interpolate_nan(img.astype(float))
+
 	return snd.minimum_filter(img.astype(float), size, *kwargs)
 
-def percentile_filter(img, percentile, size, *kwargs):
+def percentile_filter(img, percentile, size, interpolate=True, *kwargs):
+	if interpolate:
+		img = interpolate_nan(img.astype(float))
+
 	return snd.percentile_filter(img.astype(float), percentile, size, *kwargs)
 
 def subtract_filter(img, value, *kwargs):
@@ -24,14 +39,19 @@ def subtract_filter(img, value, *kwargs):
 def abs_filter(img, *kwargs):
 	return np.abs(img)
 
-def ln_filter(img, *kwargs):
+def ln_filter(img, interpolate=True, *kwargs):
+	if interpolate:
+		img = interpolate_nan(img.astype(float))
 
 	img[np.where(img>0.)] = np.log(img[np.where(img>0.)])
 	img[np.where(img<=0.)] = 0.
 
 	return img
 
-def variance_filter(img, size):
+def variance_filter(img, size, interpolate=True):
+
+	if interpolate:
+		img = interpolate_nan(img.astype(float))
 
 	size = int(size)
 	img = img.astype(float)
@@ -41,8 +61,10 @@ def variance_filter(img, size):
 
 	return img
 
-def std_filter(img, size):
+def std_filter(img, size, interpolate=True):
 
+	if interpolate:
+		img = interpolate_nan(img.astype(float))
 	size = int(size)
 	img = img.astype(float)
 	win_mean = snd.uniform_filter(img, (size,size), mode='wrap')
@@ -53,10 +75,14 @@ def std_filter(img, size):
 
 	return img
 
-def laplace_filter(img, output=float, *kwargs):
+def laplace_filter(img, output=float, interpolate=True, *kwargs):
+	if interpolate:
+		img = interpolate_nan(img.astype(float))
 	return snd.laplace(img.astype(float), *kwargs)
 
-def dog_filter(img, sigma_low, sigma_high, *kwargs):
+def dog_filter(img, sigma_low, sigma_high, interpolate=True, *kwargs):
+	if interpolate:
+		img = interpolate_nan(img.astype(float))
 	return difference_of_gaussians(img.astype(float), sigma_low, sigma_high, *kwargs)
 
 def otsu_filter(img, *kwargs):
@@ -82,7 +108,9 @@ def sauvola_filter(img, *kwargs):
 def log_filter(img, sigma, *kwargs):
 	return snd.gaussian_laplace(img.astype(float), sigma, *kwargs)
 
-def tophat_filter(img, size, connectivity=4, *kwargs):
+def tophat_filter(img, size, connectivity=4, interpolate=True, *kwargs):
+	if interpolate:
+		img = interpolate_nan(img.astype(float))
 	structure = snd.generate_binary_structure(rank=2, connectivity=connectivity)
 	img = snd.white_tophat(img.astype(float), structure=structure, size=size, *kwargs)
 	return img

celldetective/gui/classifier_widget.py

@@ -136,9 +136,10 @@ class ClassifierWidget(QWidget, Styles):
 
 		self.irreversible_event_btn = QRadioButton('irreversible event')
 		self.unique_state_btn = QRadioButton('unique state')
-		self.time_corr_options = [self.irreversible_event_btn, self.unique_state_btn]
 		time_corr_btn_group = QButtonGroup()
 		self.unique_state_btn.click()
+		self.time_corr_options = [self.irreversible_event_btn, self.unique_state_btn]
+
 		for btn in self.time_corr_options:
 			time_corr_btn_group.addButton(btn)
 			btn.setEnabled(False)
@@ -148,8 +149,28 @@ class ClassifierWidget(QWidget, Styles):
 		time_corr_layout.addWidget(self.irreversible_event_btn, 50,alignment=Qt.AlignCenter)
 		layout.addLayout(time_corr_layout)
 
+		self.r2_slider = QLabeledDoubleSlider()
+		self.r2_slider.setValue(0.75)
+		self.r2_slider.setRange(0,1)
+		self.r2_slider.setSingleStep(0.01)
+		self.r2_slider.setOrientation(1)
+		self.r2_label = QLabel('R2 tolerance:')
+		self.r2_label.setToolTip('Minimum R2 between the fit sigmoid and the binary response to the filters to accept the event.')
+		r2_threshold_layout = QHBoxLayout()
+		r2_threshold_layout.addWidget(QLabel(''), 50)
+		r2_threshold_layout.addWidget(self.r2_label, 15)
+		r2_threshold_layout.addWidget(self.r2_slider, 35)
+		layout.addLayout(r2_threshold_layout)	
+		
+		self.irreversible_event_btn.clicked.connect(self.activate_r2)
+		self.unique_state_btn.clicked.connect(self.activate_r2)
+
+		for wg in [self.r2_slider, self.r2_label]:
+			wg.setEnabled(False)
+
 		layout.addWidget(QLabel())
 
+
 		self.submit_btn = QPushButton('apply')
 		self.submit_btn.setStyleSheet(self.button_style_sheet)
 		self.submit_btn.clicked.connect(self.submit_classification)
@@ -158,14 +179,30 @@ class ClassifierWidget(QWidget, Styles):
 		self.frame_slider.valueChanged.connect(self.set_frame)
 		self.alpha_slider.valueChanged.connect(self.set_transparency)
 
+	def activate_r2(self):
+		if self.irreversible_event_btn.isChecked() and self.time_corr.isChecked():
+			for wg in [self.r2_slider, self.r2_label]:
+				wg.setEnabled(True)
+		else:
+			for wg in [self.r2_slider, self.r2_label]:
+				wg.setEnabled(False)				
+
 	def activate_time_corr_options(self):
 
 		if self.time_corr.isChecked():
 			for btn in self.time_corr_options:
 				btn.setEnabled(True)
+			if self.irreversible_event_btn.isChecked():
+				for wg in [self.r2_slider, self.r2_label]:
+					wg.setEnabled(True)
+			else:
+				for wg in [self.r2_slider, self.r2_label]:
+					wg.setEnabled(False)				
 		else:
 			for btn in self.time_corr_options:
 				btn.setEnabled(False)
+			for wg in [self.r2_slider, self.r2_label]:
+				wg.setEnabled(False)
 
 	def init_class(self):
 
@@ -207,8 +244,20 @@ class ClassifierWidget(QWidget, Styles):
 			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())
-		self.ax_props.set_xlim(1*self.df[self.features_cb[1].currentText()].min(),1.0*self.df[self.features_cb[1].currentText()].max())
-		self.ax_props.set_ylim(1*self.df[self.features_cb[0].currentText()].min(),1.0*self.df[self.features_cb[0].currentText()].max())
+
+
+		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()
@@ -400,15 +449,16 @@ class ClassifierWidget(QWidget, Styles):
 			timeline = group['FRAME'].values
 			
 			try:
-				popt, pcov = curve_fit(step_function, timeline, status_signal,p0=[self.df['FRAME'].max()//2, 0.5],maxfev=10000)
-				r2 = r2_score(status_signal, step_function(timeline, *popt))
+				popt, pcov = curve_fit(step_function, timeline.astype(int), status_signal, p0=[self.df['FRAME'].max()//2, 0.8],maxfev=30000)
+				values = [step_function(t, *popt) for t in timeline]
+				r2 = r2_score(status_signal,values)
 			except Exception as e:
 				print(e)
 				self.df.loc[indices, self.class_name_user] = 2.0
 				self.df.loc[indices, self.class_name_user.replace('class','t')] = -1
 				continue
 
-			if r2 > 0.7:
+			if r2 > float(self.r2_slider.value()):
 				t0 = popt[0]
 				self.df.loc[indices, self.class_name_user.replace('class','t')] = t0
 				self.df.loc[indices, self.class_name_user] = 0.0
@@ -426,4 +476,3 @@ class ClassifierWidget(QWidget, Styles):
 
 
 
-

celldetective/gui/control_panel.py

@@ -319,6 +319,11 @@ class ControlPanel(QMainWindow, Styles):
 					process_block.ConfigSignalAnnotator.close()
 			except:
 				pass
+			try:
+				if process_block.tab_ui:
+					process_block.tab_ui.close()
+			except:
+				pass
 
 		try:
 			if self.cfg_editor:

celldetective/gui/layouts.py

@@ -192,6 +192,7 @@ class BackgroundFitCorrectionLayout(QGridLayout, Styles):
 						   clip = clip,
 						   export= False,
 						   return_stacks=True,
+						   activation_protocol=[['gauss',2],['std',4]],
 						   show_progress_per_well = True,
 						   show_progress_per_pos = False,
 							)
@@ -701,12 +702,12 @@ class BackgroundModelFreeCorrectionLayout(QGridLayout, Styles):
 						   show_progress_per_pos = False,
 							)
 		
-
 		self.viewer = StackVisualizer(
 									  stack=corrected_stacks[0],
 									  window_title='Corrected channel',
 									  frame_slider = True,
-									  contrast_slider = True
+									  contrast_slider = True,
+									  target_channel=self.channels_cb.currentIndex(),
 									 )
 		self.viewer.show()
 	

celldetective/gui/measurement_options.py

@@ -21,8 +21,7 @@ from fonticon_mdi6 import MDI6
 from celldetective.gui.thresholds_gui import ThresholdNormalisation, ThresholdSpot
 from celldetective.utils import extract_experiment_channels, get_software_location
 from celldetective.io import interpret_tracking_configuration, load_frames, auto_load_number_of_frames
-from celldetective.measure import compute_haralick_features, contour_of_instance_segmentation, correct_image, \
-    field_normalisation, normalise_by_cell
+from celldetective.measure import compute_haralick_features, contour_of_instance_segmentation, normalise_by_cell
 import numpy as np
 from tifffile import imread
 import json
@@ -736,6 +735,17 @@ class ConfigMeasurements(QMainWindow, Styles):
                 return None
         else:
             self.current_stack = movies[0]
+            self.stack_length = auto_load_number_of_frames(self.current_stack)
+            
+            if self.stack_length is None:
+                stack = imread(self.current_stack)
+                self.stack_length = len(stack)
+                del stack
+                gc.collect()
+            
+            self.mid_time = self.stack_length // 2
+            indices = self.mid_time + np.arange(len(self.channel_names))
+            self.test_frame = load_frames(list(indices.astype(int)),self.current_stack, normalize_input=False)
 
 
     def control_haralick_digitalization(self):
@@ -824,7 +834,7 @@ class ConfigMeasurements(QMainWindow, Styles):
         Load the first mask of the detected movie.
         """
 
-        labels_path = str(Path(self.stack0).parent_window.parent_window) + f'/labels_{self.mode}/'
+        labels_path = str(Path(self.current_stack).parent.parent) + os.sep+f'labels_{self.mode}'+os.sep
         masks = natsorted(glob(labels_path + '*.tif'))
         if len(masks) == 0:
             print('no mask found')
@@ -859,47 +869,6 @@ class ConfigMeasurements(QMainWindow, Styles):
         self.im_mask.set_alpha(value)
         self.fig_contour.canvas.draw_idle()
 
-    # def populate_normalisation_tabs(self):
-
-    #     """
-    #     Multi-tab options to perform background correction before measurements.
-    #     """
-
-    #     layout = QVBoxLayout(self.normalisation_frame)
-
-    #     self.normalisation_lbl = QLabel("BACKGROUND CORRECTION")
-    #     self.normalisation_lbl.setStyleSheet("""
-    #         font-weight: bold;
-    #         padding: 0px;
-    #         """)
-    #     layout.addWidget(self.normalisation_lbl, alignment=Qt.AlignCenter)
-
-
-    #     self.tabs = QTabWidget()
-    #     self.tabs.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
-
-    #     self.tab1, self.tab2 = QWidget(), QWidget()
-    #     self.normalisation_list = QListWidget()
-    #     self.tabs.addTab(self.tab1, 'Local')
-    #     self.tabs.addTab(self.tab2, 'Field')
-    #     self.local_correction_layout = LocalCorrectionLayout(self, self.tab1)
-    #     self.fit_correction_layout = BackgroundFitCorrectionLayout(self, self.tab2)
-    #     layout.addWidget(self.tabs)
-
-    #     self.norm_list_lbl = QLabel('Background correction to perform:')
-    #     hbox = QHBoxLayout()
-    #     hbox.addWidget(self.norm_list_lbl)
-    #     self.del_norm_btn = QPushButton("")
-    #     self.del_norm_btn.setStyleSheet(self.button_select_all)
-    #     self.del_norm_btn.setIcon(icon(MDI6.trash_can, color="black"))
-    #     self.del_norm_btn.setToolTip("Remove background correction")
-    #     self.del_norm_btn.setIconSize(QSize(20, 20))
-    #     hbox.addWidget(self.del_norm_btn, alignment=Qt.AlignRight)
-    #     layout.addLayout(hbox)
-    #     self.del_norm_btn.clicked.connect(self.remove_item_from_list)
-    #     layout.addWidget(self.normalisation_list)
-
-
     def remove_item_from_list(self):
         current_item = self.normalisation_list.currentRow()
         if current_item > -1:
@@ -935,47 +904,6 @@ class ConfigMeasurements(QMainWindow, Styles):
     def fun(self, x, y):
         return x ** 2 + y
 
-    # def preview_normalisation(self):
-    #     plt.close('all')
-    #     plt.figure("Intensity Profiles",figsize=(10, 5))
-    #     self.locate_image()
-    #     diagonal_length = min(self.test_frame[:, :, self.tab2_channel_dropdown.currentIndex()].shape[0], self.test_frame[:, :, self.tab2_channel_dropdown.currentIndex()].shape[1])
-    #     if self.tab2_subtract.isChecked():
-    #         norm_operation='Subtract'
-    #     else:
-    #         norm_operation='Divide'
-    #     normalised, bg_fit = field_normalisation(self.test_frame[:, :, self.tab2_channel_dropdown.currentIndex()],
-    #                                              threshold=self.tab2_txt_threshold.text(),
-    #                                              normalisation_operation=norm_operation,
-    #                                              clip=self.tab2_clip.isChecked(),
-    #                                              mode=self.tab2_dropdown.currentText())
-    #     diagonal_original = [self.test_frame[:, :, self.tab2_channel_dropdown.currentIndex()][i, i] for i in
-    #                          range(diagonal_length)]
-    #     diagonal_corrected = [normalised[i, i] for i in range(diagonal_length)]
-    #     diagonal_indices = np.arange(diagonal_length)
-
-    #     plt.subplot(1, 2, 1)
-    #     plt.plot(diagonal_indices, diagonal_original, color='black', linewidth=0.2)  # Adjust linewidth here
-    #     plt.title('Original Image')
-    #     plt.xlabel('Pixel Index along Diagonal')
-    #     plt.ylabel('Intensity')
-
-    #     plt.subplot(1, 2, 2)
-    #     plt.plot(diagonal_indices, diagonal_corrected, color='black', linewidth=0.2)  # Adjust linewidth here
-    #     plt.title('Corrected Image')
-    #     plt.xlabel('Pixel Index along Diagonal')
-    #     plt.ylabel('Intensity')
-
-    #     plt.tight_layout()
-    #     plt.show()
-
-    #     self.fig, self.ax = plt.subplots()
-    #     self.normalised_img = FigureCanvas(self.fig, "Corrected background image preview")
-    #     self.ax.clear()
-    #     self.ax.imshow(normalised, cmap='gray')
-    #     self.normalised_img.canvas.draw()
-    #     self.normalised_img.show()
-
     def view_normalisation_contour(self):
 
         """
@@ -1061,30 +989,6 @@ class ConfigMeasurements(QMainWindow, Styles):
             if self.test_mask is not None:
                 self.spot_visual = ThresholdSpot(current_channel=self.spot_channel.currentIndex(), img=self.test_frame,
                                                  mask=self.test_mask, parent_window=self)
-        # for dictionary in self.background_correction:
-        #     if self.spot_channel.currentText() in dictionary['target channel']:
-        #         if dictionary['mode'] == 'field':
-        #             if dictionary['operation'] == 'Divide':
-        #                 normalised, bg_fit = field_normalisation(
-        #                     self.test_frame[:, :, self.spot_channel.currentIndex()],
-        #                     threshold=dictionary['threshold'],
-        #                     normalisation_operation=dictionary['operation'],
-        #                     clip=False,
-        #                     mode=dictionary['type'])
-        #             else:
-        #                 normalised, bg_fit = field_normalisation(
-        #                     self.test_frame[:, :, self.spot_channel.currentIndex()],
-        #                     threshold=dictionary['threshold'],
-        #                     normalisation_operation=dictionary['operation'],
-        #                     clip=dictionary['clip'],
-        #                     mode=dictionary['type'])
-        #             self.test_frame[:, :, self.spot_channel.currentIndex()] = normalised
-        #         if dictionary['mode'] == 'local':
-        #             normalised_image = normalise_by_cell(self.test_frame[:, :, self.spot_channel.currentIndex()].copy(), self.test_mask,
-        #                                                  distance=int(dictionary['distance']), mode=dictionary['type'],
-        #                                                  operation=dictionary['operation'])
-        #             self.test_frame[:, :, self.spot_channel.currentIndex()] = normalised_image
-
 
     def enable_spot_detection(self):
         if self.spot_check.isChecked():

celldetective/gui/plot_signals_ui.py

@@ -32,6 +32,7 @@ from lifelines import KaplanMeierFitter
 from matplotlib.cm import viridis, tab10
 import math
 from celldetective.gui import Styles
+from matplotlib import colormaps
 
 
 

celldetective/gui/process_block.py

@@ -1288,7 +1288,7 @@ class PreprocessingPanel(QFrame, Styles):
 				correct_background_model_free(self.exp_dir, 
 								   well_option=well_option,
 								   position_option=pos_option,
-								   export= True,
+								   export = True,
 								   return_stacks=False,
 								   show_progress_per_well = True,
 								   show_progress_per_pos = True,

celldetective/gui/survival_ui.py

@@ -28,6 +28,7 @@ import matplotlib.cm as mcm
 import math
 from celldetective.events import switch_to_events
 from celldetective.gui import Styles
+from matplotlib import colormaps
 
 class ConfigSurvival(QWidget, Styles):
 	
@@ -124,7 +125,12 @@ class ConfigSurvival(QWidget, Styles):
 				self.cbs[i].addItems(self.cb_options[i])
 			choice_layout.addLayout(hbox)
 
-		self.cbs[-1].addColormaps(self.cb_options[-1])
+		for cm in list(colormaps):
+			try:
+				self.cbs[-1].addColormap(cm)
+			except:
+				pass
+
 		main_layout.addLayout(choice_layout)
 
 		self.cbs[0].setCurrentIndex(0)