celldetective 1.1.1.post4__py3-none-any.whl → 1.2.1__py3-none-any.whl

celldetective/gui/signal_annotator_options.py

@@ -34,7 +34,9 @@ class ConfigSignalAnnotator(QMainWindow, Styles):
 			self.instructions_path = self.parent_window.exp_dir + "configs/signal_annotator_config_targets.json"
 		elif self.mode=="effectors":
 			self.instructions_path = self.parent_window.exp_dir + "configs/signal_annotator_config_effectors.json"
-				
+		elif self.mode == "neighborhood":
+			self.instructions_path = self.parent_window.exp_dir + "configs/signal_annotator_config_neighborhood.json"
+
 		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)

celldetective/gui/survival_ui.py

@@ -109,9 +109,10 @@ class ConfigSurvival(QWidget, Styles):
 		main_layout.addWidget(panel_title, alignment=Qt.AlignCenter)
 
 
-		labels = [QLabel('population: '), QLabel('time of\nreference: '), QLabel('time of\ninterest: '), QLabel('exclude\nclass: '), QLabel('cmap: ')] #QLabel('class: '), 
-		self.cb_options = [['targets','effectors'], ['0','t_firstdetection'], ['t0'], ['--'], list(plt.colormaps())] #['class'], 
+		labels = [QLabel('population: '), QLabel('time of\nreference: '), QLabel('time of\ninterest: '), QLabel('cmap: ')] #QLabel('class: '), 
+		self.cb_options = [['targets','effectors'], ['0'], [], list(plt.colormaps())] #['class'], 
 		self.cbs = [QComboBox() for i in range(len(labels))]
+
 		self.cbs[-1] = QColormapComboBox()
 		self.cbs[0].currentIndexChanged.connect(self.set_classes_and_times)
 
@@ -133,6 +134,12 @@ class ConfigSurvival(QWidget, Styles):
 
 		main_layout.addLayout(choice_layout)
 
+		select_layout = QHBoxLayout()
+		select_layout.addWidget(QLabel('select cells\nwith query: '), 33)
+		self.query_le = QLineEdit()
+		select_layout.addWidget(self.query_le, 66)
+		main_layout.addLayout(select_layout)
+
 		self.cbs[0].setCurrentIndex(0)
 		self.cbs[1].setCurrentText('t_firstdetection')
 
@@ -218,10 +225,12 @@ class ConfigSurvival(QWidget, Styles):
 
 		if self.df is not None:
 			
-			excluded_class = self.cbs[3].currentText()
-			if excluded_class!='--':
-				print(f"Excluding {excluded_class}...")
-				self.df = self.df.loc[~(self.df[excluded_class].isin([0,2])),:]
+			try:
+				query_text = self.query_le.text()
+				if query_text != '':
+					self.df = self.df.query(query_text)
+			except Exception as e:
+				print(e, ' The query is misunderstood and will not be applied...')
 
 			self.compute_survival_functions()
 			# prepare survival

celldetective/gui/tableUI.py

@@ -5,7 +5,7 @@ import matplotlib.pyplot as plt
 from matplotlib.cm import viridis
 plt.rcParams['svg.fonttype'] = 'none'
 from celldetective.gui.gui_utils import FigureCanvas, center_window
-from celldetective.utils import differentiate_per_track
+from celldetective.utils import differentiate_per_track, collapse_trajectories_by_status
 import numpy as np
 import seaborn as sns
 import matplotlib.cm as mcm
@@ -20,6 +20,10 @@ from matplotlib import colormaps
 
 class PandasModel(QAbstractTableModel):
 
+	"""
+	from https://stackoverflow.com/questions/31475965/fastest-way-to-populate-qtableview-from-pandas-data-frame
+	"""
+
 	def __init__(self, data):
 		QAbstractTableModel.__init__(self)
 		self._data = data
@@ -67,7 +71,7 @@ class QueryWidget(QWidget):
 		try:
 			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="static")
