celldetective 1.3.8.post1__py3-none-any.whl → 1.3.9__py3-none-any.whl

celldetective/_version.py

@@ -1 +1 @@
-__version__ = "1.3.8.post1"
+__version__ = "1.3.9"

celldetective/extra_properties.py

@@ -26,29 +26,125 @@ import numpy as np
 from scipy.ndimage import distance_transform_edt, center_of_mass
 from scipy.spatial.distance import euclidean
 from celldetective.utils import interpolate_nan, contour_of_instance_segmentation
+import skimage.measure as skm
+from stardist import fill_label_holes
+from celldetective.segmentation import segment_frame_from_thresholds
+
+
+# def area_detected_in_ricm(regionmask, intensity_image, target_channel='adhesion_channel'):
+
+# 	instructions = {
+# 		"thresholds": [
+# 			0.02,
+# 			1000
+# 		],
+# 		"filters": [
+# 			[
+# 				"subtract",
+# 				1
+# 			],
+# 			[
+# 				"abs",
+# 				2
+# 			],
+# 			[
+# 				"gauss",
+# 				0.8
+# 			]
+# 		],
+# 		#"marker_min_distance": 1,
+# 		#"marker_footprint_size": 10,
+# 		"feature_queries": [
+# 			"eccentricity > 0.99 or area < 60"
+# 		],
+# 	}
+	
+# 	lbl = segment_frame_from_thresholds(intensity_image, fill_holes=True, do_watershed=False, equalize_reference=None, edge_exclusion=False, **instructions)
+# 	lbl[lbl>0] = 1 # instance to binary
+# 	lbl[~regionmask] = 0 # make sure we don't measure stuff outside cell
+
+# 	return np.sum(lbl)
+
+def fraction_of_area_detected_in_ricm(regionmask, intensity_image, target_channel='adhesion_channel'):
+
+	instructions = {
+		"thresholds": [
+			0.02,
+			1000
+		],
+		"filters": [
+			[
+				"subtract",
+				1
+			],
+			[
+				"abs",
+				2
+			],
+			[
+				"gauss",
+				0.8
+			]
+		],
+	}
+	
+	lbl = segment_frame_from_thresholds(intensity_image, do_watershed=False, fill_holes=True, equalize_reference=None, edge_exclusion=False, **instructions)
+	lbl[lbl>0] = 1 # instance to binary
+	lbl[~regionmask] = 0 # make sure we don't measure stuff outside cell
+	
+	return float(np.sum(lbl)) / float(np.sum(regionmask))
+
+def area_detected_in_ricm(regionmask, intensity_image, target_channel='adhesion_channel'):
+
+	instructions = {
+		"thresholds": [
+			0.02,
+			1000
+		],
+		"filters": [
+			[
+				"subtract",
+				1
+			],
+			[
+				"abs",
+				2
+			],
+			[
+				"gauss",
+				0.8
+			]
+		],
+	}
+	
+	lbl = segment_frame_from_thresholds(intensity_image, do_watershed=False, fill_holes=True, equalize_reference=None, edge_exclusion=False, **instructions)
+	lbl[lbl>0] = 1 # instance to binary
+	lbl[~regionmask] = 0 # make sure we don't measure stuff outside cell
+	
+	return float(np.sum(lbl))
 
-# Percentiles
-
-def custom_area(regionmask):
-	return np.sum(regionmask)
 
-def intensity_area_under_one(regionmask, intensity_image):
+def area_dark(regionmask, intensity_image, target_channel='adhesion_channel', fill_holes=True): #, target_channel='adhesion_channel'
 	
-	subregion = regionmask[intensity_image<1]
-	if len(subregion)>0:
-		return np.sum(subregion)
-	else:
-		return 0.0
+	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 intensity_fraction_of_area_under_one(regionmask, intensity_image):
 
-	subregion = regionmask[intensity_image<1]
-	area = np.sum(regionmask)
+def fraction_of_area_dark(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)) / float(np.sum(regionmask))
 
