celldetective 1.3.4.post1__py3-none-any.whl → 1.3.5__py3-none-any.whl

celldetective/gui/signal_annotator2.py

@@ -429,27 +429,12 @@ class SignalAnnotator2(QMainWindow,Styles):
 			contrast_hbox.addWidget(self.contrast_slider,90)
 			self.right_panel.addLayout(contrast_hbox, 5)
 
-		# speed_hbox = QHBoxLayout()
-		# speed_hbox.setContentsMargins(150,5,150,5)
-		# self.interval_slider = QLabeledSlider()
-		# self.interval_slider.setSingleStep(1)
-		# self.interval_slider.setTickInterval(1)
-		# self.interval_slider.setOrientation(1)
-		# self.interval_slider.setRange(1, 10000)
-		# self.interval_slider.setValue(self.speed)
-		# self.interval_slider.valueChanged.connect(self.interval_slider_action)
-		# speed_hbox.addWidget(QLabel('interval (ms): '))
-		# speed_hbox.addWidget(self.interval_slider,90)
-		# self.right_panel.addLayout(speed_hbox, 10)
-
-		#self.selected_populationulate_left_panel()
-		#grid.addLayout(self.left_side, 0, 0, 1, 1)
-
 		main_layout.addLayout(self.left_panel, 35)
 		main_layout.addLayout(self.right_panel, 65)
 		self.button_widget.adjustSize()
 		self.compute_status_and_colors_reference()
 
+		self.extract_relevant_events()
 
 		self.setCentralWidget(self.button_widget)
 		self.show()
@@ -673,23 +658,11 @@ class SignalAnnotator2(QMainWindow,Styles):
 			self.df_relative.loc[(~self.df_relative['status_'+self.current_neighborhood].isnull())&(self.df_relative['reference_population']==self.reference_population),self.relative_time] = 0.1
 		else:
 			self.df_relative.loc[(~self.df_relative['status_'+self.current_neighborhood].isnull())&(self.df_relative['reference_population']==self.reference_population),self.relative_time] = -1
-		self.relative_class_choice_cb.disconnect()
-		self.relative_class_choice_cb.clear()
-		cols = np.array(self.df_relative.columns)
-		self.relative_class_cols = np.array([c.startswith('class') for c in list(self.df_relative.columns)])
-		self.relative_class_cols = list(cols[self.relative_class_cols])
-		try:
-			self.relative_class_cols.remove('class_color')
-			self.relative_class_cols.remove('class_id')
-		except:
-			pass
-		self.relative_class_choice_cb.currentIndexChanged.connect(self.compute_status_and_colors_pair)
-		self.relative_class_choice_cb.addItems(self.relative_class_cols)
-		idx = self.relative_class_choice_cb.findText(self.relative_class)
-		self.relative_class_choice_cb.setCurrentIndex(idx)
+		
 
-		self.pair_class_name = self.relative_class
+		self.extract_relevant_events()
 
+		self.pair_class_name = self.relative_class
 		self.pair_time_name = self.relative_time
 		self.pair_status_name = self.relative_status
 
@@ -705,167 +678,131 @@ class SignalAnnotator2(QMainWindow,Styles):
 
 		df_reference = self.dataframes[self.reference_population]
 		self.reference_class_name = self.reference_event_choice_cb.currentText()
-		self.expected_reference_status = 'status_'
-		suffix = self.reference_class_name.replace('class','').replace('_','')
-		if suffix!='':
-			self.expected_reference_status+='_'+suffix
-			self.expected_reference_time = 't_'+suffix
-		else:
-			self.expected_reference_time = 't0'
 
-		self.reference_time_name = self.expected_reference_time
-		self.reference_status_name = self.expected_reference_status
+		if self.reference_class_name!='':
 
