celldetective 1.3.4.post1__py3-none-any.whl → 1.3.6.post1__py3-none-any.whl

celldetective/_version.py

@@ -1 +1 @@
-__version__ = "1.3.4.post1"
+__version__ = "1.3.6.post1"

celldetective/events.py

@@ -143,7 +143,7 @@ def switch_to_events(classes, event_times, max_times, origin_times=None, left_ce
 		survival_times = [s*FrameToMin for s in survival_times]
 	return events, survival_times
 
-def compute_survival(df, class_of_interest, t_event, t_reference=None, FrameToMin=1, cut_observation_time=None):
+def compute_survival(df, class_of_interest, t_event, t_reference=None, FrameToMin=1, cut_observation_time=None, pairs=False):
 
 	"""
 	Computes survival analysis for a specific class of interest within a dataset, returning a fitted Kaplan-Meier 
@@ -190,9 +190,14 @@ def compute_survival(df, class_of_interest, t_event, t_reference=None, FrameToMi
 	assert t_event in cols,"The event time cannot be found in the dataframe..."
 	left_censored = False
 
-	classes = df.groupby(['position','TRACK_ID'])[class_of_interest].min().values
-	event_times = df.groupby(['position','TRACK_ID'])[t_event].min().values
-	max_times = df.groupby(['position','TRACK_ID'])['FRAME'].max().values
+	if not pairs:
+		groupby_cols = ['position','TRACK_ID']
+	else:
+		groupby_cols = ['position','REFERENCE_ID','NEIGHBOR_ID']
+
+	classes = df.groupby(groupby_cols)[class_of_interest].min().values
+	event_times = df.groupby(groupby_cols)[t_event].min().values
+	max_times = df.groupby(groupby_cols)['FRAME'].max().values
 
 	if t_reference=="0" or t_reference==0:
 		t_reference = None
@@ -202,7 +207,7 @@ def compute_survival(df, class_of_interest, t_event, t_reference=None, FrameToMi
 	if t_reference is not None:
 		left_censored = True
 		assert t_reference in cols,"The reference time cannot be found in the dataframe..."
-		first_detections = df.groupby(['position','TRACK_ID'])[t_reference].max().values
+		first_detections = df.groupby(groupby_cols)[t_reference].max().values
 	
 	events, survival_times = switch_to_events(classes, event_times, max_times, origin_times=first_detections, left_censored=left_censored, FrameToMin=FrameToMin, cut_observation_time=cut_observation_time)
 	ks = KaplanMeierFitter()

celldetective/filters.py

@@ -127,3 +127,14 @@ def tophat_filter(img, size, connectivity=4, interpolate=True, *kwargs):
 	structure = snd.generate_binary_structure(rank=2, connectivity=connectivity)
 	img = snd.white_tophat(img.astype(float), structure=structure, size=size, *kwargs)
 	return img
+
+def invert_filter(img, value=65535, *kwargs):
+	
+	img = img.astype(float)
+
+	image_fill = np.zeros_like(img)
+	image_fill[:,:] = value
+
+	inverted = np.subtract(image_fill, img, where=img==img)
+	return inverted
+

celldetective/gui/btrack_options.py

@@ -1,5 +1,7 @@
-from PyQt5.QtWidgets import QMainWindow, QApplication, QMessageBox, QScrollArea, QComboBox, QFrame, QCheckBox, QFileDialog, QGridLayout, QTextEdit, QLineEdit, QVBoxLayout, QWidget, QLabel, QHBoxLayout, QPushButton
+from PyQt5.QtWidgets import QRadioButton, QButtonGroup, QMainWindow, QApplication, QMessageBox, QScrollArea, QComboBox, QFrame, QCheckBox, QFileDialog, QGridLayout, QTextEdit, QLineEdit, QVBoxLayout, QWidget, QLabel, QHBoxLayout, QPushButton
 from PyQt5.QtCore import Qt, QSize
+from PyQt5.QtGui import QDoubleValidator
+
 from celldetective.gui.gui_utils import center_window, FeatureChoice, ListWidget, QHSeperationLine, FigureCanvas, help_generic
 from superqt import QLabeledDoubleSlider,QLabeledSlider
 from superqt.fonticon import icon
@@ -30,6 +32,8 @@ class ConfigTracking(QMainWindow, Styles):
 		self.setWindowTitle("Configure tracking")
 		self.mode = self.parent_window.mode
 		self.exp_dir = self.parent_window.exp_dir
+		self.floatValidator = QDoubleValidator()
+
 		if self.mode=="targets":
 			self.config_name = os.sep.join(["configs", "btrack_config_targets.json"])
 			self.track_instructions_write_path = self.parent_window.exp_dir + os.sep.join(["configs","tracking_instructions_targets.json"])
@@ -68,9 +72,25 @@ class ConfigTracking(QMainWindow, Styles):
 		main_layout.setContentsMargins(30,30,30,30)
 
 		# First collapsable Frame CONFIG
+
+		self.btrack_option = QRadioButton('bTrack')
+		self.btrack_option.setChecked(True)
+
+		self.trackpy_option = QRadioButton('trackpy')
+		self.tracker_option_group = QButtonGroup()
+		self.tracker_option_group.addButton(self.btrack_option)
+		self.tracker_option_group.addButton(self.trackpy_option)
+
 		self.config_frame = QFrame()
 		self.config_frame.setFrameStyle(QFrame.StyledPanel | QFrame.Raised)
 		self.populate_config_frame()
+
+		tracker_hbox = QHBoxLayout()
+		tracker_hbox.setContentsMargins(15,15,15,15)
+		tracker_hbox.addWidget(self.btrack_option, 50, alignment=Qt.AlignCenter)
+		tracker_hbox.addWidget(self.trackpy_option, 50, alignment=Qt.AlignCenter)
+		main_layout.addLayout(tracker_hbox)
+
 		main_layout.addWidget(self.config_frame)
 
 		# Second collapsable frame FEATURES
@@ -79,6 +99,12 @@ class ConfigTracking(QMainWindow, Styles):
 		self.populate_features_frame()
 		main_layout.addWidget(self.features_frame)
 
+		self.config_trackpy_frame = QFrame()
+		self.config_trackpy_frame.setFrameStyle(QFrame.StyledPanel | QFrame.Raised)
+		self.populate_config_trackpy_frame()
+		main_layout.addWidget(self.config_trackpy_frame)
+		self.config_trackpy_frame.hide()
+
 		# Third collapsable frame POST-PROCESSING
 		self.post_proc_frame = QFrame()
 		self.post_proc_frame.setFrameStyle(QFrame.StyledPanel | QFrame.Raised)
@@ -102,9 +128,27 @@ class ConfigTracking(QMainWindow, Styles):
 		self.setCentralWidget(self.scroll_area)
 		self.show()
 
+		self.btrack_option.toggled.connect(self.show_tracking_options)
+		self.trackpy_option.toggled.connect(self.show_tracking_options)
+
 		QApplication.processEvents()
 		self.adjustScrollArea()
 
+	def show_tracking_options(self):
+
+		if self.btrack_option.isChecked():
+			self.config_frame.show()
+			self.features_frame.show()
+			self.config_trackpy_frame.hide()
+			#self.scroll_area.setMinimumHeight(min(int(930), int(0.9*self.screen_height)))
+			#self.adjustSize()
+		else:
+			self.config_frame.hide()
+			self.features_frame.hide()
+			self.config_trackpy_frame.show()
+			#self.scroll_area.setMinimumHeight(self.minimum_height)
+			#self.adjustSize()
+
 
 	def populate_post_proc_frame(self):
 
@@ -539,6 +583,29 @@ class ConfigTracking(QMainWindow, Styles):
 		self.collapse_config_btn.clicked.connect(self.collapse_config_advanced)
 		#self.ContentsConfig.hide()
 
+	def populate_config_trackpy_frame(self):
+
+		grid = QGridLayout(self.config_trackpy_frame)
+		panel_title = QLabel(f"CONFIGURATION")
+		panel_title.setStyleSheet("""
+			font-weight: bold;
+			padding: 0px;
+			""")
+
+		grid.addWidget(panel_title, 0, 0, 1, 4, alignment=Qt.AlignCenter)
+
+		self.collapse_config_trackpy_btn = QPushButton()
+		self.collapse_config_trackpy_btn.setIcon(icon(MDI6.chevron_down,color="black"))
+		self.collapse_config_trackpy_btn.setIconSize(QSize(20, 20))
+		self.collapse_config_trackpy_btn.setStyleSheet(self.button_select_all)
+		grid.addWidget(self.collapse_config_trackpy_btn, 0, 0, 1, 4, alignment=Qt.AlignRight)
+		self.generate_config_trackpy_panel_contents()
+		grid.addWidget(self.ContentsConfigTrackpy, 1, 0, 1, 4, alignment=Qt.AlignTop)
+		self.collapse_config_trackpy_btn.clicked.connect(lambda: self.ContentsConfigTrackpy.setHidden(not self.ContentsConfigTrackpy.isHidden()))
+		self.collapse_config_trackpy_btn.clicked.connect(self.collapse_config_trackpy_advanced)
+		#self.ContentsConfig.hide()
+
+
 	def collapse_config_advanced(self):
 
 		"""
@@ -561,6 +628,56 @@ class ConfigTracking(QMainWindow, Styles):
 			self.collapse_config_btn.setIconSize(QSize(20, 20))
 			self.scroll_area.setMinimumHeight(min(int(930), int(0.9*self.screen_height)))
 
+	def collapse_config_trackpy_advanced(self):
+
+		"""
+		Switch the chevron icon and adjust the size for the CONFIG frame.
+		"""
+
+
+		post_open = not self.ContentsPostProc.isHidden()
+		is_open = np.array([post_open])
+
+		if self.ContentsConfigTrackpy.isHidden():
+			self.collapse_config_trackpy_btn.setIcon(icon(MDI6.chevron_down,color="black"))
+			self.collapse_config_trackpy_btn.setIconSize(QSize(20, 20))
+			if len(is_open[is_open])==0:
+				self.scroll_area.setMinimumHeight(int(self.minimum_height))
+				self.adjustSize()
+		else:
+			self.collapse_config_trackpy_btn.setIcon(icon(MDI6.chevron_up,color="black"))
+			self.collapse_config_trackpy_btn.setIconSize(QSize(20, 20))
+			self.scroll_area.setMinimumHeight(min(int(930), int(0.9*self.screen_height)))
+
+
+	def generate_config_trackpy_panel_contents(self):
+
+		self.ContentsConfigTrackpy = QFrame()
+		layout = QVBoxLayout(self.ContentsConfigTrackpy)
+		layout.setContentsMargins(0,0,0,0)
+
+		sr_layout = QHBoxLayout()
+		self.search_range_lbl = QLabel("search range [px]: ")
+		self.search_range_le = QLineEdit('30')
+		self.search_range_le.setPlaceholderText('search distance in pixels')
+		self.search_range_le.setValidator(self.floatValidator)
+		sr_layout.addWidget(self.search_range_lbl, 30)
+		sr_layout.addWidget(self.search_range_le, 70)
+		layout.addLayout(sr_layout)
+
+		memory_layout = QHBoxLayout()
+		self.memory_lbl = QLabel("memory [# frames]: ")
+		self.memory_slider = QLabeledSlider()
+		self.memory_slider.setSingleStep(1)
+		self.memory_slider.setTickInterval(1)
+		self.memory_slider.setSingleStep(1)
+		self.memory_slider.setOrientation(1)
+		self.memory_slider.setRange(0,self.parent_window.parent_window.len_movie)
+		self.memory_slider.setValue(0)
+		memory_layout.addWidget(self.memory_lbl, 30)
+		memory_layout.addWidget(self.memory_slider, 70)
+		layout.addLayout(memory_layout)
+
 
 	def generate_config_panel_contents(self):
 		
@@ -741,7 +858,23 @@ class ConfigTracking(QMainWindow, Styles):
 		"""
 
 		print('Writing instructions...')
+		
+		if self.btrack_option.isChecked():
+			btrack_option = True
+		else:
+			btrack_option = False
+
+		# Fetch trackpky params
+		if not btrack_option:
+			search_range = int(self.search_range_le.text().replace(',','.'))
+			memory = self.memory_slider.value()
+		else:
+			search_range = None
+			memory = None	
+
 		tracking_options = {'btrack_config_path': self.config_path}
+		tracking_options.update({'btrack_option': btrack_option, 'search_range': search_range, 'memory': memory})
+
 		if not self.features_ticked:
 			features = None
 			masked_channels = None
@@ -850,6 +983,23 @@ class ConfigTracking(QMainWindow, Styles):
 					self.ContentsFeatures.hide()
 					self.uncheck_features()
 
+				btrack_option = True
+				if 'btrack_option' in tracking_instructions:
+					btrack_option = tracking_instructions['btrack_option']
+				if btrack_option:
+					self.btrack_option.click()
+				else:
+					self.trackpy_option.click()
+
+				if 'search_range' in tracking_instructions:
+					search_range = tracking_instructions['search_range']
+					if search_range is not None:
+						self.search_range_le.setText(str(search_range).replace('.',','))				
+				if 'memory' in tracking_instructions:
+					memory = tracking_instructions['memory']
+					if memory is not None:
+						self.memory_slider.setValue(memory)
+
 				# Uncheck channels that are masked
 				mask_channels = tracking_instructions['mask_channels']
 				if (mask_channels is not None) and len(mask_channels)>0:

celldetective/gui/classifier_widget.py

@@ -1,5 +1,5 @@
 from PyQt5.QtWidgets import QWidget, QLineEdit, QMessageBox, QHBoxLayout, QVBoxLayout, QPushButton, QLabel, \
-	QCheckBox, QRadioButton, QButtonGroup
+	QCheckBox, QRadioButton, QButtonGroup, QComboBox
 from PyQt5.QtCore import Qt, QSize
 from superqt import QLabeledSlider,QLabeledDoubleSlider, QSearchableComboBox
 from superqt.fonticon import icon
@@ -95,7 +95,6 @@ class ClassifierWidget(QWidget, Styles):
 		layout.addLayout(slider_alpha_hbox)
 
 
-
 		self.features_cb = [QSearchableComboBox() for i in range(2)]
 		self.log_btns = [QPushButton() for i in range(2)]
 
@@ -129,7 +128,6 @@ class ClassifierWidget(QWidget, Styles):
 		layout.addLayout(hbox_classify)
 
 		self.time_corr = QCheckBox('Time correlated')
-		self.time_corr.toggled.connect(self.activate_time_corr_options)
 		if "TRACK_ID" in self.df.columns:
 			self.time_corr.setEnabled(True)
 		else:
@@ -150,19 +148,24 @@ class ClassifierWidget(QWidget, Styles):
 
 		self.irreversible_event_btn = QRadioButton('irreversible event')
 		self.unique_state_btn = QRadioButton('unique state')
+		self.transient_event_btn = QRadioButton('transient event')
 		time_corr_btn_group = QButtonGroup()
 		self.unique_state_btn.click()
-		self.time_corr_options = [self.irreversible_event_btn, self.unique_state_btn]
-
-		for btn in self.time_corr_options:
-			time_corr_btn_group.addButton(btn)
-			btn.setEnabled(False)
 
 		time_corr_layout = QHBoxLayout()
-		time_corr_layout.addWidget(self.unique_state_btn, 50, alignment=Qt.AlignCenter)
-		time_corr_layout.addWidget(self.irreversible_event_btn, 50,alignment=Qt.AlignCenter)
+		time_corr_layout.addWidget(self.unique_state_btn, 33, alignment=Qt.AlignCenter)
+		time_corr_layout.addWidget(self.irreversible_event_btn, 33,alignment=Qt.AlignCenter)
+		time_corr_layout.addWidget(self.transient_event_btn, 33,alignment=Qt.AlignCenter)
 		layout.addLayout(time_corr_layout)
 
+		self.prereq_event_check = QCheckBox('prerequisite event:')
+		self.prereq_event_check.toggled.connect(self.activate_prereq_cb)
+		self.prereq_event_cb = QComboBox()
+		event_cols = ['--'] + [c.replace('t_','') for c in self.cols if c.startswith('t_')]
+		self.prereq_event_cb.addItems(event_cols)
+		self.prereq_event_check.setEnabled(False)
+		self.prereq_event_cb.setEnabled(False)
+
 		self.r2_slider = QLabeledDoubleSlider()
 		self.r2_slider.setValue(0.75)
 		self.r2_slider.setRange(0,1)
@@ -170,18 +173,34 @@ class ClassifierWidget(QWidget, Styles):
 		self.r2_slider.setOrientation(1)
 		self.r2_label = QLabel('R2 tolerance:')
 		self.r2_label.setToolTip('Minimum R2 between the fit sigmoid and the binary response to the filters to accept the event.')
+
 		r2_threshold_layout = QHBoxLayout()
-		r2_threshold_layout.addWidget(QLabel(''), 50)
-		r2_threshold_layout.addWidget(self.r2_label, 15)
-		r2_threshold_layout.addWidget(self.r2_slider, 35)
-		layout.addLayout(r2_threshold_layout)	
+		r2_threshold_layout.addWidget(QLabel(''), 33)
+		r2_threshold_layout.addWidget(self.r2_label, 13)
+		r2_threshold_layout.addWidget(self.r2_slider, 20)
+		r2_threshold_layout.addWidget(QLabel(''), 33)
+
+		layout.addLayout(r2_threshold_layout)
 		
+		self.time_corr_options = [self.irreversible_event_btn, self.unique_state_btn, self.prereq_event_check, self.prereq_event_cb, self.transient_event_btn]
+		for btn in [self.irreversible_event_btn, self.unique_state_btn, self.transient_event_btn]:
+			time_corr_btn_group.addButton(btn)
+			btn.setEnabled(False)
+		self.time_corr.toggled.connect(self.activate_time_corr_options)
+
 		self.irreversible_event_btn.clicked.connect(self.activate_r2)
 		self.unique_state_btn.clicked.connect(self.activate_r2)
+		self.transient_event_btn.clicked.connect(self.activate_r2)
 
 		for wg in [self.r2_slider, self.r2_label]:
 			wg.setEnabled(False)
 
+		prereq_layout = QHBoxLayout()
+		prereq_layout.setContentsMargins(30,0,0,0)
+		prereq_layout.addWidget(self.prereq_event_check, 20)
+		prereq_layout.addWidget(self.prereq_event_cb, 80)
+		layout.addLayout(prereq_layout)
+
 		layout.addWidget(QLabel())
 
 		self.submit_btn = QPushButton('apply')
@@ -193,6 +212,12 @@ class ClassifierWidget(QWidget, Styles):
 		self.frame_slider.valueChanged.connect(self.set_frame)
 		self.alpha_slider.valueChanged.connect(self.set_transparency)
 
+	def activate_prereq_cb(self):
+		if self.prereq_event_check.isChecked():
+			self.prereq_event_cb.setEnabled(True)
+		else:
+			self.prereq_event_cb.setEnabled(False)
+
 	def activate_submit_btn(self):
 
 		if self.property_query_le.text()=='':
@@ -416,7 +441,11 @@ class ClassifierWidget(QWidget, Styles):
 			self.df = self.df.drop(list(set(name_map.values()) & set(self.df.columns)), axis=1).rename(columns=name_map)
 			self.df.reset_index(inplace=True, drop=True)
 
-			self.df = interpret_track_classification(self.df, self.class_name_user, irreversible_event=self.irreversible_event_btn.isChecked(), unique_state=self.unique_state_btn.isChecked(), r2_threshold=self.r2_slider.value())
+			pre_event = None
+			if self.prereq_event_check.isChecked() and "t_"+self.prereq_event_cb.currentText() in self.cols:
+				pre_event = self.prereq_event_cb.currentText()
+
+			self.df = interpret_track_classification(self.df, self.class_name_user, irreversible_event=self.irreversible_event_btn.isChecked(), unique_state=self.unique_state_btn.isChecked(), transient_event=self.transient_event_btn.isChecked(),r2_threshold=self.r2_slider.value(), pre_event=pre_event)
 		
 		else:
 			self.group_name_user = 'group_' + self.name_le.text()

celldetective/gui/configure_new_exp.py

@@ -453,6 +453,9 @@ class ConfigNewExperiment(QMainWindow, Styles):
 		config.set('Labels', 'concentrations', self.concentrations)
 		config.set('Labels', 'pharmaceutical_agents', self.pharmaceutical_agents)
 
+		config.add_section('Metadata')
+		config.set('Metadata', 'concentration_units', self.concentration_units)
+
 		# save to a file
 		with open('config.ini', 'w') as configfile:
 			config.write(configfile)
@@ -480,6 +483,8 @@ class SetupConditionLabels(QWidget, Styles):
 		self.antibodies_cbs = [QLineEdit() for i in range(self.n_wells)]
 		self.concentrations_cbs = [QLineEdit() for i in range(self.n_wells)]
 		self.pharmaceutical_agents_cbs = [QLineEdit() for i in range(self.n_wells)]
+		self.concentration_units_le = QLineEdit('pM')
+		self.concentration_units_le.setPlaceholderText('concentration units')
 
 		for i in range(self.n_wells):
 			hbox = QHBoxLayout()
@@ -504,6 +509,12 @@ class SetupConditionLabels(QWidget, Styles):
 
 			self.layout.addLayout(hbox)
 
+		concentration_units_layout = QHBoxLayout()
+		concentration_units_layout.addWidget(QLabel('concentration\nunits: '),5,alignment=Qt.AlignLeft)
+		concentration_units_layout.addWidget(self.concentration_units_le,10)
+		concentration_units_layout.addWidget(QLabel(''), 85)
+		self.layout.addLayout(concentration_units_layout)
+
 		btn_hbox = QHBoxLayout()
 		btn_hbox.setContentsMargins(0,20,0,0)
 		self.skip_btn = QPushButton('Skip')
@@ -556,6 +567,8 @@ class SetupConditionLabels(QWidget, Styles):
 		pharamaceutical_text = [c.text() for c in self.pharmaceutical_agents_cbs]
 		self.parent_window.pharmaceutical_agents = ','.join(pharamaceutical_text)
 
+		self.parent_window.concentration_units = self.concentration_units_le.text()
+
 
 
 

celldetective/gui/control_panel.py

@@ -93,6 +93,9 @@ class ControlPanel(QMainWindow, Styles):
 		self.screen_width = desktop.screenGeometry().width()
 		self.scroll.setMinimumWidth(440)
 
+		self.well_list.setCurrentIndex(0)
+		#self.position_list.setCurrentIndex(0)
+
 	def init_wells_and_positions(self):
 
 		"""
@@ -151,10 +154,8 @@ class ControlPanel(QMainWindow, Styles):
 		#self.locate_selected_position()
 
 		self.well_list.activated.connect(self.display_positions)
-		self.well_list.setCurrentIndex(0)
 
 		self.position_list.activated.connect(self.update_position_options)
-		self.position_list.setCurrentIndex(0)
 
 		self.view_stack_btn = QPushButton()
 		self.view_stack_btn.setStyleSheet(self.button_select_all)
@@ -337,6 +338,7 @@ class ControlPanel(QMainWindow, Styles):
 		self.antibodies = get_experiment_antibodies(self.exp_dir)
 		self.pharmaceutical_agents = get_experiment_pharmaceutical_agents(self.exp_dir)
 
+		self.metadata = ConfigSectionMap(self.exp_config,"Metadata")
 		print('Experiment configuration successfully read...')
 
 	def closeEvent(self, event):

celldetective/gui/generic_signal_plot.py

@@ -62,6 +62,7 @@ class GenericSignalPlotWidget(QWidget, Styles):
 		self.setLayout(self.layout)
 		self.setAttribute(Qt.WA_DeleteOnClose)
 
+
 	def populate_widget(self):
 
 		self.plot_options = [QRadioButton() for i in range(3)]
@@ -221,18 +222,13 @@ class GenericSignalPlotWidget(QWidget, Styles):
 		self.alpha_slider = QLabeledDoubleSlider()
 		alpha_hbox = QuickSliderLayout(label='single-cell\nsignal alpha: ',
 										slider=self.alpha_slider,
-										slider_initial_value=0.8,
+										slider_initial_value=self.alpha_setting,
 										slider_range=(0,1),
 										decimal_option=True,
 										precision=1.0E-05,
 										)
 		self.alpha_slider.valueChanged.connect(self.submit_alpha)
 		self.cell_lines_alpha_wdg.setLayout(alpha_hbox)
-
-		# self.submit_alpha_btn = QPushButton('submit')
-		# self.submit_alpha_btn.setStyleSheet(self.button_style_sheet_2)
-		# self.submit_alpha_btn.clicked.connect(self.submit_alpha)
-		# alpha_hbox.addWidget(self.submit_alpha_btn, 10)
 		self.layout.addWidget(self.cell_lines_alpha_wdg)
 
 		self.select_option = [QRadioButton() for i in range(2)]