-	if len(subregion) > 0:
-		return float(np.sum(subregion)) / float(area)
-	else:
-		return 0.0
 
 def intensity_percentile_ninety_nine(regionmask, intensity_image):
 	return np.nanpercentile(intensity_image[regionmask],99)

celldetective/filters.py

@@ -5,14 +5,14 @@ import numpy as np
 
 def gauss_filter(img, sigma, interpolate=True, *kwargs):
 
-	if interpolate:
+	if np.any(img!=img) and interpolate:
 		img = interpolate_nan(img.astype(float))
 
 	return snd.gaussian_filter(img.astype(float), sigma, *kwargs)
 
 def median_filter(img, size, interpolate=True, *kwargs):
 
-	if interpolate:
+	if np.any(img!=img) and interpolate:
 		img = interpolate_nan(img.astype(float))
 
 	size = int(size)
@@ -20,19 +20,19 @@ def median_filter(img, size, interpolate=True, *kwargs):
 	return snd.median_filter(img, size, *kwargs)
 
 def maximum_filter(img, size, interpolate=True, *kwargs):
-	if interpolate:
+	if np.any(img!=img) and interpolate:
 		img = interpolate_nan(img.astype(float))
 
 	return snd.maximum_filter(img.astype(float), size, *kwargs)
 
 def minimum_filter(img, size, interpolate=True, *kwargs):
-	if interpolate:
+	if np.any(img!=img) and interpolate:
 		img = interpolate_nan(img.astype(float))
 
 	return snd.minimum_filter(img.astype(float), size, *kwargs)
 
 def percentile_filter(img, percentile, size, interpolate=True, *kwargs):
-	if interpolate:
+	if np.any(img!=img) and interpolate:
 		img = interpolate_nan(img.astype(float))
 
 	return snd.percentile_filter(img.astype(float), percentile, size, *kwargs)
@@ -44,7 +44,7 @@ def abs_filter(img, *kwargs):
 	return np.abs(img)
 
 def ln_filter(img, interpolate=True, *kwargs):
-	if interpolate:
+	if np.any(img!=img) and interpolate:
 		img = interpolate_nan(img.astype(float))
 
 	img[np.where(img>0.)] = np.log(img[np.where(img>0.)])
@@ -54,7 +54,7 @@ def ln_filter(img, interpolate=True, *kwargs):
 
 def variance_filter(img, size, interpolate=True):
 
-	if interpolate:
+	if np.any(img!=img) and interpolate:
 		img = interpolate_nan(img.astype(float))
 
 	size = int(size)
@@ -67,7 +67,7 @@ def variance_filter(img, size, interpolate=True):
 
 def std_filter(img, size, interpolate=True):
 
-	if interpolate:
+	if np.any(img!=img) and interpolate:
 		img = interpolate_nan(img.astype(float))
 	
 	size = int(size)
@@ -84,13 +84,13 @@ def std_filter(img, size, interpolate=True):
 	return img
 
 def laplace_filter(img, output=float, interpolate=True, *kwargs):
-	if interpolate:
+	if np.any(img!=img) and interpolate:
 		img = interpolate_nan(img.astype(float))
 	return snd.laplace(img.astype(float), *kwargs)
 
 def dog_filter(img, blob_size=None, sigma_low=1, sigma_high=2, interpolate=True, *kwargs):
 	
-	if interpolate:
+	if np.any(img!=img) and interpolate:
 		img = interpolate_nan(img.astype(float))
 	if blob_size is not None:
 		sigma_low = 1.0 / (1.0 + np.sqrt(2)) * blob_size
@@ -121,7 +121,7 @@ def sauvola_filter(img, *kwargs):
 
 def log_filter(img, blob_size=None, sigma=1, interpolate=True, *kwargs):
 
-	if interpolate:
+	if np.any(img!=img) and interpolate:
 		img = interpolate_nan(img.astype(float))
 	if blob_size is not None:
 		sigma_low = 1.0 / (1.0 + np.sqrt(2)) * blob_size