+			self.subtable = TableUI(tab, query_text, plot_mode="static", population=self.parent_window.population)
 			self.subtable.show()
 			self.close()
 		except Exception as e:
@@ -236,7 +240,47 @@ class DifferentiateColWidget(QWidget, Styles):
 		self.parent_window.table_view.setModel(self.parent_window.model)
 		self.close()
 
+class AbsColWidget(QWidget, Styles):
 
+	def __init__(self, parent_window, column=None):
+
+		super().__init__()
+		self.parent_window = parent_window
+		self.column = column
+
+		self.setWindowTitle("abs(.)")
+		# Create the QComboBox and add some items
+		center_window(self)
+		
+		layout = QVBoxLayout(self)
+		layout.setContentsMargins(30,30,30,30)
+
+		self.measurements_cb = QComboBox()
+		self.measurements_cb.addItems(list(self.parent_window.data.columns))
+		if self.column is not None:
+			idx = self.measurements_cb.findText(self.column)
+			self.measurements_cb.setCurrentIndex(idx)
+
+		measurement_layout = QHBoxLayout()
+		measurement_layout.addWidget(QLabel('measurements: '), 25)
+		measurement_layout.addWidget(self.measurements_cb, 75)
+		layout.addLayout(measurement_layout)
+
+		self.submit_btn = QPushButton('Compute')
+		self.submit_btn.setStyleSheet(self.button_style_sheet)
+		self.submit_btn.clicked.connect(self.compute_abs_and_add_new_column)
+		layout.addWidget(self.submit_btn, 30)
+
+		self.setAttribute(Qt.WA_DeleteOnClose)
+
+
+	def compute_abs_and_add_new_column(self):
+		
+
+		self.parent_window.data['|'+self.measurements_cb.currentText()+'|'] = self.parent_window.data[self.measurements_cb.currentText()].abs()
+		self.parent_window.model = PandasModel(self.parent_window.data)
+		self.parent_window.table_view.setModel(self.parent_window.model)
+		self.close()
 
 class RenameColWidget(QWidget):
 
@@ -275,6 +319,7 @@ class RenameColWidget(QWidget):
 
 
 class TableUI(QMainWindow, Styles):
+
 	def __init__(self, data, title, population='targets',plot_mode="plot_track_signals", *args, **kwargs):
 
 		QMainWindow.__init__(self, *args, **kwargs)
@@ -286,6 +331,16 @@ class TableUI(QMainWindow, Styles):
 		self.plot_mode = plot_mode
 		self.population = population
 		self.numerics = ['int16', 'int32', 'int64', 'float16', 'float32', 'float64']
+		self.groupby_cols = ['position', 'TRACK_ID']
+		self.tracks = False
+
+		if self.population=='pairs':
+			self.groupby_cols = ['position','reference_population', 'neighbor_population','REFERENCE_ID', 'NEIGHBOR_ID']
+			self.tracks = True # for now
+		else:
+			if 'TRACK_ID' in data.columns:
+				if not np.all(data['TRACK_ID'].isnull()):
+					self.tracks = True
 
 		self._createMenuBar()
 		self._createActions()
@@ -328,6 +383,18 @@ class TableUI(QMainWindow, Styles):
 			self.groupby_action.triggered.connect(self.set_projection_mode_tracks)
 			self.groupby_action.setShortcut("Ctrl+g")
 			self.fileMenu.addAction(self.groupby_action)
+			if not self.tracks:
+				self.groupby_action.setEnabled(False)
+
+			if self.population=='pairs':
+				self.groupby_neigh_action = QAction("&Group by neighbors...", self)
+				self.groupby_neigh_action.triggered.connect(self.set_projection_mode_neigh)
+				self.fileMenu.addAction(self.groupby_neigh_action)	
+
+				self.groupby_ref_action = QAction("&Group by reference...", self)
+				self.groupby_ref_action.triggered.connect(self.set_projection_mode_ref)
+				self.fileMenu.addAction(self.groupby_ref_action)	
+
 
 			self.groupby_time_action = QAction("&Group by frames...", self)
 			self.groupby_time_action.triggered.connect(self.groupby_time_table)
