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

celldetective/gui/signal_annotator.py

@@ -27,6 +27,7 @@ from matplotlib.cm import tab10
 import pandas as pd
 from sklearn.preprocessing import MinMaxScaler
 from celldetective.gui import Styles
+from celldetective.measure import contour_of_instance_segmentation
 
 class SignalAnnotator(QMainWindow, Styles):
 	"""
@@ -76,9 +77,9 @@ class SignalAnnotator(QMainWindow, Styles):
 
 		self.populate_widget()
 
-		self.setMinimumWidth(int(0.8 * self.screen_width))
+		#self.setMinimumWidth(int(0.8 * self.screen_width))
 		# self.setMaximumHeight(int(0.8*self.screen_height))
-		self.setMinimumHeight(int(0.8 * self.screen_height))
+		#self.setMinimumHeight(int(0.8 * self.screen_height))
 		# self.setMaximumHeight(int(0.8*self.screen_height))
 
 		self.setAttribute(Qt.WA_DeleteOnClose)
@@ -119,7 +120,6 @@ class SignalAnnotator(QMainWindow, Styles):
 
 		self.class_choice_cb.addItems(self.class_cols)
 		self.class_choice_cb.currentIndexChanged.connect(self.compute_status_and_colors)
-		self.class_choice_cb.setCurrentIndex(0)
 
 		class_hbox.addWidget(self.class_choice_cb, 70)
 
@@ -346,6 +346,8 @@ class SignalAnnotator(QMainWindow, Styles):
 		main_layout.addLayout(self.right_panel, 65)
 		self.button_widget.adjustSize()
 
+		self.compute_status_and_colors(0)
+
 		self.setCentralWidget(self.button_widget)
 		self.show()
 
@@ -462,6 +464,7 @@ class SignalAnnotator(QMainWindow, Styles):
 		self.newClassWidget.close()
 
 	def compute_status_and_colors(self, i):
+
 		self.class_name = self.class_choice_cb.currentText()
 		self.expected_status = 'status'
 		suffix = self.class_name.replace('class', '').replace('_', '', 1)
@@ -474,11 +477,15 @@ class SignalAnnotator(QMainWindow, Styles):
 		self.status_name = self.expected_status
 
 		print('selection and expected names: ', self.class_name, self.expected_time, self.expected_status)
+		cols = list(self.df_tracks.columns)
 
-		if self.time_name in self.df_tracks.columns and self.class_name in self.df_tracks.columns and not self.status_name in self.df_tracks.columns:
+		if self.time_name in cols and self.class_name in cols and not self.status_name in cols:
 			# only create the status column if it does not exist to not erase static classification results
 			self.make_status_column()
-		elif self.time_name in self.df_tracks.columns and self.class_name in self.df_tracks.columns:
+		elif self.time_name in cols and self.class_name in cols and self.df_tracks[self.status_name].isnull().all():
+			print('this is the case!', )
+			self.make_status_column()
+		elif self.time_name in cols and self.class_name in cols:
 			# all good, do nothing
 			pass
 		else:
@@ -855,7 +862,7 @@ class SignalAnnotator(QMainWindow, Styles):
 			self.cell_ax.legend()
 			self.cell_fcanvas.canvas.draw()
 		except Exception as e:
-			print(f"{e=}")
+			print(f"Plot signals: {e=}")
 
 	def extract_scatter_from_trajectories(self):
 
@@ -1109,7 +1116,7 @@ class SignalAnnotator(QMainWindow, Styles):
 			if len(min_values) > 0:
 				self.cell_ax.set_ylim(np.amin(min_values), np.amax(max_values))
 		except Exception as e:
-			print(e)
+			print('Ylim error:',e)
 
 	def draw_frame(self, framedata):
 
@@ -1301,7 +1308,9 @@ class SignalAnnotator(QMainWindow, Styles):
 
 
 class MeasureAnnotator(SignalAnnotator):
+
 	def __init__(self, parent_window=None):
+
 		QMainWindow.__init__(self)
 		self.parent_window = parent_window
 		self.setWindowTitle("Signal annotator")
@@ -1315,11 +1324,11 @@ class MeasureAnnotator(SignalAnnotator):
 		self.int_validator = QIntValidator()
 		self.current_alpha=0.5
 		if self.mode == "targets":
-			self.instructions_path = self.exp_dir + "configs/signal_annotator_config_targets.json"
-			self.trajectories_path = self.pos + 'output/tables/trajectories_targets.csv'
+			self.instructions_path = self.exp_dir + os.sep.join(['configs','signal_annotator_config_targets.json'])
+			self.trajectories_path = self.pos + os.sep.join(['output','tables','trajectories_targets.csv'])
 		elif self.mode == "effectors":
-			self.instructions_path = self.exp_dir + "configs/signal_annotator_config_effectors.json"
-			self.trajectories_path = self.pos + 'output/tables/trajectories_effectors.csv'
+			self.instructions_path = self.exp_dir + os.sep.join(['configs','signal_annotator_config_effectors.json'])
+			self.trajectories_path = self.pos + os.sep.join(['output','tables','trajectories_effectors.csv'])
 
 		self.screen_height = self.parent_window.parent_window.parent_window.screen_height
 		self.screen_width = self.parent_window.parent_window.parent_window.screen_width
@@ -1330,8 +1339,13 @@ class MeasureAnnotator(SignalAnnotator):
 		center_window(self)
 
 		self.locate_stack()
+
 		data, properties, graph, labels, _ = load_napari_data(self.pos, prefix=None, population=self.mode,return_stack=False)
-		self.labels = relabel_segmentation(labels,data,properties)
+		if data is not None:
+			self.labels = relabel_segmentation(labels,data,properties)
+		else:
+			self.labels = labels
+
 		self.current_channel = 0
 
 		self.locate_tracks()
@@ -1577,8 +1591,10 @@ class MeasureAnnotator(SignalAnnotator):
 		self.class_choice_cb = QComboBox()
 
 		cols = np.array(self.df_tracks.columns)
-		self.class_cols = np.array([c.startswith('group') for c in list(self.df_tracks.columns)])
+		self.class_cols = np.array([c.startswith('group') or c.startswith('status') for c in list(self.df_tracks.columns)])
 		self.class_cols = list(cols[self.class_cols])
+		print(self.class_cols)
+
 		try:
 			self.class_cols.remove('group_id')
 		except Exception:
@@ -1711,6 +1727,14 @@ class MeasureAnnotator(SignalAnnotator):
 		btn_hbox.addWidget(self.save_btn, 90)
 		self.left_panel.addLayout(btn_hbox)
 
+		self.export_btn = QPushButton('')
+		self.export_btn.setStyleSheet(self.button_select_all)
+		self.export_btn.clicked.connect(self.export_measurements)
+		self.export_btn.setIcon(icon(MDI6.export, color="black"))
+		self.export_btn.setIconSize(QSize(25, 25))
+		btn_hbox.addWidget(self.export_btn, 10)
+		self.left_panel.addLayout(btn_hbox)
+
 		# Animation
 		animation_buttons_box = QHBoxLayout()
 
@@ -1810,6 +1834,28 @@ class MeasureAnnotator(SignalAnnotator):
 		# del self.img
 		gc.collect()
 
+
+	def export_measurements(self):
+
+		auto_dataset_name = self.pos.split(os.sep)[-4] + '_' + self.pos.split(os.sep)[-2] + f'_{str(self.current_frame).zfill(3)}' + f'_{self.status_name}.npy'
+
+		if self.normalized_signals:
+			self.normalize_features_btn.click()
+
+		subdf = self.df_tracks.loc[self.df_tracks['FRAME']==self.current_frame,:]
+		subdf['class'] = subdf[self.status_name]
+		dico = subdf.to_dict('records')
+
+		pathsave = QFileDialog.getSaveFileName(self, "Select file name", self.exp_dir + auto_dataset_name, ".npy")[0]
+		if pathsave != '':
+			if not pathsave.endswith(".npy"):
+				pathsave += ".npy"
+			try:
+				np.save(pathsave, dico)
+				print(f'File successfully written in {pathsave}.')
+			except Exception as e:
+				print(f"Error {e}...")
+
 	def set_next_frame(self):
 
 		self.current_frame = self.current_frame + 1
@@ -1887,13 +1933,17 @@ class MeasureAnnotator(SignalAnnotator):
 
 	def give_cell_information(self):
 
-		cell_selected = f"cell: {self.track_of_interest}\n"
-		if 'TRACK_ID' in self.df_tracks.columns:
-			cell_status = f"phenotype: {self.df_tracks.loc[self.df_tracks['TRACK_ID'] == self.track_of_interest, self.status_name].to_numpy()[0]}\n"
-		else:
-			cell_status = f"phenotype: {self.df_tracks.loc[self.df_tracks['ID'] == self.track_of_interest, self.status_name].to_numpy()[0]}\n"
-		self.cell_info.setText(cell_selected + cell_status)
-
+		try:
+			cell_selected = f"cell: {self.track_of_interest}\n"
+			if 'TRACK_ID' in self.df_tracks.columns:
+				cell_status = f"phenotype: {self.df_tracks.loc[self.df_tracks['TRACK_ID'] == self.track_of_interest, self.status_name].to_numpy()[0]}\n"
+			else:
+				cell_status = f"phenotype: {self.df_tracks.loc[self.df_tracks['ID'] == self.track_of_interest, self.status_name].to_numpy()[0]}\n"
+			self.cell_info.setText(cell_selected + cell_status)
+		except Exception as e:
+			print('Cell info:',e)
+			print(self.track_of_interest, self.status_name)
+			
 	def create_new_event_class(self):
 
 		# display qwidget to name the event
@@ -1978,8 +2028,14 @@ class MeasureAnnotator(SignalAnnotator):
 		self.frame_lbl.setText(f'position: {self.framedata}')
 		self.im.set_array(self.img)
 		self.status_scatter.set_offsets(self.positions[self.framedata])
-		self.status_scatter.set_edgecolors(self.colors[self.framedata][:, 0])
+		try:
+			self.status_scatter.set_edgecolors(self.colors[self.framedata][:, 0])
+		except Exception as e:
+			print('L1993: ',e)
+
 		self.current_label = self.labels[self.current_frame]
+		self.current_label = contour_of_instance_segmentation(self.current_label, 5)
+
 		self.im_mask.remove()
 		self.im_mask = self.ax.imshow(np.ma.masked_where(self.current_label == 0, self.current_label),
 											   cmap='viridis', interpolation='none',alpha=self.current_alpha,vmin=0,vmax=np.nanmax(self.labels.flatten()))
@@ -2108,9 +2164,9 @@ class MeasureAnnotator(SignalAnnotator):
 
 			self.extract_scatter_from_trajectories()
 			if 'TRACK_ID' in self.df_tracks.columns:
-				self.track_of_interest = self.df_tracks['TRACK_ID'].min()
+				self.track_of_interest = self.df_tracks.dropna(subset='TRACK_ID')['TRACK_ID'].min()
 			else:
-				self.track_of_interest = self.df_tracks['ID'].min()
+				self.track_of_interest = self.df_tracks.dropna(subset='ID')['ID'].min()
 
 			self.loc_t = []
 			self.loc_idx = []
@@ -2172,9 +2228,13 @@ class MeasureAnnotator(SignalAnnotator):
 		"""
 		self.current_frame = self.frame_slider.value()
 		self.reload_frame()