@@ -131,7 +131,7 @@ def log_filter(img, blob_size=None, sigma=1, interpolate=True, *kwargs):
 
 def tophat_filter(img, size, connectivity=4, interpolate=True, *kwargs):
 	
-	if interpolate:
+	if np.any(img!=img) and 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)

celldetective/gui/btrack_options.py

@@ -44,7 +44,7 @@ class ConfigTracking(QMainWindow, Styles):
 		
 		exp_config = self.exp_dir +"config.ini"
 		self.config_path = self.exp_dir + self.config_name
-		self.channel_names, self.channels = extract_experiment_channels(exp_config)
+		self.channel_names, self.channels = extract_experiment_channels(self.exp_dir)
 		self.channel_names = np.array(self.channel_names)
 		self.channels = np.array(self.channels)
 		self.screen_height = self.parent_window.parent_window.parent_window.screen_height

celldetective/gui/control_panel.py

@@ -330,7 +330,7 @@ class ControlPanel(QMainWindow, Styles):
 		self.movie_prefix = ConfigSectionMap(self.exp_config,"MovieSettings")["movie_prefix"]
 
 		# Read channels
-		self.exp_channels, channel_indices = extract_experiment_channels(self.exp_config)
+		self.exp_channels, channel_indices = extract_experiment_channels(self.exp_dir)
 		self.nbr_channels = len(self.exp_channels)
 
 		number_of_wells = len(self.wells)

celldetective/gui/gui_utils.py

@@ -575,10 +575,10 @@ class FeatureChoice(QWidget, Styles):
 								 "intensity_min",
 								 ]
 
-		extra_props = getmembers(extra_properties, isfunction)
-		extra_props = [extra_props[i][0] for i in range(len(extra_props))]
-		if len(extra_props) > 0:
-			standard_measurements.extend(extra_props)
+		members = getmembers(extra_properties, isfunction)
+		for o in members:
+			if isfunction(o[1]) and o[1].__module__=="celldetective.extra_properties":
+				standard_measurements.append(o[0])
 
 		self.combo_box.addItems(standard_measurements)
 

celldetective/gui/measurement_options.py

@@ -58,7 +58,7 @@ class ConfigMeasurements(QMainWindow, Styles):
 
 		exp_config = self.exp_dir + "config.ini"
 		self.config_path = self.exp_dir + self.config_name
-		self.channel_names, self.channels = extract_experiment_channels(exp_config)
+		self.channel_names, self.channels = extract_experiment_channels(self.exp_dir)
 		self.channel_names = np.array(self.channel_names)
 		self.channels = np.array(self.channels)
 

celldetective/gui/plot_signals_ui.py

@@ -164,6 +164,18 @@ class ConfigSignalPlot(QWidget, Styles):
 		pool_layout.addWidget(self.pool_option_cb, 66)
 		main_layout.addLayout(pool_layout)
 
+		n_cells_layout = QHBoxLayout()
+		n_cells_layout.setContentsMargins(20,3,20,3)
+		self.n_cells_slider = QLabeledSlider()
+		self.n_cells_slider.setSingleStep(1)
+		self.n_cells_slider.setOrientation(1)
+		self.n_cells_slider.setRange(1,100)
+		self.n_cells_slider.setValue(2)
+		n_cells_layout.addWidget(QLabel('min # cells\nfor pool:'), 33)
+		n_cells_layout.addWidget(self.n_cells_slider, 66)
+		main_layout.addLayout(n_cells_layout)
+
+
 		self.submit_btn = QPushButton('Submit')
 		self.submit_btn.setStyleSheet(self.button_style_sheet)
 		self.submit_btn.clicked.connect(self.process_signal)
@@ -363,6 +375,11 @@ class ConfigSignalPlot(QWidget, Styles):
 			return None
 
 		# Per position signal
+		self.df = self.df.dropna(subset=['FRAME'])
+		if len(self.df)==0:
+			print('Warning... The dataset is empty. Please check your filters. Abort...')
+			return None
+
 		max_time = int(self.df.FRAME.max()) + 1
 		class_col = self.class_columns[self.cbs[1].currentIndex()]
 		time_col = self.time_columns[self.cbs[2].currentIndex()]
