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

celldetective/gui/survival_ui.py

@@ -4,17 +4,19 @@ from PyQt5.QtGui import QDoubleValidator
 from celldetective.gui.gui_utils import center_window
 from superqt import QColormapComboBox
 from celldetective.gui.generic_signal_plot import SurvivalPlotWidget
-from celldetective.utils import get_software_location, _extract_labels_from_config
+from celldetective.utils import get_software_location, _extract_labels_from_config, extract_cols_from_table_list
 from celldetective.io import load_experiment_tables
 import numpy as np
 import os
 import matplotlib.pyplot as plt
 plt.rcParams['svg.fonttype'] = 'none'
 from glob import glob
-import pandas as pd
 from celldetective.gui import Styles
 from matplotlib import colormaps
 from celldetective.events import compute_survival
+from celldetective.relative_measurements import expand_pair_table
+import matplotlib.cm
+from celldetective.neighborhood import extract_neighborhood_in_pair_table
 
 class ConfigSurvival(QWidget, Styles):
 	
@@ -88,8 +90,51 @@ class ConfigSurvival(QWidget, Styles):
 		main_layout.addWidget(panel_title, alignment=Qt.AlignCenter)
 
 
-		labels = [QLabel('population: '), QLabel('time of\nreference: '), QLabel('time of\ninterest: '), QLabel('cmap: ')] #QLabel('class: '), 
-		self.cb_options = [['targets','effectors'], ['0'], [], []] #['class'], 
+		pops = []
+		for population in ['effectors','targets','pairs']:
+			tables = glob(self.exp_dir+os.sep.join(['W*','*','output','tables',f'trajectories_{population}.csv']))
+			if len(tables)>0:
+				pops.append(population)
+
+		tables_targets = glob(self.exp_dir+os.sep.join(['W*','*','output','tables',f'trajectories_targets.csv']))
+		self.cols_targets = extract_cols_from_table_list(tables_targets)
+		tables_effectors = glob(self.exp_dir+os.sep.join(['W*','*','output','tables',f'trajectories_effectors.csv']))
+		self.cols_effectors = extract_cols_from_table_list(tables_effectors)
+
+		# Smart reading of existing neighborhoods (without loading tables in memory)
+		if 'pairs' in pops and not 'targets' in pops:
+			# must be effector-effector
+			effector_neighs = [c[16:] for c in self.cols_effectors if c.startswith('inclusive_count_neighborhood')]
+			if len(effector_neighs)>0:
+				pops.pop(pops.index('pairs'))
+				pops.append('effectors-effectors')
+		elif 'pairs' in pops and not 'effectors' in pops:
+			# must be target-target
+			target_neighs = [c for c in self.cols_targets if c.startswith('inclusive_count_neighborhood')]
+			if len(target_neighs)>0:
+				pops.pop(pops.index('pairs'))
+				pops.append('targets-targets')
+		elif 'pairs' in pops:
+			# either effector-target or target-effector
+			target_neighs_cross = [c for c in self.cols_targets if c.startswith('inclusive_count_neighborhood') and '_2_' in c]
+			if len(target_neighs_cross)>0:
+				pops.append('targets-effectors')
+			effector_neighs_cross = [c for c in self.cols_effectors if c.startswith('inclusive_count_neighborhood') and '_2_' in c]
+			if len(effector_neighs_cross)>0:
+				pops.append('effectors-targets')
+			target_neighs = [c for c in self.cols_targets if c.startswith('inclusive_count_neighborhood') and 'self' in c]
+			if len(target_neighs)>0:
+				pops.append('targets-targets')
+			effector_neighs = [c for c in self.cols_effectors if c.startswith('inclusive_count_neighborhood') and 'self' in c]
+			if len(effector_neighs)>0:
+				pops.append('effectors-effectors')
+			pops.pop(pops.index('pairs'))
+		else:
+			pass
+
+
+		labels = [QLabel('population: '), QLabel('time of\nreference: '), QLabel('time of\ninterest: '), QLabel('cmap: ')] #QLabel('class: '),
+		self.cb_options = [pops, ['0'], [], []] #['class'],
 		self.cbs = [QComboBox() for i in range(len(labels))]
 
 		self.cbs[-1] = QColormapComboBox()
@@ -107,10 +152,12 @@ class ConfigSurvival(QWidget, Styles):
 
 		all_cms = list(colormaps)
 		for cm in all_cms:
-			try:
-				self.cbs[-1].addColormap(cm)
-			except:
-				pass
+			if hasattr(matplotlib.cm, str(cm).lower()):
+				self.cbs[-1].addColormap(cm.lower())
+			#try:
+			# 	self.cbs[-1].addColormap(cm)
+			# except:
+			# 	pass
 
 		main_layout.addLayout(choice_layout)
 
@@ -155,24 +202,60 @@ class ConfigSurvival(QWidget, Styles):
 	def set_classes_and_times(self):
 
 		# Look for all classes and times
-		tables = glob(self.exp_dir+os.sep.join(['W*','*','output','tables',f'trajectories_*.csv']))
-		self.all_columns = []
-		for tab in tables:
-			cols = pd.read_csv(tab, nrows=1,encoding_errors='ignore').columns.tolist()
-			self.all_columns.extend(cols)
+		self.neighborhood_keys = None
+		self.population = self.cbs[0].currentText()
+		pop_split = self.population.split('-')
 
-		self.all_columns = np.unique(self.all_columns)
-		#class_idx = np.array([s.startswith('class_') for s in self.all_columns])
-		time_idx = np.array([s.startswith('t_') for s in self.all_columns])
+		if len(pop_split)==2:
 
-		try:
-			time_columns = list(self.all_columns[time_idx])
-		except:
-			print('no column starts with t')
-			self.auto_close = True
-			return None
-		if 't0' in self.all_columns:
-			time_columns.append('t0')
+			self.population = 'pairs'
+			tables_pairs = glob(self.exp_dir+os.sep.join(['W*','*','output','tables',f'trajectories_pairs.csv']))
+			self.cols_pairs = extract_cols_from_table_list(tables_pairs)
+
+			self.population_reference = pop_split[0]
+			self.population_neigh = pop_split[1]
+			if self.population_reference=='targets':
+				cols_ref = self.cols_targets
+			else:
+				cols_ref = self.cols_effectors
+			if self.population_neigh=='targets':
+				cols_neigh = self.cols_targets
+			else:
+				cols_neigh = self.cols_effectors
+
+			time_cols_ref = np.array([s.startswith('t_') or s=='t0' for s in cols_ref])
+			if len(time_cols_ref)>0:
+				time_cols_ref = list(cols_ref[time_cols_ref])
+				time_cols_ref = ['reference_'+t for t in time_cols_ref]
+
+			time_cols_neigh = np.array([s.startswith('t_') or s=='t0' for s in cols_neigh])
+			if len(time_cols_neigh)>0:
+				time_cols_neigh = list(cols_neigh[time_cols_neigh])
+				time_cols_neigh = ['neighbor_'+t for t in time_cols_neigh]
+
+			if self.population_reference!=self.population_neigh:
+				self.neighborhood_keys = [c[16:] for c in cols_ref if c.startswith('inclusive_count_neighborhood') and '_2_' in c]
+			else:
+				self.neighborhood_keys = [c[16:] for c in cols_ref if c.startswith('inclusive_count_neighborhood') and 'self' in c]
+
+			time_idx = np.array([s.startswith('t_') or s.startswith('t0') for s in self.cols_pairs])
+			time_cols_pairs = list(self.cols_pairs[time_idx])
+
+			time_columns = time_cols_ref + time_cols_neigh + time_cols_pairs
+
+		else:
+			if self.population=='targets':
+				self.all_columns = self.cols_targets
+			else:
+				self.all_columns = self.cols_effectors
+			time_idx = np.array([s.startswith('t_') or s=='t0' for s in self.all_columns])
+
+			try:
+				time_columns = list(self.all_columns[time_idx])
+			except:
+				print('no column starts with t')
+				self.auto_close = True
+				return None
 
 		self.cbs[1].clear()
 		self.cbs[1].addItems(np.unique(self.cb_options[1]+time_columns))
@@ -184,19 +267,16 @@ class ConfigSurvival(QWidget, Styles):
 
 	def process_survival(self):
 
-		print('you clicked!!')
 		self.FrameToMin = float(self.time_calibration_le.text().replace(',','.'))
-		print(self.FrameToMin, 'set')
-
 		self.time_of_interest = self.cbs[2].currentText()
 		if self.time_of_interest=="t0":
 			self.class_of_interest = "class"
 		else:
 			self.class_of_interest = self.time_of_interest.replace('t_','class_')
 
+
 		# read instructions from combobox options
 		self.load_available_tables_local()