-		if self.reference_time_name in list(df_reference.columns) and self.reference_class_name in list(df_reference.columns) and not self.reference_status_name in list(df_reference.columns):
-			# only create the status column if it does not exist to not erase static classification results
-			self.make_reference_status_column()
-		elif self.reference_time_name in list(df_reference.columns) and self.reference_class_name in list(df_reference.columns):
-			# all good, do nothing
-			pass
-		else:
-			if not self.reference_status_name in list(df_reference.columns):
-				df_reference[self.reference_status_name] = 0
-				df_reference['status_color'] = color_from_status(0)
-				df_reference['class_color'] = color_from_class(1)
+			self.expected_reference_status = 'status_'
+			suffix = self.reference_class_name.replace('class','').replace('_','')
+			if suffix!='':
+				self.expected_reference_status+='_'+suffix
+				self.expected_reference_time = 't_'+suffix
+			else:
+				self.expected_reference_time = 't0'
 
-		if not self.reference_class_name in list(df_reference.columns):
-			df_reference[self.reference_class_name] = 1
-		if not self.reference_time_name in list(df_reference.columns):
-			df_reference[self.reference_time_name] = -1
+			self.reference_time_name = self.expected_reference_time
+			self.reference_status_name = self.expected_reference_status
 
-		df_reference['status_color'] = [color_from_status(i) for i in df_reference[self.reference_status_name].to_numpy()]
-		df_reference['class_color'] = [color_from_class(i) for i in df_reference[self.reference_class_name].to_numpy()]
+			if self.reference_time_name in list(df_reference.columns) and self.reference_class_name in list(df_reference.columns) and not self.reference_status_name in list(df_reference.columns):
+				# only create the status column if it does not exist to not erase static classification results
+				self.make_reference_status_column()
+			elif self.reference_time_name in list(df_reference.columns) and self.reference_class_name in list(df_reference.columns):
+				# all good, do nothing
+				pass
+			else:
+				if not self.reference_status_name in list(df_reference.columns):
+					df_reference[self.reference_status_name] = 0
+					df_reference['status_color'] = color_from_status(0)
+					df_reference['class_color'] = color_from_class(1)
 
-		if self.reference_population=='targets':
-			self.extract_scatter_from_target_trajectories()
-		else:
-			self.extract_scatter_from_effector_trajectories()
+			if not self.reference_class_name in list(df_reference.columns):
+				df_reference[self.reference_class_name] = 1
+			if not self.reference_time_name in list(df_reference.columns):
+				df_reference[self.reference_time_name] = -1
+
+			df_reference['status_color'] = [color_from_status(i) for i in df_reference[self.reference_status_name].to_numpy()]
+			df_reference['class_color'] = [color_from_class(i) for i in df_reference[self.reference_class_name].to_numpy()]
+
+			if self.reference_population=='targets':
+				self.extract_scatter_from_target_trajectories()
+			else:
+				self.extract_scatter_from_effector_trajectories()
 
 
 	def compute_status_and_colors_neighbor(self):
 
 		df_neighbors = self.dataframes[self.neighbor_population]
 		self.neighbor_class_name = self.neighbor_event_choice_cb.currentText()
-		self.expected_neighbor_status = 'status_'
-		suffix = self.neighbor_class_name.replace('class','').replace('_','')
-		if suffix!='':
-			self.expected_neighbor_status+='_'+suffix
-			self.expected_neighbor_time = 't_'+suffix
-		else:
-			self.expected_neighbor_time = 't0'
 
-		self.neighbor_time_name = self.expected_neighbor_time
-		self.neighbor_status_name = self.expected_neighbor_status
+		if self.neighbor_class_name!='':
 
-		if self.neighbor_time_name in list(df_neighbors.columns) and self.neighbor_class_name in list(df_neighbors.columns) and not self.neighbor_status_name in list(df_neighbors.columns):
-			# only create the status column if it does not exist to not erase static classification results
-			self.make_neighbor_status_column()
-		elif self.neighbor_time_name in list(df_neighbors.columns) and self.neighbor_class_name in list(df_neighbors.columns):
-			# all good, do nothing
-			pass
-		else:
-			if not self.neighbor_status_name in list(df_neighbors.columns):
-				df_neighbors[self.neighbor_status_name] = 0
-				df_neighbors['status_color'] = color_from_status(0)
-				df_neighbors['class_color'] = color_from_class(1)
+			self.expected_neighbor_status = 'status_'
+			suffix = self.neighbor_class_name.replace('class','').replace('_','')
+			if suffix!='':
+				self.expected_neighbor_status+='_'+suffix
+				self.expected_neighbor_time = 't_'+suffix
+			else:
+				self.expected_neighbor_time = 't0'
 
