celldetective 1.0.2.post1__py3-none-any.whl → 1.1.1__py3-none-any.whl

celldetective/gui/tableUI.py

@@ -1,14 +1,20 @@
-from PyQt5.QtWidgets import QMainWindow, QTableView, QAction, QMenu,QFileDialog, QLineEdit, QHBoxLayout, QWidget, QPushButton, QVBoxLayout, QComboBox, QLabel, QCheckBox, QMessageBox
+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
 import pandas as pd
 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
 import numpy as np
 import seaborn as sns
 import matplotlib.cm as mcm
 import os
+from celldetective.gui import Styles
+from superqt import QColormapComboBox, QLabeledSlider, QSearchableComboBox
+from math import floor
+
+from matplotlib import colormaps
 
 class PandasModel(QAbstractTableModel):
 
@@ -36,10 +42,10 @@ class PandasModel(QAbstractTableModel):
 
 class QueryWidget(QWidget):
 
-	def __init__(self, parent):
+	def __init__(self, parent_window):
 
 		super().__init__()
-		self.parent = parent
+		self.parent_window = parent_window
 		self.setWindowTitle("Filter table")
 		# Create the QComboBox and add some items
 		center_window(self)
@@ -53,11 +59,12 @@ class QueryWidget(QWidget):
 		self.submit_btn = QPushButton('submit')
 		self.submit_btn.clicked.connect(self.filter_table)
 		layout.addWidget(self.submit_btn, 30)
+		self.setAttribute(Qt.WA_DeleteOnClose)
 
 	def filter_table(self):
 		try:
 			query_text = self.query_le.text().replace('class', '`class`')
-			tab = self.parent.data.query(query_text)
+			tab = self.parent_window.data.query(query_text)
 			self.subtable = TableUI(tab, query_text, plot_mode="scatter")
 			self.subtable.show()
 			self.close()
@@ -65,12 +72,90 @@ class QueryWidget(QWidget):
 			print(e)
 			return None
 
+class DifferentiateColWidget(QWidget, Styles):
+
+	def __init__(self, parent_window, column=None):
+
+		super().__init__()
+		self.parent_window = parent_window
+		self.column = column
+
+		self.setWindowTitle("d/dt")
+		# 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.window_size_slider = QLabeledSlider()
+		self.window_size_slider.setRange(1,np.nanmax(self.parent_window.data.FRAME.to_numpy()))
+		self.window_size_slider.setValue(3)
+		window_layout = QHBoxLayout()
+		window_layout.addWidget(QLabel('window size: '), 25)
+		window_layout.addWidget(self.window_size_slider, 75)
+		layout.addLayout(window_layout)
+
+		self.backward_btn = QRadioButton('backward')
+		self.bi_btn = QRadioButton('bi')
+		self.bi_btn.click()
+		self.forward_btn = QRadioButton('forward')
+		self.mode_btn_group = QButtonGroup()
+		self.mode_btn_group.addButton(self.backward_btn)
+		self.mode_btn_group.addButton(self.bi_btn)
+		self.mode_btn_group.addButton(self.forward_btn)
+
+		mode_layout = QHBoxLayout()
+		mode_layout.addWidget(QLabel('mode: '),25)
+		mode_sublayout = QHBoxLayout()
+		mode_sublayout.addWidget(self.backward_btn, 33, alignment=Qt.AlignCenter)
+		mode_sublayout.addWidget(self.bi_btn, 33, alignment=Qt.AlignCenter)
+		mode_sublayout.addWidget(self.forward_btn, 33, alignment=Qt.AlignCenter)
+		mode_layout.addLayout(mode_sublayout, 75)
+		layout.addLayout(mode_layout)
+
+		self.submit_btn = QPushButton('Compute')
+		self.submit_btn.setStyleSheet(self.button_style_sheet)
+		self.submit_btn.clicked.connect(self.compute_derivative_and_add_new_column)
+		layout.addWidget(self.submit_btn, 30)
+
+		self.setAttribute(Qt.WA_DeleteOnClose)
+
+
+	def compute_derivative_and_add_new_column(self):
+		
+		if self.bi_btn.isChecked():
+			mode = 'bi'
+		elif self.forward_btn.isChecked():
+			mode = 'forward'
+		elif self.backward_btn.isChecked():
+			mode = 'backward'
+		self.parent_window.data = differentiate_per_track(self.parent_window.data,
+														  self.measurements_cb.currentText(),
+														  window_size=self.window_size_slider.value(),
+														  mode=mode)
+		self.parent_window.model = PandasModel(self.parent_window.data)
+		self.parent_window.table_view.setModel(self.parent_window.model)
+		self.close()
+
+
+
 class RenameColWidget(QWidget):
 
