celldetective 1.3.1__tar.gz → 1.3.3.post1__tar.gz

{celldetective-1.3.1 → celldetective-1.3.3.post1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: celldetective
-Version: 1.3.1
+Version: 1.3.3.post1
 Summary: description
 Home-page: http://github.com/remyeltorro/celldetective
 Author: Rémy Torro
@@ -172,20 +172,20 @@ For more information about how to get started, please check the [documentation](
 # How to cite?
 
 If you use this software in your research, please cite the
-[Celldetective](https://www.biorxiv.org/content/10.1101/2024.03.15.585250v1)
+[Celldetective](https://www.biorxiv.org/content/10.1101/2024.03.15.585250v3)
 paper (currently preprint):
 
 ``` raw
 @article {Torro2024.03.15.585250,
-    author = {R{\'e}my Torro and Beatriz D{\`\i}az-Bello and Dalia El Arawi and Lorna Ammer and Patrick Chames and Kheya Sengupta and Laurent Limozin},
+    author = {Torro, R{\'e}my and D{\'\i}az-Bello, Beatriz and Arawi, Dalia El and Dervanova, Ksenija and Ammer, Lorna and Dupuy, Florian and Chames, Patrick and Sengupta, Kheya and Limozin, Laurent},
     title = {Celldetective: an AI-enhanced image analysis tool for unraveling dynamic cell interactions},
     elocation-id = {2024.03.15.585250},
     year = {2024},
     doi = {10.1101/2024.03.15.585250},
     publisher = {Cold Spring Harbor Laboratory},
-    abstract = {A current key challenge in bioimaging is the analysis of multimodal and multidimensional data reporting dynamic interactions between diverse cell populations. We developed Celldetective, a software that integrates AI-based segmentation and tracking algorithms and automated signal analysis into a user-friendly graphical interface. It offers complete interactive visualization, annotation, and training capabilities. We demonstrate it by analyzing original experimental data of spreading immune effector cells as well as antibody-dependent cell cytotoxicity events using multimodal fluorescence microscopy.Competing Interest StatementThe authors have declared no competing interest.},
-    URL = {https://www.biorxiv.org/content/early/2024/03/17/2024.03.15.585250},
-    eprint = {https://www.biorxiv.org/content/early/2024/03/17/2024.03.15.585250.full.pdf},
+    abstract = {A current challenge in bioimaging for immunology and immunotherapy research lies in analyzing multimodal and multidimensional data that capture dynamic interactions between diverse cell populations. Here, we introduce Celldetective, an open-source Python-based software designed for high-performance, end-to-end analysis of image-based in vitro immune and immunotherapy assays. Purpose-built for multicondition, 2D multichannel time-lapse microscopy of mixed cell populations, Celldetective is optimized for the needs of immunology assays. The software seamlessly integrates AI-based segmentation, Bayesian tracking, and automated single-cell event detection, all within an intuitive graphical interface that supports interactive visualization, annotation, and training capabilities. We demonstrate its utility with original data on immune effector cell interactions with an activating surface, mediated by bispecific antibodies, and further showcase its potential for analyzing extensive sets of pairwise interactions in antibody-dependent cell cytotoxicity events.Competing Interest StatementThe authors have declared no competing interest.},
+    URL = {https://www.biorxiv.org/content/early/2024/11/13/2024.03.15.585250},
+    eprint = {https://www.biorxiv.org/content/early/2024/11/13/2024.03.15.585250.full.pdf},
     journal = {bioRxiv}
 }
 ```

{celldetective-1.3.1 → celldetective-1.3.3.post1}/README.md

@@ -128,20 +128,20 @@ For more information about how to get started, please check the [documentation](
 # How to cite?
 
 If you use this software in your research, please cite the
-[Celldetective](https://www.biorxiv.org/content/10.1101/2024.03.15.585250v1)
+[Celldetective](https://www.biorxiv.org/content/10.1101/2024.03.15.585250v3)
 paper (currently preprint):
 
 ``` raw
 @article {Torro2024.03.15.585250,
-    author = {R{\'e}my Torro and Beatriz D{\`\i}az-Bello and Dalia El Arawi and Lorna Ammer and Patrick Chames and Kheya Sengupta and Laurent Limozin},
+    author = {Torro, R{\'e}my and D{\'\i}az-Bello, Beatriz and Arawi, Dalia El and Dervanova, Ksenija and Ammer, Lorna and Dupuy, Florian and Chames, Patrick and Sengupta, Kheya and Limozin, Laurent},
     title = {Celldetective: an AI-enhanced image analysis tool for unraveling dynamic cell interactions},
     elocation-id = {2024.03.15.585250},
     year = {2024},
     doi = {10.1101/2024.03.15.585250},
     publisher = {Cold Spring Harbor Laboratory},
-    abstract = {A current key challenge in bioimaging is the analysis of multimodal and multidimensional data reporting dynamic interactions between diverse cell populations. We developed Celldetective, a software that integrates AI-based segmentation and tracking algorithms and automated signal analysis into a user-friendly graphical interface. It offers complete interactive visualization, annotation, and training capabilities. We demonstrate it by analyzing original experimental data of spreading immune effector cells as well as antibody-dependent cell cytotoxicity events using multimodal fluorescence microscopy.Competing Interest StatementThe authors have declared no competing interest.},
-    URL = {https://www.biorxiv.org/content/early/2024/03/17/2024.03.15.585250},
-    eprint = {https://www.biorxiv.org/content/early/2024/03/17/2024.03.15.585250.full.pdf},
+    abstract = {A current challenge in bioimaging for immunology and immunotherapy research lies in analyzing multimodal and multidimensional data that capture dynamic interactions between diverse cell populations. Here, we introduce Celldetective, an open-source Python-based software designed for high-performance, end-to-end analysis of image-based in vitro immune and immunotherapy assays. Purpose-built for multicondition, 2D multichannel time-lapse microscopy of mixed cell populations, Celldetective is optimized for the needs of immunology assays. The software seamlessly integrates AI-based segmentation, Bayesian tracking, and automated single-cell event detection, all within an intuitive graphical interface that supports interactive visualization, annotation, and training capabilities. We demonstrate its utility with original data on immune effector cell interactions with an activating surface, mediated by bispecific antibodies, and further showcase its potential for analyzing extensive sets of pairwise interactions in antibody-dependent cell cytotoxicity events.Competing Interest StatementThe authors have declared no competing interest.},
+    URL = {https://www.biorxiv.org/content/early/2024/11/13/2024.03.15.585250},
+    eprint = {https://www.biorxiv.org/content/early/2024/11/13/2024.03.15.585250.full.pdf},
     journal = {bioRxiv}
 }
 ```

celldetective-1.3.3.post1/celldetective/_version.py

@@ -0,0 +1 @@
+__version__ = "1.3.3.post1"

{celldetective-1.3.1 → celldetective-1.3.3.post1}/celldetective/events.py

@@ -104,6 +104,8 @@ def switch_to_events(classes, event_times, max_times, origin_times=None, left_ce
 							pass
 				elif c==1:
 					delta_t = mt - ot
+					if cut_observation_time is not None:
+						delta_t = cut_observation_time - ot
 					if delta_t>0:
 						events.append(0)
 						survival_times.append(delta_t)

{celldetective-1.3.1 → celldetective-1.3.3.post1}/celldetective/gui/classifier_widget.py

@@ -253,6 +253,24 @@ class ClassifierWidget(QWidget, Styles):
 
 	def update_props_scatter(self, feature_changed=True):
 
+		try:
+			if np.any(self.df[self.features_cb[0].currentText()].to_numpy() <= 0.):
+				if self.ax_props.get_yscale()=='log':
+					self.log_btns[0].click()
+				self.log_btns[0].setEnabled(False)
+			else:
+				self.log_btns[0].setEnabled(True)
+
+			if np.any(self.df[self.features_cb[1].currentText()].to_numpy() <= 0.):
+				if self.ax_props.get_xscale()=='log':
+					self.log_btns[1].click()
+				self.log_btns[1].setEnabled(False)
+			else:
+				self.log_btns[1].setEnabled(True)
+		except Exception as e:
+			#print(e)
+			pass
+
 		class_name = self.class_name
 
 		try:
@@ -279,11 +297,24 @@ class ClassifierWidget(QWidget, Styles):
 				max_x = self.df.dropna(subset=feat_x)[feat_x].max()
 				min_y = self.df.dropna(subset=feat_y)[feat_y].min()
 				max_y = self.df.dropna(subset=feat_y)[feat_y].max()
+				
+				x_padding = (max_x - min_x) * 0.05
+				y_padding = (max_y - min_y) * 0.05
+				if x_padding==0:
+					x_padding = 0.05
+				if y_padding==0:
+					y_padding = 0.05
 
 				if min_x==min_x and max_x==max_x:
-					self.ax_props.set_xlim(min_x, max_x)
+					if self.ax_props.get_xscale()=='linear':
+						self.ax_props.set_xlim(min_x - x_padding, max_x + x_padding)
+					else:
+						self.ax_props.set_xlim(min_x, max_x)
 				if min_y==min_y and max_y==max_y:
-					self.ax_props.set_ylim(min_y, max_y)
+					if self.ax_props.get_yscale()=='linear':
+						self.ax_props.set_ylim(min_y - y_padding, max_y + y_padding)
+					else:
+						self.ax_props.set_ylim(min_y, max_y)						
 			
 				self.propscanvas.canvas.toolbar.update()
 
@@ -452,22 +483,39 @@ class ClassifierWidget(QWidget, Styles):
 
 		if i==1:
 			try:
+				feat_x = self.features_cb[1].currentText()
+				min_x = self.df.dropna(subset=feat_x)[feat_x].min()
+				max_x = self.df.dropna(subset=feat_x)[feat_x].max()
+				x_padding = (max_x - min_x) * 0.05
+				if x_padding==0:
+					x_padding = 0.05
+
 				if self.ax_props.get_xscale()=='linear':
+					self.ax_props.set_xlim(min_x, max_x)
 					self.ax_props.set_xscale('log')
 					self.log_btns[i].setIcon(icon(MDI6.math_log,color="#1565c0"))
 				else:
 					self.ax_props.set_xscale('linear')
+					self.ax_props.set_xlim(min_x - x_padding, max_x + x_padding)
 					self.log_btns[i].setIcon(icon(MDI6.math_log,color="black"))
 			except Exception as e:
 				print(e)
 		elif i==0:
 			try:
+				feat_y = self.features_cb[0].currentText()
+				min_y = self.df.dropna(subset=feat_y)[feat_y].min()
+				max_y = self.df.dropna(subset=feat_y)[feat_y].max()
+				y_padding = (max_y - min_y) * 0.05
+				if y_padding==0:
+					y_padding = 0.05
+
 				if self.ax_props.get_yscale()=='linear':
-					ymin,ymax = self.ax_props.get_ylim()
+					self.ax_props.set_ylim(min_y, max_y)
 					self.ax_props.set_yscale('log')
 					self.log_btns[i].setIcon(icon(MDI6.math_log,color="#1565c0"))
 				else:
 					self.ax_props.set_yscale('linear')
+					self.ax_props.set_ylim(min_y - y_padding, max_y + y_padding)
 					self.log_btns[i].setIcon(icon(MDI6.math_log,color="black"))
 			except Exception as e:
 				print(e)

{celldetective-1.3.1 → celldetective-1.3.3.post1}/celldetective/gui/control_panel.py

@@ -181,7 +181,13 @@ class ControlPanel(QMainWindow, Styles):
 		exp_hbox = QHBoxLayout()
 		exp_hbox.addWidget(experiment_label, 25, alignment=Qt.AlignRight)
 		exp_subhbox = QHBoxLayout()
-		exp_subhbox.addWidget(QLabel(name), 90, alignment=Qt.AlignLeft)
+		if len(name)>thresh:
+			name_cut = name[:thresh - 3]+'...'
+		else:
+			name_cut = name
+		exp_name_lbl = QLabel(name_cut)
+		exp_name_lbl.setToolTip(name)
+		exp_subhbox.addWidget(exp_name_lbl, 90, alignment=Qt.AlignLeft)
 		exp_subhbox.addWidget(self.folder_exp_btn, 5, alignment=Qt.AlignRight)
 		exp_subhbox.addWidget(self.edit_config_button, 5, alignment=Qt.AlignRight)
 		exp_hbox.addLayout(exp_subhbox, 75)
@@ -444,8 +450,8 @@ class ControlPanel(QMainWindow, Styles):
 			self.view_stack_btn.setEnabled(False)
 			self.ProcessEffectors.signal_analysis_action.setEnabled(True)
 			self.ProcessTargets.signal_analysis_action.setEnabled(True)
-
-			self.delete_tracks_btn.hide()
+			if hasattr(self,'delete_tracks_btn'):
+				self.delete_tracks_btn.hide()
 			self.ProcessTargets.delete_tracks_btn.hide()
 			self.ProcessEffectors.delete_tracks_btn.hide()
 		else:

{celldetective-1.3.1 → celldetective-1.3.3.post1}/celldetective/gui/generic_signal_plot.py

@@ -5,7 +5,11 @@ from PyQt5.QtCore import Qt, QSize
 from PyQt5.QtGui import QDoubleValidator
 
 from celldetective.gui.gui_utils import center_window, FigureCanvas, ExportPlotBtn
+from celldetective.gui.tableUI import TableUI
+from celldetective.io import collect_experiment_metadata
+
 from superqt.fonticon import icon
+from superqt import QLabeledSlider
 from fonticon_mdi6 import MDI6
 import numpy as np
 import json
@@ -16,7 +20,9 @@ from glob import glob
 from matplotlib.cm import tab10
 from celldetective.gui import Styles
 import matplotlib.cm as mcm
+import pandas as pd
 
+from lifelines.utils import qth_survival_times
 
 class GenericSignalPlotWidget(QWidget, Styles):
 
@@ -136,6 +142,14 @@ class GenericSignalPlotWidget(QWidget, Styles):
 		plot_buttons_hbox.addWidget(self.export_btn, 5, alignment=Qt.AlignRight)
 		self.layout.addLayout(plot_buttons_hbox)
 
+		self.export_tabular_btn = QPushButton('')
+		self.export_tabular_btn.setIcon(icon(MDI6.table,color="black"))
+		self.export_tabular_btn.setStyleSheet(self.button_select_all)
+		self.export_tabular_btn.setToolTip('Tabulate survival values.')
+		self.export_tabular_btn.setIconSize(QSize(20, 20))
+		plot_buttons_hbox.addWidget(self.export_tabular_btn, 5, alignment=Qt.AlignRight)
+		self.export_tabular_btn.hide()
+
 		self.ax.set_prop_cycle('color',[self.cmap(i) for i in np.linspace(0, 1, len(self.parent_window.well_indices))])
 
 		self.fig.set_facecolor('none')  # or 'None'
@@ -671,7 +685,9 @@ class SurvivalPlotWidget(GenericSignalPlotWidget):
 		self.class_selection_widget.hide()
 		self.rescale_widget.hide()
 		self.cell_lines_alpha_wdg.hide()
-		
+		self.export_tabular_btn.show()
+		self.export_tabular_btn.clicked.connect(self.set_table_options)
+
 	def switch_to_log(self):
 
 		"""
@@ -790,4 +806,147 @@ class SurvivalPlotWidget(GenericSignalPlotWidget):
 		
 		# Plot a signal
 		if line==line:
-			line.plot_survival_function(ci_show=ci_option, ax=self.ax, legend=legend, color=color, label=label, xlabel='timeline [min]')
+			line.plot_survival_function(ci_show=ci_option, ax=self.ax, legend=legend, color=color, label=label, xlabel='timeline [min]')
+
+	def set_table_options(self):
+
+		self.config_table_wg = QWidget()
+		self.config_table_wg.setMinimumWidth(480)
+		self.config_table_wg.setWindowTitle('Survival data')
+		
+		layout = QVBoxLayout()
+		self.config_table_wg.setLayout(layout)
+
+		self.all_values_rb = QRadioButton('tabulate all values')
+		self.single_timepoint_rb = QRadioButton('survival at single timepoint [min]: ')
+		self.ec_rb = QRadioButton(r'EC N% survival: ')
+		self.all_values_rb.toggled.connect(self.activate_sliders)
+		self.single_timepoint_rb.toggled.connect(self.activate_sliders)
+
+		self.single_timepoint_slider = QLabeledSlider()
+		self.single_timepoint_slider.setRange(0, int(self.df['FRAME'].max()*self.parent_window.FrameToMin))
+		self.single_timepoint_slider.setValue(int(self.df['FRAME'].max()*self.parent_window.FrameToMin))
+
+		self.ec_slider = QLabeledSlider()
+		self.ec_slider.setRange(0, 100)
+		self.ec_slider.setValue(50)
+
+		self.ec_rb.toggled.connect(self.activate_sliders)
+		self.all_values_rb.click()
+
+		self.set_btn = QPushButton('Set')
+		self.set_btn.setStyleSheet(self.button_style_sheet)
+		self.set_btn.clicked.connect(self.assemble_survival_data)
+
+		layout.addWidget(self.all_values_rb)
+
+		single_tp_layout = QHBoxLayout()
+		single_tp_layout.addWidget(self.single_timepoint_rb, 33)
+		single_tp_layout.addWidget(self.single_timepoint_slider, 66)
+		layout.addLayout(single_tp_layout)
+
+		ec_layout = QHBoxLayout()
+		ec_layout.addWidget(self.ec_rb, 33)
+		ec_layout.addWidget(self.ec_slider, 66)
+		layout.addLayout(ec_layout)
+
+		layout.addWidget(self.set_btn)
+		center_window(self.config_table_wg)
+		self.config_table_wg.show()
+
+	def activate_sliders(self):
+		if self.all_values_rb.isChecked():
+			self.single_timepoint_slider.setEnabled(False)
+			self.ec_slider.setEnabled(False)
+		elif self.single_timepoint_rb.isChecked():
+			self.single_timepoint_slider.setEnabled(True)
+			self.ec_slider.setEnabled(False)
+		elif self.ec_rb.isChecked():
+			self.ec_slider.setEnabled(True)
+			self.single_timepoint_slider.setEnabled(False)
+
+	def assemble_survival_data(self):
+
+		if self.plot_options[0].isChecked():
+			data = self.df_well_info
+			groupby = ['well_path']
+		if self.plot_options[1].isChecked():
+			data = self.df_pos_info
+			groupby = ['pos_path']
+		if self.plot_options[2].isChecked():
+			print('Not implemented yet... Please select "well" or "position" as grouping...')
+			return None	
+
+		if self.all_values_rb.isChecked():
+
+			survival_table = []
+			tid=0
+			for name,group in data.groupby(groupby):
+				print(name)
+				if groupby[0]=="pos_path":
+					metadata = collect_experiment_metadata(pos_path=name[0])
+				elif groupby[0]=="well_path":
+					metadata = collect_experiment_metadata(well_path=name[0])					
+				ks_estimator = group['survival_fit'].values[0]
+				if ks_estimator!=ks_estimator:
+					continue
+				timeline = list(ks_estimator.survival_function_.index)
+				survival = ks_estimator.survival_function_['KM_estimate'].values
+				lower_error = ks_estimator.confidence_interval_['KM_estimate_lower_0.95'].values
+				upper_error = ks_estimator.confidence_interval_['KM_estimate_upper_0.95'].values
+				for k in range(len(timeline)):
+					dico = metadata.copy()
+					dico.update({'TRACK_ID': tid,'FRAME': int(timeline[k] / self.parent_window.FrameToMin),'timeline': timeline[k], 'survival': survival[k], "event_fraction": 1-survival[k], 'KM_estimate_lower_0.95': lower_error[k], 'KM_estimate_upper_0.95': upper_error[k]})
+					survival_table.append(dico)
+				tid+=1
+			
+			survival_table = pd.DataFrame(survival_table)
+			self.table = TableUI(survival_table, f"Survival data", plot_mode="plot_track_signals")
+			self.table.show()		
+
+		elif self.single_timepoint_rb.isChecked():
+
+			survival_table = []
+			tid=0
+			for name,group in data.groupby(groupby):
+				print(name)
+				if groupby[0]=="pos_path":
+					metadata = collect_experiment_metadata(pos_path=name[0])
+				elif groupby[0]=="well_path":
+					metadata = collect_experiment_metadata(well_path=name[0])					
+				ks_estimator = group['survival_fit'].values[0]
+				if ks_estimator!=ks_estimator:
+					continue
+				survival = ks_estimator.survival_function_at_times(self.single_timepoint_slider.value()).values[0]
+				dico = metadata.copy()
+				dico.update({'timepoint': self.single_timepoint_slider.value(), 'survival': survival, 'event_fraction': 1 - survival})
+				survival_table.append(dico)
+				tid+=1
+		
+			survival_table = pd.DataFrame(survival_table)
+			self.table = TableUI(survival_table, f"Survival data", plot_mode="static")
+			self.table.show()
+
+		elif self.ec_rb.isChecked():
+			
+			survival_table = []
+			tid=0
+			for name,group in data.groupby(groupby):
+				print(name)
+				if groupby[0]=="pos_path":
+					metadata = collect_experiment_metadata(pos_path=name[0])
+				elif groupby[0]=="well_path":
+					metadata = collect_experiment_metadata(well_path=name[0])					
+				ks_estimator = group['survival_fit'].values[0]
+				if ks_estimator!=ks_estimator:
+					continue
+				survival = ks_estimator.survival_function_
+				ecN = qth_survival_times(float(self.ec_slider.value())/100.0, survival)
+				dico = metadata.copy()
+				dico.update({"qth": int(self.ec_slider.value()), f'EC{int(self.ec_slider.value())}% [min]': ecN})
+				survival_table.append(dico)
+				tid+=1
+		
+			survival_table = pd.DataFrame(survival_table)
+			self.table = TableUI(survival_table, f"Survival data", plot_mode="static")
+			self.table.show()

{celldetective-1.3.1 → celldetective-1.3.3.post1}/celldetective/gui/gui_utils.py

@@ -1,7 +1,7 @@
 import numpy as np
 from PyQt5.QtWidgets import QApplication, QMessageBox, QFrame, QSizePolicy, QWidget, QLineEdit, QListWidget, QVBoxLayout, QComboBox, \
 	QPushButton, QLabel, QHBoxLayout, QCheckBox, QFileDialog
-from PyQt5.QtCore import Qt, QSize
+from PyQt5.QtCore import Qt, QSize, QAbstractTableModel
 from PyQt5.QtGui import QDoubleValidator, QIntValidator
 
 from celldetective.gui import Styles
@@ -16,6 +16,95 @@ from inspect import getmembers, isfunction
 from celldetective.filters import *
 from os import sep
 
+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
+		self.colors = dict()
+
+	def rowCount(self, parent=None):
+		return self._data.shape[0]
+
+	def columnCount(self, parent=None):
+		return self._data.shape[1]
+
+	def data(self, index, role=Qt.DisplayRole):
+		if index.isValid():
+			if role == Qt.DisplayRole:
+				return str(self._data.iloc[index.row(), index.column()])
+			if role == Qt.BackgroundRole:
+				color = self.colors.get((index.row(), index.column()))
+				if color is not None:
+					return color
+		return None
+
+	def headerData(self, rowcol, orientation, role):
+		if orientation == Qt.Horizontal and role == Qt.DisplayRole:
+			return self._data.columns[rowcol]
+		if orientation == Qt.Vertical and role == Qt.DisplayRole:
+			return self._data.index[rowcol]
+		return None
+
+	def change_color(self, row, column, color):
+		ix = self.index(row, column)
+		self.colors[(row, column)] = color
+		self.dataChanged.emit(ix, ix, (Qt.BackgroundRole,))
+
+
+class GenericOpColWidget(QWidget, Styles):
+
+	def __init__(self, parent_window, column=None, title=''):
+
+		super().__init__()
+		
+		self.parent_window = parent_window
+		self.column = column
+		self.title = title
+
+		self.setWindowTitle(self.title)
+		# Create the QComboBox and add some items
+		
+		self.layout = QVBoxLayout(self)
+		self.layout.setContentsMargins(30,30,30,30)
+
+		self.sublayout = QVBoxLayout()
+
+		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)
+		self.sublayout.addLayout(measurement_layout)
+
+		self.layout.addLayout(self.sublayout)
+		
+		self.submit_btn = QPushButton('Compute')
+		self.submit_btn.setStyleSheet(self.button_style_sheet)
+		self.submit_btn.clicked.connect(self.launch_operation)
+		self.layout.addWidget(self.submit_btn, 30)
+
+		self.setAttribute(Qt.WA_DeleteOnClose)		
+		center_window(self)
+
+	def launch_operation(self):
+
+		self.compute()
+		self.parent_window.model = PandasModel(self.parent_window.data)
+		self.parent_window.table_view.setModel(self.parent_window.model)
+		self.close()	
+
+	def compute(self):
+		pass
+
 
 class QuickSliderLayout(QHBoxLayout):
 	

{celldetective-1.3.1 → celldetective-1.3.3.post1}/celldetective/gui/measurement_options.py

@@ -10,7 +10,7 @@ from superqt import QLabeledDoubleSlider
 from superqt.fonticon import icon
 from fonticon_mdi6 import MDI6
 
-from celldetective.gui.thresholds_gui import ThresholdSpot
+#from celldetective.gui.thresholds_gui import ThresholdSpot
 from celldetective.utils import extract_experiment_channels, get_software_location
 from celldetective.io import load_frames, auto_load_number_of_frames
 from celldetective.measure import compute_haralick_features
@@ -26,7 +26,7 @@ from tifffile import imread
 from pathlib import Path
 import gc
 
-from celldetective.gui.viewers import CellEdgeVisualizer
+from celldetective.gui.viewers import CellEdgeVisualizer, SpotDetectionVisualizer
 from celldetective.gui.layouts import ProtocolDesignerLayout, BackgroundFitCorrectionLayout, LocalCorrectionLayout
 from celldetective.gui.gui_utils import ThresholdLineEdit
 from celldetective.gui import Styles
@@ -951,51 +951,54 @@ class ConfigMeasurements(QMainWindow, Styles):
 
 		layout.addWidget(self.threshold_lbl, 4, 0)
 		layout.addWidget(self.threshold_value, 4, 1)
-		self.preview_spot = QPushButton('Preview')
-		self.preview_spot.clicked.connect(self.spot_preview)
-		self.preview_spot.setStyleSheet(self.button_style_sheet_2)
-		layout.addWidget(self.preview_spot, 5, 0, 1, 2)
-		self.spot_channel.setEnabled(False)
-		self.spot_channel_lbl.setEnabled(False)
-		self.diameter_value.setEnabled(False)
-		self.diameter_lbl.setEnabled(False)
-		self.threshold_value.setEnabled(False)
-		self.threshold_lbl.setEnabled(False)
-		self.preview_spot.setEnabled(False)
 
+		self.spot_viewer_btn = QPushButton()
+		self.spot_viewer_btn.clicked.connect(self.spot_preview)
+		self.spot_viewer_btn.setIcon(icon(MDI6.image_check, color="k"))
+		self.spot_viewer_btn.setStyleSheet(self.button_select_all)
+		self.spot_viewer_btn.setToolTip('Set detection parameters visually.')
+		layout.addWidget(self.spot_viewer_btn, 1, 1, 1, 1, alignment=Qt.AlignRight)
+
+		self.spot_detection_widgets = [self.spot_channel, self.spot_channel_lbl, self.diameter_value, self.diameter_lbl, self.threshold_value, self.threshold_lbl, self.spot_viewer_btn]
+		for wg in self.spot_detection_widgets:
+			wg.setEnabled(False)
 
 	def enable_spot_preview(self):
 
 		diam = self.diameter_value.text().replace(',','').replace('.','')
 		thresh = self.threshold_value.text().replace(',','').replace('.','')
 		if diam.isnumeric() and thresh.isnumeric():
-			self.preview_spot.setEnabled(True)
+			self.spot_viewer_btn.setEnabled(True)
 		else:
-			self.preview_spot.setEnabled(False)
+			self.spot_viewer_btn.setEnabled(False)
 
 	def spot_preview(self):
 		self.locate_image()
 		if self.test_frame is not None:
 			self.locate_mask()
 			if self.test_mask is not None:
-				self.spot_visual = ThresholdSpot(current_channel=self.spot_channel.currentIndex(), img=self.test_frame,
-												 mask=self.test_mask, parent_window=self)
+				self.spot_visual = SpotDetectionVisualizer(frame_slider=True,
+														   contrast_slider=True,
+														   cell_type=self.mode,
+														   channel_cb=True,
+														   channel_names = self.channel_names,
+														   stack_path=self.current_stack,
+														   n_channels=len(self.channel_names),
+														   target_channel=self.spot_channel.currentIndex(),
+														   window_title='Detect spots',
+														   parent_channel_cb=self.spot_channel,
+														   parent_diameter_le=self.diameter_value,
+														   parent_threshold_le=self.threshold_value,
+														   PxToUm = 1,)
+				self.spot_visual.show()
+				#self.spot_visual = ThresholdSpot(current_channel=self.spot_channel.currentIndex(), img=self.test_frame,
+				#								 mask=self.test_mask, parent_window=self)
 
 	def enable_spot_detection(self):
-		if self.spot_check.isChecked():
-			self.spot_channel.setEnabled(True)
-			self.spot_channel_lbl.setEnabled(True)
-			self.diameter_value.setEnabled(True)
-			self.diameter_lbl.setEnabled(True)
-			self.threshold_value.setEnabled(True)
-			self.threshold_lbl.setEnabled(True)
-			self.preview_spot.setEnabled(True)
 
+		if self.spot_check.isChecked():
+			for wg in self.spot_detection_widgets:
+				wg.setEnabled(True)
 		else:
-			self.spot_channel.setEnabled(False)
-			self.spot_channel_lbl.setEnabled(False)
-			self.diameter_value.setEnabled(False)
-			self.diameter_lbl.setEnabled(False)
-			self.threshold_value.setEnabled(False)
-			self.threshold_lbl.setEnabled(False)
-			self.preview_spot.setEnabled(False)
+			for wg in self.spot_detection_widgets:
+				wg.setEnabled(False)

{celldetective-1.3.1 → celldetective-1.3.3.post1}/celldetective/gui/plot_signals_ui.py

@@ -96,7 +96,7 @@ class ConfigSignalPlot(QWidget, Styles):
 		main_layout.addWidget(panel_title, alignment=Qt.AlignCenter)
 
 		labels = [QLabel('population: '), QLabel('class: '), QLabel('time of\ninterest: '), QLabel('cmap: ')]
-		self.cb_options = [['targets','effectors'],['class'], ['t0'], []]
+		self.cb_options = [['targets','effectors'],[], [], []]
 		self.cbs = [QComboBox() for i in range(len(labels))]
 		self.cbs[-1] = QColormapComboBox()
 		
@@ -183,6 +183,11 @@ class ConfigSignalPlot(QWidget, Styles):
 			self.auto_close = True
 			return None
 		
+		if 'class' in self.all_columns:
+			class_columns.append("class")
+		if 't0' in self.all_columns:
+			time_columns.append('t0')
+		
 		self.cbs[2].clear()
 		self.cbs[2].addItems(np.unique(self.cb_options[2]+time_columns))
 
@@ -339,7 +344,7 @@ class ConfigSignalPlot(QWidget, Styles):
 
 		for block,movie_group in self.df.groupby(['well','position']):
 
-			well_signal_mean, well_std_mean, timeline_all, matrix_all = mean_signal(movie_group, self.feature_selected, class_col, time_col=time_col, class_value=[0,1], return_matrix=True, forced_max_duration=max_time)
+			well_signal_mean, well_std_mean, timeline_all, matrix_all = mean_signal(movie_group, self.feature_selected, class_col, time_col=time_col, class_value=None, return_matrix=True, forced_max_duration=max_time)
 			well_signal_event, well_std_event, timeline_event, matrix_event = mean_signal(movie_group, self.feature_selected, class_col, time_col=time_col, class_value=[0], return_matrix=True, forced_max_duration=max_time)		
 			well_signal_no_event, well_std_no_event, timeline_no_event, matrix_no_event = mean_signal(movie_group, self.feature_selected, class_col, time_col=time_col, class_value=[1], return_matrix=True, forced_max_duration=max_time)
 			self.mean_plots_timeline = timeline_all
@@ -354,7 +359,7 @@ class ConfigSignalPlot(QWidget, Styles):
 		# Per well
 		for well,well_group in self.df.groupby('well'):
 
-			well_signal_mean, well_std_mean, timeline_all, matrix_all = mean_signal(well_group, self.feature_selected, class_col, time_col=time_col, class_value=[0,1], return_matrix=True, forced_max_duration=max_time)
+			well_signal_mean, well_std_mean, timeline_all, matrix_all = mean_signal(well_group, self.feature_selected, class_col, time_col=time_col, class_value=None, return_matrix=True, forced_max_duration=max_time)
 			well_signal_event, well_std_event, timeline_event, matrix_event = mean_signal(well_group, self.feature_selected, class_col, time_col=time_col, class_value=[0], return_matrix=True, forced_max_duration=max_time)			
 			well_signal_no_event, well_std_no_event, timeline_no_event, matrix_no_event = mean_signal(well_group, self.feature_selected, class_col, time_col=time_col, class_value=[1], return_matrix=True, forced_max_duration=max_time)