-		if not self.neighbor_class_name in list(df_neighbors.columns):
-			df_neighbors[self.neighbor_class_name] = 1
-		if not self.neighbor_time_name in list(df_neighbors.columns):
-			df_neighbors[self.neighbor_time_name] = -1
+			self.neighbor_time_name = self.expected_neighbor_time
+			self.neighbor_status_name = self.expected_neighbor_status
 
-		df_neighbors['status_color'] = [color_from_status(i) for i in df_neighbors[self.neighbor_status_name].to_numpy()]
-		df_neighbors['class_color'] = [color_from_class(i) for i in df_neighbors[self.neighbor_class_name].to_numpy()]
+			if self.neighbor_time_name in list(df_neighbors.columns) and self.neighbor_class_name in list(df_neighbors.columns) and not self.neighbor_status_name in list(df_neighbors.columns):
+				# only create the status column if it does not exist to not erase static classification results
+				self.make_neighbor_status_column()
+			elif self.neighbor_time_name in list(df_neighbors.columns) and self.neighbor_class_name in list(df_neighbors.columns):
+				# all good, do nothing
+				pass
+			else:
+				if not self.neighbor_status_name in list(df_neighbors.columns):
+					df_neighbors[self.neighbor_status_name] = 0
+					df_neighbors['status_color'] = color_from_status(0)
+					df_neighbors['class_color'] = color_from_class(1)
 
-		if self.neighbor_population=='targets':
-			self.extract_scatter_from_target_trajectories()
-		else:
-			self.extract_scatter_from_effector_trajectories()
+			if not self.neighbor_class_name in list(df_neighbors.columns):
+				df_neighbors[self.neighbor_class_name] = 1
+			if not self.neighbor_time_name in list(df_neighbors.columns):
+				df_neighbors[self.neighbor_time_name] = -1
 
-		# if self.df_effectors is not None:
-		# 	if self.reference_population=='effectors':
-		# 		self.effector_class_name = self.reference_event_choice_cb.currentText()
-		# 	elif self.neighbor_population == 'effectors':
-		# 		self.effector_class_name = self.neighbor_event_choice_cb.currentText()
-		# 	else:
-		# 		self.effector_class_name=''
-		# 	#self.effector_class_name = self.effector_class_choice_cb.currentText()
-		# 	self.effector_expected_status = 'status'
-		# 	suffix = self.effector_class_name.replace('class','').replace('_','')
-		# 	if suffix!='':
-		# 		self.effector_expected_status+='_'+suffix
-		# 		self.effector_expected_time = 't_'+suffix
-		# 	else:
-		# 		self.effector_expected_time = 't0'
-
-		# 	self.effector_time_name = self.effector_expected_time
-		# 	self.effector_status_name = self.effector_expected_status
-
-		# 	print('selection and expected names: ', self.effector_class_name, self.effector_expected_time, self.effector_expected_status)
-
-		# 	if self.effector_time_name in self.df_effectors.columns and self.effector_class_name in self.df_effectors.columns and not self.effector_status_name in self.df_effectors.columns:
-		# 		# only create the status column if it does not exist to not erase static classification results
-		# 		self.make_effector_status_column()
-		# 	elif self.effector_time_name in self.df_effectors.columns and self.effector_class_name in self.df_effectors.columns:
-		# 		# all good, do nothing
-		# 		pass
-		# 	else:
-		# 		if not self.effector_status_name in self.df_effectors.columns:
-		# 			self.df_effectors[self.effector_status_name] = 0
-		# 			self.df_effectors['status_color'] = color_from_status(0)
-		# 			self.df_effectors['class_color'] = color_from_class(1)
-
-		# 	if not self.effector_class_name in self.df_effectors.columns:
-		# 		self.df_effectors[self.effector_class_name] = 1
-		# 	if not self.effector_time_name in self.df_effectors.columns:
-		# 		self.df_effectors[self.effector_time_name] = -1
-
-		# 	self.df_effectors['status_color'] = [color_from_status(i) for i in self.df_effectors[self.effector_status_name].to_numpy()]
-		# 	self.df_effectors['class_color'] = [color_from_class(i) for i in self.df_effectors[self.effector_class_name].to_numpy()]
-
-		# 	self.extract_scatter_from_effector_trajectories()
+			df_neighbors['status_color'] = [color_from_status(i) for i in df_neighbors[self.neighbor_status_name].to_numpy()]
+			df_neighbors['class_color'] = [color_from_class(i) for i in df_neighbors[self.neighbor_class_name].to_numpy()]
+
+			if self.neighbor_population=='targets':
+				self.extract_scatter_from_target_trajectories()
+			else:
+				self.extract_scatter_from_effector_trajectories()
 
 	def compute_status_and_colors_pair(self):
 
 		self.pair_class_name = self.relative_class_choice_cb.currentText()
