celldetective 1.3.5__py3-none-any.whl → 1.3.6.post2__py3-none-any.whl

celldetective/gui/measurement_options.py

@@ -27,9 +27,10 @@ from pathlib import Path
 
 from celldetective.gui.viewers import CellEdgeVisualizer, SpotDetectionVisualizer
 from celldetective.gui.layouts import ProtocolDesignerLayout, BackgroundFitCorrectionLayout, LocalCorrectionLayout
-from celldetective.gui.gui_utils import ThresholdLineEdit
+from celldetective.gui.gui_utils import ThresholdLineEdit, PreprocessingLayout2
 from celldetective.gui import Styles
 
+
 class ConfigMeasurements(QMainWindow, Styles):
 	"""
 	UI to set measurement instructions.
@@ -477,6 +478,8 @@ class ConfigMeasurements(QMainWindow, Styles):
 		Write the selected options in a json file for later reading by the software.
 		"""
 
+		print(f"{self.spot_preprocessing.list.items=}")
+
 		print('Writing instructions...')
 		measurement_options = {}
 		background_correction = self.protocol_layout.protocols
@@ -508,8 +511,11 @@ class ConfigMeasurements(QMainWindow, Styles):
 									'isotropic_operations': isotropic_operations})
 		spot_detection = None
 		if self.spot_check.isChecked():
+			image_preprocessing = self.spot_preprocessing.list.items
+			if image_preprocessing==[]:
+				image_preprocessing = None
 			spot_detection = {'channel': self.spot_channel.currentText(), 'diameter': float(self.diameter_value.text().replace(',','.')),
-							  'threshold': float(self.threshold_value.text().replace(',','.'))}
+							  'threshold': float(self.threshold_value.text().replace(',','.')), 'image_preprocessing': image_preprocessing}
 		measurement_options.update({'spot_detection': spot_detection})
 		if self.clear_previous_btn.isChecked():
 			self.clear_previous = True
@@ -518,7 +524,6 @@ class ConfigMeasurements(QMainWindow, Styles):
 		measurement_options.update({'clear_previous': self.clear_previous})
 
 
-
 		print('Measurement instructions: ', measurement_options)
 		file_name = self.measure_instructions_path
 		with open(file_name, 'w') as f:
@@ -589,7 +594,13 @@ class ConfigMeasurements(QMainWindow, Styles):
 							self.spot_channel.setCurrentText(idx)
 						self.diameter_value.setText(str(spot_detection['diameter']))
 						self.threshold_value.setText(str(spot_detection['threshold']))
-
+						if 'image_preprocessing' in spot_detection:
+							items = spot_detection['image_preprocessing']
+							if items is not None:
+								items_for_list = [a[0] for a in items]
+								for it in items_for_list:
+									self.spot_preprocessing.list.addItemToList(it)
+								self.spot_preprocessing.list.items = items
 
 				if 'border_distances' in measurement_instructions:
 					border_distances = measurement_instructions['border_distances']
@@ -886,43 +897,81 @@ class ConfigMeasurements(QMainWindow, Styles):
 
 	def populate_spot_detection(self):
 
-		layout = QGridLayout(self.spot_detection_frame)
+		layout = QVBoxLayout(self.spot_detection_frame)
+
 		self.spot_detection_lbl = QLabel("SPOT DETECTION")
 		self.spot_detection_lbl.setStyleSheet("""font-weight: bold;padding: 0px;""")
-		layout.addWidget(self.spot_detection_lbl, 0, 0, 1, 2, alignment=Qt.AlignCenter)
-		self.spot_check= QCheckBox('Perform spot detection')
+		layout.addWidget(self.spot_detection_lbl, alignment=Qt.AlignCenter)
+
+		perform_hbox = QHBoxLayout()
+		self.spot_check = QCheckBox('Perform spot detection')
 		self.spot_check.toggled.connect(self.enable_spot_detection)
