celldetective 1.1.0__py3-none-any.whl → 1.1.1.post1__py3-none-any.whl

celldetective/gui/tableUI.py

@@ -1,16 +1,20 @@
-from PyQt5.QtWidgets import QMainWindow, QTableView, QAction, QMenu,QFileDialog, QLineEdit, QHBoxLayout, QWidget, QPushButton, QVBoxLayout, QComboBox, QLabel, QCheckBox, QMessageBox
+from PyQt5.QtWidgets import QRadioButton, QButtonGroup, QMainWindow, QTableView, QAction, QMenu,QFileDialog, QLineEdit, QHBoxLayout, QWidget, QPushButton, QVBoxLayout, QComboBox, QLabel, QCheckBox, QMessageBox
 from PyQt5.QtCore import Qt, QAbstractTableModel
 import pandas as pd
 import matplotlib.pyplot as plt
 from matplotlib.cm import viridis
 plt.rcParams['svg.fonttype'] = 'none'
 from celldetective.gui.gui_utils import FigureCanvas, center_window
+from celldetective.utils import differentiate_per_track
 import numpy as np
 import seaborn as sns
 import matplotlib.cm as mcm
 import os
 from celldetective.gui import Styles
-from superqt import QColormapComboBox
+from superqt import QColormapComboBox, QLabeledSlider, QSearchableComboBox
+from math import floor
+
+from matplotlib import colormaps
 
 class PandasModel(QAbstractTableModel):
 
@@ -55,6 +59,7 @@ class QueryWidget(QWidget):
 		self.submit_btn = QPushButton('submit')
 		self.submit_btn.clicked.connect(self.filter_table)
 		layout.addWidget(self.submit_btn, 30)
+		self.setAttribute(Qt.WA_DeleteOnClose)
 
 	def filter_table(self):
 		try:
@@ -67,6 +72,84 @@ class QueryWidget(QWidget):
 			print(e)
 			return None
 
+class DifferentiateColWidget(QWidget, Styles):
+
+	def __init__(self, parent_window, column=None):
+
+		super().__init__()
+		self.parent_window = parent_window
+		self.column = column
+
+		self.setWindowTitle("d/dt")
+		# Create the QComboBox and add some items
+		center_window(self)
+		
+		layout = QVBoxLayout(self)
+		layout.setContentsMargins(30,30,30,30)
+
+		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)
+		layout.addLayout(measurement_layout)
+
+		self.window_size_slider = QLabeledSlider()
+		self.window_size_slider.setRange(1,np.nanmax(self.parent_window.data.FRAME.to_numpy()))
+		self.window_size_slider.setValue(3)
+		window_layout = QHBoxLayout()
+		window_layout.addWidget(QLabel('window size: '), 25)
+		window_layout.addWidget(self.window_size_slider, 75)
+		layout.addLayout(window_layout)
+
+		self.backward_btn = QRadioButton('backward')
+		self.bi_btn = QRadioButton('bi')
+		self.bi_btn.click()
+		self.forward_btn = QRadioButton('forward')
+		self.mode_btn_group = QButtonGroup()
+		self.mode_btn_group.addButton(self.backward_btn)
+		self.mode_btn_group.addButton(self.bi_btn)
+		self.mode_btn_group.addButton(self.forward_btn)
+
+		mode_layout = QHBoxLayout()
+		mode_layout.addWidget(QLabel('mode: '),25)
+		mode_sublayout = QHBoxLayout()
+		mode_sublayout.addWidget(self.backward_btn, 33, alignment=Qt.AlignCenter)
+		mode_sublayout.addWidget(self.bi_btn, 33, alignment=Qt.AlignCenter)
+		mode_sublayout.addWidget(self.forward_btn, 33, alignment=Qt.AlignCenter)
+		mode_layout.addLayout(mode_sublayout, 75)
+		layout.addLayout(mode_layout)
+
+		self.submit_btn = QPushButton('Compute')
+		self.submit_btn.setStyleSheet(self.button_style_sheet)
+		self.submit_btn.clicked.connect(self.compute_derivative_and_add_new_column)
+		layout.addWidget(self.submit_btn, 30)
+
+		self.setAttribute(Qt.WA_DeleteOnClose)
+
+
+	def compute_derivative_and_add_new_column(self):
+		
+		if self.bi_btn.isChecked():
+			mode = 'bi'
+		elif self.forward_btn.isChecked():
+			mode = 'forward'
+		elif self.backward_btn.isChecked():
+			mode = 'backward'
+		self.parent_window.data = differentiate_per_track(self.parent_window.data,
+														  self.measurements_cb.currentText(),
+														  window_size=self.window_size_slider.value(),
+														  mode=mode)
+		self.parent_window.model = PandasModel(self.parent_window.data)
+		self.parent_window.table_view.setModel(self.parent_window.model)
+		self.close()
+
+
+
 class RenameColWidget(QWidget):
 
 	def __init__(self, parent_window, column=None):
