celldetective 1.1.1__py3-none-any.whl → 1.1.1.post3__py3-none-any.whl

celldetective/gui/tableUI.py

@@ -12,6 +12,8 @@ import matplotlib.cm as mcm
 import os
 from celldetective.gui import Styles
 from superqt import QColormapComboBox, QLabeledSlider, QSearchableComboBox
+from superqt.fonticon import icon
+from fonticon_mdi6 import MDI6
 from math import floor
 
 from matplotlib import colormaps
@@ -72,6 +74,92 @@ class QueryWidget(QWidget):
 			print(e)
 			return None
 
+
+class MergeOneHotWidget(QWidget, Styles):
+
+	def __init__(self, parent_window, selected_columns=None):
+
+		super().__init__()
+		self.parent_window = parent_window
+		self.selected_columns = selected_columns
+
+		self.setWindowTitle("Merge one-hot encoded columns...")
+		# Create the QComboBox and add some items
+		center_window(self)
+		
+		self.layout = QVBoxLayout(self)
+		self.layout.setContentsMargins(30,30,30,30)
+
+		if self.selected_columns is not None:
+			n_cols = len(self.selected_columns)
+		else:
+			n_cols = 2
+
+		name_hbox = QHBoxLayout()
+		name_hbox.addWidget(QLabel('New categorical column: '), 33)
+		self.new_col_le = QLineEdit()
+		self.new_col_le.setText('categorical_')
+		self.new_col_le.textChanged.connect(self.allow_merge)
+		name_hbox.addWidget(self.new_col_le, 66)
+		self.layout.addLayout(name_hbox)
+
+
+		self.layout.addWidget(QLabel('Source columns: '))
+
+		self.cbs = [QSearchableComboBox() for i in range(n_cols)]
+		self.cbs_layout = QVBoxLayout()
+
+		for i in range(n_cols):
+			lay = QHBoxLayout()
+			lay.addWidget(QLabel(f'column {i}: '), 33)
+			self.cbs[i].addItems(['--']+list(self.parent_window.data.columns))
+			if self.selected_columns is not None:
+				self.cbs[i].setCurrentText(self.selected_columns[i])
+			lay.addWidget(self.cbs[i], 66)
+			self.cbs_layout.addLayout(lay)
+
+		self.layout.addLayout(self.cbs_layout)
+
+		hbox = QHBoxLayout()
+		self.add_col_btn = QPushButton('Add column')
+		self.add_col_btn.clicked.connect(self.add_col)
+		self.add_col_btn.setStyleSheet(self.button_add)
+		self.add_col_btn.setIcon(icon(MDI6.plus,color="black"))
+
+		hbox.addWidget(QLabel(''), 50)
+		hbox.addWidget(self.add_col_btn, 50, alignment=Qt.AlignRight)
+		self.layout.addLayout(hbox)
+
+		self.submit_btn = QPushButton('Merge')
+		self.submit_btn.setStyleSheet(self.button_style_sheet)
+		self.submit_btn.clicked.connect(self.merge_cols)
+		self.layout.addWidget(self.submit_btn, 30)
+
+		self.setAttribute(Qt.WA_DeleteOnClose)
+
+	def add_col(self):
+		self.cbs.append(QSearchableComboBox())
+		self.cbs[-1].addItems(['--']+list(self.parent_window.data.columns))
+		lay = QHBoxLayout()
+		lay.addWidget(QLabel(f'column {len(self.cbs)-1}: '), 33)
+		lay.addWidget(self.cbs[-1], 66)
+		self.cbs_layout.addLayout(lay)	
+
+	def merge_cols(self):
+		
+		self.parent_window.data[self.new_col_le.text()] = self.parent_window.data.loc[:,list(self.selected_columns)].idxmax(axis=1)
+		self.parent_window.model = PandasModel(self.parent_window.data)
+		self.parent_window.table_view.setModel(self.parent_window.model)
+		self.close()
+
+	def allow_merge(self):
+
+		if self.new_col_le.text()=='':
+			self.submit_btn.setEnabled(False)
+		else:
+			self.submit_btn.setEnabled(True)
+
+
 class DifferentiateColWidget(QWidget, Styles):
 
 	def __init__(self, parent_window, column=None):
