celldetective 1.3.6.post1__py3-none-any.whl → 1.3.7__py3-none-any.whl

celldetective/gui/plot_signals_ui.py

@@ -6,7 +6,7 @@ from PyQt5.QtGui import QIcon, QDoubleValidator
 from celldetective.gui.gui_utils import center_window
 from celldetective.gui.generic_signal_plot import GenericSignalPlotWidget
 from superqt import QLabeledSlider, QColormapComboBox, QSearchableComboBox
-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
 from celldetective.signals import mean_signal
 import numpy as np
@@ -15,7 +15,6 @@ import matplotlib.pyplot as plt
 plt.rcParams['svg.fonttype'] = 'none'
 from glob import glob
 from natsort import natsorted
-import pandas as pd
 import math
 from celldetective.gui import Styles
 from matplotlib import colormaps
@@ -92,8 +91,14 @@ class ConfigSignalPlot(QWidget, Styles):
 			""")
 		main_layout.addWidget(panel_title, alignment=Qt.AlignCenter)
 
+		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)
+
 		labels = [QLabel('population: '), QLabel('class: '), QLabel('time of\ninterest: '), QLabel('cmap: ')]
-		self.cb_options = [['targets','effectors'],[], [], []]
+		self.cb_options = [pops,[], [], []]
 		self.cbs = [QComboBox() for i in range(len(labels))]
 		self.cbs[-1] = QColormapComboBox()
 		
@@ -161,12 +166,11 @@ class ConfigSignalPlot(QWidget, Styles):
 	def set_classes_and_times(self):
 
 		# Look for all classes and times
-		tables = natsorted(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).columns.tolist()
-			self.all_columns.extend(cols)
-		self.all_columns = np.unique(self.all_columns)
+		population = self.cbs[0].currentText()
+		tables = natsorted(glob(self.exp_dir+os.sep.join(['W*','*','output','tables',f'trajectories_{population}.csv'])))
+		
+		self.all_columns = extract_cols_from_table_list(tables)
+
 		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])
 		

celldetective/gui/process_block.py

@@ -1,4 +1,4 @@
-from PyQt5.QtWidgets import QFrame, QGridLayout, QComboBox, QListWidget, QLabel, QPushButton, QVBoxLayout, QHBoxLayout, QCheckBox, \
+from PyQt5.QtWidgets import QDialog, QFrame, QGridLayout, QComboBox, QListWidget, QLabel, QPushButton, QVBoxLayout, QHBoxLayout, QCheckBox, \
 	QMessageBox, QWidget
 from PyQt5.QtCore import Qt, QSize
 from superqt.fonticon import icon
@@ -10,7 +10,7 @@ from celldetective.gui.signal_annotator import MeasureAnnotator
 from celldetective.gui.signal_annotator2 import SignalAnnotator2
 from celldetective.io import get_segmentation_models_list, control_segmentation_napari, get_signal_models_list, \
 	control_tracks, load_experiment_tables, get_pair_signal_models_list
-from celldetective.io import locate_segmentation_model, fix_missing_labels, auto_load_number_of_frames, load_frames, locate_signal_model
+from celldetective.io import locate_segmentation_model, extract_position_name, fix_missing_labels, auto_load_number_of_frames, load_frames, locate_signal_model
 from celldetective.gui import SegmentationModelLoader, ClassifierWidget, ConfigNeighborhoods, ConfigSegmentationModelTraining, ConfigTracking, SignalAnnotator, ConfigSignalModelTraining, ConfigMeasurements, ConfigSignalAnnotator, TableUI
 from celldetective.gui.gui_utils import QHSeperationLine
 from celldetective.relative_measurements import rel_measure_at_position
@@ -37,6 +37,14 @@ from celldetective.gui.layouts import CellposeParamsWidget, StarDistParamsWidget
 from celldetective.gui import Styles
 from celldetective.utils import get_software_location
 
+from celldetective.gui.workers import ProgressWindow
+from celldetective.gui.processes.segment_cells import SegmentCellThresholdProcess, SegmentCellDLProcess
+from celldetective.gui.processes.track_cells import TrackingProcess
+from celldetective.gui.processes.measure_cells import MeasurementProcess
+
+import time
+import asyncio
+
 class ProcessPanel(QFrame, Styles):
 	def __init__(self, parent_window, mode):
 
@@ -52,6 +60,8 @@ class ProcessPanel(QFrame, Styles):
 		self.wells = np.array(self.parent_window.wells,dtype=str)
 		self.cellpose_calibrated = False
 		self.stardist_calibrated = False
+		self.use_gpu = self.parent_window.parent_window.use_gpu
+		self.n_threads = self.parent_window.parent_window.n_threads
 
 		self.setFrameStyle(QFrame.StyledPanel | QFrame.Raised)
 		self.grid = QGridLayout(self)
@@ -264,7 +274,7 @@ class ProcessPanel(QFrame, Styles):
 		#self.to_disable.append(self.cell_models_list)
 
 		self.train_signal_model_btn = QPushButton("TRAIN")
-		self.train_signal_model_btn.setToolTip("Open a dialog box to create a new target segmentation model.")
+		self.train_signal_model_btn.setToolTip("Train or retrain an event detection model\non newly annotated data.")
 		self.train_signal_model_btn.setIcon(icon(MDI6.redo_variant,color='black'))
 		self.train_signal_model_btn.setIconSize(QSize(20, 20))
 		self.train_signal_model_btn.setStyleSheet(self.button_style_sheet_3)
@@ -284,7 +294,7 @@ class ProcessPanel(QFrame, Styles):
 		self.signal_models_list.addItems(signal_models)
 
 	def generate_tracking_options(self):
-		
+
 		grid_track = QHBoxLayout()
 
 		self.track_action = QCheckBox("TRACK")
@@ -363,7 +373,7 @@ class ProcessPanel(QFrame, Styles):
 		self.segment_action = QCheckBox("SEGMENT")
 		self.segment_action.setStyleSheet(self.menu_check_style)
 		self.segment_action.setIcon(icon(MDI6.bacteria, color='black'))
-		self.segment_action.setToolTip(f"Segment the {self.mode} cells on the images.")
+		self.segment_action.setToolTip(f"Segment the {self.mode[:-1]} cells on the images.")
 		self.segment_action.toggled.connect(self.enable_segmentation_model_list)
 		#self.to_disable.append(self.segment_action)
 		grid_segment.addWidget(self.segment_action, 90)
@@ -390,6 +400,7 @@ class ProcessPanel(QFrame, Styles):
 		model_zoo_layout = QHBoxLayout()
 		model_zoo_layout.addWidget(QLabel("Model zoo:"),90)
 		self.seg_model_list = QComboBox()
+		self.seg_model_list.currentIndexChanged.connect(self.reset_generalist_setup)
 		#self.to_disable.append(self.tc_seg_model_list)
 		self.seg_model_list.setGeometry(50, 50, 200, 30)
 		self.init_seg_model_list()
@@ -682,6 +693,10 @@ class ProcessPanel(QFrame, Styles):
 		self.ConfigSignalAnnotator = ConfigSignalAnnotator(self)
 		self.ConfigSignalAnnotator.show()
 
+	def reset_generalist_setup(self, index):
+		self.cellpose_calibrated = False
+		self.stardist_calibrated = False
+
 	def process_population(self):
 
 		# if self.parent_window.well_list.currentText().startswith('Multiple'):
@@ -750,18 +765,19 @@ class ProcessPanel(QFrame, Styles):
 			self.model_name = self.seg_models[self.seg_model_list.currentIndex()]
 		print(self.model_name, self.seg_model_list.currentIndex())
 
-		if self.model_name.startswith('CP') and self.model_name in self.seg_models_generic and not self.cellpose_calibrated:
+		if self.segment_action.isChecked() and self.model_name.startswith('CP') and self.model_name in self.seg_models_generic and not self.cellpose_calibrated:
 
 			self.diamWidget = CellposeParamsWidget(self, model_name=self.model_name)
 			self.diamWidget.show()
 			return None
 
-		if self.model_name.startswith('SD') and self.model_name in self.seg_models_generic and not self.stardist_calibrated:
+		if self.segment_action.isChecked() and self.model_name.startswith('SD') and self.model_name in self.seg_models_generic and not self.stardist_calibrated:
 
 			self.diamWidget = StarDistParamsWidget(self, model_name = self.model_name)
 			self.diamWidget.show()
 			return None
 
+		self.movie_prefix = self.parent_window.movie_prefix
 
 		for w_idx in self.well_index:
 
@@ -775,6 +791,7 @@ class ProcessPanel(QFrame, Styles):
 
 				self.pos = natsorted(glob(well+f"{os.path.split(well)[-1].replace('W','').replace(os.sep,'')}*/"))[pos_idx]
 				print(f"Position {self.pos}...\nLoading stack movie...")
+				self.pos_name = extract_position_name(self.pos)
 
 				if not os.path.exists(self.pos + 'output/'):
 					os.mkdir(self.pos + 'output/')
@@ -805,9 +822,27 @@ class ProcessPanel(QFrame, Styles):
 								return None
 						else:
 							print(f"Segmentation from threshold config: {self.threshold_config}")
-							segment_from_threshold_at_position(self.pos, self.mode, self.threshold_config, threads=self.parent_window.parent_window.n_threads)
+							process_args = {"pos": self.pos, "mode": self.mode, "n_threads": self.n_threads, "threshold_instructions": self.threshold_config, "use_gpu": self.use_gpu}
+							self.job = ProgressWindow(SegmentCellThresholdProcess, parent_window=self, title="Segment", process_args = process_args)
+							result = self.job.exec_()
+							if result == QDialog.Accepted:
+								pass
+							elif result == QDialog.Rejected:
+								return None
+							#segment_from_threshold_at_position(self.pos, self.mode, self.threshold_config, threads=self.parent_window.parent_window.n_threads)
 					else:
-						segment_at_position(self.pos, self.mode, self.model_name, stack_prefix=self.parent_window.movie_prefix, use_gpu=self.parent_window.parent_window.use_gpu, threads=self.parent_window.parent_window.n_threads)
+						# model = locate_segmentation_model(self.model_name)
+						# if model is None:
+						# 	process = {"output_dir": self.output_dir, "file": self.model_name}
+						# 	self.download_model_job = ProgressWindow(DownloadProcess, parent_window=self, title="Download", process_args = args)
+
+						process_args = {"pos": self.pos, "mode": self.mode, "n_threads": self.n_threads, "model_name": self.model_name, "use_gpu": self.use_gpu}
+						self.job = ProgressWindow(SegmentCellDLProcess, parent_window=self, title="Segment", process_args = process_args)
+						result = self.job.exec_()
+						if result == QDialog.Accepted:
+							pass
+						elif result == QDialog.Rejected:
+							return None
 
 				if self.track_action.isChecked():
 					if os.path.exists(os.sep.join([self.pos, 'output', 'tables', f'trajectories_{self.mode}.csv'])) and not self.parent_window.position_list.isMultipleSelection():
@@ -819,10 +854,25 @@ class ProcessPanel(QFrame, Styles):
 						returnValue = msgBox.exec()
 						if returnValue == QMessageBox.No:
 							return None
-					track_at_position(self.pos, self.mode, threads=self.parent_window.parent_window.n_threads)
+
+					process_args = {"pos": self.pos, "mode": self.mode, "n_threads": self.n_threads}
+					self.job = ProgressWindow(TrackingProcess, parent_window=self, title="Tracking", process_args=process_args)
+					result = self.job.exec_()
+					if result == QDialog.Accepted:
+						pass
+					elif result == QDialog.Rejected:
+						return None
+					#track_at_position(self.pos, self.mode, threads=self.parent_window.parent_window.n_threads)
 
 				if self.measure_action.isChecked():
-					measure_at_position(self.pos, self.mode, threads=self.parent_window.parent_window.n_threads)
+					process_args = {"pos": self.pos, "mode": self.mode, "n_threads": self.n_threads}
+					self.job = ProgressWindow(MeasurementProcess, parent_window=self, title="Measurement", process_args=process_args)
+					result = self.job.exec_()
+					if result == QDialog.Accepted:
+						pass
+					elif result == QDialog.Rejected:
+						return None
+					#measure_at_position(self.pos, self.mode, threads=self.parent_window.parent_window.n_threads)
 
 				table = os.sep.join([self.pos, 'output', 'tables', f'trajectories_{self.mode}.csv'])
 				if self.signal_analysis_action.isChecked() and os.path.exists(table):
@@ -845,12 +895,11 @@ class ProcessPanel(QFrame, Styles):
 
 			# self.stack = None
 		self.parent_window.update_position_options()
-
 		for action in [self.segment_action, self.track_action, self.measure_action, self.signal_analysis_action]:
 			if action.isChecked():
 				action.setChecked(False)
 
-		self.cellpose_calibrated = False
+		self.reset_generalist_setup(0)
 
 	def open_napari_tracking(self):
 		print(f'View the tracks before post-processing for position {self.parent_window.pos} in napari...')
@@ -1207,7 +1256,7 @@ class NeighPanel(QFrame, Styles):
 		self.neigh_action.setChecked(False)
 
 	def open_classifier_ui_pairs(self):
-		
+
 		self.mode = "pairs"
 		self.load_available_tables()
 		if self.df is None:

celldetective/gui/retrain_segmentation_model_options.py

@@ -1,4 +1,4 @@
-from PyQt5.QtWidgets import QMainWindow, QApplication,QRadioButton, QMessageBox, QScrollArea, QComboBox, QFrame, QFileDialog, QGridLayout, QLineEdit, QVBoxLayout, QWidget, QLabel, QHBoxLayout, QPushButton
+from PyQt5.QtWidgets import QDialog, QMainWindow, QApplication,QRadioButton, QMessageBox, QScrollArea, QComboBox, QFrame, QFileDialog, QGridLayout, QLineEdit, QVBoxLayout, QWidget, QLabel, QHBoxLayout, QPushButton
 from PyQt5.QtCore import Qt, QSize
 from PyQt5.QtGui import QDoubleValidator, QIntValidator, QIcon
 from celldetective.gui.gui_utils import center_window
@@ -17,6 +17,8 @@ import os
 from glob import glob
 from datetime import datetime
 from celldetective.gui import Styles
+from celldetective.gui.processes.train_segmentation_model import TrainSegModelProcess
+from celldetective.gui.workers import ProgressWindow
 
 class ConfigSegmentationModelTraining(QMainWindow, Styles):
 	
@@ -29,6 +31,7 @@ class ConfigSegmentationModelTraining(QMainWindow, Styles):
 		
 		super().__init__()
 		self.parent_window = parent_window
+		self.use_gpu = self.parent_window.use_gpu
 		self.setWindowTitle("Train segmentation model")
 		self.setWindowIcon(QIcon(os.sep.join(['celldetective','icons','mexican-hat.png'])))
 		self.mode = self.parent_window.mode
@@ -239,7 +242,7 @@ class ConfigSegmentationModelTraining(QMainWindow, Styles):
 		self.augmentation_slider.setSingleStep(0.01)
 		self.augmentation_slider.setTickInterval(0.01)		
 		self.augmentation_slider.setOrientation(1)
-		self.augmentation_slider.setRange(1, 5)
+		self.augmentation_slider.setRange(0.01, 3)
 		self.augmentation_slider.setValue(2.0)
 
 		augmentation_hbox.addWidget(self.augmentation_slider, 70)
@@ -597,24 +600,34 @@ class ConfigSegmentationModelTraining(QMainWindow, Styles):
 		epochs = self.epochs_slider.value()
 		spatial_calib = float(self.spatial_calib_le.text().replace(',','.'))
 
-		training_instructions = {'model_name': model_name,'model_type': model_type, 'pretrained': pretrained_model, 'spatial_calibration': spatial_calib, 'channel_option': channels, 'normalization_percentile': normalization_mode,
+		self.training_instructions = {'model_name': model_name,'model_type': model_type, 'pretrained': pretrained_model, 'spatial_calibration': spatial_calib, 'channel_option': channels, 'normalization_percentile': normalization_mode,
 		'normalization_clip': clip_values,'normalization_values': norm_values, 'ds': data_folders, 'augmentation_factor': aug_factor, 'validation_split': val_split,
 		'learning_rate': lr, 'batch_size': bs, 'epochs': epochs}
 
-		print(training_instructions)
 
 		model_folder = os.sep.join([self.software_models_dir,model_name, ''])
 		print(model_folder)
 		if not os.path.exists(model_folder):
 			os.mkdir(model_folder)
 
-		training_instructions.update({'target_directory': self.software_models_dir})
+		self.training_instructions.update({'target_directory': self.software_models_dir})
+
+		print(f"Set of instructions: {self.training_instructions}")
+
+		self.instructions = model_folder+"training_instructions.json"
 
-		print(f"Set of instructions: {training_instructions}")
 		with open(model_folder+"training_instructions.json", 'w') as f:
-			json.dump(training_instructions, f, indent=4)
+			json.dump(self.training_instructions, f, indent=4)
 		
-		train_segmentation_model(model_folder+"training_instructions.json", use_gpu=self.parent_window.parent_window.parent_window.use_gpu)
+		# process_args = {"instructions": self.instructions, "use_gpu": self.use_gpu}
+		# self.job = ProgressWindow(TrainSegModelProcess, parent_window=self, title="Training", position_info=False, process_args=process_args)
+		# result = self.job.exec_()
+		# if result == QDialog.Accepted:
+		# 	pass
+		# elif result == QDialog.Rejected:
+		# 	return None		
+
+		train_segmentation_model(self.instructions, use_gpu=self.parent_window.parent_window.parent_window.use_gpu)
 
 		self.parent_window.init_seg_model_list()
 		idx = self.parent_window.seg_model_list.findText(model_name)

celldetective/gui/retrain_signal_model_options.py

@@ -1,4 +1,4 @@
-from PyQt5.QtWidgets import QMainWindow, QApplication, QMessageBox, QScrollArea, QComboBox, QFrame, QCheckBox, QFileDialog, QGridLayout, QLineEdit, QVBoxLayout, QWidget, QLabel, QHBoxLayout, QPushButton
+from PyQt5.QtWidgets import QMainWindow, QApplication, QDialog, QMessageBox, QScrollArea, QComboBox, QFrame, QCheckBox, QFileDialog, QGridLayout, QLineEdit, QVBoxLayout, QWidget, QLabel, QHBoxLayout, QPushButton
 from PyQt5.QtCore import Qt, QSize
 from PyQt5.QtGui import QDoubleValidator, QIntValidator, QIcon
 from celldetective.gui.gui_utils import center_window
@@ -16,6 +16,8 @@ from glob import glob
 from datetime import datetime
 from celldetective.gui import Styles
 from pandas.api.types import is_numeric_dtype
+from celldetective.gui.processes.train_signal_model import TrainSignalModelProcess
+from celldetective.gui.workers import ProgressWindow
 
 class ConfigSignalModelTraining(QMainWindow, Styles):
 	
@@ -584,6 +586,14 @@ class ConfigSignalModelTraining(QMainWindow, Styles):
 		with open(model_folder+"training_instructions.json", 'w') as f:
 			json.dump(training_instructions, f, indent=4)
 		
-		train_signal_model(model_folder+"training_instructions.json")
+		# self.instructions = model_folder+"training_instructions.json"
+		# process_args = {"instructions": self.instructions} # "use_gpu": self.use_gpu
+		# self.job = ProgressWindow(TrainSignalModelProcess, parent_window=self, title="Training", position_info=False, process_args=process_args)
+		# result = self.job.exec_()
+		# if result == QDialog.Accepted:
+		# 	pass
+		# elif result == QDialog.Rejected:
+		# 	return None	
 
+		train_signal_model(model_folder+"training_instructions.json")
 		self.parent_window.refresh_signal_models()

celldetective/gui/signal_annotator.py

@@ -83,6 +83,15 @@ class SignalAnnotator(QMainWindow, Styles):
 
 			self.populate_widget()
 
+	def resizeEvent(self, event):
+		
+		super().resizeEvent(event)
+
+		try:
+			self.cell_fig.tight_layout()
+		except:
+			pass
+
 	def populate_widget(self):
 
 		"""