-		if 'ID' in self.df_tracks.columns:
+		if 'TRACK_ID' in list(self.df_tracks.columns):
+			pass
+		elif 'ID' in list(self.df_tracks.columns):
+			print('ID in cols... change class of interest... ')
 			self.track_of_interest = self.df_tracks[self.df_tracks['FRAME'] == self.current_frame]['ID'].min()
 			self.modify()
+
 		self.draw_frame(self.current_frame)
 		self.fcanvas.canvas.draw()
 		self.plot_signals()
@@ -2302,7 +2362,7 @@ class MeasureAnnotator(SignalAnnotator):
 		try:
 			self.selection.pop(0)
 		except Exception as e:
-			print(e)
+			print('Cancel selection: ',e)
 
 		try:
 			for k, (t, idx) in enumerate(zip(self.loc_t, self.loc_idx)):

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
@@ -63,15 +65,101 @@ class QueryWidget(QWidget):
 
 	def filter_table(self):
 		try:
-			query_text = self.query_le.text().replace('class', '`class`')
+			query_text = self.query_le.text() #.replace('class', '`class`')
 			tab = self.parent_window.data.query(query_text)
-			self.subtable = TableUI(tab, query_text, plot_mode="scatter")
+			self.subtable = TableUI(tab, query_text, plot_mode="static")
 			self.subtable.show()
 			self.close()
 		except Exception as e:
 			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):
