celldetective 1.1.1__tar.gz → 1.1.1.post3__tar.gz

{celldetective-1.1.1 → celldetective-1.1.1.post3}/PKG-INFO

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

{celldetective-1.1.1 → celldetective-1.1.1.post3}/celldetective/extra_properties.py

@@ -7,7 +7,7 @@ If intensity is in function name, it will be replaced by the name of the channel
 import warnings
 
 import numpy as np
-from scipy.ndimage import distance_transform_edt
+from scipy.ndimage import distance_transform_edt, center_of_mass
 from scipy.spatial.distance import euclidean
 
 

{celldetective-1.1.1 → celldetective-1.1.1.post3}/celldetective/filters.py

@@ -1,21 +1,36 @@
 from skimage.filters import difference_of_gaussians, threshold_otsu, threshold_local, threshold_niblack, threshold_sauvola
+from celldetective.utils import interpolate_nan
 import scipy.ndimage as snd
 import numpy as np
 
-def gauss_filter(img, sigma, *kwargs):
+def gauss_filter(img, sigma, interpolate=True, *kwargs):
+	if interpolate:
+		img = interpolate_nan(img.astype(float))
 	return snd.gaussian_filter(img.astype(float), sigma, *kwargs)
 
-def median_filter(img, size, *kwargs):
+def median_filter(img, size, interpolate=True, *kwargs):
+	if interpolate:
+		img = interpolate_nan(img.astype(float))
+
 	size = int(size)
 	return snd.median_filter(img, size, *kwargs)
 
-def maximum_filter(img, size, *kwargs):
+def maximum_filter(img, size, interpolate=True, *kwargs):
+	if interpolate:
+		img = interpolate_nan(img.astype(float))
+
 	return snd.maximum_filter(img.astype(float), size, *kwargs)
 
-def minimum_filter(img, size, *kwargs):
+def minimum_filter(img, size, interpolate=True, *kwargs):
+	if interpolate:
+		img = interpolate_nan(img.astype(float))
+
 	return snd.minimum_filter(img.astype(float), size, *kwargs)
 
-def percentile_filter(img, percentile, size, *kwargs):
+def percentile_filter(img, percentile, size, interpolate=True, *kwargs):
+	if interpolate:
+		img = interpolate_nan(img.astype(float))
+
 	return snd.percentile_filter(img.astype(float), percentile, size, *kwargs)
 
 def subtract_filter(img, value, *kwargs):
@@ -24,14 +39,19 @@ def subtract_filter(img, value, *kwargs):
 def abs_filter(img, *kwargs):
 	return np.abs(img)
 
-def ln_filter(img, *kwargs):
+def ln_filter(img, interpolate=True, *kwargs):
+	if interpolate:
+		img = interpolate_nan(img.astype(float))
 
 	img[np.where(img>0.)] = np.log(img[np.where(img>0.)])
 	img[np.where(img<=0.)] = 0.
 
 	return img
 
-def variance_filter(img, size):
+def variance_filter(img, size, interpolate=True):
+
+	if interpolate:
+		img = interpolate_nan(img.astype(float))
 
 	size = int(size)
 	img = img.astype(float)
@@ -41,8 +61,10 @@ def variance_filter(img, size):
 
 	return img
 
-def std_filter(img, size):
+def std_filter(img, size, interpolate=True):
 
+	if interpolate:
+		img = interpolate_nan(img.astype(float))
 	size = int(size)
 	img = img.astype(float)
 	win_mean = snd.uniform_filter(img, (size,size), mode='wrap')
@@ -53,10 +75,14 @@ def std_filter(img, size):
 
 	return img
 
-def laplace_filter(img, output=float, *kwargs):
+def laplace_filter(img, output=float, interpolate=True, *kwargs):
+	if interpolate:
+		img = interpolate_nan(img.astype(float))
 	return snd.laplace(img.astype(float), *kwargs)
 
-def dog_filter(img, sigma_low, sigma_high, *kwargs):
+def dog_filter(img, sigma_low, sigma_high, interpolate=True, *kwargs):
+	if interpolate:
+		img = interpolate_nan(img.astype(float))
 	return difference_of_gaussians(img.astype(float), sigma_low, sigma_high, *kwargs)
 
 def otsu_filter(img, *kwargs):
@@ -82,7 +108,9 @@ def sauvola_filter(img, *kwargs):
 def log_filter(img, sigma, *kwargs):
 	return snd.gaussian_laplace(img.astype(float), sigma, *kwargs)
 
-def tophat_filter(img, size, connectivity=4, *kwargs):
+def tophat_filter(img, size, connectivity=4, interpolate=True, *kwargs):
+	if interpolate:
+		img = interpolate_nan(img.astype(float))
 	structure = snd.generate_binary_structure(rank=2, connectivity=connectivity)
 	img = snd.white_tophat(img.astype(float), structure=structure, size=size, *kwargs)
 	return img

{celldetective-1.1.1 → celldetective-1.1.1.post3}/celldetective/gui/classifier_widget.py

@@ -136,9 +136,10 @@ class ClassifierWidget(QWidget, Styles):
 
 		self.irreversible_event_btn = QRadioButton('irreversible event')
 		self.unique_state_btn = QRadioButton('unique state')