-		print(f'{self.pair_class_name=}')
-
-		self.pair_expected_status = 'status'
-		suffix = self.pair_class_name.replace('class','').replace('_','',1)
-		if suffix!='':
-			self.pair_expected_status+='_'+suffix
-			self.pair_expected_time = 't0_'+suffix
-			if not self.pair_expected_time in list(self.df_relative.columns):
-				self.pair_expected_time = 't_'+suffix
-		else:
-			self.pair_expected_time = 't0'
+		
+		if self.pair_class_name!='':
+
+			self.pair_expected_status = 'status'
+			suffix = self.pair_class_name.replace('class','').replace('_','',1)
+			if suffix!='':
+				self.pair_expected_status+='_'+suffix
+				self.pair_expected_time = 't0_'+suffix
+				if not self.pair_expected_time in list(self.df_relative.columns):
+					self.pair_expected_time = 't_'+suffix
+			else:
+				self.pair_expected_time = 't0'
 
-		self.pair_time_name = self.pair_expected_time
-		self.pair_status_name = self.pair_expected_status
+			self.pair_time_name = self.pair_expected_time
+			self.pair_status_name = self.pair_expected_status
 
-		if self.pair_time_name in self.df_relative.columns and self.pair_class_name in self.df_relative.columns and not self.pair_status_name in self.df_relative.columns:
-			# only create the status column if it does not exist to not erase static classification results
-			self.make_relative_status_column()
-		elif self.pair_time_name in self.df_relative.columns and self.pair_class_name in self.df_relative.columns:
-			# all good, do nothing
-			pass
-		else:
-			if not self.pair_status_name in self.df_relative.columns:
-				self.df_relative[self.pair_status_name] = 0
-				self.df_relative['status_color'] = color_from_status(0)
-				self.df_relative['class_color'] = color_from_class(1)
+			if self.pair_time_name in self.df_relative.columns and self.pair_class_name in self.df_relative.columns and not self.pair_status_name in self.df_relative.columns:
+				# only create the status column if it does not exist to not erase static classification results
+				self.make_relative_status_column()
+			elif self.pair_time_name in self.df_relative.columns and self.pair_class_name in self.df_relative.columns:
+				# all good, do nothing
+				pass
+			else:
+				if not self.pair_status_name in self.df_relative.columns:
+					self.df_relative[self.pair_status_name] = 0
+					self.df_relative['status_color'] = color_from_status(0)
+					self.df_relative['class_color'] = color_from_class(1)
 
-		if not self.pair_class_name in self.df_relative.columns:
-			self.df_relative[self.pair_time_name] = 1
-		if not self.pair_time_name in self.df_relative.columns:
-			self.df_relative[self.pair_time_name] = -1
+			if not self.pair_class_name in self.df_relative.columns:
+				self.df_relative[self.pair_time_name] = 1
+			if not self.pair_time_name in self.df_relative.columns:
+				self.df_relative[self.pair_time_name] = -1
 
-		self.df_relative['status_color'] = [color_from_status(i) for i in self.df_relative[self.pair_status_name].to_numpy()]
-		self.df_relative['class_color'] = [color_from_class(i) for i in self.df_relative[self.pair_class_name].to_numpy()]
+			self.df_relative['status_color'] = [color_from_status(i) for i in self.df_relative[self.pair_status_name].to_numpy()]
+			self.df_relative['class_color'] = [color_from_class(i) for i in self.df_relative[self.pair_class_name].to_numpy()]
 