-
 		if self.df is not None:
 			
 			try:
@@ -241,7 +321,8 @@ class ConfigSurvival(QWidget, Styles):
 		self.well_option = self.parent_window.parent_window.well_list.getSelectedIndices()
 		self.position_option = self.parent_window.parent_window.position_list.getSelectedIndices()
 
-		self.df, self.df_pos_info = load_experiment_tables(self.exp_dir, well_option=self.well_option, position_option=self.position_option, population=self.cbs[0].currentText(), return_pos_info=True)
+		self.df, self.df_pos_info = load_experiment_tables(self.exp_dir, well_option=self.well_option, position_option=self.position_option, population=self.population, return_pos_info=True)
+
 		if self.df is None:
 			msgBox = QMessageBox()
 			msgBox.setIcon(QMessageBox.Warning)
@@ -255,6 +336,11 @@ class ConfigSurvival(QWidget, Styles):
 			self.df_well_info = self.df_pos_info.loc[:,['well_path', 'well_index', 'well_name', 'well_number', 'well_alias']].drop_duplicates()
 			#print(f"{self.df_well_info=}")
 
+		if self.population=='pairs':
+			self.df = expand_pair_table(self.df)
+			self.df = extract_neighborhood_in_pair_table(self.df, reference_population=self.population_reference, neighbor_population=self.population_neigh, neighborhood_key=self.neighborhood_keys[0], contact_only=True)
+
+
 	def compute_survival_functions(self):
 
 		cut_observation_time = None
@@ -265,19 +351,20 @@ class ConfigSurvival(QWidget, Styles):
 				cut_observation_time = None		
 		except Exception as e:
 			pass
-		print(f"{cut_observation_time=}")
+
+		pairs = False
+		if self.neighborhood_keys is not None:
+			pairs = True
 
 		# Per position survival
 		for block,movie_group in self.df.groupby(['well','position']):
-
-			ks = compute_survival(movie_group, self.class_of_interest, self.cbs[2].currentText(), t_reference=self.cbs[1].currentText(), FrameToMin=self.FrameToMin, cut_observation_time=cut_observation_time)
+			ks = compute_survival(movie_group, self.class_of_interest, self.cbs[2].currentText(), t_reference=self.cbs[1].currentText(), FrameToMin=self.FrameToMin, cut_observation_time=cut_observation_time, pairs=pairs)
 			if ks is not None:
 				self.df_pos_info.loc[self.df_pos_info['pos_path']==block[1],'survival_fit'] = ks
 
 		# Per well survival
 		for well,well_group in self.df.groupby('well'):
-
-			ks = compute_survival(well_group, self.class_of_interest, self.cbs[2].currentText(), t_reference=self.cbs[1].currentText(), FrameToMin=self.FrameToMin, cut_observation_time=cut_observation_time)
+			ks = compute_survival(well_group, self.class_of_interest, self.cbs[2].currentText(), t_reference=self.cbs[1].currentText(), FrameToMin=self.FrameToMin, cut_observation_time=cut_observation_time, pairs=pairs)
 			if ks is not None:
 				self.df_well_info.loc[self.df_well_info['well_path']==well,'survival_fit'] = ks
 

celldetective/gui/tableUI.py

@@ -19,6 +19,7 @@ from fonticon_mdi6 import MDI6
 from math import floor
 
 from matplotlib import colormaps
+import matplotlib.cm
 
 
 class QueryWidget(QWidget):
@@ -473,6 +474,14 @@ class TableUI(QMainWindow, Styles):
 		self.table_view.resizeColumnsToContents()
 		self.setAttribute(Qt.WA_DeleteOnClose)
 
+	def resizeEvent(self, event):
+
+		super().resizeEvent(event)
+
+		try:
+			self.fig.tight_layout()
+		except:
+			pass
 
 	def _createActions(self):
 
@@ -718,8 +727,11 @@ class TableUI(QMainWindow, Styles):
 	def save_as_csv_inplace_per_pos(self):
 
 		print("Saving each table in its respective position folder...")
-		for pos,pos_group in self.data.groupby('position'):
-			pos_group.to_csv(pos+os.sep.join(['output', 'tables', f'trajectories_{self.population}.csv']), index=False)
+		for pos,pos_group in self.data.groupby(['position']):
+			invalid_cols = [c for c in list(pos_group.columns) if c.startswith('Unnamed')]
+			if len(invalid_cols)>0:
+				pos_group = pos_group.drop(invalid_cols, axis=1)
+			pos_group.to_csv(pos[0]+os.sep.join(['output', 'tables', f'trajectories_{self.population}.csv']), index=False)
 		print("Done...")
 
 	def differenciate_selected_feature(self):