-		self.time_corr_options = [self.irreversible_event_btn, self.unique_state_btn]
 		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)
@@ -148,8 +149,28 @@ class ClassifierWidget(QWidget, Styles):
 		time_corr_layout.addWidget(self.irreversible_event_btn, 50,alignment=Qt.AlignCenter)
 		layout.addLayout(time_corr_layout)
 
+		self.r2_slider = QLabeledDoubleSlider()
+		self.r2_slider.setValue(0.75)
+		self.r2_slider.setRange(0,1)
+		self.r2_slider.setSingleStep(0.01)
+		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)	
+		
+		self.irreversible_event_btn.clicked.connect(self.activate_r2)
+		self.unique_state_btn.clicked.connect(self.activate_r2)
+
+		for wg in [self.r2_slider, self.r2_label]:
+			wg.setEnabled(False)
+
 		layout.addWidget(QLabel())
 
+
 		self.submit_btn = QPushButton('apply')
 		self.submit_btn.setStyleSheet(self.button_style_sheet)
 		self.submit_btn.clicked.connect(self.submit_classification)
@@ -158,14 +179,30 @@ class ClassifierWidget(QWidget, Styles):
 		self.frame_slider.valueChanged.connect(self.set_frame)
 		self.alpha_slider.valueChanged.connect(self.set_transparency)
 
+	def activate_r2(self):
+		if self.irreversible_event_btn.isChecked() and self.time_corr.isChecked():
+			for wg in [self.r2_slider, self.r2_label]:
+				wg.setEnabled(True)
+		else:
+			for wg in [self.r2_slider, self.r2_label]:
+				wg.setEnabled(False)				
+
 	def activate_time_corr_options(self):
 
 		if self.time_corr.isChecked():
 			for btn in self.time_corr_options:
 				btn.setEnabled(True)
+			if self.irreversible_event_btn.isChecked():
+				for wg in [self.r2_slider, self.r2_label]:
+					wg.setEnabled(True)
+			else:
+				for wg in [self.r2_slider, self.r2_label]:
+					wg.setEnabled(False)				
 		else:
 			for btn in self.time_corr_options:
 				btn.setEnabled(False)
+			for wg in [self.r2_slider, self.r2_label]:
+				wg.setEnabled(False)
 
 	def init_class(self):
 
@@ -207,8 +244,20 @@ class ClassifierWidget(QWidget, Styles):
 			self.scat_props.set_alpha(self.currentAlpha)
 			self.ax_props.set_xlabel(self.features_cb[1].currentText())
 			self.ax_props.set_ylabel(self.features_cb[0].currentText())
-		self.ax_props.set_xlim(1*self.df[self.features_cb[1].currentText()].min(),1.0*self.df[self.features_cb[1].currentText()].max())
-		self.ax_props.set_ylim(1*self.df[self.features_cb[0].currentText()].min(),1.0*self.df[self.features_cb[0].currentText()].max())
+
+
+		feat_x = self.features_cb[1].currentText()
+		feat_y = self.features_cb[0].currentText()
+		min_x = self.df.dropna(subset=feat_x)[feat_x].min()
+		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()
+
+		if min_x==min_x and max_x==max_x:
+			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 feature_changed:
 			self.propscanvas.canvas.toolbar.update()
 		self.propscanvas.canvas.draw_idle()
@@ -400,15 +449,16 @@ class ClassifierWidget(QWidget, Styles):
 			timeline = group['FRAME'].values
 			
 			try:
-				popt, pcov = curve_fit(step_function, timeline, status_signal,p0=[self.df['FRAME'].max()//2, 0.5],maxfev=10000)
-				r2 = r2_score(status_signal, step_function(timeline, *popt))
+				popt, pcov = curve_fit(step_function, timeline.astype(int), status_signal, p0=[self.df['FRAME'].max()//2, 0.8],maxfev=30000)
+				values = [step_function(t, *popt) for t in timeline]
+				r2 = r2_score(status_signal,values)
 			except Exception as e:
 				print(e)
 				self.df.loc[indices, self.class_name_user] = 2.0
 				self.df.loc[indices, self.class_name_user.replace('class','t')] = -1
 				continue
 
-			if r2 > 0.7:
+			if r2 > float(self.r2_slider.value()):
 				t0 = popt[0]
 				self.df.loc[indices, self.class_name_user.replace('class','t')] = t0
 				self.df.loc[indices, self.class_name_user] = 0.0
@@ -426,4 +476,3 @@ class ClassifierWidget(QWidget, Styles):
 
 
 
-

{celldetective-1.1.1 → celldetective-1.1.1.post3}/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):
 	
@@ -702,12 +945,12 @@ class BackgroundModelFreeCorrectionLayout(QGridLayout, Styles):
 						   show_progress_per_pos = False,
 							)
 		
-
 		self.viewer = StackVisualizer(
 									  stack=corrected_stacks[0],
 									  window_title='Corrected channel',
 									  frame_slider = True,
-									  contrast_slider = True
+									  contrast_slider = True,
+									  target_channel=self.channels_cb.currentIndex(),
 									 )
 		self.viewer.show()