@@ -371,9 +388,9 @@ class ConfigSignalPlot(QWidget, Styles):
 
 		for block,movie_group in self.df.groupby(['well','position']):
 
-			well_signal_mean, well_std_mean, timeline_all, matrix_all = mean_signal(movie_group, self.feature_selected, class_col, time_col=time_col, class_value=None, return_matrix=True, forced_max_duration=max_time, projection=self.pool_option_cb.currentText())
-			well_signal_event, well_std_event, timeline_event, matrix_event = mean_signal(movie_group, self.feature_selected, class_col, time_col=time_col, class_value=[0], return_matrix=True, forced_max_duration=max_time, projection=self.pool_option_cb.currentText())		
-			well_signal_no_event, well_std_no_event, timeline_no_event, matrix_no_event = mean_signal(movie_group, self.feature_selected, class_col, time_col=time_col, class_value=[1], return_matrix=True, forced_max_duration=max_time, projection=self.pool_option_cb.currentText())
+			well_signal_mean, well_std_mean, timeline_all, matrix_all = mean_signal(movie_group, self.feature_selected, class_col, time_col=time_col, class_value=None, return_matrix=True, forced_max_duration=max_time, projection=self.pool_option_cb.currentText(), min_nbr_values=self.n_cells_slider.value())
+			well_signal_event, well_std_event, timeline_event, matrix_event = mean_signal(movie_group, self.feature_selected, class_col, time_col=time_col, class_value=[0], return_matrix=True, forced_max_duration=max_time, projection=self.pool_option_cb.currentText(), min_nbr_values=self.n_cells_slider.value())
+			well_signal_no_event, well_std_no_event, timeline_no_event, matrix_no_event = mean_signal(movie_group, self.feature_selected, class_col, time_col=time_col, class_value=[1], return_matrix=True, forced_max_duration=max_time, projection=self.pool_option_cb.currentText(), min_nbr_values=self.n_cells_slider.value())
 			self.mean_plots_timeline = timeline_all
 
 			self.df_pos_info.loc[self.df_pos_info['pos_path'] == block[1], 'signal'] = [
@@ -386,9 +403,9 @@ class ConfigSignalPlot(QWidget, Styles):
 		# Per well
 		for well,well_group in self.df.groupby('well'):
 
-			well_signal_mean, well_std_mean, timeline_all, matrix_all = mean_signal(well_group, self.feature_selected, class_col, time_col=time_col, class_value=None, return_matrix=True, forced_max_duration=max_time, projection=self.pool_option_cb.currentText())
-			well_signal_event, well_std_event, timeline_event, matrix_event = mean_signal(well_group, self.feature_selected, class_col, time_col=time_col, class_value=[0], return_matrix=True, forced_max_duration=max_time, projection=self.pool_option_cb.currentText())			
-			well_signal_no_event, well_std_no_event, timeline_no_event, matrix_no_event = mean_signal(well_group, self.feature_selected, class_col, time_col=time_col, class_value=[1], return_matrix=True, forced_max_duration=max_time, projection=self.pool_option_cb.currentText())
+			well_signal_mean, well_std_mean, timeline_all, matrix_all = mean_signal(well_group, self.feature_selected, class_col, time_col=time_col, class_value=None, return_matrix=True, forced_max_duration=max_time, projection=self.pool_option_cb.currentText(), min_nbr_values=self.n_cells_slider.value())
+			well_signal_event, well_std_event, timeline_event, matrix_event = mean_signal(well_group, self.feature_selected, class_col, time_col=time_col, class_value=[0], return_matrix=True, forced_max_duration=max_time, projection=self.pool_option_cb.currentText(), min_nbr_values=self.n_cells_slider.value())			
+			well_signal_no_event, well_std_no_event, timeline_no_event, matrix_no_event = mean_signal(well_group, self.feature_selected, class_col, time_col=time_col, class_value=[1], return_matrix=True, forced_max_duration=max_time, projection=self.pool_option_cb.currentText(), min_nbr_values=self.n_cells_slider.value())
 			
 			self.df_well_info.loc[self.df_well_info['well_path']==well,'signal'] = [{'mean_all': well_signal_mean, 'std_all': well_std_mean,'matrix_all': matrix_all,'mean_event': well_signal_event, 'std_event': well_std_event,
 																					'matrix_event': matrix_event,'mean_no_event': well_signal_no_event, 'std_no_event': well_std_no_event, 'matrix_no_event': matrix_no_event, 'timeline':  self.mean_plots_timeline}]

celldetective/gui/process_block.py

@@ -1503,7 +1503,7 @@ class PreprocessingPanel(QFrame, Styles):
 		self.exp_dir = self.parent_window.exp_dir
 		self.wells = np.array(self.parent_window.wells,dtype=str)
 		exp_config = self.exp_dir + "config.ini"
-		self.channel_names, self.channels = extract_experiment_channels(exp_config)
+		self.channel_names, self.channels = extract_experiment_channels(self.exp_dir)
 		self.channel_names = np.array(self.channel_names)
 		self.background_correction = []
 		self.onlyFloat = QDoubleValidator()

celldetective/gui/processes/measure_cells.py

@@ -75,7 +75,7 @@ class MeasurementProcess(Process):
 	def read_measurement_instructions(self):
 
 		print('Looking for measurement instruction file...')
-		instr_path = PurePath(self.expfolder,Path(f"{self.instruction_file}"))
+		instr_path = PurePath(self.exp_dir,Path(f"{self.instruction_file}"))
 		if os.path.exists(instr_path):
 			with open(instr_path, 'r') as f:
 				self.instructions = json.load(f)
@@ -175,14 +175,14 @@ class MeasurementProcess(Process):
 		self.shape_x = int(ConfigSectionMap(self.config,"MovieSettings")["shape_x"])
 		self.shape_y = int(ConfigSectionMap(self.config,"MovieSettings")["shape_y"])
 
-		self.channel_names, self.channel_indices = extract_experiment_channels(self.config)
+		self.channel_names, self.channel_indices = extract_experiment_channels(self.exp_dir)
 		self.nbr_channels = len(self.channel_names)
 
 	def locate_experiment_config(self):
 
 		parent1 = Path(self.pos).parent
-		self.expfolder = parent1.parent
-		self.config = PurePath(self.expfolder,Path("config.ini"))
+		self.exp_dir = parent1.parent
+		self.config = PurePath(self.exp_dir,Path("config.ini"))
 
 		if not os.path.exists(self.config):
 			print('The configuration file for the experiment was not found...')

celldetective/gui/processes/segment_cells.py

@@ -66,13 +66,13 @@ class BaseSegmentProcess(Process):
 		self.len_movie = float(ConfigSectionMap(self.config,"MovieSettings")["len_movie"])
 		self.movie_prefix = ConfigSectionMap(self.config,"MovieSettings")["movie_prefix"]
 		self.nbr_channels = _extract_nbr_channels_from_config(self.config)
-		self.channel_names, self.channel_indices = extract_experiment_channels(self.config)
+		self.channel_names, self.channel_indices = extract_experiment_channels(self.exp_dir)
 
 	def locate_experiment_config(self):
 
 		parent1 = Path(self.pos).parent
-		expfolder = parent1.parent
-		self.config = PurePath(expfolder,Path("config.ini"))
+		self.exp_dir = parent1.parent
+		self.config = PurePath(self.exp_dir,Path("config.ini"))
 
 		if not os.path.exists(self.config):
 			print('The configuration file for the experiment could not be located. Abort.')

celldetective/gui/processes/track_cells.py

@@ -60,7 +60,7 @@ class TrackingProcess(Process):
 
 	def read_tracking_instructions(self):
 
-		instr_path = PurePath(self.expfolder,Path(f"{self.instruction_file}"))
+		instr_path = PurePath(self.exp_dir,Path(f"{self.instruction_file}"))
 		if os.path.exists(instr_path):
 			print(f"Tracking instructions for the {self.mode} population have been successfully loaded...")
 			with open(instr_path, 'r') as f:
@@ -156,14 +156,14 @@ class TrackingProcess(Process):
 		self.shape_x = int(ConfigSectionMap(self.config,"MovieSettings")["shape_x"])
 		self.shape_y = int(ConfigSectionMap(self.config,"MovieSettings")["shape_y"])
 
-		self.channel_names, self.channel_indices = extract_experiment_channels(self.config)
+		self.channel_names, self.channel_indices = extract_experiment_channels(self.exp_dir)
 		self.nbr_channels = len(self.channel_names)
 
 	def locate_experiment_config(self):
 
 		parent1 = Path(self.pos).parent
-		self.expfolder = parent1.parent
-		self.config = PurePath(self.expfolder,Path("config.ini"))
+		self.exp_dir = parent1.parent
+		self.config = PurePath(self.exp_dir,Path("config.ini"))
 
 		if not os.path.exists(self.config):
 			print('The configuration file for the experiment was not found...')

celldetective/gui/signal_annotator.py

@@ -7,7 +7,7 @@ from celldetective.gui.gui_utils import center_window, color_from_state
 from superqt import QLabeledDoubleSlider, QLabeledDoubleRangeSlider, QSearchableComboBox
 from celldetective.utils import extract_experiment_channels, get_software_location, _get_img_num_per_channel
 from celldetective.io import auto_load_number_of_frames, load_frames, \
-	load_napari_data, get_experiment_metadata
+	load_napari_data, get_experiment_metadata, get_experiment_labels
 from celldetective.gui.gui_utils import FigureCanvas, color_from_status, color_from_class, ExportPlotBtn
 import json
 import numpy as np
@@ -687,7 +687,7 @@ class SignalAnnotator(QMainWindow, Styles):
 			if len_movie_auto is not None:
 				self.len_movie = len_movie_auto
 			exp_config = self.exp_dir + "config.ini"
-			self.channel_names, self.channels = extract_experiment_channels(exp_config)
+			self.channel_names, self.channels = extract_experiment_channels(self.exp_dir)
 			self.channel_names = np.array(self.channel_names)
 			self.channels = np.array(self.channels)
 			self.nbr_channels = len(self.channels)
@@ -780,6 +780,7 @@ class SignalAnnotator(QMainWindow, Styles):
 
 			self.MinMaxScaler = MinMaxScaler()
 			self.columns_to_rescale = list(self.df_tracks.columns)
+			#self.columns_to_rescale = self.df_tracks.select_dtypes(exclude=['object']).columns
 
 			# is_number = np.vectorize(lambda x: np.issubdtype(x, np.number))
 			# is_number_test = is_number(self.df_tracks.dtypes)
@@ -788,17 +789,25 @@ class SignalAnnotator(QMainWindow, Styles):
 
 			cols_to_remove = ['status', 'status_color', 'class_color', 'TRACK_ID', 'FRAME', 'x_anim', 'y_anim', 't',
 							  'state', 'generation', 'root', 'parent', 'class_id', 'class', 't0', 'POSITION_X',
-							  'POSITION_Y', 'position', 'well', 'well_index', 'well_name', 'pos_name', 'index',
-							  'concentration', 'cell_type', 'antibody', 'pharmaceutical_agent'] + self.class_cols
+							  'POSITION_Y', 'position', 'well', 'well_index', 'well_name', 'pos_name', 'index',] + self.class_cols
+			
 			meta = get_experiment_metadata(self.exp_dir)
 			if meta is not None:
 				keys = list(meta.keys())
 				cols_to_remove.extend(keys)
 
