celldetective 1.1.1.post1__tar.gz → 1.1.1.post4__tar.gz

{celldetective-1.1.1.post1 → celldetective-1.1.1.post4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: celldetective
-Version: 1.1.1.post1
+Version: 1.1.1.post4
 Summary: description
 Home-page: http://github.com/remyeltorro/celldetective
 Author: Rémy Torro

{celldetective-1.1.1.post1 → celldetective-1.1.1.post4}/celldetective/__main__.py

@@ -108,6 +108,10 @@ class AppInitWindow(QMainWindow):
 		OptionsMenu.addAction(self.MemoryAndThreadsAction)
 		menuBar.addMenu(OptionsMenu)
 
+		PluginsMenu = QMenu("Plugins", self)
+		PluginsMenu.addAction(self.CorrectAnnotationAction)
+		menuBar.addMenu(PluginsMenu)
+
 		helpMenu = QMenu("Help", self)
 		helpMenu.clear()
 		helpMenu.addAction(self.DocumentationAction)
@@ -130,6 +134,8 @@ class AppInitWindow(QMainWindow):
 
 		self.MemoryAndThreadsAction = QAction('Memory & Threads...')
 
+		self.CorrectAnnotationAction = QAction('Correct a segmentation annotation...')
+
 		self.newExpAction = QAction('New', self)
 		self.newExpAction.setShortcut("Ctrl+N")
 		self.newExpAction.setShortcutVisibleInContextMenu(True)
@@ -156,6 +162,7 @@ class AppInitWindow(QMainWindow):
 		self.openModels.triggered.connect(self.open_models_folder)
 		self.AboutAction.triggered.connect(self.open_about_window)
 		self.MemoryAndThreadsAction.triggered.connect(self.set_memory_and_threads)
+		self.CorrectAnnotationAction.triggered.connect(self.correct_seg_annotation)
 
 		self.DocumentationAction.triggered.connect(self.open_documentation)
 
@@ -186,6 +193,15 @@ class AppInitWindow(QMainWindow):
 			for r in self.recentFileActs:
 				r.triggered.connect(lambda checked, item=r: self.load_recent_exp(item.text()))
 
+	def correct_seg_annotation(self):
+		
+		self.filename,_ = QFileDialog.getOpenFileName(self,"Open Image", "/home/", "TIF Files (*.tif)")
+		if self.filename!='':
+			print('Opening ',self.filename,' in napari...')
+			correct_annotation(self.filename)
+		else:
+			return None
+
 	def set_memory_and_threads(self):
 		
 		print('setting memory and threads')
@@ -405,6 +421,7 @@ if __name__ == "__main__":
 	import subprocess
 	import os
 	from celldetective.gui.about import AboutWidget
+	from celldetective.io import correct_annotation
 	import psutil
 	import subprocess
 	import json

{celldetective-1.1.1.post1 → celldetective-1.1.1.post4}/celldetective/gui/classifier_widget.py

@@ -12,6 +12,7 @@ from sklearn.metrics import r2_score
 from scipy.optimize import curve_fit
 from celldetective.gui import Styles
 from math import ceil
+from celldetective.utils import extract_cols_from_query
 
 def step_function(t, t_shift, dt):
 	return 1/(1+np.exp(-(t-t_shift)/dt))
@@ -263,17 +264,23 @@ class ClassifierWidget(QWidget, Styles):
 		self.propscanvas.canvas.draw_idle()
 
 	def apply_property_query(self):
+
 		query = self.property_query_le.text()
 		self.df[self.class_name] = 1
 
-		print(query, self.class_name)
+		cols = extract_cols_from_query(query) 
+		print(cols)
+		cols_in_df = np.all([c in list(self.df.columns) for c in cols], axis=0)
+		print(f'Testing if columns from query are in the dataframe: {cols_in_df}...')
 
 		if query=='':
 			print('empty query')
 		else:
 			try:
-				self.selection = self.df.query(query).index
-				print(self.selection)
+				if cols_in_df:
+					self.selection = self.df.dropna(subset=cols).query(query).index
+				else:
+					self.selection = self.df.query(query).index
 				self.df.loc[self.selection, self.class_name] = 0
 			except Exception as e:
 				print(e)

{celldetective-1.1.1.post1 → celldetective-1.1.1.post4}/celldetective/gui/control_panel.py

@@ -16,6 +16,7 @@ import subprocess
 from celldetective.gui.viewers import StackVisualizer
 from celldetective.utils import extract_experiment_channels
 from celldetective.gui import Styles
+import pandas as pd
 
 class ControlPanel(QMainWindow, Styles):
 
@@ -452,26 +453,32 @@ class ControlPanel(QMainWindow, Styles):
 					self.ProcessEffectors.check_tracking_result_btn.setEnabled(False)
 
 				if os.path.exists(os.sep.join([self.pos,'output','tables','trajectories_effectors.csv'])):
+					cols = pd.read_csv(os.sep.join([self.pos,'output','tables','trajectories_effectors.csv']), nrows=1).columns.tolist()
 					self.ProcessEffectors.check_measurements_btn.setEnabled(True)
-					self.ProcessEffectors.check_signals_btn.setEnabled(True)
+					if 'TRACK_ID' in cols:
+						self.ProcessEffectors.check_signals_btn.setEnabled(True)
 					#self.ProcessEffectors.signal_analysis_action.setEnabled(True)
 					self.ProcessEffectors.view_tab_btn.setEnabled(True)
-
+					self.ProcessEffectors.classify_btn.setEnabled(True)
 				else:
 					self.ProcessEffectors.check_measurements_btn.setEnabled(False)
 					self.ProcessEffectors.check_signals_btn.setEnabled(False)
 					#self.ProcessEffectors.signal_analysis_action.setEnabled(False)
 					self.ProcessEffectors.view_tab_btn.setEnabled(False)
+					self.ProcessEffectors.classify_btn.setEnabled(False)
 
 				if os.path.exists(os.sep.join([self.pos,'output','tables','trajectories_targets.csv'])):
+					cols = pd.read_csv(os.sep.join([self.pos,'output','tables','trajectories_targets.csv']), nrows=1).columns.tolist()
 					self.ProcessTargets.check_measurements_btn.setEnabled(True)
-					self.ProcessTargets.check_signals_btn.setEnabled(True)
+					if 'TRACK_ID' in cols:
+						self.ProcessTargets.check_signals_btn.setEnabled(True)
 					#self.ProcessTargets.signal_analysis_action.setEnabled(True)
 					self.ProcessTargets.view_tab_btn.setEnabled(True)
-
+					self.ProcessTargets.classify_btn.setEnabled(True)
 				else:
 					self.ProcessTargets.check_measurements_btn.setEnabled(False)
 					self.ProcessTargets.check_signals_btn.setEnabled(False)
 					#self.ProcessTargets.signal_analysis_action.setEnabled(False)
 					self.ProcessTargets.view_tab_btn.setEnabled(False)
+					self.ProcessTargets.classify_btn.setEnabled(False)
 

{celldetective-1.1.1.post1 → celldetective-1.1.1.post4}/celldetective/gui/layouts.py

@@ -3,7 +3,7 @@ from celldetective.gui.gui_utils import ThresholdLineEdit
 from PyQt5.QtCore import Qt, QSize
 from PyQt5.QtGui import QIntValidator
 
-from superqt import QLabeledRangeSlider, QLabeledSlider, QLabeledDoubleRangeSlider
+from superqt import QLabeledRangeSlider, QLabeledSlider, QLabeledDoubleRangeSlider, QSearchableComboBox
 
 from superqt.fonticon import icon
 from fonticon_mdi6 import MDI6
@@ -12,6 +12,249 @@ from celldetective.gui.viewers import ThresholdedStackVisualizer, CellEdgeVisual
 from celldetective.gui import Styles
 from celldetective.gui.gui_utils import QuickSliderLayout
 from celldetective.preprocessing import correct_background_model, correct_background_model_free, estimate_background_per_condition
+from functools import partial
+from glob import glob
+import os
+import pandas as pd
+import numpy as np
+
+class ChannelNormGenerator(QVBoxLayout, Styles):
+	
+	"""Generator for list of channels"""
+	
+	def __init__(self, parent_window=None, init_n_channels=4, mode='signals', *args):
+		super().__init__(*args)
+
+		self.parent_window = parent_window
+		self.mode = mode
+		self.init_n_channels = init_n_channels
+		
+		if hasattr(self.parent_window.parent_window, 'locate_image'):
+			self.attr_parent = self.parent_window.parent_window
+		elif hasattr(self.parent_window.parent_window.parent_window, 'locate_image'):
+			self.attr_parent = self.parent_window.parent_window.parent_window
+		else:
+			self.attr_parent = self.parent_window.parent_window.parent_window.parent_window
+
+		self.channel_names = self.attr_parent.exp_channels
+		self.setContentsMargins(15,15,15,15)
+		self.generate_widgets()
+		self.add_to_layout()
+
+	def generate_widgets(self):
+		
+		self.channel_cbs = [QSearchableComboBox() for i in range(self.init_n_channels)]
+		self.normalization_mode_btns = [QPushButton('') for i in range(self.init_n_channels)]
+		self.normalization_mode = [True for i in range(self.init_n_channels)]
+		self.normalization_clip_btns = [QPushButton('') for i in range(self.init_n_channels)]
+		self.clip_option = [False for i in range(self.init_n_channels)]
+		
+		for i in range(self.init_n_channels):
+			self.normalization_mode_btns[i].setIcon(icon(MDI6.percent_circle,color="#1565c0"))
+			self.normalization_mode_btns[i].setIconSize(QSize(20, 20))	
+			self.normalization_mode_btns[i].setStyleSheet(self.button_select_all)	
+			self.normalization_mode_btns[i].setToolTip("Switch to absolute normalization values.")
+			self.normalization_mode_btns[i].clicked.connect(partial(self.switch_normalization_mode, i))
+
+			self.normalization_clip_btns[i].setIcon(icon(MDI6.content_cut,color="black"))
+			self.normalization_clip_btns[i].setIconSize(QSize(20, 20))	
+			self.normalization_clip_btns[i].setStyleSheet(self.button_select_all)	
+			self.normalization_clip_btns[i].clicked.connect(partial(self.switch_clipping_mode, i))
+			self.normalization_clip_btns[i].setToolTip('clip')
+
+		self.normalization_min_value_lbl = [QLabel('Min %: ') for i in range(self.init_n_channels)]
+		self.normalization_min_value_le = [QLineEdit('0.1') for i in range(self.init_n_channels)]
+		self.normalization_max_value_lbl = [QLabel('Max %: ') for i in range(self.init_n_channels)]		
+		self.normalization_max_value_le = [QLineEdit('99.99') for i in range(self.init_n_channels)]
+		
+		if self.mode=='signals':
+			tables = glob(self.parent_window.exp_dir+os.sep.join(['W*','*','output','tables',f'trajectories_{self.parent_window.mode}.csv']))
+			all_measurements = []
+			for tab in tables:
+				cols = pd.read_csv(tab, nrows=1).columns.tolist()
+				all_measurements.extend(cols)
+			all_measurements = np.unique(all_measurements)		
+
+		if self.mode=='signals':
+			generic_measurements = ['brightfield_channel', 'live_nuclei_channel', 'dead_nuclei_channel', 
+								 'effector_fluo_channel', 'adhesion_channel', 'fluo_channel_1', 'fluo_channel_2',
+								 "area", "area_bbox","area_convex","area_filled","major_axis_length", 
+								 "minor_axis_length", 
+								"eccentricity",
+								"equivalent_diameter_area",
+								"euler_number",
+								"extent",
+								"feret_diameter_max",
+								"orientation", 
+								"perimeter",
+								"perimeter_crofton",
+								"solidity",
+								"angular_second_moment",
+								"contrast",
+								"correlation",
+								"sum_of_square_variance",
+								"inverse_difference_moment",
+								"sum_average",
+								"sum_variance",
+								"sum_entropy",
+								"entropy",
+								"difference_variance",
+								"difference_entropy",
+								"information_measure_of_correlation_1",
+								"information_measure_of_correlation_2",
+								"maximal_correlation_coefficient",
+								"POSITION_X",
+								"POSITION_Y",
+								]
+		elif self.mode=='channels':
+			generic_measurements = ['brightfield_channel', 'live_nuclei_channel', 'dead_nuclei_channel', 
+								 'effector_fluo_channel', 'adhesion_channel', 'fluo_channel_1', 'fluo_channel_2', 'None']
+
+		if self.mode=='channels':
+			all_measurements = []
+			exp_ch = self.attr_parent.exp_channels
+			for c in exp_ch:
+				all_measurements.append(c)
+
+		self.channel_items = np.unique(generic_measurements + list(all_measurements))
+		self.channel_items = np.insert(self.channel_items, 0, '--')
+
+		self.add_col_btn = QPushButton('Add channel')
+		self.add_col_btn.clicked.connect(self.add_channel)
+		self.add_col_btn.setStyleSheet(self.button_add)
+		self.add_col_btn.setIcon(icon(MDI6.plus,color="black"))
+
+	def add_channel(self):
+
+		self.channel_cbs.append(QSearchableComboBox())
+		self.channel_cbs[-1].addItems(self.channel_items)
+		self.channel_cbs[-1].currentIndexChanged.connect(self.check_valid_channels)
+
+		self.normalization_mode_btns.append(QPushButton(''))
+		self.normalization_mode.append(True)
+		self.normalization_clip_btns.append(QPushButton(''))
+		self.clip_option.append(False)
+
+		self.normalization_mode_btns[-1].setIcon(icon(MDI6.percent_circle,color="#1565c0"))
+		self.normalization_mode_btns[-1].setIconSize(QSize(20, 20))	
+		self.normalization_mode_btns[-1].setStyleSheet(self.button_select_all)	
+		self.normalization_mode_btns[-1].setToolTip("Switch to absolute normalization values.")
+		self.normalization_mode_btns[-1].clicked.connect(partial(self.switch_normalization_mode, len(self.channel_cbs)-1))
+
+		self.normalization_clip_btns[-1].setIcon(icon(MDI6.content_cut,color="black"))
+		self.normalization_clip_btns[-1].setIconSize(QSize(20, 20))	
+		self.normalization_clip_btns[-1].setStyleSheet(self.button_select_all)	
+		self.normalization_clip_btns[-1].clicked.connect(partial(self.switch_clipping_mode, len(self.channel_cbs)-1))
+		self.normalization_clip_btns[-1].setToolTip('clip')
+
+		self.normalization_min_value_lbl.append(QLabel('Min %: '))
+		self.normalization_min_value_le.append(QLineEdit('0.1'))
+		self.normalization_max_value_lbl.append(QLabel('Max %: '))
+		self.normalization_max_value_le.append(QLineEdit('99.99'))
+
+		ch_layout = QHBoxLayout()
+		ch_layout.addWidget(QLabel(f'channel {len(self.channel_cbs)-1}: '), 30)
+		ch_layout.addWidget(self.channel_cbs[-1], 70)
+		self.channels_vb.addLayout(ch_layout)
+
+		channel_norm_options_layout = QHBoxLayout()
+		channel_norm_options_layout.setContentsMargins(130,0,0,0)
+		channel_norm_options_layout.addWidget(self.normalization_min_value_lbl[-1])			
+		channel_norm_options_layout.addWidget(self.normalization_min_value_le[-1])
+		channel_norm_options_layout.addWidget(self.normalization_max_value_lbl[-1])
+		channel_norm_options_layout.addWidget(self.normalization_max_value_le[-1])
+		channel_norm_options_layout.addWidget(self.normalization_clip_btns[-1])
+		channel_norm_options_layout.addWidget(self.normalization_mode_btns[-1])
+		self.channels_vb.addLayout(channel_norm_options_layout)
+
+
+	def add_to_layout(self):
+
+		self.channels_vb = QVBoxLayout()
+		self.channel_option_layouts = []
+		for i in range(len(self.channel_cbs)):
+			
+			ch_layout = QHBoxLayout()
+			ch_layout.addWidget(QLabel(f'channel {i}: '), 30)
+			self.channel_cbs[i].addItems(self.channel_items)
+			self.channel_cbs[i].currentIndexChanged.connect(self.check_valid_channels)
+			ch_layout.addWidget(self.channel_cbs[i], 70)
+			self.channels_vb.addLayout(ch_layout)
+
+			channel_norm_options_layout = QHBoxLayout()
+			channel_norm_options_layout.setContentsMargins(130,0,0,0)
+			channel_norm_options_layout.addWidget(self.normalization_min_value_lbl[i])			
+			channel_norm_options_layout.addWidget(self.normalization_min_value_le[i])
+			channel_norm_options_layout.addWidget(self.normalization_max_value_lbl[i])
+			channel_norm_options_layout.addWidget(self.normalization_max_value_le[i])
+			channel_norm_options_layout.addWidget(self.normalization_clip_btns[i])
+			channel_norm_options_layout.addWidget(self.normalization_mode_btns[i])
+			self.channels_vb.addLayout(channel_norm_options_layout)
+
+		self.addLayout(self.channels_vb)
+
+		add_hbox = QHBoxLayout()
+		add_hbox.addWidget(QLabel(''), 66)
+		add_hbox.addWidget(self.add_col_btn, 33, alignment=Qt.AlignRight)
+		self.addLayout(add_hbox)
+
+	def switch_normalization_mode(self, index):
+
+		"""
+		Use absolute or percentile values for the normalization of each individual channel.
+		
+		"""
+
+		currentNormMode = self.normalization_mode[index]
+		self.normalization_mode[index] = not currentNormMode
+
+		if self.normalization_mode[index]:
+			self.normalization_mode_btns[index].setIcon(icon(MDI6.percent_circle,color="#1565c0"))
+			self.normalization_mode_btns[index].setIconSize(QSize(20, 20))	
+			self.normalization_mode_btns[index].setStyleSheet(self.button_select_all)	
+			self.normalization_mode_btns[index].setToolTip("Switch to absolute normalization values.")
+			self.normalization_min_value_lbl[index].setText('Min %: ')
+			self.normalization_max_value_lbl[index].setText('Max %: ')
+			self.normalization_min_value_le[index].setText('0.1')
+			self.normalization_max_value_le[index].setText('99.99')
+
+		else:
+			self.normalization_mode_btns[index].setIcon(icon(MDI6.percent_circle_outline,color="black"))
+			self.normalization_mode_btns[index].setIconSize(QSize(20, 20))	
+			self.normalization_mode_btns[index].setStyleSheet(self.button_select_all)	
+			self.normalization_mode_btns[index].setToolTip("Switch to percentile normalization values.")
+			self.normalization_min_value_lbl[index].setText('Min: ')
+			self.normalization_min_value_le[index].setText('0')
+			self.normalization_max_value_lbl[index].setText('Max: ')
+			self.normalization_max_value_le[index].setText('1000')
+	
+	def switch_clipping_mode(self, index):
+
+		currentClipMode = self.clip_option[index]
+		self.clip_option[index] = not currentClipMode
+
+		if self.clip_option[index]:
+			self.normalization_clip_btns[index].setIcon(icon(MDI6.content_cut,color="#1565c0"))
+			self.normalization_clip_btns[index].setIconSize(QSize(20, 20))
+			self.normalization_clip_btns[index].setStyleSheet(self.button_select_all)	
+
+		else:
+			self.normalization_clip_btns[index].setIcon(icon(MDI6.content_cut,color="black"))
+			self.normalization_clip_btns[index].setIconSize(QSize(20, 20))		
+			self.normalization_clip_btns[index].setStyleSheet(self.button_select_all)	
+
+	def check_valid_channels(self):
+
+		if np.all([cb.currentText()=='--' for cb in self.channel_cbs]):
+			self.parent_window.submit_btn.setEnabled(False)
+
+		if hasattr(self.parent_window, "spatial_calib_le"):
+			if self.parent_window.spatial_calib_le.text()!='--':
+				self.parent_window.submit_btn.setEnabled(True)
+		else:
+			self.parent_window.submit_btn.setEnabled(True)
+
+
 
 class BackgroundFitCorrectionLayout(QGridLayout, Styles):
 	
@@ -747,10 +990,12 @@ class BackgroundModelFreeCorrectionLayout(QGridLayout, Styles):
 											)
 		bg = bg[0]
 		bg = bg['bg']
