celldetective 1.1.1.post1__py3-none-any.whl → 1.1.1.post3__py3-none-any.whl

celldetective/gui/retrain_signal_model_options.py

@@ -2,6 +2,7 @@ from PyQt5.QtWidgets import QMainWindow, QApplication, QMessageBox, QScrollArea,
 from PyQt5.QtCore import Qt, QSize
 from PyQt5.QtGui import QDoubleValidator, QIntValidator, QIcon
 from celldetective.gui.gui_utils import center_window, FeatureChoice, ListWidget, QHSeperationLine, FigureCanvas, GeometryChoice, OperationChoice
+from celldetective.gui.layouts import ChannelNormGenerator
 from superqt import QLabeledDoubleRangeSlider, QLabeledDoubleSlider,QLabeledSlider
 from superqt.fonticon import icon
 from fonticon_mdi6 import MDI6
@@ -306,103 +307,9 @@ class ConfigSignalModelTraining(QMainWindow, Styles):
 		recompile_layout.addWidget(self.recompile_option, 70)
 		layout.addLayout(recompile_layout)
 
-		#self.channel_cbs = [QComboBox() for i in range(4)]
-
 		self.max_nbr_channels = 5
-		self.channel_cbs = [QComboBox() for i in range(self.max_nbr_channels)]
-		self.normalization_mode_btns = [QPushButton('') for i in range(self.max_nbr_channels)]
-		self.normalization_mode = [True for i in range(self.max_nbr_channels)]
-
-		self.normalization_clip_btns = [QPushButton('') for i in range(self.max_nbr_channels)]
-		self.clip_option = [False for i in range(self.max_nbr_channels)]
-
-		for i in range(self.max_nbr_channels):
-
-			self.normalization_mode_btns[i].setIcon(icon(MDI6.percent_circle,color="#1565c0"))
-			self.normalization_mode_btns[i].setIconSize(QSize(20, 20))	
-			self.normalization_mode_btns[i].setStyleSheet(self.button_select_all)	
-			self.normalization_mode_btns[i].setToolTip("Switch to absolute normalization values.")
-			self.normalization_mode_btns[i].clicked.connect(partial(self.switch_normalization_mode, i))
-
-			self.normalization_clip_btns[i].setIcon(icon(MDI6.content_cut,color="black"))
-			self.normalization_clip_btns[i].setIconSize(QSize(20, 20))	
-			self.normalization_clip_btns[i].setStyleSheet(self.button_select_all)	
-			self.normalization_clip_btns[i].clicked.connect(partial(self.switch_clipping_mode, i))
-			self.normalization_clip_btns[i].setToolTip('clip')
-
-		self.normalization_min_value_lbl = [QLabel('Min %: ') for i in range(self.max_nbr_channels)]
-		self.normalization_min_value_le = [QLineEdit('0.1') for i in range(self.max_nbr_channels)]
-
-		self.normalization_max_value_lbl = [QLabel('Max %: ') for i in range(self.max_nbr_channels)]		
-		self.normalization_max_value_le = [QLineEdit('99.99') for i in range(self.max_nbr_channels)]
-
-		tables = glob(self.exp_dir+os.sep.join(['W*','*','output','tables',f'trajectories_{self.mode}.csv']))
-		print(tables)
-		all_measurements = []
-		for tab in tables:
-			cols = pd.read_csv(tab, nrows=1).columns.tolist()
-			all_measurements.extend(cols)
-		all_measurements = np.unique(all_measurements)
-		generic_measurements = ['brightfield_channel', 'live_nuclei_channel', 'dead_nuclei_channel', 
-							 'effector_fluo_channel', 'adhesion_channel', 'fluo_channel_1', 'fluo_channel_2',
-							 "area", "area_bbox","area_convex","area_filled","major_axis_length", 
-							 "minor_axis_length", 
-							"eccentricity",
-							"equivalent_diameter_area",
-							"euler_number",
-							"extent",
-							"feret_diameter_max",
-							"orientation", 
-							"perimeter",
-							"perimeter_crofton",
-							"solidity",
-							"angular_second_moment",
-							"contrast",
-							"correlation",
-							"sum_of_square_variance",
-							"inverse_difference_moment",
-							"sum_average",
-							"sum_variance",
-							"sum_entropy",
-							"entropy",
-							"difference_variance",
-							"difference_entropy",
-							"information_measure_of_correlation_1",
-							"information_measure_of_correlation_2",
-							"maximal_correlation_coefficient",
-							"POSITION_X",
-							"POSITION_Y",
-							]
-
-		self.channel_items = np.unique(generic_measurements + list(all_measurements))
-		self.channel_items = np.insert(self.channel_items, 0, '--')
-
-		self.channel_option_layouts = []
-		for i in range(len(self.channel_cbs)):
-			ch_layout = QHBoxLayout()
-			ch_layout.addWidget(QLabel(f'channel {i}: '), 30)
-			self.channel_cbs[i].addItems(self.channel_items)
-			self.channel_cbs[i].currentIndexChanged.connect(self.check_valid_channels)
-			ch_layout.addWidget(self.channel_cbs[i], 70)
-			layout.addLayout(ch_layout)
-
-			channel_norm_options_layout = QHBoxLayout()
-			channel_norm_options_layout.setContentsMargins(130,0,0,0)
-			channel_norm_options_layout.addWidget(self.normalization_min_value_lbl[i])			
-			channel_norm_options_layout.addWidget(self.normalization_min_value_le[i])
-			channel_norm_options_layout.addWidget(self.normalization_max_value_lbl[i])
-			channel_norm_options_layout.addWidget(self.normalization_max_value_le[i])
-			channel_norm_options_layout.addWidget(self.normalization_clip_btns[i])
-			channel_norm_options_layout.addWidget(self.normalization_mode_btns[i])
-			layout.addLayout(channel_norm_options_layout)
-
-		# for i in range(len(self.channel_cbs)):
-		# 	ch_layout = QHBoxLayout()
-		# 	ch_layout.addWidget(QLabel(f'channel {i}: '), 30)
-		# 	self.channel_cbs[i].addItems(self.channel_items)
-		# 	self.channel_cbs[i].currentIndexChanged.connect(self.check_valid_channels)
-		# 	ch_layout.addWidget(self.channel_cbs[i], 70)
-		# 	layout.addLayout(ch_layout)
+		self.ch_norm = ChannelNormGenerator(self, mode='signals')
+		layout.addLayout(self.ch_norm)
 
 		model_length_layout = QHBoxLayout()
 		model_length_layout.addWidget(QLabel('Max signal length: '), 30)