@@ -90,6 +173,7 @@ class RenameColWidget(QWidget):
 		self.submit_btn = QPushButton('rename')
 		self.submit_btn.clicked.connect(self.rename_col)
 		layout.addWidget(self.submit_btn, 30)
+		self.setAttribute(Qt.WA_DeleteOnClose)
 
 	def rename_col(self):
 		
@@ -128,6 +212,8 @@ class TableUI(QMainWindow, Styles):
 		self.model = PandasModel(data)
 		self.table_view.setModel(self.model)
 		self.table_view.resizeColumnsToContents()
+		self.setAttribute(Qt.WA_DeleteOnClose)
+
 
 	def _createActions(self):
 
@@ -146,6 +232,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")
@@ -231,8 +322,17 @@ class TableUI(QMainWindow, Styles):
 		# check only one col selected and assert is numerical
 		# open widget to select window parameters, directionality
 		# create new col
-		print('you want to differentiate? cool but I"m too tired to code it now...')
-		pass
+		
+		x = self.table_view.selectedIndexes()
+		col_idx = np.unique(np.array([l.column() for l in x]))
+		if col_idx!=0:
+			cols = np.array(list(self.data.columns))
+			selected_col = str(cols[col_idx][0])
+		else:
+			selected_col = None
+
+		self.diffWidget = DifferentiateColWidget(self, selected_col)
+		self.diffWidget.show()
 
 
 	def groupby_time_table(self):
@@ -270,25 +370,102 @@ class TableUI(QMainWindow, Styles):
 	def set_projection_mode_tracks(self):
 
 		self.projectionWidget = QWidget()
+		self.projectionWidget.setMinimumWidth(500)
 		self.projectionWidget.setWindowTitle('Set projection mode')
 		
 		layout = QVBoxLayout()
 		self.projectionWidget.setLayout(layout)
+
+		self.projection_option = QRadioButton('global operation: ')
+		self.projection_option.setToolTip('Collapse the cell track measurements with an operation over each track.')
+		self.projection_option.toggled.connect(self.enable_projection_options)
 		self.projection_op_cb = QComboBox()
 		self.projection_op_cb.addItems(['mean','median','min','max', 'prod', 'sum'])
-		hbox = QHBoxLayout()
-		hbox.addWidget(QLabel('operation: '), 33)
-		hbox.addWidget(self.projection_op_cb, 66)
-		layout.addLayout(hbox)
 