-	def __init__(self, parent, column=None):
+	def __init__(self, parent_window, column=None):
 
 		super().__init__()
-		self.parent = parent
+		self.parent_window = parent_window
 		self.column = column
 		if self.column is None:
 			self.column = ''
@@ -88,20 +173,21 @@ class RenameColWidget(QWidget):
 		self.submit_btn = QPushButton('rename')
 		self.submit_btn.clicked.connect(self.rename_col)
 		layout.addWidget(self.submit_btn, 30)
+		self.setAttribute(Qt.WA_DeleteOnClose)
 
 	def rename_col(self):
 		
 		old_name = self.column
 		new_name = self.new_col_name.text()
-		self.parent.data = self.parent.data.rename(columns={old_name: new_name})
+		self.parent_window.data = self.parent_window.data.rename(columns={old_name: new_name})
 		print(self.parent.data.columns)
 
-		self.parent.model = PandasModel(self.parent.data)
-		self.parent.table_view.setModel(self.parent.model)
+		self.parent_window.model = PandasModel(self.parent_window.data)
+		self.parent_window.table_view.setModel(self.parent_window.model)
 		self.close()
 
 
-class TableUI(QMainWindow):
+class TableUI(QMainWindow, Styles):
 	def __init__(self, data, title, population='targets',plot_mode="plot_track_signals", *args, **kwargs):
 
 		QMainWindow.__init__(self, *args, **kwargs)
@@ -126,6 +212,8 @@ class TableUI(QMainWindow):
 		self.model = PandasModel(data)
 		self.table_view.setModel(self.model)
 		self.table_view.resizeColumnsToContents()
+		self.setAttribute(Qt.WA_DeleteOnClose)
+
 
 	def _createActions(self):
 
@@ -229,8 +317,17 @@ class TableUI(QMainWindow):
 		# check only one col selected and assert is numerical
 		# open widget to select window parameters, directionality
 		# create new col
-		print('you want to differentiate? cool but I"m too tired to code it now...')
-		pass
+		
+		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.diffWidget = DifferentiateColWidget(self, selected_col)
+		self.diffWidget.show()
 
 
 	def groupby_time_table(self):
@@ -268,24 +365,102 @@ class TableUI(QMainWindow):
 	def set_projection_mode_tracks(self):
 
 		self.projectionWidget = QWidget()
+		self.projectionWidget.setMinimumWidth(500)
 		self.projectionWidget.setWindowTitle('Set projection mode')
 		
 		layout = QVBoxLayout()
 		self.projectionWidget.setLayout(layout)
+
+		self.projection_option = QRadioButton('global operation: ')
+		self.projection_option.setToolTip('Collapse the cell track measurements with an operation over each track.')
+		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'])
-		hbox = QHBoxLayout()
-		hbox.addWidget(QLabel('operation: '), 33)
-		hbox.addWidget(self.projection_op_cb, 66)
-		layout.addLayout(hbox)
 