@@ -180,7 +268,6 @@ class RenameColWidget(QWidget):
 		old_name = self.column
 		new_name = self.new_col_name.text()
 		self.parent_window.data = self.parent_window.data.rename(columns={old_name: new_name})
-		print(self.parent.data.columns)
 
 		self.parent_window.model = PandasModel(self.parent_window.data)
 		self.parent_window.table_view.setModel(self.parent_window.model)
@@ -264,7 +351,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 +426,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,16 +582,20 @@ 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.scat_check = QCheckBox('scatter plot')
 		self.swarm_check = QCheckBox('swarm')
 		self.violin_check = QCheckBox('violin')
 		self.strip_check = QCheckBox('strip')
-		self.box_check = QCheckBox('Boxplot')
-		self.boxenplot_check = QCheckBox('Boxenplot')
+		self.box_check = QCheckBox('boxplot')
+		self.boxenplot_check = QCheckBox('boxenplot')
 
 		layout.addWidget(self.hist_check)
 		layout.addWidget(self.kde_check)
+		layout.addWidget(self.count_check)
 		layout.addWidget(self.ecdf_check)
+		layout.addWidget(self.scat_check)
 		layout.addWidget(self.swarm_check)
 		layout.addWidget(self.violin_check)
 		layout.addWidget(self.strip_check)
@@ -496,16 +605,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 +670,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 +685,76 @@ 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.scat_check.isChecked():
+			if self.x_option:
+				sns.scatterplot(data=self.data, x=self.x,y=self.y, hue=hue_variable,legend=legend, ax=self.ax, palette=colors)
+				legend = False
+			else:
+				print('please provide a -x variable...')
+				pass
 
 		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 +903,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