+			labels = get_experiment_labels(self.exp_dir)
+			if labels is not None:
+				keys = list(labels.keys())
+				cols_to_remove.extend(labels)
+
 			cols = np.array(list(self.df_tracks.columns))
 			time_cols = np.array([c.startswith('t_') for c in cols])
 			time_cols = list(cols[time_cols])
 			cols_to_remove += time_cols
+			#cols_to_remove.extend(self.df_tracks.select_dtypes(include=['object']).columns)
+
+			print(f"{cols_to_remove=}")
 
 			for tr in cols_to_remove:
 				try:
@@ -2273,12 +2282,23 @@ class MeasureAnnotator(SignalAnnotator):
 							  'state', 'generation', 'root', 'parent', 'class_id', 'class', 't0', 'POSITION_X',
 							  'POSITION_Y', 'position', 'well', 'well_index', 'well_name', 'pos_name', 'index',
 							  'concentration', 'cell_type', 'antibody', 'pharmaceutical_agent', 'ID'] + self.class_cols
-			cols = np.array(list(self.df_tracks.columns))
+
+			meta = get_experiment_metadata(self.exp_dir)
+			if meta is not None:
+				keys = list(meta.keys())
+				cols_to_remove.extend(keys)
+
+			labels = get_experiment_labels(self.exp_dir)
+			if labels is not None:
+				keys = list(labels.keys())
+				cols_to_remove.extend(labels)
+
 			for tr in cols_to_remove:
 				try:
 					self.columns_to_rescale.remove(tr)
 				except:
 					pass