@@ -232,6 +320,11 @@ class TableUI(QMainWindow, Styles):
 			self.plot_action.setShortcut("Ctrl+p")
 			self.fileMenu.addAction(self.plot_action)		
 
+			self.plot_inst_action = QAction("&Plot instantaneous...", self)
+			self.plot_inst_action.triggered.connect(self.plot_instantaneous)
+			self.plot_inst_action.setShortcut("Ctrl+i")
+			self.fileMenu.addAction(self.plot_inst_action)	
+
 			self.groupby_action = QAction("&Group by tracks...", self)
 			self.groupby_action.triggered.connect(self.set_projection_mode_tracks)
 			self.groupby_action.setShortcut("Ctrl+g")
@@ -259,7 +352,12 @@ class TableUI(QMainWindow, Styles):
 			self.derivative_action = QAction('&Differentiate...', self)
 			self.derivative_action.triggered.connect(self.differenciate_selected_feature)
 			self.derivative_action.setShortcut("Ctrl+D")
-			self.mathMenu.addAction(self.derivative_action)			
+			self.mathMenu.addAction(self.derivative_action)
+
+			self.onehot_action = QAction('&One hot to categorical...', self)
+			self.onehot_action.triggered.connect(self.transform_one_hot_cols_to_categorical)
+			#self.onehot_action.setShortcut("Ctrl+D")
+			self.mathMenu.addAction(self.onehot_action)		
 
 	def delete_columns(self):
 
@@ -329,6 +427,19 @@ class TableUI(QMainWindow, Styles):
 		self.diffWidget = DifferentiateColWidget(self, selected_col)
 		self.diffWidget.show()
 
+	def transform_one_hot_cols_to_categorical(self):
+
+		x = self.table_view.selectedIndexes()
+		col_idx = np.unique(np.array([l.column() for l in x]))
+		if list(col_idx):
+			cols = np.array(list(self.data.columns))
+			selected_cols = cols[col_idx]
+		else:
+			selected_cols = None
+
+		self.mergewidget = MergeOneHotWidget(self, selected_columns=selected_cols)
+		self.mergewidget.show()
+
 
 	def groupby_time_table(self):
 
@@ -408,7 +519,7 @@ class TableUI(QMainWindow, Styles):
 		self.status_operation.setEnabled(False)
 		self.status_operation.addItems(['mean','median','min','max', 'prod', 'sum'])
 
-		status_cols = np.array([c.startswith('status_') for c in cols])
+		status_cols = np.array([c.startswith('status_') or c.startswith('group_') for c in cols])
 		status_cols = list(cols[status_cols])
 		if 'status' in list(self.data.columns):
 			status_cols.append('status')
@@ -472,6 +583,7 @@ class TableUI(QMainWindow, Styles):
 		layout.addWidget(QLabel('Representations: '))
 		self.hist_check = QCheckBox('histogram')
 		self.kde_check = QCheckBox('KDE plot')
+		self.count_check = QCheckBox('Countplot')
 		self.ecdf_check = QCheckBox('ECDF plot')
 		self.swarm_check = QCheckBox('swarm')
 		self.violin_check = QCheckBox('violin')
@@ -481,6 +593,7 @@ class TableUI(QMainWindow, Styles):
 
 		layout.addWidget(self.hist_check)
 		layout.addWidget(self.kde_check)
+		layout.addWidget(self.count_check)
 		layout.addWidget(self.ecdf_check)
 		layout.addWidget(self.swarm_check)
 		layout.addWidget(self.violin_check)
@@ -491,16 +604,38 @@ class TableUI(QMainWindow, Styles):
 		self.x_cb = QSearchableComboBox()
 		self.x_cb.addItems(['--']+list(self.data.columns))
 
+		self.y_cb = QSearchableComboBox()
+		self.y_cb.addItems(['--']+list(self.data.columns))
+
 		self.hue_cb = QSearchableComboBox()
 		self.hue_cb.addItems(['--']+list(self.data.columns))
 		idx = self.hue_cb.findText('--')
+		self.hue_cb.setCurrentIndex(idx)
+
+		# Set selected column
+
+		try:
+			x = self.table_view.selectedIndexes()
+			col_idx = np.array([l.column() for l in x])
+			row_idx = np.array([l.row() for l in x])
+			column_names = self.data.columns
+			unique_cols = np.unique(col_idx)[0]
+			y = column_names[unique_cols]
+			idx = self.y_cb.findText(y)
+			self.y_cb.setCurrentIndex(idx)
+		except:
+			pass
 