-		layout.addWidget(self.spot_check, 1, 0)
-		self.spot_channel_lbl = QLabel("Choose channel for spot detection: ")
+		perform_hbox.addWidget(self.spot_check, 95)
+		
+		self.spot_viewer_btn = QPushButton()
+		self.spot_viewer_btn.clicked.connect(self.spot_preview)
+		self.spot_viewer_btn.setIcon(icon(MDI6.image_check, color="k"))
+		self.spot_viewer_btn.setStyleSheet(self.button_select_all)
+		self.spot_viewer_btn.setToolTip('Set detection parameters visually.')
+		perform_hbox.addWidget(self.spot_viewer_btn, 5)
+		layout.addLayout(perform_hbox)
+
+		channel_hbox = QHBoxLayout()
+		self.spot_channel_lbl = QLabel("Channel: ")
 		self.spot_channel = QComboBox()
 		self.spot_channel.addItems(self.channel_names)
-		layout.addWidget(self.spot_channel_lbl, 2, 0)
-		layout.addWidget(self.spot_channel, 2, 1)
+		channel_hbox.addWidget(self.spot_channel_lbl, 30)
+		channel_hbox.addWidget(self.spot_channel, 70)
+		layout.addLayout(channel_hbox)
+
+		self.spot_preprocessing = PreprocessingLayout2(fraction=30, parent_window=self)
+		layout.addLayout(self.spot_preprocessing)
+
+		# continue switching to VBox + HBox down
+		diam_hbox = QHBoxLayout()
 		self.diameter_lbl = QLabel('Spot diameter: ')
 		self.diameter_value = QLineEdit()
 		self.diameter_value.setValidator(self.onlyFloat)
 		self.diameter_value.setText('7')
 		self.diameter_value.textChanged.connect(self.enable_spot_preview)
 
-		layout.addWidget(self.diameter_lbl, 3, 0)
-		layout.addWidget(self.diameter_value, 3, 1)
+		diam_hbox.addWidget(self.diameter_lbl,30)
+		diam_hbox.addWidget(self.diameter_value, 70)
+		layout.addLayout(diam_hbox)
+
+		thresh_hbox = QHBoxLayout()
 		self.threshold_lbl = QLabel('Spot threshold: ')
 		self.threshold_value = QLineEdit()
 		self.threshold_value.setValidator(self.onlyFloat)
 		self.threshold_value.setText('0')
 		self.threshold_value.textChanged.connect(self.enable_spot_preview)
 
-		layout.addWidget(self.threshold_lbl, 4, 0)
-		layout.addWidget(self.threshold_value, 4, 1)
-
-		self.spot_viewer_btn = QPushButton()
-		self.spot_viewer_btn.clicked.connect(self.spot_preview)
-		self.spot_viewer_btn.setIcon(icon(MDI6.image_check, color="k"))
-		self.spot_viewer_btn.setStyleSheet(self.button_select_all)
-		self.spot_viewer_btn.setToolTip('Set detection parameters visually.')
-		layout.addWidget(self.spot_viewer_btn, 1, 1, 1, 1, alignment=Qt.AlignRight)
-
-		self.spot_detection_widgets = [self.spot_channel, self.spot_channel_lbl, self.diameter_value, self.diameter_lbl, self.threshold_value, self.threshold_lbl, self.spot_viewer_btn]
+		thresh_hbox.addWidget(self.threshold_lbl, 30)
+		thresh_hbox.addWidget(self.threshold_value, 70)
+		layout.addLayout(thresh_hbox)
+
+		# #invert_layout = QHBoxLayout()
+		# self.invert_check = QCheckBox('invert')
+		# self.invert_value_le = QLineEdit('65535')
+		# self.invert_value_le.setValidator(self.onlyFloat)
+		# layout.addWidget(self.invert_check, 6, 0)
+		# layout.addWidget(self.invert_value_le, 6, 1)
+		# #layout.addLayout(invert_layout, 5, 1, 1, 1)
+
+		self.spot_detection_widgets = [self.spot_channel, 
+									   self.spot_channel_lbl,
+									   self.diameter_value,
+									   self.diameter_lbl, 
+									   self.threshold_value,
+									   self.threshold_lbl,
+									   self.spot_viewer_btn,  
+									   #self.invert_check, 
+									   #self.invert_value_le, 
+									   self.spot_preprocessing.list, 
+									   self.spot_preprocessing.add_filter_btn, 
+									   self.spot_preprocessing.delete_filter_btn, 
+									   self.spot_preprocessing.preprocess_lbl
+									  ]
 		for wg in self.spot_detection_widgets:
 			wg.setEnabled(False)
 