+
 			# print(f'column {tr} could not be found...')
 
 			x = self.df_tracks[self.columns_to_rescale].values
@@ -2496,7 +2516,7 @@ class MeasureAnnotator(SignalAnnotator):
 			if len_movie_auto is not None:
 				self.len_movie = len_movie_auto
 			exp_config = self.exp_dir + "config.ini"
-			self.channel_names, self.channels = extract_experiment_channels(exp_config)
+			self.channel_names, self.channels = extract_experiment_channels(self.exp_dir)
 			self.channel_names = np.array(self.channel_names)
 			self.channels = np.array(self.channels)
 			self.nbr_channels = len(self.channels)

celldetective/gui/signal_annotator2.py

@@ -1043,7 +1043,7 @@ class SignalAnnotator2(QMainWindow,Styles):
 			if len_movie_auto is not None:
 				self.len_movie = len_movie_auto
 			exp_config = self.exp_dir +"config.ini"
-			self.channel_names, self.channels = extract_experiment_channels(exp_config)
+			self.channel_names, self.channels = extract_experiment_channels(self.exp_dir)
 			self.channel_names = np.array(self.channel_names)
 			self.channels = np.array(self.channels)
 			self.nbr_channels = len(self.channels)

celldetective/gui/signal_annotator_options.py