@@ -812,7 +824,7 @@ class TableUI(QMainWindow, Styles):
 
 		num_df = self.data.select_dtypes(include=self.numerics)
 
-		timeseries = num_df.groupby("FRAME").sum().copy()
+		timeseries = num_df.groupby(["FRAME"]).sum().copy()
 		timeseries["timeline"] = timeseries.index
 		self.subtable = TableUI(timeseries,"Group by frames", plot_mode="plot_timeseries")
 		self.subtable.show()
@@ -1029,11 +1041,10 @@ class TableUI(QMainWindow, Styles):
 		layout.addLayout(hbox)
 
 		self.cmap_cb = QColormapComboBox()
-		for cm in list(colormaps):
-			try:
-				self.cmap_cb.addColormap(cm)
-			except:
-				pass
+		all_cms = list(colormaps)
+		for cm in all_cms:
+			if hasattr(matplotlib.cm, str(cm).lower()):
+				self.cmap_cb.addColormap(cm.lower())
 		
 		hbox = QHBoxLayout()
 		hbox.addWidget(QLabel('colormap: '), 33)
@@ -1324,6 +1335,9 @@ class TableUI(QMainWindow, Styles):
 		if file_name:
 			if not file_name.endswith(".csv"):
 				file_name += ".csv"
+			invalid_cols = [c for c in list(self.data.columns) if c.startswith('Unnamed')]
+			if len(invalid_cols)>0:
+				self.data = self.data.drop(invalid_cols, axis=1)	
 			self.data.to_csv(file_name, index=False)
 
 	def test_bool(self, array):
@@ -1417,8 +1431,8 @@ class TableUI(QMainWindow, Styles):
 					row_idx_i = row_idx[np.where(col_idx == unique_cols[k])[0]]
 					y = self.data.iloc[row_idx_i, unique_cols[k]]
 					print(unique_cols[k])
-					for w,well_group in self.data.groupby('well_name'):
-						for pos,pos_group in well_group.groupby('pos_name'):
+					for w,well_group in self.data.groupby(['well_name']):
+						for pos,pos_group in well_group.groupby(['pos_name']):
 							for tid,group_track in pos_group.groupby(self.groupby_cols[1:]):
 								ax.plot(group_track["FRAME"], group_track[column_names[unique_cols[k]]],label=column_names[unique_cols[k]])
 					#ax.plot(self.data["FRAME"][row_idx_i], y, label=column_names[unique_cols[k]])
@@ -1454,8 +1468,8 @@ class TableUI(QMainWindow, Styles):
 				# else:
 				# 	ref_time_col = 'FRAME'
 
-				for w,well_group in self.data.groupby('well_name'):
-					for pos,pos_group in well_group.groupby('pos_name'):
+				for w,well_group in self.data.groupby(['well_name']):
+					for pos,pos_group in well_group.groupby(['pos_name']):
 						for tid,group_track in pos_group.groupby(self.groupby_cols[1:]):
 							self.ax.plot(group_track["FRAME"], group_track[column_names[unique_cols[0]]],c="k", alpha = 0.1)
 				self.ax.set_xlabel(r"$t$ [frame]")

celldetective/gui/thresholds_gui.py

@@ -3,7 +3,8 @@ from PyQt5.QtWidgets import QAction, QMenu, QMainWindow, QMessageBox, QLabel, QW
 from PyQt5.QtGui import QDoubleValidator, QIntValidator
 
 from celldetective.filters import std_filter, gauss_filter
-from celldetective.gui.gui_utils import center_window, FigureCanvas, ListWidget, FilterChoice, color_from_class, help_generic
+from celldetective.gui.gui_utils import center_window, FigureCanvas, color_from_class, help_generic
+from celldetective.gui.gui_utils import PreprocessingLayout
 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
@@ -23,6 +24,7 @@ import os
 
 from celldetective.gui import Styles
 