celldetective/gui/signal_annotator2.py

@@ -134,6 +134,14 @@ class SignalAnnotator2(QMainWindow,Styles):
 
 		self.setAttribute(Qt.WA_DeleteOnClose)
 
+	def resizeEvent(self, event):
+
+		super().resizeEvent(event)
+		try:
+			self.cell_fig.tight_layout()
+		except:
+			pass
+
 	def populate_widget(self):
 
 		"""
@@ -205,14 +213,14 @@ class SignalAnnotator2(QMainWindow,Styles):
 
 		self.cell_events_hbox = QHBoxLayout()
 		self.cell_events_hbox.setContentsMargins(0,0,0,0)
-		self.cell_events_hbox.addWidget(QLabel('reference event: '), 25)
+		self.cell_events_hbox.addWidget(QLabel('Event: '), 25)
 		self.reference_event_choice_cb = QComboBox()
 		self.cell_events_hbox.addWidget(self.reference_event_choice_cb, 75)
 		
 		#if 'self' not in self.neighborhood_choice_cb.currentText():
 		self.neigh_cell_events_hbox = QHBoxLayout()
 		self.neigh_cell_events_hbox.setContentsMargins(0,0,0,0)
-		self.neigh_lab=QLabel('neighbor event: ')
+		self.neigh_lab=QLabel('Event: ')
 		self.neigh_cell_events_hbox.addWidget(self.neigh_lab, 25)
 		self.neighbor_event_choice_cb = QComboBox()
 		self.neigh_cell_events_hbox.addWidget(self.neighbor_event_choice_cb, 75)
@@ -233,7 +241,7 @@ class SignalAnnotator2(QMainWindow,Styles):
 		neighbor_layout.addLayout(self.neigh_cell_events_hbox)
 
 		self.cell_info_hbox.addLayout(reference_layout, 33)
-		self.cell_info_hbox.addWidget(self.pair_info, 33, alignment=Qt.AlignCenter)
+		self.cell_info_hbox.addWidget(self.pair_info, 33)
 		self.cell_info_hbox.addLayout(neighbor_layout, 33)
 
 		self.left_panel.addLayout(self.cell_info_hbox)
@@ -2378,41 +2386,41 @@ class SignalAnnotator2(QMainWindow,Styles):
 
 		df_reference = self.dataframes[self.reference_population]
 		if self.reference_track_of_interest is not None:
-			reference_cell_selected = f"reference cell: {self.reference_track_of_interest}\n"
-			reference_cell_population = f"population: {self.reference_population}\n"
+			reference_cell_selected = f"Ref #{self.reference_track_of_interest}\n"
+			reference_cell_population = f"Pop: {self.reference_population}\n"
 			#reference_cell_class = f"class: {df_reference[df_reference['TRACK_ID']==self.reference_track_of_interest, self.reference_event_choice_cb.currentText()].values[0]}\n"
 			#reference_cell_time = f"time of interest: {df_reference[df_reference['TRACK_ID']==self.reference_track_of_interest, ''].values[0]}\n"
 			self.reference_cell_info.setText(reference_cell_selected+reference_cell_population)
 		else:
-			reference_cell_selected = f"reference cell: None\n"
-			reference_cell_population = f"population: {self.reference_population}\n"
+			reference_cell_selected = f"Ref: None\n"
+			reference_cell_population = f"Pop: {self.reference_population}\n"
 			self.reference_cell_info.setText(reference_cell_selected+reference_cell_population)
 
 	def give_neighbor_cell_information(self):
 
 		if self.neighbor_track_of_interest is not None:
-			neighbor_cell_selected = f"neighbor cell: {self.neighbor_track_of_interest}\n"
-			neighbor_cell_population = f"population: {self.neighbor_population}\n"
+			neighbor_cell_selected = f"Neigh #{self.neighbor_track_of_interest}\n"
+			neighbor_cell_population = f"Pop: {self.neighbor_population}\n"
 			#neighbor_cell_time = f"time of interest: {self.df_relative.loc[(self.df_relative['REFERENCE_ID']==self.reference_track_of_interest)&(self.df_relative['NEIGHBOR_ID']==self.neighbor_track_of_interest), self.pair_time_name].to_numpy()[0]}\n"
 			#neighbor_cell_class = f"class: {self.df_relative.loc[(self.df_relative['REFERENCE_ID']==self.reference_track_of_interest)&(self.df_relative['NEIGHBOR_ID']==self.neighbor_track_of_interest), self.pair_class_name].to_numpy()[0]}\n"
 			self.neighbor_cell_info.setText(neighbor_cell_selected+neighbor_cell_population) #neighbor_cell_class+neighbor_cell_time 
 		else:
-			neighbor_cell_selected = f"neighbor cell: None\n"
-			neighbor_cell_population = f"population: {self.neighbor_population}\n"
+			neighbor_cell_selected = f"Neigh: None\n"
+			neighbor_cell_population = f"Pop: {self.neighbor_population}\n"
 			self.neighbor_cell_info.setText(neighbor_cell_selected+neighbor_cell_population)
 
 	def give_pair_information(self):
 
 		if self.neighbor_track_of_interest is not None and self.reference_track_of_interest is not None:
-			pair_selected = f"(reference/neighbor) pair: ({self.reference_track_of_interest},{self.neighbor_track_of_interest})\n"
-			pair_populations = f"populations: ({self.reference_population}, {self.neighbor_population})\n"
+			pair_selected = f"Pair: ({self.reference_track_of_interest},{self.neighbor_track_of_interest})\n"
+			pair_populations = "" #f"populations: ({self.reference_population}, {self.neighbor_population})\n"
 			current_class = self.relative_class_choice_cb.currentText()
-			pair_class = f"interaction event class: {self.df_relative.loc[(self.df_relative['REFERENCE_ID']==self.reference_track_of_interest)&(self.df_relative['NEIGHBOR_ID']==self.neighbor_track_of_interest)&(self.df_relative['reference_population']==self.reference_population)&(self.df_relative['neighbor_population']==self.neighbor_population)&(~self.df_relative['status_'+self.current_neighborhood].isnull()), current_class].values[0]}\n"
-			pair_time = f"time of interest: {self.df_relative.loc[(self.df_relative['REFERENCE_ID']==self.reference_track_of_interest)&(self.df_relative['NEIGHBOR_ID']==self.neighbor_track_of_interest)&(self.df_relative['reference_population']==self.reference_population)&(self.df_relative['neighbor_population']==self.neighbor_population)&(~self.df_relative['status_'+self.current_neighborhood].isnull()), self.pair_time_name].values[0]}\n"
+			pair_class = f"Event class: {self.df_relative.loc[(self.df_relative['REFERENCE_ID']==self.reference_track_of_interest)&(self.df_relative['NEIGHBOR_ID']==self.neighbor_track_of_interest)&(self.df_relative['reference_population']==self.reference_population)&(self.df_relative['neighbor_population']==self.neighbor_population)&(~self.df_relative['status_'+self.current_neighborhood].isnull()), current_class].values[0]}\n"
+			pair_time = f"Time: {self.df_relative.loc[(self.df_relative['REFERENCE_ID']==self.reference_track_of_interest)&(self.df_relative['NEIGHBOR_ID']==self.neighbor_track_of_interest)&(self.df_relative['reference_population']==self.reference_population)&(self.df_relative['neighbor_population']==self.neighbor_population)&(~self.df_relative['status_'+self.current_neighborhood].isnull()), self.pair_time_name].values[0]}\n"
 			self.pair_info.setText(pair_selected+pair_populations+pair_class+pair_time)
 		else:
-			pair_selected = f"(reference/neighbor) pair: None\n"
-			pair_populations = f"populations: ({self.reference_population}, {self.neighbor_population})\n"
+			pair_selected = f"Pair: None\n"
+			pair_populations = "" #f"populations: ({self.reference_population}, {self.neighbor_population})\n"
 			self.pair_info.setText(pair_selected+pair_populations)
 
 

celldetective/gui/styles.py

@@ -125,6 +125,7 @@ class Styles(object):
 				font-size: 8px;
 			}
 			QPushButton:hover {
+				color: white;
 				background-color: #2070EB;
 			}
 			QPushButton:pressed {

celldetective/gui/tableUI.py

@@ -1337,7 +1337,7 @@ class TableUI(QMainWindow, Styles):
 				file_name += ".csv"
 			invalid_cols = [c for c in list(self.data.columns) if c.startswith('Unnamed')]
 			if len(invalid_cols)>0:
-				self.data = self.data.drop(invalid_cols, axis=1)	
+				self.data = self.data.drop(invalid_cols, axis=1)
 			self.data.to_csv(file_name, index=False)
 
 	def test_bool(self, array):

celldetective/gui/workers.py

@@ -0,0 +1,136 @@
+from multiprocessing import Queue
+from PyQt5.QtWidgets import QDialog, QPushButton, QVBoxLayout, QHBoxLayout, QWidget, QLabel, QProgressBar
+from PyQt5.QtCore import QRunnable, QObject, pyqtSignal, QThreadPool, QSize, Qt
+from celldetective.gui.gui_utils import center_window
+import time
+import math
+
+class ProgressWindow(QDialog):
+
+	def __init__(self, process=None, parent_window=None, title="", position_info=True, process_args=None):
+		QDialog.__init__(self)
+
+		self.setWindowTitle(f'{title} Progress')
+		self.__process = process
+		self.parent_window = parent_window
+		self.position_info = position_info
+		if self.position_info:
+			self.pos_name = self.parent_window.pos_name
+
+		#self.__btn_run = QPushButton("Start")
+		self.__btn_stp = QPushButton("Cancel")
+		if self.position_info:
+			self.position_label = QLabel(f'Processing position {self.pos_name}...')
+		self.__label   = QLabel("Idle")
+		self.time_left_lbl = QLabel('')
+
+		self.progress_bar = QProgressBar()
+		self.progress_bar.setValue(0)
+
+		self.__runner  = Runner(process=self.__process, progress_bar=self.progress_bar, process_args=process_args, remaining_time_label=self.time_left_lbl)
+		self.pool = QThreadPool.globalInstance()
+		#print("Multithreading with maximum %d threads" % self.pool.maxThreadCount())
+
+		#self.__btn_run.clicked.connect(self.__run_net)
+		self.__btn_stp.clicked.connect(self.__stp_net)
+		self.__runner.signals.finished.connect(self.__on_finished)
+		self.__runner.signals.finished.connect(self.__on_error)
+		self.__runner.signals.update.connect(self.progress_bar.setValue)
+		self.__runner.signals.update_time.connect(self.time_left_lbl.setText)
+
+		self.__btn_stp.setDisabled(True)
+
+		self.layout = QVBoxLayout()
+		if self.position_info:
+			self.layout.addWidget(self.position_label)
+		self.layout.addWidget(self.time_left_lbl)
+		self.layout.addWidget(self.progress_bar)
+		self.btn_layout = QHBoxLayout()
+		self.btn_layout.addWidget(self.__btn_stp)
+		self.btn_layout.addWidget(self.__label)
+		self.layout.addLayout(self.btn_layout)
+
+		self.setLayout(self.layout)
+		self.setFixedSize(QSize(250, 130))
+		self.__run_net()
+		self.setModal(True)
+		center_window(self)
+
+	def closeEvent(self, evnt):
+		# if self._want_to_close:
+		# 	super(MyDialog, self).closeEvent(evnt)
+		# else:
+		evnt.ignore()
+		self.setWindowState(Qt.WindowMinimized)
+
+	def __run_net(self):
+		#self.__btn_run.setDisabled(True)
+		self.__btn_stp.setEnabled(True)
+		self.__label.setText("Running...")
+		self.pool.start(self.__runner)
+
+	def __stp_net(self):
+		self.__runner.close()
+		print('\n Job cancelled... Abort.')
+		self.reject()
+
+	def __on_finished(self):
+		self.__btn_stp.setDisabled(True)
+		self.__label.setText("\nFinished!")
+		self.__runner.close()
+		self.accept()
+
+	def __on_error(self):
+		self.__btn_stp.setDisabled(True)
+		self.__label.setText("\nError")
+		self.__runner.close()
+		self.accept()
+
+class Runner(QRunnable):
+
+	def __init__(self, process=None, progress_bar=None, remaining_time_label=None, process_args=None):
+		QRunnable.__init__(self)
+
+		print(f"{process_args=}")
+		self.progress_bar = progress_bar
+		#self.parent_window = parent_window
+		self.remaining_time_label = remaining_time_label
+		self.__queue = Queue()
+		self.__process = process(self.__queue, process_args=process_args)
+		self.signals = RunnerSignal()
+
+	def run(self):
+		self.__process.start()
+		while True:
+			try:
+				data = self.__queue.get()
+				if len(data)==2:
+					progress, time = data
+					time = int(time)
+					remaining_minutes = time // 60
+					remaining_seconds = int(time % 60)
+					time_left = "About "+str(remaining_minutes)+" min and "+str(remaining_seconds)+" s remaining"
+					if remaining_minutes == 0:
+						time_left = "About "+str(remaining_seconds)+" s remaining"
+					self.signals.update_time.emit(time_left)
+					if isinstance(progress, (float,int)):
+						self.signals.update.emit(math.ceil(progress))
+				if data == "finished":
+					self.signals.finished.emit()
+					break
+				elif data == "error":
+					self.signals.error.emit()
+			except Exception as e:
+				print(e)
+				pass
+
+	def close(self):
+		self.__process.end_process()
+
+
+class RunnerSignal(QObject):
+
+	update = pyqtSignal(int)
+	update_time = pyqtSignal(str)
+	finished = pyqtSignal()
+	error = pyqtSignal()