@@ -465,8 +372,9 @@ class ConfigSignalModelTraining(QMainWindow, Styles):
 		
 		self.pretrained_model = None
 		self.pretrained_lbl.setText('No folder chosen')
-		for cb in self.channel_cbs:
+		for cb in self.ch_norm.channel_cbs:
 			cb.setEnabled(True)
+		self.ch_norm.add_col_btn.setEnabled(True)
 		self.recompile_option.setEnabled(False)
 		self.cancel_pretrained.setVisible(False)
 		self.model_length_slider.setEnabled(True)
@@ -495,14 +403,15 @@ class ConfigSignalModelTraining(QMainWindow, Styles):
 		self.model_length_slider.setValue(int(signal_length))
 		self.model_length_slider.setEnabled(False)
 
-		for c,cb in zip(channels, self.channel_cbs):
+		for c,cb in zip(channels, self.ch_norm.channel_cbs):
 			index = cb.findText(c)
 			cb.setCurrentIndex(index)
 
-		if len(channels)<len(self.channel_cbs):
-			for k in range(len(self.channel_cbs)-len(channels)):
-				self.channel_cbs[len(channels)+k].setCurrentIndex(0)
-				self.channel_cbs[len(channels)+k].setEnabled(False)
+		if len(channels)<len(self.ch_norm.channel_cbs):
+			for k in range(len(self.ch_norm.channel_cbs)-len(channels)):
+				self.ch_norm.channel_cbs[len(channels)+k].setCurrentIndex(0)
+				self.ch_norm.channel_cbs[len(channels)+k].setEnabled(False)
+		self.ch_norm.add_col_btn.setEnabled(False)
 
 
 	def adjustScrollArea(self):
@@ -524,23 +433,23 @@ class ConfigSignalModelTraining(QMainWindow, Styles):
 		recompile_op = self.recompile_option.isChecked()
 
 		channels = []
-		for i in range(len(self.channel_cbs)):
-			channels.append(self.channel_cbs[i].currentText())
+		for i in range(len(self.ch_norm.channel_cbs)):
+			channels.append(self.ch_norm.channel_cbs[i].currentText())
 
 		slots_to_keep = np.where(np.array(channels)!='--')[0]
 		while '--' in channels:
 			channels.remove('--')
 