@@ -39,7 +39,7 @@ class ConfigSignalAnnotator(QMainWindow, Styles):
 
 		exp_config = self.exp_dir +"config.ini"
 		#self.config_path = self.exp_dir + self.config_name
-		self.channel_names, self.channels = extract_experiment_channels(exp_config)
+		self.channel_names, self.channels = extract_experiment_channels(self.exp_dir)
 		self.channel_names = np.array(self.channel_names)
 		self.channels = np.array(self.channels)
 		self.log_option = False

celldetective/gui/survival_ui.py

@@ -153,7 +153,10 @@ class ConfigSurvival(QWidget, Styles):
 		all_cms = list(colormaps)
 		for cm in all_cms:
 			if hasattr(matplotlib.cm, str(cm).lower()):
-				self.cbs[-1].addColormap(cm.lower())
+				try:
+					self.cbs[-1].addColormap(cm.lower())
+				except:
+					pass
 			#try:
 			# 	self.cbs[-1].addColormap(cm)
 			# except:

celldetective/gui/thresholds_gui.py

@@ -181,7 +181,7 @@ class ThresholdConfigWizard(QMainWindow, Styles):
 		self.threshold_slider.setSingleStep(0.00001)
 		self.threshold_slider.setTickInterval(0.00001)
 		self.threshold_slider.setOrientation(1)