-		self.x_cb.findText('--')
 		hbox = QHBoxLayout()
 		hbox.addWidget(QLabel('x: '), 33)
 		hbox.addWidget(self.x_cb, 66)
 		layout.addLayout(hbox)
 
+		hbox = QHBoxLayout()
+		hbox.addWidget(QLabel('y: '), 33)
+		hbox.addWidget(self.y_cb, 66)
+		layout.addLayout(hbox)
+
 		hbox = QHBoxLayout()
 		hbox.addWidget(QLabel('hue: '), 33)
 		hbox.addWidget(self.hue_cb, 66)
@@ -534,18 +669,10 @@ class TableUI(QMainWindow, Styles):
 			self.x_option = True
 			self.x = self.x_cb.currentText()
 
-		x = self.table_view.selectedIndexes()
-		col_idx = np.array([l.column() for l in x])
-		row_idx = np.array([l.row() for l in x])
-		column_names = self.data.columns
-		unique_cols = np.unique(col_idx)[0]
-
 		self.fig, self.ax = plt.subplots(1,1,figsize=(4,3))
 		self.plot1dWindow = FigureCanvas(self.fig, title="scatter")
 		self.ax.clear()
-		row_idx_i = row_idx[np.where(col_idx==unique_cols)[0]]
-		y = self.data.iloc[row_idx_i, unique_cols]
-		
+
 		cmap = getattr(mcm, self.cmap_cb.currentText())
 
 		try:
@@ -557,58 +684,68 @@ class TableUI(QMainWindow, Styles):
 		if self.hue_cb.currentText()=='--':
 			hue_variable = None
 
-		#for w,well_group in self.data.groupby('well_index'):
+		if self.y_cb.currentText()=='--':
+			self.y = None
+		else:
+			self.y = self.y_cb.currentText()
+
+		if self.x_cb.currentText()=='--':
+			self.x = None
+		else:
+			self.x = self.x_cb.currentText()
 
 		legend=True
 		if self.hist_check.isChecked():
-			sns.histplot(data=self.data, x=column_names[unique_cols], hue=hue_variable, legend=legend, ax=self.ax, palette=colors, kde=True, common_norm=False, stat='density')
+			sns.histplot(data=self.data, x=self.x, hue=hue_variable, legend=legend, ax=self.ax, palette=colors, kde=True, common_norm=False, stat='density')
 			legend = False
 		if self.kde_check.isChecked():
-			sns.kdeplot(data=self.data, x=column_names[unique_cols], hue=hue_variable, legend=legend, ax=self.ax, palette=colors, cut=0)
+			sns.kdeplot(data=self.data, x=self.x, hue=hue_variable, legend=legend, ax=self.ax, palette=colors, cut=0)
+			legend = False
+		if self.count_check.isChecked():
+			sns.countplot(data=self.data, x=self.x, hue=hue_variable, legend=legend, ax=self.ax, palette=colors)
 			legend = False
-
 		if self.ecdf_check.isChecked():
-			sns.ecdfplot(data=self.data, x=column_names[unique_cols], hue=hue_variable, legend=legend, ax=self.ax, palette=colors)
+			sns.ecdfplot(data=self.data, x=self.x, hue=hue_variable, legend=legend, ax=self.ax, palette=colors)
 			legend = False
 
 		if self.swarm_check.isChecked():
 			if self.x_option:
-				sns.swarmplot(data=self.data, x=self.x,y=column_names[unique_cols],dodge=True, hue=hue_variable,legend=legend, ax=self.ax, palette=colors)
+				sns.swarmplot(data=self.data, x=self.x,y=self.y,dodge=True, hue=hue_variable,legend=legend, ax=self.ax, palette=colors)
 				legend = False
 			else:
-				sns.swarmplot(data=self.data, y=column_names[unique_cols],dodge=True, hue=hue_variable,legend=legend, ax=self.ax, palette=colors)
+				sns.swarmplot(data=self.data, y=self.y,dodge=True, hue=hue_variable,legend=legend, ax=self.ax, palette=colors)
 				legend = False
 
 		if self.violin_check.isChecked():
 			if self.x_option:
-				sns.stripplot(data=self.data,x=self.x, y=column_names[unique_cols],dodge=True, ax=self.ax, hue=hue_variable, legend=legend, palette=colors)
+				sns.stripplot(data=self.data,x=self.x, y=self.y,dodge=True, ax=self.ax, hue=hue_variable, legend=legend, palette=colors)
 				legend = False
 			else:
-				sns.violinplot(data=self.data, y=column_names[unique_cols],dodge=True, hue=hue_variable,legend=legend, ax=self.ax, palette=colors, cut=0)
+				sns.violinplot(data=self.data, y=self.y,dodge=True, hue=hue_variable,legend=legend, ax=self.ax, palette=colors, cut=0)
 				legend = False
 
 		if self.box_check.isChecked():
 			if self.x_option:
-				sns.boxplot(data=self.data, x=self.x, y=column_names[unique_cols],dodge=True, hue=hue_variable,legend=legend, ax=self.ax, fill=False,palette=colors, linewidth=2,)
+				sns.boxplot(data=self.data, x=self.x, y=self.y,dodge=True, hue=hue_variable,legend=legend, ax=self.ax, fill=False,palette=colors, linewidth=2,)
 				legend = False
 			else:
-				sns.boxplot(data=self.data, y=column_names[unique_cols],dodge=True, hue=hue_variable,legend=legend, ax=self.ax, fill=False,palette=colors, linewidth=2,)
+				sns.boxplot(data=self.data, y=self.y,dodge=True, hue=hue_variable,legend=legend, ax=self.ax, fill=False,palette=colors, linewidth=2,)
 				legend = False
 
 		if self.boxenplot_check.isChecked():
 			if self.x_option:
-				sns.boxenplot(data=self.data, x = self.x, y=column_names[unique_cols],dodge=True, hue=hue_variable,legend=legend, ax=self.ax, fill=False,palette=colors, linewidth=2,)
+				sns.boxenplot(data=self.data, x=self.x, y=self.y,dodge=True, hue=hue_variable,legend=legend, ax=self.ax, fill=False,palette=colors, linewidth=2,)
 				legend = False
 			else:
-				sns.boxenplot(data=self.data, y=column_names[unique_cols],dodge=True, hue=hue_variable,legend=legend, ax=self.ax, fill=False,palette=colors, linewidth=2,)
+				sns.boxenplot(data=self.data, y=self.y,dodge=True, hue=hue_variable,legend=legend, ax=self.ax, fill=False,palette=colors, linewidth=2,)
 				legend = False
 
 		if self.strip_check.isChecked():
 			if self.x_option:
-				sns.stripplot(data=self.data, x = self.x, y=column_names[unique_cols],dodge=True, ax=self.ax, hue=hue_variable, legend=legend, palette=colors)
+				sns.stripplot(data=self.data, x = self.x, y=self.y,dodge=True, ax=self.ax, hue=hue_variable, legend=legend, palette=colors)
 				legend = False
 			else:
-				sns.stripplot(data=self.data, y=column_names[unique_cols],dodge=True, ax=self.ax, hue=hue_variable, legend=legend, palette=colors)
+				sns.stripplot(data=self.data, y=self.y,dodge=True, ax=self.ax, hue=hue_variable, legend=legend, palette=colors)
 				legend = False
 
 		plt.tight_layout()
@@ -739,6 +876,15 @@ class TableUI(QMainWindow, Styles):
 		else:
 			return array
 
+	def plot_instantaneous(self):
+		
+		if self.plot_mode=='plot_track_signals':
+			self.plot_mode = 'static'
+			self.plot()
+			self.plot_mode = 'plot_track_signals'
+		elif self.plot_mode=="static":
+			self.plot()
+
 	def plot(self):
 		if self.plot_mode == "static":
 	
@@ -748,42 +894,10 @@ class TableUI(QMainWindow, Styles):
 			column_names = self.data.columns
 			unique_cols = np.unique(col_idx)
 
-			if len(unique_cols)==1:
-				# 1D plot
-				# Open widget to set 1D data representations
+			if len(unique_cols)==1 or len(unique_cols)==0:
 				self.set_1D_plot_params()
 