-		self.set_projection_btn = QPushButton('set')
+		projection_layout = QHBoxLayout()
+		projection_layout.addWidget(self.projection_option, 33)
+		projection_layout.addWidget(self.projection_op_cb, 66)
+		layout.addLayout(projection_layout)
+
+		self.event_time_option = QRadioButton('@event time: ')
+		self.event_time_option.setToolTip('Pick the measurements at a specific event time.')
+		self.event_time_option.toggled.connect(self.enable_projection_options)
+		self.event_times_cb = QComboBox()
+		cols = np.array(self.data.columns)
+		time_cols = np.array([c.startswith('t_') for c in cols])
+		time_cols = list(cols[time_cols])
+		if 't0' in list(self.data.columns):
+			time_cols.append('t0')
+		self.event_times_cb.addItems(time_cols)
+		self.event_times_cb.setEnabled(False)
+
+		event_time_layout = QHBoxLayout()
+		event_time_layout.addWidget(self.event_time_option, 33)
+		event_time_layout.addWidget(self.event_times_cb, 66)
+		layout.addLayout(event_time_layout)
+
+
+		self.per_status_option = QRadioButton('per status: ')
+		self.per_status_option.setToolTip('Collapse the cell track measurements independently for each of the cell state.')
+		self.per_status_option.toggled.connect(self.enable_projection_options)
+		self.per_status_cb = QComboBox()
+		self.status_operation = QComboBox()
+		self.status_operation.setEnabled(False)
+		self.status_operation.addItems(['mean','median','min','max', 'prod', 'sum'])
+
+		status_cols = np.array([c.startswith('status_') for c in cols])
+		status_cols = list(cols[status_cols])
+		if 'status' in list(self.data.columns):
+			status_cols.append('status')
+		self.per_status_cb.addItems(status_cols)
+		self.per_status_cb.setEnabled(False)
+
+		per_status_layout = QHBoxLayout()
+		per_status_layout.addWidget(self.per_status_option, 33)
+		per_status_layout.addWidget(self.per_status_cb, 66)
+		layout.addLayout(per_status_layout)
+
+		status_operation_layout = QHBoxLayout()
+		status_operation_layout.addWidget(QLabel('operation: '), 33, alignment=Qt.AlignRight)
+		status_operation_layout.addWidget(self.status_operation, 66)
+		layout.addLayout(status_operation_layout)
+
+		self.btn_projection_group = QButtonGroup()
+		self.btn_projection_group.addButton(self.projection_option)
+		self.btn_projection_group.addButton(self.event_time_option)
+		self.btn_projection_group.addButton(self.per_status_option)
+
+		apply_layout = QHBoxLayout()
+
+		self.set_projection_btn = QPushButton('Apply')
+		self.set_projection_btn.setStyleSheet(self.button_style_sheet)
 		self.set_projection_btn.clicked.connect(self.set_proj_mode)
-		layout.addWidget(self.set_projection_btn)
+		apply_layout.addWidget(QLabel(''), 33)
+		apply_layout.addWidget(self.set_projection_btn,33)
+		apply_layout.addWidget(QLabel(''),33)
+		layout.addLayout(apply_layout)
 
 		self.projectionWidget.show()
 		center_window(self.projectionWidget)
 
+	def enable_projection_options(self):
+
+		if self.projection_option.isChecked():
+			self.projection_op_cb.setEnabled(True)
+			self.event_times_cb.setEnabled(False)
+			self.per_status_cb.setEnabled(False)
+			self.status_operation.setEnabled(False)
+		elif self.event_time_option.isChecked():
+			self.projection_op_cb.setEnabled(False)
+			self.event_times_cb.setEnabled(True)
+			self.per_status_cb.setEnabled(False)
+			self.status_operation.setEnabled(False)
+		elif self.per_status_option.isChecked():
+			self.projection_op_cb.setEnabled(False)
+			self.event_times_cb.setEnabled(False)
+			self.per_status_cb.setEnabled(True)
+			self.status_operation.setEnabled(True)
+
 	def set_1D_plot_params(self):
 
 		self.plot1Dparams = QWidget()