-
-		self.viewer = StackVisualizer(
-									  stack=[bg],
-									  window_title='Reconstructed background',
-									  frame_slider = False,
-									 )
-		self.viewer.show()
+		print(bg)
+		if len(bg)>0:
+
+			self.viewer = StackVisualizer(
+										  stack=[bg],
+										  window_title='Reconstructed background',
+										  frame_slider = False,
+										 )
+			self.viewer.show()

{celldetective-1.1.1.post1 → celldetective-1.1.1.post4}/celldetective/gui/neighborhood_options.py

@@ -319,16 +319,16 @@ class ConfigNeighborhoods(QWidget, Styles):
 	def fill_cbs_of_neighbor_population(self):
 
 		population = self.neighbor_population_cb.currentText()
-		class_cols, status_cols, time_cols = self.locate_population_specific_columns(population)
+		class_cols, status_cols, group_cols, time_cols = self.locate_population_specific_columns(population)
 		self.neighbor_population_status_cb.clear()
-		self.neighbor_population_status_cb.addItems(['--','class', 'status']+class_cols+status_cols)
+		self.neighbor_population_status_cb.addItems(['--','class', 'status']+class_cols+status_cols+group_cols)
 
 	def fill_cbs_of_reference_population(self):
 
 		population = self.reference_population_cb.currentText()