-		self.set_projection_btn = QPushButton('set')
+		projection_layout = QHBoxLayout()
+		projection_layout.addWidget(self.projection_option, 33)
+		projection_layout.addWidget(self.projection_op_cb, 66)
+		layout.addLayout(projection_layout)
+
+		self.event_time_option = QRadioButton('@event time: ')
+		self.event_time_option.setToolTip('Pick the measurements at a specific event time.')
+		self.event_time_option.toggled.connect(self.enable_projection_options)
+		self.event_times_cb = QComboBox()
+		cols = np.array(self.data.columns)
+		time_cols = np.array([c.startswith('t_') for c in cols])
+		time_cols = list(cols[time_cols])
+		if 't0' in list(self.data.columns):
+			time_cols.append('t0')
+		self.event_times_cb.addItems(time_cols)
+		self.event_times_cb.setEnabled(False)
+
+		event_time_layout = QHBoxLayout()
+		event_time_layout.addWidget(self.event_time_option, 33)
+		event_time_layout.addWidget(self.event_times_cb, 66)
+		layout.addLayout(event_time_layout)
+
+
+		self.per_status_option = QRadioButton('per status: ')
+		self.per_status_option.setToolTip('Collapse the cell track measurements independently for each of the cell state.')
+		self.per_status_option.toggled.connect(self.enable_projection_options)
+		self.per_status_cb = QComboBox()
+		self.status_operation = QComboBox()
+		self.status_operation.setEnabled(False)
+		self.status_operation.addItems(['mean','median','min','max', 'prod', 'sum'])
+
+		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')
+		self.per_status_cb.addItems(status_cols)
+		self.per_status_cb.setEnabled(False)
+
+		per_status_layout = QHBoxLayout()
+		per_status_layout.addWidget(self.per_status_option, 33)
+		per_status_layout.addWidget(self.per_status_cb, 66)
+		layout.addLayout(per_status_layout)
+
+		status_operation_layout = QHBoxLayout()
+		status_operation_layout.addWidget(QLabel('operation: '), 33, alignment=Qt.AlignRight)
+		status_operation_layout.addWidget(self.status_operation, 66)
+		layout.addLayout(status_operation_layout)
+
+		self.btn_projection_group = QButtonGroup()
+		self.btn_projection_group.addButton(self.projection_option)
+		self.btn_projection_group.addButton(self.event_time_option)
+		self.btn_projection_group.addButton(self.per_status_option)
+
+		apply_layout = QHBoxLayout()
+
+		self.set_projection_btn = QPushButton('Apply')
 		self.set_projection_btn.setStyleSheet(self.button_style_sheet)
 		self.set_projection_btn.clicked.connect(self.set_proj_mode)
-		layout.addWidget(self.set_projection_btn)
+		apply_layout.addWidget(QLabel(''), 33)
+		apply_layout.addWidget(self.set_projection_btn,33)
+		apply_layout.addWidget(QLabel(''),33)
+		layout.addLayout(apply_layout)
 
 		self.projectionWidget.show()
 		center_window(self.projectionWidget)
 
+	def enable_projection_options(self):
+
+		if self.projection_option.isChecked():
+			self.projection_op_cb.setEnabled(True)
+			self.event_times_cb.setEnabled(False)
+			self.per_status_cb.setEnabled(False)
+			self.status_operation.setEnabled(False)
+		elif self.event_time_option.isChecked():
+			self.projection_op_cb.setEnabled(False)
+			self.event_times_cb.setEnabled(True)
+			self.per_status_cb.setEnabled(False)
+			self.status_operation.setEnabled(False)
+		elif self.per_status_option.isChecked():
+			self.projection_op_cb.setEnabled(False)
+			self.event_times_cb.setEnabled(False)
+			self.per_status_cb.setEnabled(True)
+			self.status_operation.setEnabled(True)
+
 	def set_1D_plot_params(self):
 
 		self.plot1Dparams = QWidget()
@@ -316,12 +493,12 @@ class TableUI(QMainWindow, Styles):
 		layout.addWidget(self.box_check)
 		layout.addWidget(self.boxenplot_check)
 
-		self.x_cb = QComboBox()
+		self.x_cb = QSearchableComboBox()
 		self.x_cb.addItems(['--']+list(self.data.columns))
 
-		self.hue_cb = QComboBox()
-		self.hue_cb.addItems(list(self.data.columns))
-		idx = self.hue_cb.findText('well_index')
+		self.hue_cb = QSearchableComboBox()
+		self.hue_cb.addItems(['--']+list(self.data.columns))
+		idx = self.hue_cb.findText('--')
 
 		self.x_cb.findText('--')
 		hbox = QHBoxLayout()
@@ -335,7 +512,12 @@ class TableUI(QMainWindow, Styles):
 		layout.addLayout(hbox)
 
 		self.cmap_cb = QColormapComboBox()
-		self.cmap_cb.addColormaps(list(plt.colormaps()))
+		for cm in list(colormaps):
+			try:
+				self.cmap_cb.addColormap(cm)
+			except:
+				pass
+		
 		hbox = QHBoxLayout()
 		hbox.addWidget(QLabel('colormap: '), 33)
 		hbox.addWidget(self.cmap_cb, 66)
@@ -370,9 +552,16 @@ class TableUI(QMainWindow, Styles):
 		y = self.data.iloc[row_idx_i, unique_cols]
 		
 		cmap = getattr(mcm, self.cmap_cb.currentText())
-		hue_variable = self.hue_cb.currentText()
 
