celldetective 1.2.2.post2__py3-none-any.whl → 1.3.0.post1__py3-none-any.whl

celldetective/gui/signal_annotator.py

@@ -1438,59 +1438,65 @@ class MeasureAnnotator(SignalAnnotator):
 		self.plot_signals()
 
 	def plot_signals(self):
-		try:
-			current_frame = self.current_frame  # Assuming you have a variable for the current frame
-			yvalues = []
-			all_yvalues = []
-			current_yvalues = []
-			all_median_values = []
-			labels = []
-			for i in range(len(self.signal_choice_cb)):
-				signal_choice = self.signal_choice_cb[i].currentText()
+		
+		#try:
+		current_frame = self.current_frame  # Assuming you have a variable for the current frame
+		
+		yvalues = []
+		all_yvalues = []
+		current_yvalues = []
+		all_median_values = []
+		labels = []
+
+		for i in range(len(self.signal_choice_cb)):
+
+			signal_choice = self.signal_choice_cb[i].currentText()
 
-				if signal_choice != "--":
-					if 'TRACK_ID' in self.df_tracks.columns:
-						ydata = self.df_tracks.loc[
-							(self.df_tracks['TRACK_ID'] == self.track_of_interest) &
-							(self.df_tracks['FRAME'] == current_frame), signal_choice].to_numpy()
-					else:
-						ydata = self.df_tracks.loc[
-							(self.df_tracks['ID'] == self.track_of_interest), signal_choice].to_numpy()
-					all_ydata = self.df_tracks.loc[:, signal_choice].to_numpy()
-					ydata = ydata[ydata == ydata]  # remove nan
-					current_ydata = self.df_tracks.loc[
+			if signal_choice != "--":
+				if 'TRACK_ID' in self.df_tracks.columns:
+					ydata = self.df_tracks.loc[
+						(self.df_tracks['TRACK_ID'] == self.track_of_interest) &
 						(self.df_tracks['FRAME'] == current_frame), signal_choice].to_numpy()
-					current_ydata = current_ydata[current_ydata == current_ydata]
-					all_ydata = all_ydata[all_ydata == all_ydata]
-					yvalues.extend(ydata)
-					current_yvalues.append(current_ydata)
-					all_yvalues.append(all_ydata)
-					labels.append(signal_choice)
+				else:
+					ydata = self.df_tracks.loc[
+						(self.df_tracks['ID'] == self.track_of_interest), signal_choice].to_numpy()
+				all_ydata = self.df_tracks.loc[:, signal_choice].to_numpy()
+				ydataNaN = ydata
+				ydata = ydata[ydata == ydata]  # remove nan
+				current_ydata = self.df_tracks.loc[
+					(self.df_tracks['FRAME'] == current_frame), signal_choice].to_numpy()
+				current_ydata = current_ydata[current_ydata == current_ydata]
+				all_ydata = all_ydata[all_ydata == all_ydata]
+				yvalues.extend(ydataNaN)
+				current_yvalues.append(current_ydata)
+				all_yvalues.append(all_ydata)
+				labels.append(signal_choice)
 
-			self.cell_ax.clear()
+		self.cell_ax.clear()
 
-			if len(yvalues) > 0:
-				self.cell_ax.boxplot(all_yvalues, showfliers=self.show_fliers)
-				ylim = self.cell_ax.get_ylim()
-				self.cell_ax.set_ylim(ylim)
-				x_pos = np.arange(len(all_yvalues)) + 1
+		if len(yvalues) > 0:
+			self.cell_ax.boxplot(all_yvalues, showfliers=self.show_fliers)
+			ylim = self.cell_ax.get_ylim()
+			self.cell_ax.set_ylim(ylim)
+			x_pos = np.arange(len(all_yvalues)) + 1
 
-				for index, feature in enumerate(current_yvalues):
-					x_values_strip = (index + 1) + np.random.normal(0, 0.04, size=len(
-						feature))
-					self.cell_ax.plot(x_values_strip, feature, marker='o', linestyle='None', color=tab10.colors[0],
-									  alpha=0.1)
-				self.cell_ax.plot(x_pos, yvalues, marker='H', linestyle='None', color=tab10.colors[3], alpha=1)
+			for index, feature in enumerate(current_yvalues):
+				x_values_strip = (index + 1) + np.random.normal(0, 0.04, size=len(
+					feature))
+				self.cell_ax.plot(x_values_strip, feature, marker='o', linestyle='None', color=tab10.colors[0],
+								  alpha=0.1)
+			
+			self.cell_ax.plot(x_pos, yvalues, marker='H', linestyle='None', color=tab10.colors[3], alpha=1)
 
 
-			else:
-				self.cell_ax.text(0.5, 0.5, "No data available", horizontalalignment='center',
-								  verticalalignment='center', transform=self.cell_ax.transAxes)
+		else:
+			self.cell_ax.text(0.5, 0.5, "No data available", horizontalalignment='center',
+							  verticalalignment='center', transform=self.cell_ax.transAxes)
 
-			self.cell_fcanvas.canvas.draw()
+		self.cell_fcanvas.canvas.draw()
 
-		except Exception as e:
-			print(f"{e=}")
+		# except Exception as e:
+		# 	print("plot_signals: ",f"{e=}")
 
 	def configure_ylims(self):
 
@@ -1954,7 +1960,7 @@ class MeasureAnnotator(SignalAnnotator):
 		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"
+				cell_status = f"phenotype: {self.df_tracks.loc[(self.df_tracks['FRAME']==self.current_frame)&(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)
@@ -2032,9 +2038,8 @@ class MeasureAnnotator(SignalAnnotator):
 
 	def assign_color_state(self, state):
 		if np.isnan(state):
-			pass
-		else:
-			return self.state_color_map[state]
+		 	state = "nan"
+		return self.state_color_map[state]
 
 	def draw_frame(self, framedata):
 
@@ -2045,10 +2050,10 @@ 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])
-		try:
-			self.status_scatter.set_edgecolors(self.colors[self.framedata][:, 0])
-		except Exception as e:
-			pass
+		# try:
+		self.status_scatter.set_edgecolors(self.colors[self.framedata][:, 0])
+		# except Exception as e:
+		# 	pass
 
 		self.current_label = self.labels[self.current_frame]
 		self.current_label = contour_of_instance_segmentation(self.current_label, 5)