-		norm_values = np.array([[float(a.replace(',','.')),float(b.replace(',','.'))] for a,b in zip([l.text() for l in self.normalization_min_value_le],
-											[l.text() for l in self.normalization_max_value_le])])
+		norm_values = np.array([[float(a.replace(',','.')),float(b.replace(',','.'))] for a,b in zip([l.text() for l in self.ch_norm.normalization_min_value_le],
+											[l.text() for l in self.ch_norm.normalization_max_value_le])])
 		norm_values = norm_values[slots_to_keep]
 		norm_values = [list(v) for v in norm_values]
 
-		clip_values = np.array(self.clip_option)
+		clip_values = np.array(self.ch_norm.clip_option)
 		clip_values = list(clip_values[slots_to_keep])
 		clip_values = [bool(c) for c in clip_values]
 
-		normalization_mode = np.array(self.normalization_mode)
+		normalization_mode = np.array(self.ch_norm.normalization_mode)
 		normalization_mode = list(normalization_mode[slots_to_keep])
 		normalization_mode = [bool(m) for m in normalization_mode]
 
@@ -586,59 +495,4 @@ class ConfigSignalModelTraining(QMainWindow, Styles):
 		
 		train_signal_model(model_folder+"training_instructions.json")
 
-		self.parent_window.refresh_signal_models()
-
-
-	def check_valid_channels(self):
-
-		if np.all([cb.currentText()=='--' for cb in self.channel_cbs]):
-			self.submit_btn.setEnabled(False)
-		else:
-			self.submit_btn.setEnabled(True)
-
-
-	def switch_normalization_mode(self, index):
-
-		"""
-		Use absolute or percentile values for the normalization of each individual channel.
-		
-		"""
-
-		currentNormMode = self.normalization_mode[index]
-		self.normalization_mode[index] = not currentNormMode
-
-		if self.normalization_mode[index]:
-			self.normalization_mode_btns[index].setIcon(icon(MDI6.percent_circle,color="#1565c0"))
-			self.normalization_mode_btns[index].setIconSize(QSize(20, 20))	
-			self.normalization_mode_btns[index].setStyleSheet(self.button_select_all)	
-			self.normalization_mode_btns[index].setToolTip("Switch to absolute normalization values.")
-			self.normalization_min_value_lbl[index].setText('Min %: ')
-			self.normalization_max_value_lbl[index].setText('Max %: ')
-			self.normalization_min_value_le[index].setText('0.1')
-			self.normalization_max_value_le[index].setText('99.99')
-
-		else:
-			self.normalization_mode_btns[index].setIcon(icon(MDI6.percent_circle_outline,color="black"))
-			self.normalization_mode_btns[index].setIconSize(QSize(20, 20))	
-			self.normalization_mode_btns[index].setStyleSheet(self.button_select_all)	
-			self.normalization_mode_btns[index].setToolTip("Switch to percentile normalization values.")
-			self.normalization_min_value_lbl[index].setText('Min: ')
-			self.normalization_min_value_le[index].setText('0')
-			self.normalization_max_value_lbl[index].setText('Max: ')
-			self.normalization_max_value_le[index].setText('1000')
-
-	def switch_clipping_mode(self, index):
-
-		currentClipMode = self.clip_option[index]
-		self.clip_option[index] = not currentClipMode
-
-		if self.clip_option[index]:
-			self.normalization_clip_btns[index].setIcon(icon(MDI6.content_cut,color="#1565c0"))
-			self.normalization_clip_btns[index].setIconSize(QSize(20, 20))
-			self.normalization_clip_btns[index].setStyleSheet(self.button_select_all)	
-
-		else:
-			self.normalization_clip_btns[index].setIcon(icon(MDI6.content_cut,color="black"))
-			self.normalization_clip_btns[index].setIconSize(QSize(20, 20))		
-			self.normalization_clip_btns[index].setStyleSheet(self.button_select_all)	
-
+		self.parent_window.refresh_signal_models()

celldetective/gui/tableUI.py

@@ -12,6 +12,8 @@ import matplotlib.cm as mcm
 import os
 from celldetective.gui import Styles
 from superqt import QColormapComboBox, QLabeledSlider, QSearchableComboBox
+from superqt.fonticon import icon
+from fonticon_mdi6 import MDI6
 from math import floor
 
 from matplotlib import colormaps
@@ -72,6 +74,92 @@ class QueryWidget(QWidget):
 			print(e)
 			return None
 