-		class_cols, status_cols, time_cols = self.locate_population_specific_columns(population)
+		class_cols, status_cols, group_cols, time_cols = self.locate_population_specific_columns(population)
 		self.reference_population_status_cb.clear()
-		self.reference_population_status_cb.addItems(['--','class', 'status']+class_cols+status_cols)
+		self.reference_population_status_cb.addItems(['--','class', 'status']+class_cols+status_cols+group_cols)
 		self.event_time_cb.addItems(['--', 't0']+time_cols)
 
 	def switch_not_reference(self):
@@ -364,6 +364,7 @@ class ConfigNeighborhoods(QWidget, Styles):
 
 		class_idx = np.array([s.startswith('class_') for s in self.all_columns])
 		status_idx = np.array([s.startswith('status_') for s in self.all_columns])
+		group_idx = np.array([s.startswith('group_') for s in self.all_columns])		
 		time_idx = np.array([s.startswith('t_') for s in self.all_columns])
 
 		if len(class_idx)>0:
@@ -379,12 +380,17 @@ class ConfigNeighborhoods(QWidget, Styles):
 		else:
 			status_columns = []
 
+		if len(group_idx)>0:
+			group_columns = list(self.all_columns[group_idx])
+		else:
+			group_columns = []
+
 		if len(time_idx)>0:
 			time_columns = list(self.all_columns[time_idx])
 		else:
 			time_columns = []
 
-		return class_columns, status_columns, time_columns
+		return class_columns, status_columns, group_columns, time_columns
 
 	def write_instructions(self):