@@ -2060,18 +2065,23 @@ class MeasureAnnotator(SignalAnnotator):
 		return (self.im, self.status_scatter,self.im_mask,)
 
 	def compute_status_and_colors(self):
+		print('compute status and colors!')
 		if self.class_choice_cb.currentText() == '':
 			self.status_name=self.target_class
 		else:
 			self.status_name = self.class_choice_cb.currentText()
 
+		print(f'{self.status_name=}')
 		if self.status_name not in self.df_tracks.columns:
+			print('not in df, make column')
 			self.make_status_column()
 		else:
 			all_states = self.df_tracks.loc[:, self.status_name].tolist()
 			all_states = np.array(all_states)
 			self.state_color_map = color_from_state(all_states, recently_modified=False)
+			print(f'{self.state_color_map=}')
 			self.df_tracks['group_color'] = self.df_tracks[self.status_name].apply(self.assign_color_state)
+			print(self.df_tracks['group_color'])
 
 	def del_event_class(self):
 
@@ -2342,9 +2352,11 @@ class MeasureAnnotator(SignalAnnotator):
 	# self.extract_scatter_from_trajectories()
 
 	def modify(self):
+
 		all_states = self.df_tracks.loc[:, self.status_name].tolist()
 		all_states = np.array(all_states)
 		self.state_color_map = color_from_state(all_states, recently_modified=False)
+		print(f'{self.state_color_map=}')
 
 		self.df_tracks['group_color'] = self.df_tracks[self.status_name].apply(self.assign_color_state)
 
@@ -2383,7 +2395,7 @@ class MeasureAnnotator(SignalAnnotator):
 				self.colors[t][idx, 0] = self.previous_color[k][0]
 			# self.colors[t][idx, 1] = self.previous_color[k][1]
 		except Exception as e:
-			print(f'{e=}')
+			print("cancel_selection: ",f'{e=}')
 
 	def locate_stack(self):
 

celldetective/gui/tableUI.py