@@ -940,6 +989,13 @@ class ConfigMeasurements(QMainWindow, Styles):
 		if self.test_frame is not None:
 			self.locate_mask()
 			if self.test_mask is not None:
+
+				# invert_value = self.invert_value_le.text().replace(',','.')
+				# if invert_value != '':
+				# 	invert_value = float(invert_value)
+				# else:
+				# 	invert_value = None
+
 				self.spot_visual = SpotDetectionVisualizer(frame_slider=True,
 														   contrast_slider=True,
 														   cell_type=self.mode,
@@ -952,6 +1008,10 @@ class ConfigMeasurements(QMainWindow, Styles):
 														   parent_channel_cb=self.spot_channel,
 														   parent_diameter_le=self.diameter_value,
 														   parent_threshold_le=self.threshold_value,
+														   parent_preprocessing_list=self.spot_preprocessing.list,
+														   #parent_invert_check=self.invert_check,
+														   #invert = self.invert_check.isChecked(),
+														   #invert_value = self.invert_value_le.text().replace(',','.'),
 														   PxToUm = 1,)
 				self.spot_visual.show()
 				#self.spot_visual = ThresholdSpot(current_channel=self.spot_channel.currentIndex(), img=self.test_frame,

celldetective/gui/neighborhood_options.py

@@ -400,7 +400,7 @@ class ConfigNeighborhoods(QWidget, Styles):
 		
 		status_options = [self.reference_population_status_cb.currentText(), self.neighbor_population_status_cb.currentText()]
 		for k in range(2):
-			if status_options[k]=='--':
+			if status_options[k]=='--' or status_options[k]=='':
 				status_options[k] = None
 		if pop[0]!=pop[1]:
 			mode = 'two-pop'

celldetective/gui/signal_annotator.py

@@ -7,7 +7,7 @@ from celldetective.gui.gui_utils import center_window, color_from_state
 from superqt import QLabeledDoubleSlider, QLabeledDoubleRangeSlider, QSearchableComboBox
 from celldetective.utils import extract_experiment_channels, get_software_location, _get_img_num_per_channel
 from celldetective.io import auto_load_number_of_frames, load_frames, \
-	load_napari_data
+	load_napari_data, get_experiment_metadata
 from celldetective.gui.gui_utils import FigureCanvas, color_from_status, color_from_class, ExportPlotBtn
 import json
 import numpy as np
@@ -781,6 +781,11 @@ class SignalAnnotator(QMainWindow, Styles):
 							  'state', 'generation', 'root', 'parent', 'class_id', 'class', 't0', 'POSITION_X',
 							  'POSITION_Y', 'position', 'well', 'well_index', 'well_name', 'pos_name', 'index',
 							  'concentration', 'cell_type', 'antibody', 'pharmaceutical_agent'] + self.class_cols
+			meta = get_experiment_metadata(self.exp_dir)
+			if meta is not None:
+				keys = list(meta.keys())
+				cols_to_remove.extend(keys)
+
 			cols = np.array(list(self.df_tracks.columns))
 			time_cols = np.array([c.startswith('t_') for c in cols])
 			time_cols = list(cols[time_cols])

celldetective/gui/signal_annotator2.py

@@ -7,7 +7,7 @@ from celldetective.gui import Styles
 from celldetective.gui.gui_utils import center_window
 from superqt import QLabeledDoubleRangeSlider, QSearchableComboBox
 from celldetective.utils import extract_experiment_channels, get_software_location, _get_img_num_per_channel
-from celldetective.io import auto_load_number_of_frames, load_frames
+from celldetective.io import auto_load_number_of_frames, load_frames, get_experiment_metadata
 from celldetective.gui.gui_utils import FigureCanvas, color_from_status, color_from_class
 import json
 import numpy as np
@@ -66,7 +66,10 @@ class SignalAnnotator2(QMainWindow,Styles):
 					 't0', 'POSITION_X', 'POSITION_Y', 'position', 'well', 'well_index', 'well_name', 'pos_name',
 					 'index', 'relxy', 'tc', 'nk', 'concentration', 'antibody', 'cell_type', 'pharmaceutical_agent',
 					 'reference_population', 'neighbor_population']