-		self.extract_scatter_from_lines()
-		self.give_pair_information()
-		self.plot_signals()
+			self.extract_scatter_from_lines()
+			self.give_pair_information()
+			self.plot_signals()
 
 	def contrast_slider_action(self):
 
@@ -1329,30 +1266,6 @@ class SignalAnnotator2(QMainWindow,Styles):
 			self.MinMaxScaler_effectors.fit(x)
 
 
-	# def make_effector_status_column(self):
-	# 	print('remaking the status column for the effectors')
-	# 	for tid, group in self.df_effectors.groupby('TRACK_ID'):
-
-	# 		indices = group.index
-	# 		t0 = group[self.].to_numpy()[0]
-	# 		cclass = group[self.class_name].to_numpy()[0]
-	# 		timeline = group['FRAME'].to_numpy()
-	# 		status = np.zeros_like(timeline)
-	# 		if t0 > 0:
-	# 			status[timeline >= t0] = 1.
-	# 		if cclass == 2:
-	# 			status[:] = 2
-	# 		if cclass > 2:
-	# 			status[:] = 42
-	# 		status_color = [color_from_status(s) for s in status]
-	# 		class_color = [color_from_class(cclass) for i in range(len(status))]
-
-	# 		self.df_tracks.loc[indices, self.status_name] = status
-	# 		self.df_tracks.loc[indices, 'status_color'] = status_color
-	# 		self.df_tracks.loc[indices, 'class_color'] = class_color
-
-
-
 	def locate_relative_tracks(self):
 
 		population = 'relative'
@@ -1392,6 +1305,9 @@ class SignalAnnotator2(QMainWindow,Styles):
 			self.relative_time_name = 't0'
 			self.relative_status_name = 'status'
 
+		for col in list(self.df_relative.columns):
+			if np.all(self.df_relative[col].isnull()) or self.df_relative[col].dtype==object:
+				self.cols_to_remove.append(col)
 
 		self.MinMaxScaler_pairs = MinMaxScaler()
 		self.pair_columns = list(self.df_relative.columns)
@@ -1408,7 +1324,7 @@ class SignalAnnotator2(QMainWindow,Styles):
 				pass
 
 		x = self.df_relative[self.pair_columns].values
-		self.MinMaxScaler_pairs.fit(x)	
+		self.MinMaxScaler_pairs.fit(x)
 
 
 	def set_reference_and_neighbor_populations(self):
@@ -1813,6 +1729,7 @@ class SignalAnnotator2(QMainWindow,Styles):
 		self.cancel_selection()
 		self.set_reference_and_neighbor_populations()
 		# Update reference classes and neighbor classes
+		self.extract_relevant_events()
 		self.fill_class_cbs()
 
 		self.update_cell_events()
@@ -1820,6 +1737,39 @@ class SignalAnnotator2(QMainWindow,Styles):
 		# self.draw_frame(self.framedata)
 		self.plot_signals()
 
+	def extract_relevant_events(self):
+		
+		if self.reference_population!=self.neighbor_population:
+			pattern = "_2_"
+		else:
+			pattern = "_self_"
+
+		try:
+			self.relative_class_choice_cb.disconnect()
+		except:
+			pass
+
+		self.relative_class_choice_cb.clear()
+
+		cols = list(self.df_relative.columns)
+		self.relative_class_cols = [c for c in cols if c.startswith('class')]
+		for c in ['class_color', 'class_id']:
+			if c in self.relative_class_cols:
+				self.relative_class_cols.remove(c)
+		
+		# Keep only valid classes for which there are values
+		self.new_relative_class_cols = []
+		for c in self.relative_class_cols:
+			if ~self.df_relative.loc[(self.df_relative['reference_population']==self.reference_population)&(self.df_relative['neighbor_population']==self.neighbor_population),c].isnull().all():
+				self.new_relative_class_cols.append(c)
+
+		if len(self.new_relative_class_cols)>0:
+			self.relative_class = self.new_relative_class_cols[0]
+			self.relative_class_choice_cb.currentIndexChanged.connect(self.compute_status_and_colors_pair)
+			self.relative_class_choice_cb.addItems(self.new_relative_class_cols)		
+			idx = self.relative_class_choice_cb.findText(self.relative_class)
+			self.relative_class_choice_cb.setCurrentIndex(idx)
+
 
 	def closeEvent(self, event):
 