-
-
-				# x = self.table_view.selectedIndexes()
-				# col_idx = np.array([l.column() for l in x])
-				# row_idx = np.array([l.row() for l in x])
-				# column_names = self.data.columns
-				# unique_cols = np.unique(col_idx)[0]
-
-				# self.fig, self.ax = plt.subplots(1,1,figsize=(4,3))
-				# self.histogram_window = FigureCanvas(self.fig, title="scatter")
-				# self.ax.clear()
-				# row_idx_i = row_idx[np.where(col_idx==unique_cols)[0]]
-				# y = self.data.iloc[row_idx_i, unique_cols]
-
-				# colors = [viridis(i / len(self.data['well_index'].unique())) for i in range(len(self.data['well_index'].unique()))]
-				# #for w,well_group in self.data.groupby('well_index'):
-				# sns.boxplot(data=self.data, y=column_names[unique_cols],dodge=True, hue='well_index',legend=False, ax=self.ax, fill=False,palette=colors, linewidth=2,)
-				# sns.stripplot(data=self.data, y=column_names[unique_cols],dodge=True, ax=self.ax, hue='well_index', legend=False, palette=colors)
-				# # sns.kdeplot(data=self.data, x=column_names[unique_cols], hue='well_index', ax=self.ax, fill=False,common_norm=False, palette=colors, alpha=.5, linewidth=2,)
-				# # for k,(w,well_group) in enumerate(self.data.groupby('well_index')):
-				# # 	self.ax.hist(well_group[column_names[unique_cols]],label=w, density=True, alpha=0.5, color=colors[k])
-				# #self.ax.legend()
-				# self.ax.set_xlabel(column_names[unique_cols])
-				# plt.tight_layout()
-				# self.fig.set_facecolor('none')  # or 'None'
-				# self.fig.canvas.setStyleSheet("background-color: transparent;")
-				# self.histogram_window.canvas.draw()
-				# self.histogram_window.show()
-
-
-			elif len(unique_cols) == 2:
+			if len(unique_cols) == 2:
 
 				print("two columns, plot mode")
 				x1 = self.test_bool(self.data.iloc[row_idx, unique_cols[0]])

celldetective/gui/thresholds_gui.py

@@ -2,7 +2,7 @@ import math
 
 import skimage
 from PyQt5.QtWidgets import QAction, QMenu, QMainWindow, QMessageBox, QLabel, QWidget, QFileDialog, QHBoxLayout, \
-	QGridLayout, QLineEdit, QScrollArea, QVBoxLayout, QComboBox, QPushButton, QApplication, QPushButton
+	QGridLayout, QLineEdit, QScrollArea, QVBoxLayout, QComboBox, QPushButton, QApplication, QPushButton, QRadioButton, QButtonGroup
 from PyQt5.QtGui import QDoubleValidator, QIntValidator
 from matplotlib.backends.backend_qt import NavigationToolbar2QT
 from matplotlib.patches import Circle
@@ -17,6 +17,7 @@ from celldetective.io import auto_load_number_of_frames, load_frames
 from celldetective.segmentation import threshold_image, identify_markers_from_binary, apply_watershed, \
 	segment_frame_from_thresholds
 from scipy.ndimage import binary_fill_holes
+import scipy.ndimage as ndi
 from PyQt5.QtCore import Qt, QSize
 from glob import glob
 from superqt.fonticon import icon
@@ -263,10 +264,20 @@ class ThresholdConfigWizard(QMainWindow, Styles):
 		marker_box = QVBoxLayout()
 		marker_box.setContentsMargins(30, 30, 30, 30)
 
-		marker_lbl = QLabel('Markers')
+		marker_lbl = QLabel('Objects')
 		marker_lbl.setStyleSheet("font-weight: bold;")
 		marker_box.addWidget(marker_lbl, alignment=Qt.AlignCenter)
 
+		object_option_hbox = QHBoxLayout()
+		self.marker_option = QRadioButton('markers')
+		self.all_objects_option = QRadioButton('all non-contiguous objects')
+		self.marker_option_group = QButtonGroup()
+		self.marker_option_group.addButton(self.marker_option)
+		self.marker_option_group.addButton(self.all_objects_option)
+		object_option_hbox.addWidget(self.marker_option, 50, alignment=Qt.AlignCenter)
+		object_option_hbox.addWidget(self.all_objects_option, 50, alignment=Qt.AlignCenter)
+		marker_box.addLayout(object_option_hbox)
+
 		hbox_footprint = QHBoxLayout()
 		hbox_footprint.addWidget(QLabel('Footprint: '), 20)
 		self.footprint_slider = QLabeledSlider()