@@ -348,16 +415,76 @@ class TableUI(QMainWindow, Styles):
 			#self.rename_col_action.setShortcut(Qt.Key_Delete)
 			self.editMenu.addAction(self.rename_col_action)
 
+			if self.population=='pairs':
+				self.merge_action = QAction('&Merge...', self)
+				self.merge_action.triggered.connect(self.merge_tables)
+				#self.rename_col_action.setShortcut(Qt.Key_Delete)
+				self.editMenu.addAction(self.merge_action)
+
 			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.abs_action = QAction('&Absolute value...', self)
+			self.abs_action.triggered.connect(self.take_abs_of_selected_feature)
+			#self.derivative_action.setShortcut("Ctrl+D")
+			self.mathMenu.addAction(self.abs_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 merge_tables(self):
+
+		expanded_table = []
+		
+		for neigh, group in self.data.groupby(['reference_population','neighbor_population']):
+			print(f'{neigh=}')
+			ref_pop = neigh[0]; neigh_pop = neigh[1];
+			for pos,pos_group in group.groupby('position'):
+				print(f'{pos=}')
+				
+				ref_tab = os.sep.join([pos,'output','tables',f'trajectories_{ref_pop}.csv'])
+				neigh_tab = os.sep.join([pos,'output','tables',f'trajectories_{neigh_pop}.csv'])
+				if os.path.exists(ref_tab):
+					df_ref = pd.read_csv(ref_tab)
+					if 'TRACK_ID' in df_ref.columns:
+						if not np.all(df_ref['TRACK_ID'].isnull()):
+							ref_merge_cols = ['TRACK_ID','FRAME']
+						else:
+							ref_merge_cols = ['ID','FRAME']
+					else:
+						ref_merge_cols = ['ID','FRAME']
+				if os.path.exists(neigh_tab):
+					df_neigh = pd.read_csv(neigh_tab)
+					if 'TRACK_ID' in df_neigh.columns:
+						if not np.all(df_neigh['TRACK_ID'].isnull()):
+							neigh_merge_cols = ['TRACK_ID','FRAME']
+						else:
+							neigh_merge_cols = ['ID','FRAME']
+					else:
+						neigh_merge_cols = ['ID','FRAME']
+
+				df_ref = df_ref.add_prefix('reference_',axis=1)
+				df_neigh = df_neigh.add_prefix('neighbor_',axis=1)
+				ref_merge_cols = ['reference_'+c for c in ref_merge_cols]
+				neigh_merge_cols = ['neighbor_'+c for c in neigh_merge_cols]
+
+				merge_ref = pos_group.merge(df_ref, how='outer', left_on=['REFERENCE_ID','FRAME'], right_on=ref_merge_cols, suffixes=('', '_reference'))
+				print(f'{merge_ref.columns=}')
+				merge_neigh = merge_ref.merge(df_neigh, how='outer', left_on=['NEIGHBOR_ID','FRAME'], right_on=neigh_merge_cols, suffixes=('_reference', '_neighbor'))
+				print(f'{merge_neigh.columns=}')
+				expanded_table.append(merge_neigh)
+
+		df_expanded = pd.concat(expanded_table, axis=0, ignore_index = True)
+		df_expanded = df_expanded.sort_values(by=['position', 'reference_population','neighbor_population','REFERENCE_ID','NEIGHBOR_ID','FRAME'])
+		df_expanded = df_expanded.dropna(axis=0, subset=['REFERENCE_ID','NEIGHBOR_ID','reference_population','neighbor_population'])
+		self.subtable = TableUI(df_expanded, 'merge', plot_mode = "static", population='pairs')
+		self.subtable.show()	
+
+
 	def delete_columns(self):
 
 		x = self.table_view.selectedIndexes()
@@ -407,8 +534,6 @@ class TableUI(QMainWindow, Styles):
 			pos_group.to_csv(pos+os.sep.join(['output', 'tables', f'trajectories_{self.population}.csv']), index=False)
 		print("Done...")
 
-
-
 	def differenciate_selected_feature(self):
 		
 		# check only one col selected and assert is numerical
@@ -426,6 +551,24 @@ class TableUI(QMainWindow, Styles):
 		self.diffWidget = DifferentiateColWidget(self, selected_col)
 		self.diffWidget.show()
 
+	def take_abs_of_selected_feature(self):
+		
+		# check only one col selected and assert is numerical
+		# open widget to select window parameters, directionality
+		# create new col
+		
+		x = self.table_view.selectedIndexes()
+		col_idx = np.unique(np.array([l.column() for l in x]))
+		if col_idx!=0:
+			cols = np.array(list(self.data.columns))
+			selected_col = str(cols[col_idx][0])
+		else:
+			selected_col = None
+
+		self.absWidget = AbsColWidget(self, selected_col)
+		self.absWidget.show()
+
+
 	def transform_one_hot_cols_to_categorical(self):
 
 		x = self.table_view.selectedIndexes()
@@ -450,7 +593,7 @@ class TableUI(QMainWindow, Styles):
 
 		num_df = self.data.select_dtypes(include=self.numerics)
 
-		timeseries = num_df.groupby("FRAME").mean().copy()
+		timeseries = num_df.groupby("FRAME").sum().copy()
 		timeseries["timeline"] = timeseries.index
 		self.subtable = TableUI(timeseries,"Group by frames", plot_mode="plot_timeseries")
 		self.subtable.show()
@@ -472,6 +615,16 @@ class TableUI(QMainWindow, Styles):
 		# self.subtable = TableUI(timeseries,"Group by frames", plot_mode="plot_timeseries")
 		# self.subtable.show()
 
+	def set_projection_mode_neigh(self):
+
+		self.groupby_cols = ['position', 'reference_population', 'neighbor_population', 'NEIGHBOR_ID', 'FRAME']
+		self.set_projection_mode_tracks()
+
+	def set_projection_mode_ref(self):
+		
+		self.groupby_cols = ['position', 'reference_population', 'neighbor_population', 'REFERENCE_ID', 'FRAME']
+		self.set_projection_mode_tracks()
+
 	def set_projection_mode_tracks(self):
 
 		self.projectionWidget = QWidget()
@@ -483,6 +636,7 @@ class TableUI(QMainWindow, Styles):
 
 		self.projection_option = QRadioButton('global operation: ')
 		self.projection_option.setToolTip('Collapse the cell track measurements with an operation over each track.')
+		self.projection_option.setChecked(True)
 		self.projection_option.toggled.connect(self.enable_projection_options)
 		self.projection_op_cb = QComboBox()
 		self.projection_op_cb.addItems(['mean','median','min','max', 'prod', 'sum'])
@@ -696,19 +850,42 @@ class TableUI(QMainWindow, Styles):
 			self.x = self.x_cb.currentText()
 
 		legend=True
+		
 		if self.hist_check.isChecked():
-			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.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')
+				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')
+				legend = False
+			else:
+				pass
+
 		if self.kde_check.isChecked():
-			sns.kdeplot(data=self.data, x=self.x, hue=hue_variable, legend=legend, ax=self.ax, palette=colors, cut=0)
-			legend = False
+			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)
+				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)
+				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)
 			legend = False