@@ -1,10 +1,11 @@
 from PyQt5.QtWidgets import QRadioButton, QButtonGroup, QMainWindow, QTableView, QAction, QMenu,QFileDialog, QLineEdit, QHBoxLayout, QWidget, QPushButton, QVBoxLayout, QComboBox, QLabel, QCheckBox, QMessageBox
 from PyQt5.QtCore import Qt, QAbstractTableModel
+from PyQt5.QtGui import QBrush, QColor
 import pandas as pd
 import matplotlib.pyplot as plt
 plt.rcParams['svg.fonttype'] = 'none'
-from celldetective.gui.gui_utils import FigureCanvas, center_window
-from celldetective.utils import differentiate_per_track, collapse_trajectories_by_status
+from celldetective.gui.gui_utils import FigureCanvas, center_window, QHSeperationLine
+from celldetective.utils import differentiate_per_track, collapse_trajectories_by_status, test_2samp_generic
 import numpy as np
 import seaborn as sns
 import matplotlib.cm as mcm
@@ -26,6 +27,7 @@ class PandasModel(QAbstractTableModel):
 	def __init__(self, data):
 		QAbstractTableModel.__init__(self)
 		self._data = data
+		self.colors = dict()
 
 	def rowCount(self, parent=None):
 		return self._data.shape[0]
@@ -37,13 +39,24 @@ class PandasModel(QAbstractTableModel):
 		if index.isValid():
 			if role == Qt.DisplayRole:
 				return str(self._data.iloc[index.row(), index.column()])
+			if role == Qt.BackgroundRole:
+				color = self.colors.get((index.row(), index.column()))
+				if color is not None:
+					return color
 		return None
 
-	def headerData(self, col, orientation, role):
+	def headerData(self, rowcol, orientation, role):
 		if orientation == Qt.Horizontal and role == Qt.DisplayRole:
-			return self._data.columns[col]
+			return self._data.columns[rowcol]
+		if orientation == Qt.Vertical and role == Qt.DisplayRole:
+			return self._data.index[rowcol]
 		return None
 
+	def change_color(self, row, column, color):
+		ix = self.index(row, column)
+		self.colors[(row, column)] = color
+		self.dataChanged.emit(ix, ix, (Qt.BackgroundRole,))
+
 
 class QueryWidget(QWidget):
 
@@ -316,6 +329,111 @@ class RenameColWidget(QWidget):
 		self.parent_window.table_view.setModel(self.parent_window.model)
 		self.close()
 