-		colors = [cmap(i / len(self.data[hue_variable].unique())) for i in range(len(self.data[hue_variable].unique()))]
+		try:
+			hue_variable = self.hue_cb.currentText()
+			colors = [cmap(i / len(self.data[hue_variable].unique())) for i in range(len(self.data[hue_variable].unique()))]
+		except:
+			colors = None
+
+		if self.hue_cb.currentText()=='--':
+			hue_variable = None
+
 		#for w,well_group in self.data.groupby('well_index'):
 
 		legend=True
@@ -435,18 +624,86 @@ class TableUI(QMainWindow, Styles):
 
 
 	def set_proj_mode(self):
-		self.projection_mode = self.projection_op_cb.currentText()
-		#eval(self.projection_mode)
-		op = getattr(self.data.groupby(['position', 'TRACK_ID']), self.projection_mode)
-		group_table = op(self.data.groupby(['position', 'TRACK_ID']))
+		
+		self.static_columns = ['well_index', 'well_name', 'pos_name', 'position', 'well', 'status', 't0', 'class','cell_type','concentration', 'antibody', 'pharmaceutical_agent','TRACK_ID','position']
+
+		if self.projection_option.isChecked():
+
+			self.projection_mode = self.projection_op_cb.currentText()
+			op = getattr(self.data.groupby(['position', 'TRACK_ID']), self.projection_mode)
+			group_table = op(self.data.groupby(['position', 'TRACK_ID']))
+
+			for c in self.static_columns:
+				try:
+					group_table[c] = self.data.groupby(['position','TRACK_ID'])[c].apply(lambda x: x.unique()[0])
+				except Exception as e:
+					print(e)
+					pass
+			
+			for col in ['TRACK_ID']:
+				first_column = group_table.pop(col) 
+				group_table.insert(0, col, first_column)
+			group_table.pop('FRAME')
+
+
+		elif self.event_time_option.isChecked():
+			time_of_interest = self.event_times_cb.currentText()
+			self.projection_mode = f"measurements at {time_of_interest}"
+			new_table = []
+			for tid,group in self.data.groupby(['position','TRACK_ID']):
+				time = group[time_of_interest].values[0]
+				if time==time:
+					time = floor(time) # floor for onset
+				else:
+					continue
+				frames = group['FRAME'].values
+				values = group.loc[group['FRAME']==time,:].to_numpy()
+				if len(values)>0:
+					values = dict(zip(list(self.data.columns), values[0]))
+					values.update({'TRACK_ID': tid[1]})
+					values.update({'position': tid[0]})
+					new_table.append(values)
+			
+			group_table = pd.DataFrame(new_table)
+			for col in ['TRACK_ID']:
+				first_column = group_table.pop(col) 
+				group_table.insert(0, col, first_column)
+			
+			group_table = group_table.sort_values(by=['position','TRACK_ID','FRAME'],ignore_index=True)
+			group_table = group_table.reset_index(drop=True)
+
+
+		elif self.per_status_option.isChecked():
+
+			status_of_interest = self.per_status_cb.currentText()
+			self.projection_mode = f'{self.status_operation.currentText()} per {status_of_interest}'
+			self.data = self.data.dropna(subset=status_of_interest,ignore_index=True)
+			unique_statuses = np.unique(self.data[status_of_interest].to_numpy())
+
+			df_sections = []
+			for s in unique_statuses:
+				subtab = self.data.loc[self.data[status_of_interest]==s,:]
+				op = getattr(subtab.groupby(['position', 'TRACK_ID']), self.status_operation.currentText())
+				subtab_projected = op(subtab.groupby(['position', 'TRACK_ID']))
+				frame_duration = subtab.groupby(['position','TRACK_ID']).size().to_numpy()
+				for c in self.static_columns:
+					try:
+						subtab_projected[c] = subtab.groupby(['position', 'TRACK_ID'])[c].apply(lambda x: x.unique()[0])
+					except Exception as e:
+						print(e)
+						pass
+				subtab_projected['duration_in_state'] = frame_duration
+				df_sections.append(subtab_projected)
+
+			group_table = pd.concat(df_sections,axis=0,ignore_index=True)
+			for col in ['duration_in_state',status_of_interest,'TRACK_ID']:
+				first_column = group_table.pop(col) 
+				group_table.insert(0, col, first_column)
+			group_table.pop('FRAME')
+			group_table = group_table.sort_values(by=['position','TRACK_ID',status_of_interest],ignore_index=True)
+			group_table = group_table.reset_index(drop=True)
+
 