+
 class ThresholdConfigWizard(QMainWindow, Styles):
 	"""
 	UI to create a threshold pipeline for segmentation.
@@ -140,53 +142,8 @@ class ThresholdConfigWizard(QMainWindow, Styles):
 
 	def populate_left_panel(self):
 
-		self.filters_qlist = ListWidget(FilterChoice, [])
-
-		grid_preprocess = QGridLayout()
-		grid_preprocess.setContentsMargins(20, 20, 20, 20)
-
-		filter_list_option_grid = QHBoxLayout()
-		section_preprocess = QLabel("Preprocessing")
-		section_preprocess.setStyleSheet("font-weight: bold;")
-		filter_list_option_grid.addWidget(section_preprocess, 90, alignment=Qt.AlignLeft)
-
-		self.delete_filter = QPushButton("")
-		self.delete_filter.setStyleSheet(self.button_select_all)
-		self.delete_filter.setIcon(icon(MDI6.trash_can, color="black"))
-		self.delete_filter.setToolTip("Remove filter")
-		self.delete_filter.setIconSize(QSize(20, 20))
-		self.delete_filter.clicked.connect(self.filters_qlist.removeSel)
-
-		self.add_filter = QPushButton("")
-		self.add_filter.setStyleSheet(self.button_select_all)
-		self.add_filter.setIcon(icon(MDI6.filter_plus, color="black"))
-		self.add_filter.setToolTip("Add filter")
-		self.add_filter.setIconSize(QSize(20, 20))
-		self.add_filter.clicked.connect(self.filters_qlist.addItem)
-
-		self.help_prefilter_btn = QPushButton()
-		self.help_prefilter_btn.setIcon(icon(MDI6.help_circle,color=self.help_color))
-		self.help_prefilter_btn.setIconSize(QSize(20, 20))
-		self.help_prefilter_btn.clicked.connect(self.help_prefilter)
-		self.help_prefilter_btn.setStyleSheet(self.button_select_all)
-		self.help_prefilter_btn.setToolTip("Help.")
-
-		# filter_list_option_grid.addWidget(QLabel(""),90)
-		filter_list_option_grid.addWidget(self.delete_filter, 5)
-		filter_list_option_grid.addWidget(self.add_filter, 5)
-		filter_list_option_grid.addWidget(self.help_prefilter_btn, 5)
-
-		grid_preprocess.addLayout(filter_list_option_grid, 0, 0, 1, 3)
-		grid_preprocess.addWidget(self.filters_qlist, 1, 0, 1, 3)
-
-		self.apply_filters_btn = QPushButton("Apply")
-		self.apply_filters_btn.setIcon(icon(MDI6.filter_cog_outline, color="white"))
-		self.apply_filters_btn.setIconSize(QSize(20, 20))
-		self.apply_filters_btn.setStyleSheet(self.button_style_sheet)
-		self.apply_filters_btn.clicked.connect(self.preprocess_image)
-		grid_preprocess.addWidget(self.apply_filters_btn, 2, 0, 1, 3)
-
-		self.left_panel.addLayout(grid_preprocess)
+		self.preprocessing = PreprocessingLayout(self)
+		self.left_panel.addLayout(self.preprocessing)
 
 		###################
 		# THRESHOLD SECTION
@@ -484,7 +441,7 @@ class ThresholdConfigWizard(QMainWindow, Styles):
 		self.fcanvas = FigureCanvas(self.fig, interactive=True)
 		self.ax.clear()
 
-		self.im = self.ax.imshow(self.img, cmap='gray')
+		self.im = self.ax.imshow(self.img, cmap='gray', interpolation='none')
 
 		self.binary = threshold_image(self.img, self.threshold_slider.value()[0], self.threshold_slider.value()[1],
 									  foreground_value=1., fill_holes=True, edge_exclusion=None)
@@ -640,7 +597,7 @@ class ThresholdConfigWizard(QMainWindow, Styles):
 		"""
 
 		self.reload_frame()
-		filters = self.filters_qlist.items
+		filters = self.preprocessing.list.items
 		self.edge = estimate_unreliable_edge(filters)
 		self.img = filter_image(self.img, filters)
 		self.refresh_imshow()