+
+class MergeOneHotWidget(QWidget, Styles):
+
+	def __init__(self, parent_window, selected_columns=None):
+
+		super().__init__()
+		self.parent_window = parent_window
+		self.selected_columns = selected_columns
+
+		self.setWindowTitle("Merge one-hot encoded columns...")
+		# Create the QComboBox and add some items
+		center_window(self)
+		
+		self.layout = QVBoxLayout(self)
+		self.layout.setContentsMargins(30,30,30,30)
+
+		if self.selected_columns is not None:
+			n_cols = len(self.selected_columns)
+		else:
+			n_cols = 2
+
+		name_hbox = QHBoxLayout()
+		name_hbox.addWidget(QLabel('New categorical column: '), 33)
+		self.new_col_le = QLineEdit()
+		self.new_col_le.setText('categorical_')
+		self.new_col_le.textChanged.connect(self.allow_merge)
+		name_hbox.addWidget(self.new_col_le, 66)
+		self.layout.addLayout(name_hbox)
+
+
+		self.layout.addWidget(QLabel('Source columns: '))
+
+		self.cbs = [QSearchableComboBox() for i in range(n_cols)]
+		self.cbs_layout = QVBoxLayout()
+
+		for i in range(n_cols):
+			lay = QHBoxLayout()
+			lay.addWidget(QLabel(f'column {i}: '), 33)
+			self.cbs[i].addItems(['--']+list(self.parent_window.data.columns))
+			if self.selected_columns is not None:
+				self.cbs[i].setCurrentText(self.selected_columns[i])
+			lay.addWidget(self.cbs[i], 66)
+			self.cbs_layout.addLayout(lay)
+
+		self.layout.addLayout(self.cbs_layout)
+
+		hbox = QHBoxLayout()
+		self.add_col_btn = QPushButton('Add column')
+		self.add_col_btn.clicked.connect(self.add_col)
+		self.add_col_btn.setStyleSheet(self.button_add)
+		self.add_col_btn.setIcon(icon(MDI6.plus,color="black"))
+
+		hbox.addWidget(QLabel(''), 50)
+		hbox.addWidget(self.add_col_btn, 50, alignment=Qt.AlignRight)
+		self.layout.addLayout(hbox)
+
+		self.submit_btn = QPushButton('Merge')
+		self.submit_btn.setStyleSheet(self.button_style_sheet)
+		self.submit_btn.clicked.connect(self.merge_cols)
+		self.layout.addWidget(self.submit_btn, 30)
+
+		self.setAttribute(Qt.WA_DeleteOnClose)
+
+	def add_col(self):
+		self.cbs.append(QSearchableComboBox())
+		self.cbs[-1].addItems(['--']+list(self.parent_window.data.columns))
+		lay = QHBoxLayout()
+		lay.addWidget(QLabel(f'column {len(self.cbs)-1}: '), 33)
+		lay.addWidget(self.cbs[-1], 66)
+		self.cbs_layout.addLayout(lay)	
+
+	def merge_cols(self):
+		
+		self.parent_window.data[self.new_col_le.text()] = self.parent_window.data.loc[:,list(self.selected_columns)].idxmax(axis=1)
+		self.parent_window.model = PandasModel(self.parent_window.data)
+		self.parent_window.table_view.setModel(self.parent_window.model)
+		self.close()
+
+	def allow_merge(self):
+
+		if self.new_col_le.text()=='':
+			self.submit_btn.setEnabled(False)
+		else:
+			self.submit_btn.setEnabled(True)
+
+
 class DifferentiateColWidget(QWidget, Styles):
 
 	def __init__(self, parent_window, column=None):
@@ -264,7 +352,12 @@ class TableUI(QMainWindow, Styles):
 			self.derivative_action = QAction('&Differentiate...', self)
 			self.derivative_action.triggered.connect(self.differenciate_selected_feature)
 			self.derivative_action.setShortcut("Ctrl+D")
-			self.mathMenu.addAction(self.derivative_action)			
+			self.mathMenu.addAction(self.derivative_action)
+
+			self.onehot_action = QAction('&One hot to categorical...', self)
+			self.onehot_action.triggered.connect(self.transform_one_hot_cols_to_categorical)
+			#self.onehot_action.setShortcut("Ctrl+D")
+			self.mathMenu.addAction(self.onehot_action)		
 
 	def delete_columns(self):
 
@@ -334,6 +427,19 @@ class TableUI(QMainWindow, Styles):
 		self.diffWidget = DifferentiateColWidget(self, selected_col)
 		self.diffWidget.show()
 
+	def transform_one_hot_cols_to_categorical(self):
+
+		x = self.table_view.selectedIndexes()
+		col_idx = np.unique(np.array([l.column() for l in x]))
+		if list(col_idx):
+			cols = np.array(list(self.data.columns))
+			selected_cols = cols[col_idx]
+		else:
+			selected_cols = None
+
+		self.mergewidget = MergeOneHotWidget(self, selected_columns=selected_cols)
+		self.mergewidget.show()
+
 
 	def groupby_time_table(self):
 