-		self.threshold_slider.setDecimals(3)
+		self.threshold_slider.setDecimals(5)
 		self.threshold_slider.setRange(np.amin(self.img[self.img==self.img]), np.amax(self.img[self.img==self.img]))
 		self.threshold_slider.setValue([np.percentile(self.img.flatten(), 90), np.amax(self.img)])
 		self.threshold_slider.valueChanged.connect(self.threshold_changed)
@@ -422,7 +422,7 @@ class ThresholdConfigWizard(QMainWindow, Styles):
 			if len_movie_auto is not None:
 				self.len_movie = len_movie_auto
 			exp_config = self.exp_dir + "config.ini"
-			self.channel_names, self.channels = extract_experiment_channels(exp_config)
+			self.channel_names, self.channels = extract_experiment_channels(self.exp_dir)
 			self.channel_names = np.array(self.channel_names)
 			self.channels = np.array(self.channels)
 			self.nbr_channels = len(self.channels)
@@ -861,11 +861,12 @@ class ThresholdConfigWizard(QMainWindow, Styles):
 
 		filters = threshold_instructions['filters']
 		items_to_add = [f[0] + '_filter' for f in filters]
-		self.filters_qlist.list_widget.clear()
-		self.filters_qlist.list_widget.addItems(items_to_add)
+		self.preprocessing.list.list_widget.clear()
+		self.preprocessing.list.list_widget.addItems(items_to_add)
 		self.preprocessing.list.items = filters
 
-		self.apply_filters_btn.click()
+		self.preprocessing.apply_btn.click()
+		#self.apply_filters_btn.click()
 
 		thresholds = threshold_instructions['thresholds']
 		self.threshold_slider.setValue(thresholds)

celldetective/io.py

@@ -25,7 +25,7 @@ from pathlib import Path, PurePath
 from shutil import copyfile, rmtree
 
 from celldetective.utils import _rearrange_multichannel_frame, _fix_no_contrast, zoom_multiframes,ConfigSectionMap, extract_experiment_channels, _extract_labels_from_config, get_zenodo_files, download_zenodo_file
-from celldetective.utils import interpolate_nan_multichannel, _estimate_scale_factor, _extract_channel_indices_from_config, _extract_channel_indices, _extract_nbr_channels_from_config, _get_img_num_per_channel, normalize_per_channel
+from celldetective.utils import interpolate_nan_multichannel, _estimate_scale_factor, _extract_channel_indices_from_config, _extract_channel_indices, _extract_nbr_channels_from_config, _get_img_num_per_channel, normalize_per_channel, get_config
 
 from stardist import fill_label_holes
 from skimage.transform import resize
@@ -261,49 +261,6 @@ def get_experiment_wells(experiment):
 	return np.array(wells, dtype=str)
 
 
-def get_config(experiment):
-
-	"""
-	Retrieves the path to the configuration file for a given experiment.
-
-	Parameters
-	----------
-	experiment : str
-		The file system path to the experiment directory.
-
-	Returns
-	-------
-	str
-		The full path to the configuration file (`config.ini`) within the experiment directory.
-
-	Raises
-	------
-	AssertionError
-		If the `config.ini` file does not exist in the specified experiment directory.
-
-	Notes
-	-----
-	- The function ensures that the provided experiment path ends with the appropriate file separator (`os.sep`) 
-	  before appending `config.ini` to locate the configuration file.
-	- The configuration file is expected to be named `config.ini` and located at the root of the experiment directory.
-
-	Example
-	-------
-	>>> experiment = "/path/to/experiment"
-	>>> config_path = get_config(experiment)
-	>>> print(config_path)
-	'/path/to/experiment/config.ini'
-
-	"""
-
-	if not experiment.endswith(os.sep):
-		experiment += os.sep
-
-	config = experiment + 'config.ini'
-	config = rf"{config}"
-	assert os.path.exists(config), 'The experiment configuration could not be located...'
-	return config
-
 
 def get_spatial_calibration(experiment):