@@ -853,7 +810,7 @@ class ThresholdConfigWizard(QMainWindow, Styles):
 		instructions = {
 			"target_channel": self.channels_cb.currentText(),  # for now index but would be more universal to use name
 			"thresholds": self.threshold_slider.value(),
-			"filters": self.filters_qlist.items,
+			"filters": self.preprocessing.list.items,
 			"marker_min_distance": self.min_dist,
 			"marker_footprint_size": self.footprint,
 			"feature_queries": [self.property_query_le.text()],
@@ -906,7 +863,7 @@ class ThresholdConfigWizard(QMainWindow, Styles):
 		items_to_add = [f[0] + '_filter' for f in filters]
 		self.filters_qlist.list_widget.clear()
 		self.filters_qlist.list_widget.addItems(items_to_add)
-		self.filters_qlist.items = filters
+		self.preprocessing.list.items = filters
 
 		self.apply_filters_btn.click()
 

celldetective/gui/viewers.py

@@ -14,7 +14,7 @@ import os
 from PyQt5.QtWidgets import QWidget, QHBoxLayout, QPushButton, QLabel, QComboBox, QLineEdit, QListWidget, QShortcut
 from PyQt5.QtCore import Qt, QSize
 from PyQt5.QtGui import QKeySequence, QDoubleValidator
-from celldetective.gui.gui_utils import FigureCanvas, center_window, QuickSliderLayout, QHSeperationLine, ThresholdLineEdit
+from celldetective.gui.gui_utils import FigureCanvas, center_window, QuickSliderLayout, QHSeperationLine, ThresholdLineEdit, PreprocessingLayout2
 from celldetective.gui import Styles
 from superqt import QLabeledDoubleSlider, QLabeledSlider, QLabeledDoubleRangeSlider
 from superqt.fonticon import icon
@@ -626,21 +626,26 @@ class CellEdgeVisualizer(StackVisualizer):
 
 class SpotDetectionVisualizer(StackVisualizer):
 	
-	def __init__(self, parent_channel_cb=None, parent_diameter_le=None, parent_threshold_le=None, cell_type='targets', labels=None, *args, **kwargs):
+	def __init__(self, parent_channel_cb=None, parent_diameter_le=None, parent_threshold_le=None, parent_preprocessing_list=None, cell_type='targets', labels=None, *args, **kwargs):
 
 		super().__init__(*args, **kwargs)
 		
 		self.cell_type = cell_type
 		self.labels = labels
 		self.detection_channel = self.target_channel
+
 		self.parent_channel_cb = parent_channel_cb
 		self.parent_diameter_le = parent_diameter_le
 		self.parent_threshold_le = parent_threshold_le
-		self.spot_sizes = []
+		self.parent_preprocessing_list = parent_preprocessing_list
 
+		self.spot_sizes = []
 		self.floatValidator = QDoubleValidator()
 		self.init_scatter()
-		self.generate_detection_channel()
+		
+		self.generate_detection_channel()		
+		self.detection_channel = self.detection_channel_cb.currentIndex()
+
 		self.generate_spot_detection_params()
 		self.generate_add_measurement_btn()
 		self.load_labels()
@@ -663,10 +668,10 @@ class SpotDetectionVisualizer(StackVisualizer):
 
 		# Data-to-pixel scale
 		ax_width_in_pixels = self.ax.bbox.width
-		ax_height_in_pixels = self.ax.bbox.height
+		ax_height_in_pixels =self.ax.bbox.height
 
-		x_scale = (xlim[1] - xlim[0]) / ax_width_in_pixels
-		y_scale = (ylim[1] - ylim[0]) / ax_height_in_pixels
+		x_scale = (float(xlim[1]) - float(xlim[0])) / ax_width_in_pixels
+		y_scale = (float(ylim[1]) - float(ylim[0])) / ax_height_in_pixels
 
 		# Choose the smaller scale for square pixels
 		scale = min(x_scale, y_scale)
@@ -674,7 +679,7 @@ class SpotDetectionVisualizer(StackVisualizer):
 		# Convert radius_px to data units
 		if len(self.spot_sizes)>0:
 
-			radius_data_units = self.spot_sizes / scale
+			radius_data_units = self.spot_sizes / float(scale)
 
 			# Convert to scatter `s` size (points squared)
 			radius_pts = radius_data_units * (72. / self.fig.dpi )
@@ -697,8 +702,7 @@ class SpotDetectionVisualizer(StackVisualizer):
 		if self.mode=='virtual':
 			self.init_label = imread(self.mask_paths[value])
 			self.target_img = load_frames(self.img_num_per_channel[self.detection_channel, value], 
-								self.stack_path,
-								normalize_input=False).astype(float)[:,:,0]
+								self.stack_path,normalize_input=False).astype(float)[:,:,0]
 		elif self.mode=='direct':
 			self.init_label = self.labels[value,:,:]
 			self.target_img = self.stack[value,:,:,self.detection_channel].copy()