+class PivotTableUI(QWidget):
+
+	def __init__(self, data, title="", mode=None, *args, **kwargs):
+
+		QWidget.__init__(self, *args, **kwargs)
+		
+		self.data = data
+		self.title = title
+		self.mode = mode
+
+		self.setWindowTitle(title)
+		print("tab to show: ",self.data)
+
+		self.table = QTableView(self)
+
+		self.v_layout = QVBoxLayout()
+		self.information_label = QLabel('Information about color code...')
+		self.v_layout.addWidget(self.information_label)
+		self.v_layout.addWidget(self.table)
+		self.setLayout(self.v_layout)
+
+		self.showdata()
+
+		if self.mode=="cliff":
+			self.color_cells_cliff()
+		elif self.mode=="pvalue":
+			self.color_cells_pvalue()
+
+		self.table.resizeColumnsToContents()
+		self.setAttribute(Qt.WA_DeleteOnClose)
+		center_window(self)
+
+	def showdata(self):
+		self.model = PandasModel(self.data)
+		self.table.setModel(self.model)
+
+	def set_cell_color(self, row, column, color='red'):
+		self.model.change_color(row, column, QBrush(QColor(color))) #eval(f"Qt.{color}")
+
+	def color_cells_cliff(self):
+
+		color_codes = {
+			"negligible": "#eff3ff",  # Green
+			"small": "#bdd7e7",       # Yellow
+			"medium": "#6baed6",      # Orange
+			"large": "#2171b5"        # Red
+		}
+
+		for i in range(self.data.shape[0]):
+			for j in range(self.data.shape[1]):
+				value = self.data.iloc[i,j]
+				if value < 0.147:
+					self.set_cell_color(i,j,color_codes['negligible'])
+				elif value < 0.33:
+					self.set_cell_color(i,j,color_codes['small'])
+				elif value < 0.474:
+					self.set_cell_color(i,j,color_codes['medium'])
+				elif value >= 0.474:
+					self.set_cell_color(i,j,color_codes['large'])
+	
+		# Create the HTML text for the label
+		html_caption = f"""
+		<p style="background-color:black; padding: 5px; font-weight:bold;">
+			<span style="color:{color_codes['negligible']}">Negligible</span>, 
+			<span style="color:{color_codes['small']}">Small</span>, 
+			<span style="color:{color_codes['medium']}">Medium</span>, 
+			<span style="color:{color_codes['large']}">Large</span>
+		</p>
+		"""
+		self.information_label.setText(html_caption)
+
+	def color_cells_pvalue(self):
+
+		color_codes = {
+			"ns": "#fee5d9",
+			"*": "#fcae91",
+			"**": "#fb6a4a",
+			"***": "#de2d26",
+			"****": "#a50f15"
+		}
+
+		for i in range(self.data.shape[0]):
+			for j in range(self.data.shape[1]):
+				value = self.data.iloc[i,j]
+				if value <= 0.0001:
+					self.set_cell_color(i,j,color_codes['****'])
+				elif value <= 0.001:
+					self.set_cell_color(i,j,color_codes['***'])
+				elif value <= 0.01:
+					self.set_cell_color(i,j,color_codes['**'])
+				elif value <= 0.05:
+					self.set_cell_color(i,j,color_codes['*'])
+				elif value > 0.05:
+					self.set_cell_color(i,j,color_codes['ns'])
+		
+		html_caption = f"""
+		<p style="background-color:black; padding: 5px; font-weight:bold;">
+			<span style="color:{color_codes['ns']}">ns</span>, 
+			<span style="color:{color_codes['*']}">*</span>, 
+			<span style="color:{color_codes['**']}">**</span>, 
+			<span style="color:{color_codes['***']}">***</span>,
+			<span style="color:{color_codes['****']}">****</span>
+		</p>
+		"""
+		self.information_label.setText(html_caption)
 
 class TableUI(QMainWindow, Styles):
 
@@ -744,6 +862,10 @@ class TableUI(QMainWindow, Styles):
 		self.box_check = QCheckBox('boxplot')
 		self.boxenplot_check = QCheckBox('boxenplot')
 
+		self.sep_line = QHSeperationLine()
+		self.pvalue_check = QCheckBox("Compute KS test p-value?")
+		self.effect_size_check = QCheckBox("Compute effect size?\n(Cliff's Delta)")
+
 		layout.addWidget(self.hist_check)
 		layout.addWidget(self.kde_check)
 		layout.addWidget(self.count_check)
@@ -754,6 +876,9 @@ class TableUI(QMainWindow, Styles):
 		layout.addWidget(self.strip_check)
 		layout.addWidget(self.box_check)
 		layout.addWidget(self.boxenplot_check)
+		layout.addWidget(self.sep_line)
+		layout.addWidget(self.pvalue_check)
+		layout.addWidget(self.effect_size_check)
 
 		self.x_cb = QSearchableComboBox()
 		self.x_cb.addItems(['--']+list(self.data.columns))
@@ -830,13 +955,13 @@ class TableUI(QMainWindow, Styles):
 		cmap = getattr(mcm, self.cmap_cb.currentText())
 
 		try:
-			hue_variable = self.hue_cb.currentText()
-			colors = [cmap(i / len(self.data[hue_variable].unique())) for i in range(len(self.data[hue_variable].unique()))]
+			self.hue_variable = self.hue_cb.currentText()
+			colors = [cmap(i / len(self.data[self.hue_variable].unique())) for i in range(len(self.data[self.hue_variable].unique()))]
 		except:
 			colors = None
 
 		if self.hue_cb.currentText()=='--':
-			hue_variable = None
+			self.hue_variable = None
 
 		if self.y_cb.currentText()=='--':
 			self.y = None
@@ -852,42 +977,42 @@ class TableUI(QMainWindow, Styles):
 		
 		if self.hist_check.isChecked():
 			if self.x is not None:
-				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')
+				sns.histplot(data=self.data, x=self.x, hue=self.hue_variable, legend=legend, ax=self.ax, palette=colors, kde=True, common_norm=False, stat='density')
 				legend = False
 			elif self.x is None and self.y is not None:
-				sns.histplot(data=self.data, x=self.y, hue=hue_variable, legend=legend, ax=self.ax, palette=colors, kde=True, common_norm=False, stat='density')
+				sns.histplot(data=self.data, x=self.y, hue=self.hue_variable, legend=legend, ax=self.ax, palette=colors, kde=True, common_norm=False, stat='density')
 				legend = False
 			else:
 				pass
 
 		if self.kde_check.isChecked():
 			if self.x is not None:
-				sns.kdeplot(data=self.data, x=self.x, hue=hue_variable, legend=legend, ax=self.ax, palette=colors, cut=0)
+				sns.kdeplot(data=self.data, x=self.x, hue=self.hue_variable, legend=legend, ax=self.ax, palette=colors, cut=0)
 				legend = False
 			elif self.x is None and self.y is not None:
-				sns.kdeplot(data=self.data, x=self.y, hue=hue_variable, legend=legend, ax=self.ax, palette=colors, cut=0)
+				sns.kdeplot(data=self.data, x=self.y, hue=self.hue_variable, legend=legend, ax=self.ax, palette=colors, cut=0)
 				legend = False	
 			else:
 				pass
 
 		if self.count_check.isChecked():
-			sns.countplot(data=self.data, x=self.x, hue=hue_variable, legend=legend, ax=self.ax, palette=colors)
+			sns.countplot(data=self.data, x=self.x, hue=self.hue_variable, legend=legend, ax=self.ax, palette=colors)
 			legend = False
 
 
 		if self.ecdf_check.isChecked():
 			if self.x is not None:
-				sns.ecdfplot(data=self.data, x=self.x, hue=hue_variable, legend=legend, ax=self.ax, palette=colors)
+				sns.ecdfplot(data=self.data, x=self.x, hue=self.hue_variable, legend=legend, ax=self.ax, palette=colors)
 				legend = False
 			elif self.x is None and self.y is not None:
-				sns.ecdfplot(data=self.data, x=self.y, hue=hue_variable, legend=legend, ax=self.ax, palette=colors)
+				sns.ecdfplot(data=self.data, x=self.y, hue=self.hue_variable, legend=legend, ax=self.ax, palette=colors)
 				legend = False
 			else:
 				pass
 						
 		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)
+				sns.scatterplot(data=self.data, x=self.x,y=self.y, hue=self.hue_variable,legend=legend, ax=self.ax, palette=colors)
 				legend = False
 			else:
 				print('please provide a -x variable...')
@@ -895,42 +1020,42 @@ class TableUI(QMainWindow, Styles):
 
 		if self.swarm_check.isChecked():
 			if self.x_option:
-				sns.swarmplot(data=self.data, x=self.x,y=self.y,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=self.hue_variable,legend=legend, ax=self.ax, palette=colors)
 				legend = False
 			else:
-				sns.swarmplot(data=self.data, y=self.y,dodge=True, hue=hue_variable,legend=legend, ax=self.ax, palette=colors)
+				sns.swarmplot(data=self.data, y=self.y,dodge=True, hue=self.hue_variable,legend=legend, ax=self.ax, palette=colors)
 				legend = False
 
 		if self.violin_check.isChecked():
 			if self.x_option:
-				sns.violinplot(data=self.data,x=self.x, y=self.y,dodge=True, ax=self.ax, hue=hue_variable, legend=legend, palette=colors)
+				sns.violinplot(data=self.data,x=self.x, y=self.y,dodge=True, ax=self.ax, hue=self.hue_variable, legend=legend, palette=colors)
 				legend = False
 			else:
-				sns.violinplot(data=self.data, y=self.y,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=self.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=self.y,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=self.hue_variable,legend=legend, ax=self.ax, fill=False,palette=colors, linewidth=2,)
 				legend = False
 			else:
-				sns.boxplot(data=self.data, y=self.y,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=self.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=self.y,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=self.hue_variable,legend=legend, ax=self.ax, fill=False,palette=colors, linewidth=2,)
 				legend = False
 			else:
-				sns.boxenplot(data=self.data, y=self.y,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=self.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=self.y,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=self.hue_variable, legend=legend, palette=colors)
 				legend = False
 			else:
-				sns.stripplot(data=self.data, y=self.y,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=self.hue_variable, legend=legend, palette=colors)
 				legend = False
 
 		plt.tight_layout()
@@ -939,6 +1064,51 @@ class TableUI(QMainWindow, Styles):
 		self.plot1dWindow.canvas.draw()
 		self.plot1dWindow.show()
 
+		if self.effect_size_check.isChecked():
+			self.compute_effect_size()
+		if self.pvalue_check.isChecked():
+			self.compute_pvalue()
+
+	def extract_groupby_cols(self):
+
+		x = self.x
+		y = self.y
+		hue_variable = self.hue_variable
+
+		if self.hist_check.isChecked() or self.ecdf_check.isChecked() or self.kde_check.isChecked():
+			y = self.x
+			x = None
+
+		groupby_cols = []
+		if x is not None:
+			groupby_cols.append(x)
+		if hue_variable is not None:
+			groupby_cols.append(hue_variable)
+
+		return groupby_cols, y
+
+	def compute_effect_size(self):
+
+		if self.count_check.isChecked() or self.scat_check.isChecked():
+			print('Please select a valid plot representation to compute effect size (histogram, boxplot, etc.)...')
+			return None
+
+		groupby_cols, y = self.extract_groupby_cols()
+		pivot = test_2samp_generic(self.data, feature=y, groupby_cols=groupby_cols, method="cliffs_delta")
+		self.effect_size_table = PivotTableUI(pivot, title="Effect size (Cliff's Delta)", mode="cliff")
+		self.effect_size_table.show()
+
+	def compute_pvalue(self):
+
+		if self.count_check.isChecked() or self.scat_check.isChecked():
+			print('Please select a valid plot representation to compute effect size (histogram, boxplot, etc.)...')
+			return None
+
+		groupby_cols, y = self.extract_groupby_cols()
+		pivot = test_2samp_generic(self.data, feature=y, groupby_cols=groupby_cols, method="ks_2samp")
+		self.pval_table = PivotTableUI(pivot, title="p-value (1-sided KS test)", mode="pvalue")
+		self.pval_table.show()
+
 
 	def set_proj_mode(self):
 		
@@ -1003,7 +1173,7 @@ class TableUI(QMainWindow, Styles):
 
 
 		elif self.per_status_option.isChecked():
-
+			self.projection_mode = self.status_operation.currentText()
 			group_table = collapse_trajectories_by_status(self.data, status=self.per_status_cb.currentText(),population=self.population, projection=self.status_operation.currentText(), groupby_columns=self.groupby_cols)
 
 		self.subtable = TableUI(group_table,f"Group by tracks: {self.projection_mode}", plot_mode="static")

celldetective/io.py

@@ -766,6 +766,9 @@ def locate_stack_and_labels(position, prefix='Aligned', population="target"):
 	position = position.replace('\\', '/')
 	labels = locate_labels(position, population=population)
 	stack = locate_stack(position, prefix=prefix)
+	if len(labels) < len(stack):
+		fix_missing_labels(position, population=population, prefix=prefix)
+		labels = locate_labels(position, population=population)
 	assert len(stack) == len(
 		labels), f"The shape of the stack {stack.shape} does not match with the shape of the labels {labels.shape}"
 
@@ -1272,7 +1275,7 @@ def view_on_napari_btrack(data, properties, graph, stack=None, labels=None, rela
 	if stack is not None:
 		viewer.add_image(stack, channel_axis=-1, colormap=["gray"] * stack.shape[-1])
 	if labels is not None:
-		viewer.add_labels(labels, name='segmentation', opacity=0.4)
+		viewer.add_labels(labels.astype(int), name='segmentation', opacity=0.4)
 	viewer.add_points(vertices, size=4, name='points', opacity=0.3)
 	if data.shape[1]==4:
 		viewer.add_tracks(data, properties=properties, graph=graph, name='tracks')