-
+		meta = get_experiment_metadata(self.exp_dir)
+		if meta is not None:
+			keys = list(meta.keys())
+			self.cols_to_remove.extend(keys)		
 
 		# Read instructions from target block for now...
 		self.mode = "neighborhood"
@@ -202,14 +205,14 @@ class SignalAnnotator2(QMainWindow,Styles):
 
 		self.cell_events_hbox = QHBoxLayout()
 		self.cell_events_hbox.setContentsMargins(0,0,0,0)
-		self.cell_events_hbox.addWidget(QLabel('reference event: '), 25)
+		self.cell_events_hbox.addWidget(QLabel('Event: '), 25)
 		self.reference_event_choice_cb = QComboBox()
 		self.cell_events_hbox.addWidget(self.reference_event_choice_cb, 75)
 		
 		#if 'self' not in self.neighborhood_choice_cb.currentText():
 		self.neigh_cell_events_hbox = QHBoxLayout()
 		self.neigh_cell_events_hbox.setContentsMargins(0,0,0,0)
-		self.neigh_lab=QLabel('neighbor event: ')
+		self.neigh_lab=QLabel('Event: ')
 		self.neigh_cell_events_hbox.addWidget(self.neigh_lab, 25)
 		self.neighbor_event_choice_cb = QComboBox()
 		self.neigh_cell_events_hbox.addWidget(self.neighbor_event_choice_cb, 75)
@@ -230,7 +233,7 @@ class SignalAnnotator2(QMainWindow,Styles):
 		neighbor_layout.addLayout(self.neigh_cell_events_hbox)
 
 		self.cell_info_hbox.addLayout(reference_layout, 33)
-		self.cell_info_hbox.addWidget(self.pair_info, 33, alignment=Qt.AlignCenter)
+		self.cell_info_hbox.addWidget(self.pair_info, 33)
 		self.cell_info_hbox.addLayout(neighbor_layout, 33)
 
 		self.left_panel.addLayout(self.cell_info_hbox)
@@ -2375,41 +2378,41 @@ class SignalAnnotator2(QMainWindow,Styles):
 
 		df_reference = self.dataframes[self.reference_population]
 		if self.reference_track_of_interest is not None:
-			reference_cell_selected = f"reference cell: {self.reference_track_of_interest}\n"
-			reference_cell_population = f"population: {self.reference_population}\n"
+			reference_cell_selected = f"Ref #{self.reference_track_of_interest}\n"
+			reference_cell_population = f"Pop: {self.reference_population}\n"
 			#reference_cell_class = f"class: {df_reference[df_reference['TRACK_ID']==self.reference_track_of_interest, self.reference_event_choice_cb.currentText()].values[0]}\n"
 			#reference_cell_time = f"time of interest: {df_reference[df_reference['TRACK_ID']==self.reference_track_of_interest, ''].values[0]}\n"
 			self.reference_cell_info.setText(reference_cell_selected+reference_cell_population)
 		else:
-			reference_cell_selected = f"reference cell: None\n"
-			reference_cell_population = f"population: {self.reference_population}\n"
+			reference_cell_selected = f"Ref: None\n"
+			reference_cell_population = f"Pop: {self.reference_population}\n"
 			self.reference_cell_info.setText(reference_cell_selected+reference_cell_population)
 
 	def give_neighbor_cell_information(self):
 
 		if self.neighbor_track_of_interest is not None:
-			neighbor_cell_selected = f"neighbor cell: {self.neighbor_track_of_interest}\n"
-			neighbor_cell_population = f"population: {self.neighbor_population}\n"
+			neighbor_cell_selected = f"Neigh #{self.neighbor_track_of_interest}\n"
+			neighbor_cell_population = f"Pop: {self.neighbor_population}\n"
 			#neighbor_cell_time = f"time of interest: {self.df_relative.loc[(self.df_relative['REFERENCE_ID']==self.reference_track_of_interest)&(self.df_relative['NEIGHBOR_ID']==self.neighbor_track_of_interest), self.pair_time_name].to_numpy()[0]}\n"
 			#neighbor_cell_class = f"class: {self.df_relative.loc[(self.df_relative['REFERENCE_ID']==self.reference_track_of_interest)&(self.df_relative['NEIGHBOR_ID']==self.neighbor_track_of_interest), self.pair_class_name].to_numpy()[0]}\n"
 			self.neighbor_cell_info.setText(neighbor_cell_selected+neighbor_cell_population) #neighbor_cell_class+neighbor_cell_time 
 		else:
-			neighbor_cell_selected = f"neighbor cell: None\n"
-			neighbor_cell_population = f"population: {self.neighbor_population}\n"
+			neighbor_cell_selected = f"Neigh: None\n"
+			neighbor_cell_population = f"Pop: {self.neighbor_population}\n"
 			self.neighbor_cell_info.setText(neighbor_cell_selected+neighbor_cell_population)
 
 	def give_pair_information(self):
 
 		if self.neighbor_track_of_interest is not None and self.reference_track_of_interest is not None:
-			pair_selected = f"(reference/neighbor) pair: ({self.reference_track_of_interest},{self.neighbor_track_of_interest})\n"
-			pair_populations = f"populations: ({self.reference_population}, {self.neighbor_population})\n"
+			pair_selected = f"Pair: ({self.reference_track_of_interest},{self.neighbor_track_of_interest})\n"
+			pair_populations = "" #f"populations: ({self.reference_population}, {self.neighbor_population})\n"
 			current_class = self.relative_class_choice_cb.currentText()
-			pair_class = f"interaction event class: {self.df_relative.loc[(self.df_relative['REFERENCE_ID']==self.reference_track_of_interest)&(self.df_relative['NEIGHBOR_ID']==self.neighbor_track_of_interest)&(self.df_relative['reference_population']==self.reference_population)&(self.df_relative['neighbor_population']==self.neighbor_population)&(~self.df_relative['status_'+self.current_neighborhood].isnull()), current_class].values[0]}\n"
-			pair_time = f"time of interest: {self.df_relative.loc[(self.df_relative['REFERENCE_ID']==self.reference_track_of_interest)&(self.df_relative['NEIGHBOR_ID']==self.neighbor_track_of_interest)&(self.df_relative['reference_population']==self.reference_population)&(self.df_relative['neighbor_population']==self.neighbor_population)&(~self.df_relative['status_'+self.current_neighborhood].isnull()), self.pair_time_name].values[0]}\n"
+			pair_class = f"Event class: {self.df_relative.loc[(self.df_relative['REFERENCE_ID']==self.reference_track_of_interest)&(self.df_relative['NEIGHBOR_ID']==self.neighbor_track_of_interest)&(self.df_relative['reference_population']==self.reference_population)&(self.df_relative['neighbor_population']==self.neighbor_population)&(~self.df_relative['status_'+self.current_neighborhood].isnull()), current_class].values[0]}\n"
+			pair_time = f"Time: {self.df_relative.loc[(self.df_relative['REFERENCE_ID']==self.reference_track_of_interest)&(self.df_relative['NEIGHBOR_ID']==self.neighbor_track_of_interest)&(self.df_relative['reference_population']==self.reference_population)&(self.df_relative['neighbor_population']==self.neighbor_population)&(~self.df_relative['status_'+self.current_neighborhood].isnull()), self.pair_time_name].values[0]}\n"
 			self.pair_info.setText(pair_selected+pair_populations+pair_class+pair_time)
 		else:
-			pair_selected = f"(reference/neighbor) pair: None\n"
-			pair_populations = f"populations: ({self.reference_population}, {self.neighbor_population})\n"
+			pair_selected = f"Pair: None\n"
+			pair_populations = "" #f"populations: ({self.reference_population}, {self.neighbor_population})\n"
 			self.pair_info.setText(pair_selected+pair_populations)
 
 

celldetective/gui/survival_ui.py

@@ -11,11 +11,9 @@ 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 natsort import natsorted
 from celldetective.relative_measurements import expand_pair_table
 import matplotlib.cm
 from celldetective.neighborhood import extract_neighborhood_in_pair_table

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):