@@ -313,24 +488,38 @@ class TableUI(QMainWindow):
 		layout.addWidget(self.box_check)
 		layout.addWidget(self.boxenplot_check)
 
-		self.hue_cb = QComboBox()
-		self.hue_cb.addItems(list(self.data.columns))
-		idx = self.hue_cb.findText('well_index')
-		self.hue_cb.setCurrentIndex(idx)
+		self.x_cb = QSearchableComboBox()
+		self.x_cb.addItems(['--']+list(self.data.columns))
+
+		self.hue_cb = QSearchableComboBox()
+		self.hue_cb.addItems(['--']+list(self.data.columns))
+		idx = self.hue_cb.findText('--')
+
+		self.x_cb.findText('--')
+		hbox = QHBoxLayout()
+		hbox.addWidget(QLabel('x: '), 33)
+		hbox.addWidget(self.x_cb, 66)
+		layout.addLayout(hbox)
+
 		hbox = QHBoxLayout()
 		hbox.addWidget(QLabel('hue: '), 33)
 		hbox.addWidget(self.hue_cb, 66)
 		layout.addLayout(hbox)
 
-
-		self.cmap_cb = QComboBox()
-		self.cmap_cb.addItems(list(plt.colormaps()))
+		self.cmap_cb = QColormapComboBox()
+		for cm in list(colormaps):
+			try:
+				self.cmap_cb.addColormap(cm)
+			except:
+				pass
+		
 		hbox = QHBoxLayout()
 		hbox.addWidget(QLabel('colormap: '), 33)
 		hbox.addWidget(self.cmap_cb, 66)
 		layout.addLayout(hbox)
 
 		self.plot1d_btn = QPushButton('set')
+		self.plot1d_btn.setStyleSheet(self.button_style_sheet)
 		self.plot1d_btn.clicked.connect(self.plot1d)
 		layout.addWidget(self.plot1d_btn)
 
@@ -340,6 +529,11 @@ class TableUI(QMainWindow):
 
 	def plot1d(self):
 
+		self.x_option = False
+		if self.x_cb.currentText()!='--':
+			self.x_option = True
+			self.x = self.x_cb.currentText()
+
 		x = self.table_view.selectedIndexes()
 		col_idx = np.array([l.column() for l in x])
 		row_idx = np.array([l.row() for l in x])
@@ -353,9 +547,16 @@ class TableUI(QMainWindow):
 		y = self.data.iloc[row_idx_i, unique_cols]
 		
 		cmap = getattr(mcm, self.cmap_cb.currentText())
-		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()))]
+		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()))]
+		except:
+			colors = None
+
+		if self.hue_cb.currentText()=='--':
+			hue_variable = None
+
 		#for w,well_group in self.data.groupby('well_index'):
 
 		legend=True
@@ -371,24 +572,44 @@ class TableUI(QMainWindow):
 			legend = False
 
 		if self.swarm_check.isChecked():
-			sns.swarmplot(data=self.data, y=column_names[unique_cols],dodge=True, hue=hue_variable,legend=legend, ax=self.ax, palette=colors)
-			legend = False
+			if self.x_option:
+				sns.swarmplot(data=self.data, x=self.x,y=column_names[unique_cols],dodge=True, hue=hue_variable,legend=legend, ax=self.ax, palette=colors)
+				legend = False
+			else:
+				sns.swarmplot(data=self.data, y=column_names[unique_cols],dodge=True, hue=hue_variable,legend=legend, ax=self.ax, palette=colors)
+				legend = False
 
 		if self.violin_check.isChecked():
-			sns.violinplot(data=self.data, y=column_names[unique_cols],dodge=True, hue=hue_variable,legend=legend, ax=self.ax, palette=colors, cut=0)
-			legend = False
+			if self.x_option:
+				sns.stripplot(data=self.data,x=self.x, y=column_names[unique_cols],dodge=True, ax=self.ax, hue=hue_variable, legend=legend, palette=colors)
+				legend = False
+			else:
+				sns.violinplot(data=self.data, y=column_names[unique_cols],dodge=True, hue=hue_variable,legend=legend, ax=self.ax, palette=colors, cut=0)
+				legend = False
 
 		if self.box_check.isChecked():