celldetective/gui/survival_ui.py

@@ -4,7 +4,7 @@ from PyQt5.QtGui import QDoubleValidator
 from celldetective.gui.gui_utils import center_window
 from superqt import QColormapComboBox
 from celldetective.gui.generic_signal_plot import SurvivalPlotWidget
-from celldetective.utils import get_software_location, _extract_labels_from_config
+from celldetective.utils import get_software_location, _extract_labels_from_config, extract_cols_from_table_list
 from celldetective.io import load_experiment_tables
 import numpy as np
 import os
@@ -15,6 +15,10 @@ import pandas as pd
 from celldetective.gui import Styles
 from matplotlib import colormaps
 from celldetective.events import compute_survival
+from natsort import natsorted
+from celldetective.relative_measurements import expand_pair_table
+import matplotlib.cm
+from celldetective.neighborhood import extract_neighborhood_in_pair_table
 
 class ConfigSurvival(QWidget, Styles):
 	
@@ -88,8 +92,51 @@ class ConfigSurvival(QWidget, Styles):
 		main_layout.addWidget(panel_title, alignment=Qt.AlignCenter)
 
 
-		labels = [QLabel('population: '), QLabel('time of\nreference: '), QLabel('time of\ninterest: '), QLabel('cmap: ')] #QLabel('class: '), 
-		self.cb_options = [['targets','effectors'], ['0'], [], []] #['class'], 
+		pops = []
+		for population in ['effectors','targets','pairs']:
+			tables = glob(self.exp_dir+os.sep.join(['W*','*','output','tables',f'trajectories_{population}.csv']))
+			if len(tables)>0:
+				pops.append(population)
+
+		tables_targets = glob(self.exp_dir+os.sep.join(['W*','*','output','tables',f'trajectories_targets.csv']))
+		self.cols_targets = extract_cols_from_table_list(tables_targets)
+		tables_effectors = glob(self.exp_dir+os.sep.join(['W*','*','output','tables',f'trajectories_effectors.csv']))
+		self.cols_effectors = extract_cols_from_table_list(tables_effectors)
+
+		# Smart reading of existing neighborhoods (without loading tables in memory)
+		if 'pairs' in pops and not 'targets' in pops:
+			# must be effector-effector
+			effector_neighs = [c[16:] for c in self.cols_effectors if c.startswith('inclusive_count_neighborhood')]
+			if len(effector_neighs)>0:
+				pops.pop(pops.index('pairs'))
+				pops.append('effectors-effectors')
+		elif 'pairs' in pops and not 'effectors' in pops:
+			# must be target-target
+			target_neighs = [c for c in self.cols_targets if c.startswith('inclusive_count_neighborhood')]
+			if len(target_neighs)>0:
+				pops.pop(pops.index('pairs'))
+				pops.append('targets-targets')
+		elif 'pairs' in pops:
+			# either effector-target or target-effector
+			target_neighs_cross = [c for c in self.cols_targets if c.startswith('inclusive_count_neighborhood') and '_2_' in c]
+			if len(target_neighs_cross)>0:
+				pops.append('targets-effectors')
+			effector_neighs_cross = [c for c in self.cols_effectors if c.startswith('inclusive_count_neighborhood') and '_2_' in c]
+			if len(effector_neighs_cross)>0:
+				pops.append('effectors-targets')
+			target_neighs = [c for c in self.cols_targets if c.startswith('inclusive_count_neighborhood') and 'self' in c]
+			if len(target_neighs)>0:
+				pops.append('targets-targets')
+			effector_neighs = [c for c in self.cols_effectors if c.startswith('inclusive_count_neighborhood') and 'self' in c]
+			if len(effector_neighs)>0:
+				pops.append('effectors-effectors')
+			pops.pop(pops.index('pairs'))
+		else:
+			pass
+
+
+		labels = [QLabel('population: '), QLabel('time of\nreference: '), QLabel('time of\ninterest: '), QLabel('cmap: ')] #QLabel('class: '),
+		self.cb_options = [pops, ['0'], [], []] #['class'],
 		self.cbs = [QComboBox() for i in range(len(labels))]
 
 		self.cbs[-1] = QColormapComboBox()