@@ -707,18 +711,28 @@ class SpotDetectionVisualizer(StackVisualizer):
 
 		self.reset_detection()
 		self.control_valid_parameters() # set current diam and threshold
-		blobs_filtered = extract_blobs_in_image(self.target_img, self.init_label,threshold=self.thresh, diameter=self.diameter)
+		#self.change_frame(self.frame_slider.value())
+		#self.set_detection_channel_index(self.detection_channel_cb.currentIndex())
+
+		image_preprocessing = self.preprocessing.list.items
+		if image_preprocessing==[]:
+			image_preprocessing = None
+
+		blobs_filtered = extract_blobs_in_image(self.target_img, self.init_label,threshold=self.thresh, diameter=self.diameter, image_preprocessing=image_preprocessing)
 		if blobs_filtered is not None:
 			self.spot_positions = np.array([[x,y] for y,x,_ in blobs_filtered])
-			
-			self.spot_sizes = np.sqrt(2)*np.array([sig for _,_,sig in blobs_filtered])
-			print(f"{self.spot_sizes=}")
+			if len(self.spot_positions)>0:
+				self.spot_sizes = np.sqrt(2)*np.array([sig for _,_,sig in blobs_filtered])
 			#radius_pts = self.spot_sizes * (self.fig.dpi / 72.0)
 			#sizes = np.pi*(radius_pts**2)
-
-			self.spot_scat.set_offsets(self.spot_positions)
+			if len(self.spot_positions)>0:
+				self.spot_scat.set_offsets(self.spot_positions)
+			else:
+				empty_offset = np.ma.masked_array([0, 0], mask=True)
+				self.spot_scat.set_offsets(empty_offset)
 			#self.spot_scat.set_sizes(sizes)
-			self.update_marker_sizes()
+			if len(self.spot_positions)>0:
+				self.update_marker_sizes()
 			self.canvas.canvas.draw()
 
 	def reset_detection(self):
@@ -778,17 +792,34 @@ class SpotDetectionVisualizer(StackVisualizer):
 		self.detection_channel_cb.addItems(self.channel_names)
 		self.detection_channel_cb.currentIndexChanged.connect(self.set_detection_channel_index)
 		channel_layout.addWidget(self.detection_channel_cb, 75)
+
+		# self.invert_check = QCheckBox('invert')
+		# if self.invert:
+		# 	self.invert_check.setChecked(True)
+		# self.invert_check.toggled.connect(self.set_invert)
+		# channel_layout.addWidget(self.invert_check, 10)
+
 		self.canvas.layout.addLayout(channel_layout)
+		
+		self.preprocessing = PreprocessingLayout2(fraction=25, parent_window=self)
+		self.preprocessing.setContentsMargins(15,0,15,0)
+		self.canvas.layout.addLayout(self.preprocessing)
+
+
+	# def set_invert(self):
+	# 	if self.invert_check.isChecked():
+	# 		self.invert = True
+	# 	else:
+	# 		self.invert = False
 
 	def set_detection_channel_index(self, value):
 
 		self.detection_channel = value
 		if self.mode == 'direct':
-			self.last_frame = self.stack[-1,:,:,self.target_channel]
+			self.target_img = self.stack[-1,:,:,self.detection_channel]
 		elif self.mode == 'virtual':
-			self.target_img = load_frames(self.img_num_per_channel[self.detection_channel, self.stack_length-1], 
-										  self.stack_path,
-										  normalize_input=False).astype(float)[:,:,0]
+			self.target_img = load_frames(self.img_num_per_channel[self.detection_channel, self.frame_slider.value()], 
+										  self.stack_path,normalize_input=False).astype(float)[:,:,0]
 
 	def generate_spot_detection_params(self):
 
@@ -865,6 +896,12 @@ class SpotDetectionVisualizer(StackVisualizer):
 			self.parent_diameter_le.setText(self.spot_diam_le.text())
 		if self.parent_threshold_le is not None:
 			self.parent_threshold_le.setText(self.spot_thresh_le.text())
+		if self.parent_preprocessing_list is not None:
+			self.parent_preprocessing_list.clear()
+			items = self.preprocessing.list.getItems()
+			for item in items:
+				self.parent_preprocessing_list.addItemToList(item)
+			self.parent_preprocessing_list.items = self.preprocessing.list.items
 		self.close()
 
 class CellSizeViewer(StackVisualizer):