@@ -477,6 +583,7 @@ class TableUI(QMainWindow, Styles):
 		layout.addWidget(QLabel('Representations: '))
 		self.hist_check = QCheckBox('histogram')
 		self.kde_check = QCheckBox('KDE plot')
+		self.count_check = QCheckBox('Countplot')
 		self.ecdf_check = QCheckBox('ECDF plot')
 		self.swarm_check = QCheckBox('swarm')
 		self.violin_check = QCheckBox('violin')
@@ -486,6 +593,7 @@ class TableUI(QMainWindow, Styles):
 
 		layout.addWidget(self.hist_check)
 		layout.addWidget(self.kde_check)
+		layout.addWidget(self.count_check)
 		layout.addWidget(self.ecdf_check)
 		layout.addWidget(self.swarm_check)
 		layout.addWidget(self.violin_check)
@@ -496,16 +604,38 @@ class TableUI(QMainWindow, Styles):
 		self.x_cb = QSearchableComboBox()
 		self.x_cb.addItems(['--']+list(self.data.columns))
 
+		self.y_cb = QSearchableComboBox()
+		self.y_cb.addItems(['--']+list(self.data.columns))
+
 		self.hue_cb = QSearchableComboBox()
 		self.hue_cb.addItems(['--']+list(self.data.columns))
 		idx = self.hue_cb.findText('--')
+		self.hue_cb.setCurrentIndex(idx)
+
+		# Set selected column
+
+		try:
+			x = self.table_view.selectedIndexes()
+			col_idx = np.array([l.column() for l in x])
+			row_idx = np.array([l.row() for l in x])
+			column_names = self.data.columns
+			unique_cols = np.unique(col_idx)[0]
+			y = column_names[unique_cols]
+			idx = self.y_cb.findText(y)
+			self.y_cb.setCurrentIndex(idx)
+		except:
+			pass
 
-		self.x_cb.findText('--')
 		hbox = QHBoxLayout()
 		hbox.addWidget(QLabel('x: '), 33)
 		hbox.addWidget(self.x_cb, 66)
 		layout.addLayout(hbox)
 
+		hbox = QHBoxLayout()
+		hbox.addWidget(QLabel('y: '), 33)
+		hbox.addWidget(self.y_cb, 66)
+		layout.addLayout(hbox)
+
 		hbox = QHBoxLayout()
 		hbox.addWidget(QLabel('hue: '), 33)
 		hbox.addWidget(self.hue_cb, 66)
@@ -539,18 +669,10 @@ class TableUI(QMainWindow, Styles):
 			self.x_option = True
 			self.x = self.x_cb.currentText()
 
-		x = self.table_view.selectedIndexes()
-		col_idx = np.array([l.column() for l in x])
-		row_idx = np.array([l.row() for l in x])
-		column_names = self.data.columns
-		unique_cols = np.unique(col_idx)[0]
-
 		self.fig, self.ax = plt.subplots(1,1,figsize=(4,3))
 		self.plot1dWindow = FigureCanvas(self.fig, title="scatter")
 		self.ax.clear()
-		row_idx_i = row_idx[np.where(col_idx==unique_cols)[0]]
-		y = self.data.iloc[row_idx_i, unique_cols]
-		
+
 		cmap = getattr(mcm, self.cmap_cb.currentText())
 
 		try:
@@ -562,58 +684,68 @@ class TableUI(QMainWindow, Styles):
 		if self.hue_cb.currentText()=='--':
 			hue_variable = None
 
-		#for w,well_group in self.data.groupby('well_index'):
+		if self.y_cb.currentText()=='--':
+			self.y = None
+		else:
+			self.y = self.y_cb.currentText()
+
+		if self.x_cb.currentText()=='--':
+			self.x = None
+		else:
+			self.x = self.x_cb.currentText()
 
 		legend=True
 		if self.hist_check.isChecked():
-			sns.histplot(data=self.data, x=column_names[unique_cols], hue=hue_variable, legend=legend, ax=self.ax, palette=colors, kde=True, common_norm=False, stat='density')
+			sns.histplot(data=self.data, x=self.x, hue=hue_variable, legend=legend, ax=self.ax, palette=colors, kde=True, common_norm=False, stat='density')
 			legend = False
 		if self.kde_check.isChecked():