@@ -107,10 +154,12 @@ class ConfigSurvival(QWidget, Styles):
 
 		all_cms = list(colormaps)
 		for cm in all_cms:
-			try:
-				self.cbs[-1].addColormap(cm)
-			except:
-				pass
+			if hasattr(matplotlib.cm, str(cm).lower()):
+				self.cbs[-1].addColormap(cm.lower())
+			#try:
+			# 	self.cbs[-1].addColormap(cm)
+			# except:
+			# 	pass
 
 		main_layout.addLayout(choice_layout)
 
@@ -155,24 +204,60 @@ class ConfigSurvival(QWidget, Styles):
 	def set_classes_and_times(self):
 
 		# Look for all classes and times
-		tables = glob(self.exp_dir+os.sep.join(['W*','*','output','tables',f'trajectories_*.csv']))
-		self.all_columns = []
-		for tab in tables:
-			cols = pd.read_csv(tab, nrows=1,encoding_errors='ignore').columns.tolist()
-			self.all_columns.extend(cols)
+		self.neighborhood_keys = None
+		self.population = self.cbs[0].currentText()
+		pop_split = self.population.split('-')
 
-		self.all_columns = np.unique(self.all_columns)
-		#class_idx = np.array([s.startswith('class_') for s in self.all_columns])
-		time_idx = np.array([s.startswith('t_') for s in self.all_columns])
+		if len(pop_split)==2:
 
-		try:
-			time_columns = list(self.all_columns[time_idx])
-		except:
-			print('no column starts with t')
-			self.auto_close = True
-			return None
-		if 't0' in self.all_columns:
-			time_columns.append('t0')
+			self.population = 'pairs'
+			tables_pairs = glob(self.exp_dir+os.sep.join(['W*','*','output','tables',f'trajectories_pairs.csv']))
+			self.cols_pairs = extract_cols_from_table_list(tables_pairs)
+
+			self.population_reference = pop_split[0]
+			self.population_neigh = pop_split[1]
+			if self.population_reference=='targets':
+				cols_ref = self.cols_targets
+			else:
+				cols_ref = self.cols_effectors
+			if self.population_neigh=='targets':
+				cols_neigh = self.cols_targets
+			else:
+				cols_neigh = self.cols_effectors
+
+			time_cols_ref = np.array([s.startswith('t_') or s=='t0' for s in cols_ref])
+			if len(time_cols_ref)>0:
+				time_cols_ref = list(cols_ref[time_cols_ref])
+				time_cols_ref = ['reference_'+t for t in time_cols_ref]
+
+			time_cols_neigh = np.array([s.startswith('t_') or s=='t0' for s in cols_neigh])
+			if len(time_cols_neigh)>0:
+				time_cols_neigh = list(cols_neigh[time_cols_neigh])
+				time_cols_neigh = ['neighbor_'+t for t in time_cols_neigh]
+
+			if self.population_reference!=self.population_neigh:
+				self.neighborhood_keys = [c[16:] for c in cols_ref if c.startswith('inclusive_count_neighborhood') and '_2_' in c]
+			else:
+				self.neighborhood_keys = [c[16:] for c in cols_ref if c.startswith('inclusive_count_neighborhood') and 'self' in c]
+
+			time_idx = np.array([s.startswith('t_') or s.startswith('t0') for s in self.cols_pairs])
+			time_cols_pairs = list(self.cols_pairs[time_idx])
+
+			time_columns = time_cols_ref + time_cols_neigh + time_cols_pairs
+
+		else:
+			if self.population=='targets':
+				self.all_columns = self.cols_targets
+			else:
+				self.all_columns = self.cols_effectors
+			time_idx = np.array([s.startswith('t_') or s=='t0' for s in self.all_columns])
+
+			try:
+				time_columns = list(self.all_columns[time_idx])
+			except:
+				print('no column starts with t')
+				self.auto_close = True
+				return None
 
 		self.cbs[1].clear()
 		self.cbs[1].addItems(np.unique(self.cb_options[1]+time_columns))