-		self.static_columns = ['well_index', 'well_name', 'pos_name', 'position', 'well', 'status', 't0', 'class', 'concentration', 'antibody', 'pharmaceutical_agent']
-		for c in self.static_columns:
-			try:
-				group_table[c] = self.data.groupby(['position','TRACK_ID'])[c].apply(lambda x: x.unique()[0])
-			except Exception as e:
-				print(e)
-				pass
 		self.subtable = TableUI(group_table,f"Group by tracks: {self.projection_mode}", plot_mode="static")
 		self.subtable.show()
 
@@ -487,6 +744,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":
 	

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
@@ -12,11 +12,12 @@ from skimage.morphology import disk
 
 from celldetective.filters import std_filter, gauss_filter
 from celldetective.gui.gui_utils import center_window, FigureCanvas, ListWidget, FilterChoice, color_from_class
-from celldetective.utils import get_software_location, extract_experiment_channels, rename_intensity_column
+from celldetective.utils import get_software_location, extract_experiment_channels, rename_intensity_column, estimate_unreliable_edge
 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
@@ -61,6 +62,7 @@ class ThresholdConfigWizard(QMainWindow, Styles):
 		self.onlyFloat = QDoubleValidator()
 		self.onlyInt = QIntValidator()
 		self.cell_properties = ['centroid', 'area', 'perimeter', 'eccentricity', 'intensity_mean', 'solidity']
+		self.edge = None
 
 		if self.mode == "targets":
 			self.config_out_name = "threshold_targets.json"
@@ -262,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()
@@ -274,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()
@@ -285,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()
@@ -304,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()
@@ -437,7 +466,7 @@ class ThresholdConfigWizard(QMainWindow, Styles):
 		self.im = self.ax.imshow(self.img, cmap='gray')
 
 		self.binary = threshold_image(self.img, self.threshold_slider.value()[0], self.threshold_slider.value()[1],
-									  foreground_value=255., fill_holes=False)
+									  foreground_value=1., fill_holes=True, edge_exclusion=None)
 		self.thresholded_image = np.ma.masked_where(self.binary == 0., self.binary)
 		self.image_thresholded = self.ax.imshow(self.thresholded_image, cmap="viridis", alpha=0.5, interpolation='none')
 
@@ -591,6 +620,7 @@ class ThresholdConfigWizard(QMainWindow, Styles):
 
 		self.reload_frame()
 		filters = self.filters_qlist.items
+		self.edge = estimate_unreliable_edge(filters)
 		self.img = filter_image(self.img, filters)
 		self.refresh_imshow()
 		self.update_histogram()
@@ -637,7 +667,7 @@ class ThresholdConfigWizard(QMainWindow, Styles):
 		"""
 
 		self.binary = threshold_image(self.img, self.threshold_slider.value()[0], self.threshold_slider.value()[1],
-									  foreground_value=255., fill_holes=False)
+									  foreground_value=1., fill_holes=True, edge_exclusion=self.edge)
 		self.thresholded_image = np.ma.masked_where(self.binary == 0., self.binary)
 		self.image_thresholded.set_data(self.thresholded_image)
 		self.fcanvas.canvas.draw_idle()
@@ -658,7 +688,7 @@ class ThresholdConfigWizard(QMainWindow, Styles):
 
 		if self.binary.ndim == 3:
 			self.binary = np.squeeze(self.binary)
-		self.binary = binary_fill_holes(self.binary)
+		#self.binary = binary_fill_holes(self.binary)
 		self.coords, self.edt_map = identify_markers_from_binary(self.binary, self.min_dist,
 																 footprint_size=self.footprint, footprint=None,
 																 return_edt=True)
@@ -673,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())
@@ -785,7 +818,7 @@ class ThresholdConfigWizard(QMainWindow, Styles):
 		self.property_query_le.setText('')
 
 		self.binary = threshold_image(self.img, self.threshold_slider.value()[0], self.threshold_slider.value()[1],
-									  foreground_value=255., fill_holes=False)
+									  foreground_value=1., fill_holes=True, edge_exclusion=self.edge)
 		self.thresholded_image = np.ma.masked_where(self.binary == 0., self.binary)
 
 		self.scat_markers.set_color('tab:red')
@@ -804,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)
@@ -871,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):