-			sns.kdeplot(data=self.data, x=column_names[unique_cols], hue=hue_variable, legend=legend, ax=self.ax, palette=colors, cut=0)
+			sns.kdeplot(data=self.data, x=self.x, hue=hue_variable, legend=legend, ax=self.ax, palette=colors, cut=0)
+			legend = False
+		if self.count_check.isChecked():
+			sns.countplot(data=self.data, x=self.x, hue=hue_variable, legend=legend, ax=self.ax, palette=colors)
 			legend = False
-
 		if self.ecdf_check.isChecked():
-			sns.ecdfplot(data=self.data, x=column_names[unique_cols], hue=hue_variable, legend=legend, ax=self.ax, palette=colors)
+			sns.ecdfplot(data=self.data, x=self.x, hue=hue_variable, legend=legend, ax=self.ax, palette=colors)
 			legend = False
 
 		if self.swarm_check.isChecked():
 			if self.x_option:
-				sns.swarmplot(data=self.data, x=self.x,y=column_names[unique_cols],dodge=True, hue=hue_variable,legend=legend, ax=self.ax, palette=colors)
+				sns.swarmplot(data=self.data, x=self.x,y=self.y,dodge=True, hue=hue_variable,legend=legend, ax=self.ax, palette=colors)
 				legend = False
 			else:
-				sns.swarmplot(data=self.data, y=column_names[unique_cols],dodge=True, hue=hue_variable,legend=legend, ax=self.ax, palette=colors)
+				sns.swarmplot(data=self.data, y=self.y,dodge=True, hue=hue_variable,legend=legend, ax=self.ax, palette=colors)
 				legend = False
 
 		if self.violin_check.isChecked():
 			if self.x_option:
-				sns.stripplot(data=self.data,x=self.x, y=column_names[unique_cols],dodge=True, ax=self.ax, hue=hue_variable, legend=legend, palette=colors)
+				sns.stripplot(data=self.data,x=self.x, y=self.y,dodge=True, ax=self.ax, hue=hue_variable, legend=legend, palette=colors)
 				legend = False
 			else:
-				sns.violinplot(data=self.data, y=column_names[unique_cols],dodge=True, hue=hue_variable,legend=legend, ax=self.ax, palette=colors, cut=0)
+				sns.violinplot(data=self.data, y=self.y,dodge=True, hue=hue_variable,legend=legend, ax=self.ax, palette=colors, cut=0)
 				legend = False
 
 		if self.box_check.isChecked():
 			if self.x_option:
-				sns.boxplot(data=self.data, x=self.x, y=column_names[unique_cols],dodge=True, hue=hue_variable,legend=legend, ax=self.ax, fill=False,palette=colors, linewidth=2,)
+				sns.boxplot(data=self.data, x=self.x, y=self.y,dodge=True, hue=hue_variable,legend=legend, ax=self.ax, fill=False,palette=colors, linewidth=2,)
 				legend = False
 			else:
-				sns.boxplot(data=self.data, y=column_names[unique_cols],dodge=True, hue=hue_variable,legend=legend, ax=self.ax, fill=False,palette=colors, linewidth=2,)
+				sns.boxplot(data=self.data, y=self.y,dodge=True, hue=hue_variable,legend=legend, ax=self.ax, fill=False,palette=colors, linewidth=2,)
 				legend = False
 
 		if self.boxenplot_check.isChecked():
 			if self.x_option:
-				sns.boxenplot(data=self.data, x = self.x, y=column_names[unique_cols],dodge=True, hue=hue_variable,legend=legend, ax=self.ax, fill=False,palette=colors, linewidth=2,)
+				sns.boxenplot(data=self.data, x=self.x, y=self.y,dodge=True, hue=hue_variable,legend=legend, ax=self.ax, fill=False,palette=colors, linewidth=2,)
 				legend = False
 			else:
-				sns.boxenplot(data=self.data, y=column_names[unique_cols],dodge=True, hue=hue_variable,legend=legend, ax=self.ax, fill=False,palette=colors, linewidth=2,)
+				sns.boxenplot(data=self.data, y=self.y,dodge=True, hue=hue_variable,legend=legend, ax=self.ax, fill=False,palette=colors, linewidth=2,)
 				legend = False
 
 		if self.strip_check.isChecked():
 			if self.x_option:
-				sns.stripplot(data=self.data, x = self.x, y=column_names[unique_cols],dodge=True, ax=self.ax, hue=hue_variable, legend=legend, palette=colors)
+				sns.stripplot(data=self.data, x = self.x, y=self.y,dodge=True, ax=self.ax, hue=hue_variable, legend=legend, palette=colors)
 				legend = False
 			else:
-				sns.stripplot(data=self.data, y=column_names[unique_cols],dodge=True, ax=self.ax, hue=hue_variable, legend=legend, palette=colors)
+				sns.stripplot(data=self.data, y=self.y,dodge=True, ax=self.ax, hue=hue_variable, legend=legend, palette=colors)
 				legend = False
 
 		plt.tight_layout()
@@ -762,42 +894,10 @@ class TableUI(QMainWindow, Styles):
 			column_names = self.data.columns
 			unique_cols = np.unique(col_idx)
 
-			if len(unique_cols)==1:
-				# 1D plot
-				# Open widget to set 1D data representations
+			if len(unique_cols)==1 or len(unique_cols)==0:
 				self.set_1D_plot_params()
 
-
-
-				# x = self.table_view.selectedIndexes()
-				# col_idx = np.array([l.column() for l in x])
-				# row_idx = np.array([l.row() for l in x])
-				# column_names = self.data.columns
-				# unique_cols = np.unique(col_idx)[0]
-
-				# self.fig, self.ax = plt.subplots(1,1,figsize=(4,3))
-				# self.histogram_window = FigureCanvas(self.fig, title="scatter")
-				# self.ax.clear()
-				# row_idx_i = row_idx[np.where(col_idx==unique_cols)[0]]
-				# y = self.data.iloc[row_idx_i, unique_cols]
-
-				# colors = [viridis(i / len(self.data['well_index'].unique())) for i in range(len(self.data['well_index'].unique()))]
-				# #for w,well_group in self.data.groupby('well_index'):
-				# sns.boxplot(data=self.data, y=column_names[unique_cols],dodge=True, hue='well_index',legend=False, ax=self.ax, fill=False,palette=colors, linewidth=2,)
-				# sns.stripplot(data=self.data, y=column_names[unique_cols],dodge=True, ax=self.ax, hue='well_index', legend=False, palette=colors)
-				# # sns.kdeplot(data=self.data, x=column_names[unique_cols], hue='well_index', ax=self.ax, fill=False,common_norm=False, palette=colors, alpha=.5, linewidth=2,)
-				# # for k,(w,well_group) in enumerate(self.data.groupby('well_index')):
-				# # 	self.ax.hist(well_group[column_names[unique_cols]],label=w, density=True, alpha=0.5, color=colors[k])
-				# #self.ax.legend()
-				# self.ax.set_xlabel(column_names[unique_cols])
-				# plt.tight_layout()
-				# self.fig.set_facecolor('none')  # or 'None'
-				# self.fig.canvas.setStyleSheet("background-color: transparent;")
-				# self.histogram_window.canvas.draw()
-				# self.histogram_window.show()
-
-
-			elif len(unique_cols) == 2:
+			if len(unique_cols) == 2:
 
 				print("two columns, plot mode")
 				x1 = self.test_bool(self.data.iloc[row_idx, unique_cols[0]])

celldetective/gui/viewers.py

@@ -396,7 +396,7 @@ class ThresholdedStackVisualizer(StackVisualizer):
 		# Compute the mask based on the threshold value
 		self.preprocess_image()
 		edge = estimate_unreliable_edge(self.preprocessing)
-		self.mask = threshold_image(self.processed_image, threshold_value, 1.0E06, foreground_value=1, edge_exclusion=edge).astype(int)
+		self.mask = threshold_image(self.processed_image, threshold_value, np.inf, foreground_value=1, edge_exclusion=edge).astype(int)
 
 	def preprocess_image(self):
 		# Preprocess the image before thresholding		

celldetective/preprocessing.py

@@ -15,6 +15,8 @@ from gc import collect
 from lmfit import Parameters, Model, models
 import tifffile.tifffile as tiff
 
+from tifffile import imwrite
+
 def estimate_background_per_condition(experiment, threshold_on_std=1, well_option='*', target_channel="channel_name", frame_range=[0,5], mode="timeseries", activation_protocol=[['gauss',2],['std',4]], show_progress_per_pos=False, show_progress_per_well=True):
 	
 	"""
@@ -69,6 +71,7 @@ def estimate_background_per_condition(experiment, threshold_on_std=1, well_optio
 	...     print(bg["well"], bg["bg"].shape)
 	"""
 
+
 	config = get_config(experiment)
 	wells = get_experiment_wells(experiment)
 	len_movie = float(ConfigSectionMap(config,"MovieSettings")["len_movie"])