+
+
 		if self.ecdf_check.isChecked():
-			sns.ecdfplot(data=self.data, x=self.x, hue=hue_variable, legend=legend, ax=self.ax, palette=colors)
-			legend = False
-		
+			if self.x is not None:
+				sns.ecdfplot(data=self.data, x=self.x, hue=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)
+				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)
@@ -727,7 +904,7 @@ class TableUI(QMainWindow, Styles):
 
 		if self.violin_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.violinplot(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=self.y,dodge=True, hue=hue_variable,legend=legend, ax=self.ax, palette=colors, cut=0)
@@ -766,32 +943,39 @@ class TableUI(QMainWindow, Styles):
 
 	def set_proj_mode(self):
 		
-		self.static_columns = ['well_index', 'well_name', 'pos_name', 'position', 'well', 'status', 't0', 'class','cell_type','concentration', 'antibody', 'pharmaceutical_agent','TRACK_ID','position']
+		self.static_columns = ['well_index', 'well_name', 'pos_name', 'position', 'well', 'status', 't0', 'class','cell_type','concentration', 'antibody', 'pharmaceutical_agent','TRACK_ID','position', 'neighbor_population', 'reference_population', 'NEIGHBOR_ID', 'REFERENCE_ID', 'FRAME']
 
 		if self.projection_option.isChecked():
 
 			self.projection_mode = self.projection_op_cb.currentText()