@@ -275,7 +286,8 @@ class ThresholdConfigWizard(QMainWindow, Styles):
 		self.footprint_slider.setRange(1, self.binary.shape[0] // 4)
 		self.footprint_slider.setValue(self.footprint)
 		self.footprint_slider.valueChanged.connect(self.set_footprint)
-		hbox_footprint.addWidget(self.footprint_slider, 80)
+		hbox_footprint.addWidget(self.footprint_slider, 30)
+		hbox_footprint.addWidget(QLabel(''), 50)
 		marker_box.addLayout(hbox_footprint)
 
 		hbox_distance = QHBoxLayout()
@@ -286,7 +298,8 @@ class ThresholdConfigWizard(QMainWindow, Styles):
 		self.min_dist_slider.setRange(0, self.binary.shape[0] // 4)
 		self.min_dist_slider.setValue(self.min_dist)
 		self.min_dist_slider.valueChanged.connect(self.set_min_dist)
-		hbox_distance.addWidget(self.min_dist_slider, 80)
+		hbox_distance.addWidget(self.min_dist_slider, 30)
+		hbox_distance.addWidget(QLabel(''), 50)
 		marker_box.addLayout(hbox_distance)
 
 		hbox_marker_btns = QHBoxLayout()
@@ -305,8 +318,23 @@ class ThresholdConfigWizard(QMainWindow, Styles):
 		hbox_marker_btns.addWidget(self.watershed_btn)
 		marker_box.addLayout(hbox_marker_btns)
 
+		self.marker_option.clicked.connect(self.enable_marker_options)
+		self.all_objects_option.clicked.connect(self.enable_marker_options)
+		self.marker_option.click()
+
 		self.left_panel.addLayout(marker_box)
 
+	def enable_marker_options(self):
+		if self.marker_option.isChecked():
+			self.footprint_slider.setEnabled(True)
+			self.min_dist_slider.setEnabled(True)
+			self.markers_btn.setEnabled(True)
+		else:
+			self.footprint_slider.setEnabled(False)
+			self.min_dist_slider.setEnabled(False)
+			self.markers_btn.setEnabled(False)
+			self.watershed_btn.setEnabled(True)	
+
 	def generate_props_contents(self):
 
 		properties_box = QVBoxLayout()
@@ -675,7 +703,10 @@ class ThresholdConfigWizard(QMainWindow, Styles):
 
 	def apply_watershed_to_selection(self):
 
-		self.labels = apply_watershed(self.binary, self.coords, self.edt_map)
+		if self.marker_option.isChecked():
+			self.labels = apply_watershed(self.binary, self.coords, self.edt_map)
+		else:
+			self.labels,_ = ndi.label(self.binary.astype(int))
 
 		self.current_channel = self.channels_cb.currentIndex()
 		t = int(self.frame_slider.value())
@@ -806,6 +837,7 @@ class ThresholdConfigWizard(QMainWindow, Styles):
 			"marker_footprint_size": self.footprint,
 			"feature_queries": [self.property_query_le.text()],
 			"equalize_reference": [self.equalize_option, self.frame_slider.value()],
+			"do_watershed": self.marker_option.isChecked(),
 		}
 
 		print('The following instructions will be written: ', instructions)
@@ -873,6 +905,13 @@ class ThresholdConfigWizard(QMainWindow, Styles):
 		self.property_query_le.setText(feature_queries[0])
 		self.submit_query_btn.click()
 
+		if 'do_watershed' in threshold_instructions:
+			do_watershed = threshold_instructions['do_watershed']
+			if do_watershed:
+				self.marker_option.click()
+			else:
+				self.all_objects_option.click()
+
 
 class ThresholdNormalisation(ThresholdConfigWizard):
 	def __init__(self, min_threshold, current_channel, parent_window=None):

celldetective/gui/viewers.py

@@ -396,7 +396,7 @@ class ThresholdedStackVisualizer(StackVisualizer):
 		# Compute the mask based on the threshold value
 		self.preprocess_image()
 		edge = estimate_unreliable_edge(self.preprocessing)
-		self.mask = threshold_image(self.processed_image, threshold_value, 1.0E06, foreground_value=1, edge_exclusion=edge).astype(int)
+		self.mask = threshold_image(self.processed_image, threshold_value, np.inf, foreground_value=1, edge_exclusion=edge).astype(int)
 
 	def preprocess_image(self):
 		# Preprocess the image before thresholding		

celldetective/io.py

@@ -1238,12 +1238,23 @@ def load_napari_data(position, prefix="Aligned", population="target", return_sta
 	"""
 	position = position.replace('\\','/')
 	if population.lower()=="target" or population.lower()=="targets":
-		napari_data = np.load(position+os.sep.join(['output','tables','napari_target_trajectories.npy']), allow_pickle=True)
+		if os.path.exists(position+os.sep.join(['output','tables','napari_target_trajectories.npy'])):
+			napari_data = np.load(position+os.sep.join(['output','tables','napari_target_trajectories.npy']), allow_pickle=True)
+		else:
+			napari_data = None
 	elif population.lower()=="effector" or population.lower()=="effectors":
-		napari_data = np.load(position+os.sep.join(['output', 'tables', 'napari_effector_trajectories.npy']), allow_pickle=True)
-	data = napari_data.item()['data']
-	properties = napari_data.item()['properties']
-	graph = napari_data.item()['graph']
+		if os.path.exists(position+os.sep.join(['output', 'tables', 'napari_effector_trajectories.npy'])):
+			napari_data = np.load(position+os.sep.join(['output', 'tables', 'napari_effector_trajectories.npy']), allow_pickle=True)
+		else:
+			napari_data = None
+	if napari_data is not None:
+		data = napari_data.item()['data']
+		properties = napari_data.item()['properties']
+		graph = napari_data.item()['graph']
+	else:
+		data = None
+		properties = None
+		graph = None
 	if return_stack:
 		stack,labels = locate_stack_and_labels(position, prefix=prefix, population=population)
 	else:
@@ -1968,15 +1979,19 @@ def normalize_multichannel(multichannel_frame, percentiles=None,
 			v = values[c]
 		else:
 			v = None
-		norm = normalize(mf[:,:,c].copy(),
-							  percentiles=percentiles[c],
-							  values=v,
-							  ignore_gray_value=ignore_gray_value,
-							  clip=clip,
-							  amplification=amplification,
-							  dtype=dtype,
-							  )
-		mf_new.append(norm)
+
+		if np.all(mf[:,:,c]==0.):
+			mf_new.append(mf[:,:,c].copy())
+		else:
+			norm = normalize(mf[:,:,c].copy(),
+								  percentiles=percentiles[c],
+								  values=v,
+								  ignore_gray_value=ignore_gray_value,
+								  clip=clip,
+								  amplification=amplification,
+								  dtype=dtype,
+								  )
+			mf_new.append(norm)
 
 	return np.moveaxis(mf_new,0,-1)
 

celldetective/preprocessing.py

@@ -15,6 +15,8 @@ from gc import collect
 from lmfit import Parameters, Model, models
 import tifffile.tifffile as tiff
 
+from tifffile import imwrite
+
 def estimate_background_per_condition(experiment, threshold_on_std=1, well_option='*', target_channel="channel_name", frame_range=[0,5], mode="timeseries", activation_protocol=[['gauss',2],['std',4]], show_progress_per_pos=False, show_progress_per_well=True):
 	
 	"""
@@ -69,6 +71,7 @@ def estimate_background_per_condition(experiment, threshold_on_std=1, well_optio
 	...     print(bg["well"], bg["bg"].shape)
 	"""
 
+
 	config = get_config(experiment)
 	wells = get_experiment_wells(experiment)
 	len_movie = float(ConfigSectionMap(config,"MovieSettings")["len_movie"])
@@ -79,7 +82,7 @@ def estimate_background_per_condition(experiment, threshold_on_std=1, well_optio
 	channel_indices = _extract_channel_indices_from_config(config, [target_channel])
 	nbr_channels = _extract_nbr_channels_from_config(config)
 	img_num_channels = _get_img_num_per_channel(channel_indices, int(len_movie), nbr_channels)
-	
+
 	backgrounds = []
 
 	for k, well_path in enumerate(tqdm(wells[well_indices], disable=not show_progress_per_well)):
@@ -110,7 +113,7 @@ def estimate_background_per_condition(experiment, threshold_on_std=1, well_optio
 				frame = frame_mean.copy().astype(float)
 				std_frame = filter_image(frame.copy(),filters=activation_protocol)
 				edge = estimate_unreliable_edge(activation_protocol)
-				mask = threshold_image(std_frame, threshold_on_std, 1.0E06, foreground_value=1, edge_exclusion=edge)
+				mask = threshold_image(std_frame, threshold_on_std, np.inf, foreground_value=1, edge_exclusion=edge)
 				frame[np.where(mask.astype(int)==1)] = np.nan
 
 			elif mode=="tiles":
@@ -118,21 +121,23 @@ def estimate_background_per_condition(experiment, threshold_on_std=1, well_optio
 				frames = load_frames(img_num_channels[0,:], stack_path, normalize_input=False).astype(float)
 				frames = np.moveaxis(frames, -1, 0).astype(float)
 
+				new_frames = []
 				for i in range(len(frames)):
 
 					if np.all(frames[i].flatten()==0):
-						frames[i,:,:] = np.nan
+						empty_frame = np.zeros_like(frames[i])
+						empty_frame[:,:] = np.nan
+						new_frames.append(empty_frame)
 						continue
 
 					f = frames[i].copy()
 					std_frame = filter_image(f.copy(),filters=activation_protocol)
 					edge = estimate_unreliable_edge(activation_protocol)
-					mask = threshold_image(std_frame, threshold_on_std, 1.0E06, foreground_value=1, edge_exclusion=edge)
+					mask = threshold_image(std_frame, threshold_on_std, np.inf, foreground_value=1, edge_exclusion=edge)
 					f[np.where(mask.astype(int)==1)] = np.nan
-
-					frames[i,:,:] = f
+					new_frames.append(f.copy())
 				
-				frame = np.nanmedian(frames, axis=0)
+				frame = np.nanmedian(new_frames, axis=0)
 
 			# store
 			frame_mean_per_position.append(frame)
@@ -371,18 +376,25 @@ def apply_background_to_stack(stack_path, background, target_channel_index=0, nb
 
 			std_frame = filter_image(target_copy.copy(),filters=activation_protocol)
 			edge = estimate_unreliable_edge(activation_protocol)
-			mask = threshold_image(std_frame, threshold_on_std, 1.0E06, foreground_value=1, edge_exclusion=edge)
+			mask = threshold_image(std_frame, threshold_on_std, np.inf, foreground_value=1, edge_exclusion=edge)
 			target_copy[np.where(mask.astype(int)==1)] = np.nan
 
 			loss = []
 			
 			# brute-force regression, could do gradient descent instead
 			for c in coefficients:
+				
 				target_crop = unpad(target_copy,edge)
 				bg_crop = unpad(background, edge)
-				diff = np.subtract(target_crop, c*bg_crop, where=target_crop==target_crop)
-				s = np.sum(np.abs(diff, where=diff==diff), where=diff==diff)
+				
+				roi = np.zeros_like(target_crop).astype(int)
+				roi[target_crop!=target_crop] = 1
+				roi[bg_crop!=bg_crop] = 1
+
+				diff = np.subtract(target_crop, c*bg_crop, where=roi==0)
+				s = np.sum(np.abs(diff, where=roi==0), where=roi==0)
 				loss.append(s)
+
 			c = coefficients[np.argmin(loss)]
 			print(f"Frame: {i}; optimal coefficient: {c}...")
 			# if c==min(coefficients) or c==max(coefficients):
@@ -954,7 +966,7 @@ def field_correction(img, threshold_on_std=1, operation='divide', model='parabol
 
 	std_frame = filter_image(target_copy,filters=activation_protocol)
 	edge = estimate_unreliable_edge(activation_protocol)
-	mask = threshold_image(std_frame, threshold_on_std, 1.0E06, foreground_value=1, edge_exclusion=edge).astype(int)
+	mask = threshold_image(std_frame, threshold_on_std, np.inf, foreground_value=1, edge_exclusion=edge).astype(int)
 	background = fit_background_model(img, cell_masks=mask, model=model, edge_exclusion=edge)
 
 	if operation=="divide":