@@ -79,7 +82,7 @@ def estimate_background_per_condition(experiment, threshold_on_std=1, well_optio
 	channel_indices = _extract_channel_indices_from_config(config, [target_channel])
 	nbr_channels = _extract_nbr_channels_from_config(config)
 	img_num_channels = _get_img_num_per_channel(channel_indices, int(len_movie), nbr_channels)
-	
+
 	backgrounds = []
 
 	for k, well_path in enumerate(tqdm(wells[well_indices], disable=not show_progress_per_well)):
@@ -110,7 +113,7 @@ def estimate_background_per_condition(experiment, threshold_on_std=1, well_optio
 				frame = frame_mean.copy().astype(float)
 				std_frame = filter_image(frame.copy(),filters=activation_protocol)
 				edge = estimate_unreliable_edge(activation_protocol)
-				mask = threshold_image(std_frame, threshold_on_std, 1.0E06, foreground_value=1, edge_exclusion=edge)
+				mask = threshold_image(std_frame, threshold_on_std, np.inf, foreground_value=1, edge_exclusion=edge)
 				frame[np.where(mask.astype(int)==1)] = np.nan
 
 			elif mode=="tiles":
@@ -118,21 +121,23 @@ def estimate_background_per_condition(experiment, threshold_on_std=1, well_optio
 				frames = load_frames(img_num_channels[0,:], stack_path, normalize_input=False).astype(float)
 				frames = np.moveaxis(frames, -1, 0).astype(float)
 
+				new_frames = []
 				for i in range(len(frames)):
 
 					if np.all(frames[i].flatten()==0):
-						frames[i,:,:] = np.nan
+						empty_frame = np.zeros_like(frames[i])
+						empty_frame[:,:] = np.nan
+						new_frames.append(empty_frame)
 						continue
 
 					f = frames[i].copy()
 					std_frame = filter_image(f.copy(),filters=activation_protocol)
 					edge = estimate_unreliable_edge(activation_protocol)
-					mask = threshold_image(std_frame, threshold_on_std, 1.0E06, foreground_value=1, edge_exclusion=edge)
+					mask = threshold_image(std_frame, threshold_on_std, np.inf, foreground_value=1, edge_exclusion=edge)
 					f[np.where(mask.astype(int)==1)] = np.nan
-
-					frames[i,:,:] = f
+					new_frames.append(f.copy())
 				
-				frame = np.nanmedian(frames, axis=0)
+				frame = np.nanmedian(new_frames, axis=0)
 
 			# store
 			frame_mean_per_position.append(frame)
@@ -371,18 +376,25 @@ def apply_background_to_stack(stack_path, background, target_channel_index=0, nb
 
 			std_frame = filter_image(target_copy.copy(),filters=activation_protocol)
 			edge = estimate_unreliable_edge(activation_protocol)
-			mask = threshold_image(std_frame, threshold_on_std, 1.0E06, foreground_value=1, edge_exclusion=edge)
+			mask = threshold_image(std_frame, threshold_on_std, np.inf, foreground_value=1, edge_exclusion=edge)
 			target_copy[np.where(mask.astype(int)==1)] = np.nan
 
 			loss = []
 			
 			# brute-force regression, could do gradient descent instead
 			for c in coefficients:
+				
 				target_crop = unpad(target_copy,edge)
 				bg_crop = unpad(background, edge)
-				diff = np.subtract(target_crop, c*bg_crop, where=target_crop==target_crop)
-				s = np.sum(np.abs(diff, where=diff==diff), where=diff==diff)
+				
+				roi = np.zeros_like(target_crop).astype(int)
+				roi[target_crop!=target_crop] = 1
+				roi[bg_crop!=bg_crop] = 1
+
+				diff = np.subtract(target_crop, c*bg_crop, where=roi==0)
+				s = np.sum(np.abs(diff, where=roi==0), where=roi==0)
 				loss.append(s)
+
 			c = coefficients[np.argmin(loss)]
 			print(f"Frame: {i}; optimal coefficient: {c}...")
 			# if c==min(coefficients) or c==max(coefficients):
@@ -954,7 +966,7 @@ def field_correction(img, threshold_on_std=1, operation='divide', model='parabol
 
 	std_frame = filter_image(target_copy,filters=activation_protocol)
 	edge = estimate_unreliable_edge(activation_protocol)
-	mask = threshold_image(std_frame, threshold_on_std, 1.0E06, foreground_value=1, edge_exclusion=edge).astype(int)
+	mask = threshold_image(std_frame, threshold_on_std, np.inf, foreground_value=1, edge_exclusion=edge).astype(int)
 	background = fit_background_model(img, cell_masks=mask, model=model, edge_exclusion=edge)
 
 	if operation=="divide":