-			sns.boxplot(data=self.data, y=column_names[unique_cols],dodge=True, hue=hue_variable,legend=legend, ax=self.ax, fill=False,palette=colors, linewidth=2,)
-			legend = False
+			if self.x_option:
+				sns.boxplot(data=self.data, x=self.x, y=column_names[unique_cols],dodge=True, hue=hue_variable,legend=legend, ax=self.ax, fill=False,palette=colors, linewidth=2,)
+				legend = False
+			else:
+				sns.boxplot(data=self.data, y=column_names[unique_cols],dodge=True, hue=hue_variable,legend=legend, ax=self.ax, fill=False,palette=colors, linewidth=2,)
+				legend = False
 
 		if self.boxenplot_check.isChecked():
-			sns.boxenplot(data=self.data, y=column_names[unique_cols],dodge=True, hue=hue_variable,legend=legend, ax=self.ax, fill=False,palette=colors, linewidth=2,)
-			legend = False
+			if self.x_option:
+				sns.boxenplot(data=self.data, x = self.x, y=column_names[unique_cols],dodge=True, hue=hue_variable,legend=legend, ax=self.ax, fill=False,palette=colors, linewidth=2,)
+				legend = False
+			else:
+				sns.boxenplot(data=self.data, y=column_names[unique_cols],dodge=True, hue=hue_variable,legend=legend, ax=self.ax, fill=False,palette=colors, linewidth=2,)
+				legend = False
 
 		if self.strip_check.isChecked():
-			sns.stripplot(data=self.data, y=column_names[unique_cols],dodge=True, ax=self.ax, hue=hue_variable, legend=legend, palette=colors)
-			legend = False
+			if self.x_option:
+				sns.stripplot(data=self.data, x = self.x, y=column_names[unique_cols],dodge=True, ax=self.ax, hue=hue_variable, legend=legend, palette=colors)
+				legend = False
+			else:
+				sns.stripplot(data=self.data, y=column_names[unique_cols],dodge=True, ax=self.ax, hue=hue_variable, legend=legend, palette=colors)
+				legend = False
 
 		plt.tight_layout()
 		self.fig.set_facecolor('none')  # or 'None'
@@ -398,18 +619,86 @@ class TableUI(QMainWindow):
 
 
 	def set_proj_mode(self):
-		self.projection_mode = self.projection_op_cb.currentText()
-		#eval(self.projection_mode)
-		op = getattr(self.data.groupby(['position', 'TRACK_ID']), self.projection_mode)
-		group_table = op(self.data.groupby(['position', 'TRACK_ID']))
+		
+		self.static_columns = ['well_index', 'well_name', 'pos_name', 'position', 'well', 'status', 't0', 'class','cell_type','concentration', 'antibody', 'pharmaceutical_agent','TRACK_ID','position']
+
+		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']))
+
+			for c in self.static_columns:
+				try:
+					group_table[c] = self.data.groupby(['position','TRACK_ID'])[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')
+
+
+		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']):
+				time = group[time_of_interest].values[0]
+				if time==time:
+					time = floor(time) # floor for onset
+				else:
+					continue
+				frames = group['FRAME'].values
+				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]})
+					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)
+			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)
+
 
-		self.static_columns = ['well_index', 'well_name', 'pos_name', 'position', 'well', 'status', 't0', 'class', 'concentration', 'antibody', 'pharmaceutical_agent']
-		for c in self.static_columns:
-			try:
-				group_table[c] = self.data.groupby(['position','TRACK_ID'])[c].apply(lambda x: x.unique()[0])
-			except Exception as e:
-				print(e)
-				pass
 		self.subtable = TableUI(group_table,f"Group by tracks: {self.projection_mode}", plot_mode="static")
 		self.subtable.show()