@@ -184,19 +269,16 @@ class ConfigSurvival(QWidget, Styles):
 
 	def process_survival(self):
 
-		print('you clicked!!')
 		self.FrameToMin = float(self.time_calibration_le.text().replace(',','.'))
-		print(self.FrameToMin, 'set')
-
 		self.time_of_interest = self.cbs[2].currentText()
 		if self.time_of_interest=="t0":
 			self.class_of_interest = "class"
 		else:
 			self.class_of_interest = self.time_of_interest.replace('t_','class_')
 
+
 		# read instructions from combobox options
 		self.load_available_tables_local()
-
 		if self.df is not None:
 			
 			try:
@@ -241,7 +323,8 @@ class ConfigSurvival(QWidget, Styles):
 		self.well_option = self.parent_window.parent_window.well_list.getSelectedIndices()
 		self.position_option = self.parent_window.parent_window.position_list.getSelectedIndices()
 
-		self.df, self.df_pos_info = load_experiment_tables(self.exp_dir, well_option=self.well_option, position_option=self.position_option, population=self.cbs[0].currentText(), return_pos_info=True)
+		self.df, self.df_pos_info = load_experiment_tables(self.exp_dir, well_option=self.well_option, position_option=self.position_option, population=self.population, return_pos_info=True)
+
 		if self.df is None:
 			msgBox = QMessageBox()
 			msgBox.setIcon(QMessageBox.Warning)
@@ -255,6 +338,11 @@ class ConfigSurvival(QWidget, Styles):
 			self.df_well_info = self.df_pos_info.loc[:,['well_path', 'well_index', 'well_name', 'well_number', 'well_alias']].drop_duplicates()
 			#print(f"{self.df_well_info=}")
 
+		if self.population=='pairs':
+			self.df = expand_pair_table(self.df)
+			self.df = extract_neighborhood_in_pair_table(self.df, reference_population=self.population_reference, neighbor_population=self.population_neigh, neighborhood_key=self.neighborhood_keys[0], contact_only=True)
+
+
 	def compute_survival_functions(self):
 
 		cut_observation_time = None
@@ -265,19 +353,20 @@ class ConfigSurvival(QWidget, Styles):
 				cut_observation_time = None		
 		except Exception as e:
 			pass
-		print(f"{cut_observation_time=}")
+
+		pairs = False
+		if self.neighborhood_keys is not None:
+			pairs = True
 
 		# Per position survival
 		for block,movie_group in self.df.groupby(['well','position']):
-
-			ks = compute_survival(movie_group, self.class_of_interest, self.cbs[2].currentText(), t_reference=self.cbs[1].currentText(), FrameToMin=self.FrameToMin, cut_observation_time=cut_observation_time)
+			ks = compute_survival(movie_group, self.class_of_interest, self.cbs[2].currentText(), t_reference=self.cbs[1].currentText(), FrameToMin=self.FrameToMin, cut_observation_time=cut_observation_time, pairs=pairs)
 			if ks is not None:
 				self.df_pos_info.loc[self.df_pos_info['pos_path']==block[1],'survival_fit'] = ks
 
 		# Per well survival
 		for well,well_group in self.df.groupby('well'):
-
-			ks = compute_survival(well_group, self.class_of_interest, self.cbs[2].currentText(), t_reference=self.cbs[1].currentText(), FrameToMin=self.FrameToMin, cut_observation_time=cut_observation_time)
+			ks = compute_survival(well_group, self.class_of_interest, self.cbs[2].currentText(), t_reference=self.cbs[1].currentText(), FrameToMin=self.FrameToMin, cut_observation_time=cut_observation_time, pairs=pairs)
 			if ks is not None:
 				self.df_well_info.loc[self.df_well_info['well_path']==well,'survival_fit'] = ks