-			op = getattr(self.data.groupby(['position', 'TRACK_ID']), self.projection_mode)
-			group_table = op(self.data.groupby(['position', 'TRACK_ID']))
+			op = getattr(self.data.groupby(self.groupby_cols), self.projection_mode)
+			group_table = op(self.data.groupby(self.groupby_cols))
 
 			for c in self.static_columns:
 				try:
-					group_table[c] = self.data.groupby(['position','TRACK_ID'])[c].apply(lambda x: x.unique()[0])
+					group_table[c] = self.data.groupby(self.groupby_cols)[c].apply(lambda x: x.unique()[0])
 				except Exception as e:
 					print(e)
 					pass
 			
-			for col in ['TRACK_ID']:
-				first_column = group_table.pop(col) 
-				group_table.insert(0, col, first_column)
-			group_table.pop('FRAME')
+			if self.population=='pairs':
+				for col in reversed(self.groupby_cols): #['neighbor_population', 'reference_population', 'NEIGHBOR_ID', 'REFERENCE_ID']
+					if col in group_table:
+						first_column = group_table.pop(col)
+						group_table.insert(0, col, first_column)				
+			else:
+				for col in ['TRACK_ID']:
+					first_column = group_table.pop(col) 
+					group_table.insert(0, col, first_column)
+				group_table.pop('FRAME')
 
 
 		elif self.event_time_option.isChecked():
+
 			time_of_interest = self.event_times_cb.currentText()
 			self.projection_mode = f"measurements at {time_of_interest}"
 			new_table = []
-			for tid,group in self.data.groupby(['position','TRACK_ID']):
+			for tid,group in self.data.groupby(self.groupby_cols):
 				time = group[time_of_interest].values[0]
 				if time==time:
 					time = floor(time) # floor for onset
@@ -801,49 +985,27 @@ class TableUI(QMainWindow, Styles):
 				values = group.loc[group['FRAME']==time,:].to_numpy()
 				if len(values)>0:
 					values = dict(zip(list(self.data.columns), values[0]))
-					values.update({'TRACK_ID': tid[1]})
-					values.update({'position': tid[0]})
+					for k,c in enumerate(self.groupby_cols):
+						values.update({c: tid[k]})
 					new_table.append(values)
 			
 			group_table = pd.DataFrame(new_table)
-			for col in ['TRACK_ID']:
-				first_column = group_table.pop(col) 
-				group_table.insert(0, col, first_column)
-			
-			group_table = group_table.sort_values(by=['position','TRACK_ID','FRAME'],ignore_index=True)
+			if self.population=='pairs':
+				for col in self.groupby_cols[1:]:
+					first_column = group_table.pop(col) 
+					group_table.insert(0, col, first_column)				
+			else:
+				for col in ['TRACK_ID']:
+					first_column = group_table.pop(col) 
+					group_table.insert(0, col, first_column)
+				
+			group_table = group_table.sort_values(by=self.groupby_cols+['FRAME'],ignore_index=True)
 			group_table = group_table.reset_index(drop=True)
 
 
 		elif self.per_status_option.isChecked():
 
-			status_of_interest = self.per_status_cb.currentText()
-			self.projection_mode = f'{self.status_operation.currentText()} per {status_of_interest}'
-			self.data = self.data.dropna(subset=status_of_interest,ignore_index=True)
-			unique_statuses = np.unique(self.data[status_of_interest].to_numpy())
-
-			df_sections = []
-			for s in unique_statuses:
-				subtab = self.data.loc[self.data[status_of_interest]==s,:]
-				op = getattr(subtab.groupby(['position', 'TRACK_ID']), self.status_operation.currentText())
-				subtab_projected = op(subtab.groupby(['position', 'TRACK_ID']))
-				frame_duration = subtab.groupby(['position','TRACK_ID']).size().to_numpy()
-				for c in self.static_columns:
-					try:
-						subtab_projected[c] = subtab.groupby(['position', 'TRACK_ID'])[c].apply(lambda x: x.unique()[0])
-					except Exception as e:
-						print(e)
-						pass
-				subtab_projected['duration_in_state'] = frame_duration
-				df_sections.append(subtab_projected)
-
-			group_table = pd.concat(df_sections,axis=0,ignore_index=True)
-			for col in ['duration_in_state',status_of_interest,'TRACK_ID']:
-				first_column = group_table.pop(col) 
-				group_table.insert(0, col, first_column)
-			group_table.pop('FRAME')
-			group_table = group_table.sort_values(by=['position','TRACK_ID',status_of_interest],ignore_index=True)
-			group_table = group_table.reset_index(drop=True)
-
+			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")
 		self.subtable.show()
@@ -972,7 +1134,7 @@ class TableUI(QMainWindow, Styles):
 					print(unique_cols[k])
 					for w,well_group in self.data.groupby('well_name'):
 						for pos,pos_group in well_group.groupby('pos_name'):
-							for tid,group_track in pos_group.groupby('TRACK_ID'):
+							for tid,group_track in pos_group.groupby(self.groupby_cols[1:]):
 								ax.plot(group_track["FRAME"], group_track[column_names[unique_cols[k]]],label=column_names[unique_cols[k]])
 					#ax.plot(self.data["FRAME"][row_idx_i], y, label=column_names[unique_cols[k]])
 				ax.legend()
@@ -986,7 +1148,7 @@ class TableUI(QMainWindow, Styles):
 				self.fig, self.ax = plt.subplots(1, 1, figsize=(4, 3))
 				self.scatter_wdw = FigureCanvas(self.fig, title="scatter")
 				self.ax.clear()
-				for tid,group in self.data.groupby('TRACK_ID'):
+				for tid,group in self.data.groupby(self.groupby_cols[1:]):
 					self.ax.plot(group[column_names[unique_cols[0]]], group[column_names[unique_cols[1]]], marker="o")
 				self.ax.set_xlabel(column_names[unique_cols[0]])
 				self.ax.set_ylabel(column_names[unique_cols[1]])
@@ -1009,7 +1171,7 @@ class TableUI(QMainWindow, Styles):
 
 				for w,well_group in self.data.groupby('well_name'):
 					for pos,pos_group in well_group.groupby('pos_name'):
-						for tid,group_track in pos_group.groupby('TRACK_ID'):
+						for tid,group_track in pos_group.groupby(self.groupby_cols[1:]):
 							self.ax.plot(group_track["FRAME"], group_track[column_names[unique_cols[0]]],c="k", alpha = 0.1)
 				self.ax.set_xlabel(r"$t$ [frame]")
 				self.ax.set_ylabel(column_names[unique_cols[0]])