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

celldetective/gui/gui_utils.py

@@ -1,7 +1,7 @@
 import numpy as np
-from PyQt5.QtWidgets import QApplication, QMessageBox, QFrame, QSizePolicy, QWidget, QLineEdit, QListWidget, QVBoxLayout, QComboBox, \
+from PyQt5.QtWidgets import QGridLayout, QApplication, QMessageBox, QFrame, QSizePolicy, QWidget, QLineEdit, QListWidget, QVBoxLayout, QComboBox, \
 	QPushButton, QLabel, QHBoxLayout, QCheckBox, QFileDialog, QToolButton, QMenu, QStylePainter, QStyleOptionComboBox, QStyle
-from PyQt5.QtCore import Qt, QSize, QAbstractTableModel
+from PyQt5.QtCore import Qt, QSize, QAbstractTableModel, QEvent, pyqtSignal
 from PyQt5.QtGui import QDoubleValidator, QIntValidator, QStandardItemModel, QPalette
 
 from celldetective.gui import Styles
@@ -15,6 +15,125 @@ import celldetective.extra_properties as extra_properties
 from inspect import getmembers, isfunction
 from celldetective.filters import *
 from os import sep
+import json
+
+
+class PreprocessingLayout(QVBoxLayout, Styles):
+
+	"""
+	A widget that allows user to choose preprocessing filters for an image
+	"""
+
+	def __init__(self, parent_window=None, apply_btn_option=True, *args, **kwargs):
+		super().__init__(*args, **kwargs)
+
+		self.parent_window = parent_window
+		self.apply_btn_option = apply_btn_option
+		self.generate_components()
+		self.add_to_layout()
+
+	def add_to_layout(self):
+		
+		self.setContentsMargins(20, 20, 20, 20)
+		
+		button_layout = QHBoxLayout()
+		button_layout.addWidget(self.preprocess_lbl, 85, alignment=Qt.AlignLeft)
+		button_layout.addWidget(self.delete_filter_btn, 5)
+		button_layout.addWidget(self.add_filter_btn, 5)
+		button_layout.addWidget(self.help_prefilter_btn, 5)
+		self.addLayout(button_layout, 25)
+
+		self.addWidget(self.list, 70)
+		if self.apply_btn_option:
+			self.addWidget(self.apply_btn, 5)
+
+	def generate_components(self):
+		
+		self.list = ListWidget(FilterChoice, [])
+
+		self.preprocess_lbl = QLabel('Preprocessing')
+		self.preprocess_lbl.setStyleSheet("font-weight: bold;")
+
+		self.delete_filter_btn = QPushButton()
+		self.delete_filter_btn.setStyleSheet(self.button_select_all)
+		self.delete_filter_btn.setIcon(icon(MDI6.trash_can, color="black"))
+		self.delete_filter_btn.setToolTip("Remove filter")
+		self.delete_filter_btn.setIconSize(QSize(20, 20))
+		self.delete_filter_btn.clicked.connect(self.list.removeSel)
+
+		self.add_filter_btn = QPushButton()
+		self.add_filter_btn.setStyleSheet(self.button_select_all)
+		self.add_filter_btn.setIcon(icon(MDI6.filter_plus, color="black"))
+		self.add_filter_btn.setToolTip("Add filter")
+		self.add_filter_btn.setIconSize(QSize(20, 20))
+		self.add_filter_btn.clicked.connect(self.list.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.")
+		
+		if self.apply_btn_option:
+			self.apply_btn = QPushButton("Apply")
+			self.apply_btn.setIcon(icon(MDI6.filter_cog_outline, color="white"))
+			self.apply_btn.setIconSize(QSize(20, 20))
+			self.apply_btn.setStyleSheet(self.button_style_sheet)
+			self.apply_btn.clicked.connect(self.parent_window.preprocess_image)
+
+	def help_prefilter(self):
+
+		"""
+		Helper for prefiltering strategy
+		"""
+
+		dict_path = os.sep.join([get_software_location(),'celldetective','gui','help','prefilter-for-segmentation.json'])
+
+		with open(dict_path) as f:
+			d = json.load(f)
+
+		suggestion = help_generic(d)
+		if isinstance(suggestion, str):
+			print(f"{suggestion=}")
+			msgBox = QMessageBox()
+			msgBox.setIcon(QMessageBox.Information)
+			msgBox.setTextFormat(Qt.RichText)
+			msgBox.setText(f"The suggested technique is to {suggestion}.\nSee a tutorial <a href='https://celldetective.readthedocs.io/en/latest/segment.html'>here</a>.")
+			msgBox.setWindowTitle("Info")
+			msgBox.setStandardButtons(QMessageBox.Ok)
+			returnValue = msgBox.exec()
+			if returnValue == QMessageBox.Ok:
+				return None
+
+
+class PreprocessingLayout2(PreprocessingLayout):
+
+	def __init__(self, fraction=75, *args, **kwargs):
+
+		self.fraction = fraction
+		super().__init__(apply_btn_option=False, *args, **kwargs)
+		self.preprocess_lbl.setText('Preprocessing: ')
+		self.preprocess_lbl.setStyleSheet("")
+		self.setContentsMargins(0,0,0,0)
+
+	def add_to_layout(self):
+		
+		main_layout = QHBoxLayout()
+		main_layout.setContentsMargins(0,0,0,0)
+		main_layout.setSpacing(5)
+		main_layout.addWidget(self.preprocess_lbl, self.fraction, alignment=Qt.AlignTop)
+
+		list_grid = QGridLayout()
+		list_grid.addWidget(self.list, 0, 0, 2, 2)
+		list_grid.addWidget(self.add_filter_btn, 0, 2, 1, 1)
+		list_grid.addWidget(self.delete_filter_btn, 1, 2, 1, 1)
+		main_layout.addLayout(list_grid, 100-self.fraction)
+		self.add_filter_btn.setFixedWidth(35)  # Ensure the button width is fixed
+		self.delete_filter_btn.setFixedWidth(35)
+		list_grid.setColumnStretch(2, 0)
+
+		self.addLayout(main_layout)
 
 
 class QCheckableComboBox(QComboBox):
@@ -23,12 +142,13 @@ class QCheckableComboBox(QComboBox):
 	adapted from https://stackoverflow.com/questions/22775095/pyqt-how-to-set-combobox-items-be-checkable
 	"""
 
+	activated = pyqtSignal(str)
+
 	def __init__(self, obj='', parent_window=None, *args, **kwargs):
 		
 		super().__init__(parent_window, *args, **kwargs)
 
 		self.setTitle('')
-		self.view().pressed.connect(self.handleItemPressed)
 		self.setModel(QStandardItemModel(self))
 		self.obj = obj
 		self.toolButton = QToolButton(parent_window)
@@ -38,6 +158,9 @@ class QCheckableComboBox(QComboBox):
 		self.toolButton.setPopupMode(QToolButton.InstantPopup)
 		self.anySelected = False
 
+		self.view().viewport().installEventFilter(self)		
+		self.view().pressed.connect(self.handleItemPressed)
+
 	def clear(self):
 		
 		self.unselectAll()
@@ -70,6 +193,8 @@ class QCheckableComboBox(QComboBox):
 		elif len(options_checked[options_checked])==0:
 			self.setTitle(f"No {self.obj} selected...")
 			self.anySelected = False
+		
+		self.activated.emit(self.title())
 
 	def setCurrentIndex(self, index):
 
@@ -101,6 +226,7 @@ class QCheckableComboBox(QComboBox):
 
 	def setTitle(self, title):
 		self._title = title
+		self.update()
 		self.repaint()
 
 	def paintEvent(self, event):
@@ -155,7 +281,12 @@ class QCheckableComboBox(QComboBox):
 
 	def isAnySelected(self):
 		return not self.title().startswith('No')
-
+	
+	def eventFilter(self, source, event):
+		if source is self.view().viewport():
+			if event.type() == QEvent.MouseButtonRelease:
+				return True  # Prevent the popup from closing
+		return super().eventFilter(source, event)
 
 class PandasModel(QAbstractTableModel):
 
@@ -415,7 +546,7 @@ class QHSeperationLine(QFrame):
 		self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Minimum)
 
 
-class FeatureChoice(QWidget):
+class FeatureChoice(QWidget, Styles):
 
 	def __init__(self, parent_window):
 		super().__init__()
@@ -423,7 +554,6 @@ class FeatureChoice(QWidget):
 		self.setWindowTitle("Add feature")
 		# Create the QComboBox and add some items
 		self.combo_box = QComboBox(self)
-		center_window(self)
 
 		standard_measurements = ["area",
 								 "area_bbox",
@@ -453,12 +583,15 @@ class FeatureChoice(QWidget):
 		self.combo_box.addItems(standard_measurements)
 
 		self.add_btn = QPushButton("Add")
+		self.add_btn.setStyleSheet(self.button_style_sheet)
 		self.add_btn.clicked.connect(self.add_current_feature)
 
 		# Create the layout
 		layout = QVBoxLayout(self)
 		layout.addWidget(self.combo_box)
 		layout.addWidget(self.add_btn)
+		center_window(self)
+
 
 	def add_current_feature(self):
 		filtername = self.combo_box.currentText()
@@ -466,7 +599,7 @@ class FeatureChoice(QWidget):
 		self.close()
 
 
-class FilterChoice(QWidget):
+class FilterChoice(QWidget, Styles):
 
 	def __init__(self, parent_window):
 
@@ -487,6 +620,7 @@ class FilterChoice(QWidget):
 			'laplace_filter': None,
 			'abs_filter': None,
 			'ln_filter': None,
+			'invert_filter': {'value': 65535},
 			'subtract_filter': {'value': 1},
 			'dog_filter': {'sigma_low': 0.8, 'sigma_high': 1.6},
 			'log_filter': {'sigma': 2},
@@ -503,20 +637,26 @@ class FilterChoice(QWidget):
 		self.combo_box.currentTextChanged.connect(self.update_arguments)
 		layout.addWidget(self.combo_box)
 
+		self.floatValidator = QDoubleValidator()
 		self.arguments_le = [QLineEdit() for i in range(3)]
+		for i in range(3):
+			self.arguments_le[i].setValidator(self.floatValidator)
+
 		self.arguments_labels = [QLabel('') for i in range(3)]
 		for i in range(2):
 			hbox = QHBoxLayout()
-			hbox.addWidget(self.arguments_labels[i], 20)
-			hbox.addWidget(self.arguments_le[i], 80)
+			hbox.addWidget(self.arguments_labels[i], 40)
+			hbox.addWidget(self.arguments_le[i], 60)
 			layout.addLayout(hbox)
 
 		self.add_btn = QPushButton("Add")
+		self.add_btn.setStyleSheet(self.button_style_sheet)
 		self.add_btn.clicked.connect(self.add_current_feature)
 		layout.addWidget(self.add_btn)
 
 		self.combo_box.setCurrentIndex(0)
 		self.update_arguments()
+		center_window(self)
 
 	def add_current_feature(self):
 
@@ -525,8 +665,10 @@ class FilterChoice(QWidget):
 
 		filter_instructions = [filtername.split('_')[0]]
 		for a in self.arguments_le:
-			arg = a.text()
+			
+			arg = a.text().replace(',','.')
 			arg_num = arg
+
 			if (arg != '') and arg_num.replace('.', '').replace(',', '').isnumeric():
 				num = float(arg)
 				if num.is_integer():
@@ -666,12 +808,14 @@ class DistanceChoice(QWidget):
 		super().__init__()
 		self.parent_window = parent_window
 		self.setWindowTitle("Set distances")
+		self.floatValidator = QDoubleValidator()
 		center_window(self)
 
 		# Create the QComboBox and add some items
 
 		self.dist_label = QLabel('Distance [px]: ')
 		self.dist_le = QLineEdit('10')
+		self.dist_le.setValidator(self.floatValidator)
 
 		self.add_btn = QPushButton("Add")
 		self.add_btn.clicked.connect(self.add_current_feature)
@@ -686,7 +830,7 @@ class DistanceChoice(QWidget):
 		layout.addWidget(self.add_btn)
 
 	def add_current_feature(self):
-		value = self.dist_le.text()
+		value = self.dist_le.text().replace(',','.')
 		values = [value]
 		self.parent_window.list_widget.addItems(values)
 		self.close()
@@ -767,6 +911,9 @@ class ListWidget(QWidget):
 		self.addItemWindow = self.choiceWidget(self)
 		self.addItemWindow.show()
 
+	def addItemToList(self, item):
+		self.list_widget.addItems([item])
+
 	def getItems(self):
 
 		"""
@@ -794,6 +941,9 @@ class ListWidget(QWidget):
 				items.append(self.dtype(self.list_widget.item(x).text()))
 		return items
 
+	def clear(self):
+		self.items = []
+		self.list_widget.clear()
 
 	def removeSel(self):
 		
@@ -827,13 +977,21 @@ class FigureCanvas(QWidget):
 		if interactive:
 			self.toolbar = NavigationToolbar2QT(self.canvas)
 		self.layout = QVBoxLayout(self)
-		self.layout.addWidget(self.canvas)
+		self.layout.addWidget(self.canvas,90)
 		if interactive:
 			self.layout.addWidget(self.toolbar)
 
 		center_window(self)
 		self.setAttribute(Qt.WA_DeleteOnClose)
 
+	def resizeEvent(self, event):
+		
+		super().resizeEvent(event)
+		try:
+			self.fig.tight_layout()
+		except:
+			pass
+
 	def draw(self):
 		self.canvas.draw()
 

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.
@@ -261,7 +262,7 @@ class ConfigMeasurements(QMainWindow, Styles):
 		self.add_feature_btn.setToolTip("Add feature")
 		self.add_feature_btn.setIconSize(QSize(20, 20))
 
-		self.features_list = ListWidget(FeatureChoice, initial_features=['area', 'intensity_nanmean', ])
+		self.features_list = ListWidget(FeatureChoice, initial_features=['area', 'intensity_mean', ])
 
 		self.del_feature_btn.clicked.connect(self.features_list.removeSel)
 		self.add_feature_btn.clicked.connect(self.features_list.addItem)
@@ -313,25 +314,6 @@ class ConfigMeasurements(QMainWindow, Styles):
 
 		self.feat_sep3 = QHSeperationLine()
 		layout.addWidget(self.feat_sep3)
-		# self.radial_intensity_btn = QCheckBox('Measure radial intensity distribution')
-		# layout.addWidget(self.radial_intensity_btn)
-		# self.radial_intensity_btn.clicked.connect(self.enable_step_size)
-		# self.channel_chechkboxes=[]
-		# for channel in self.channel_names:
-		#     channel_checkbox=QCheckBox(channel)
-		#     self.channel_chechkboxes.append(channel_checkbox)
-		#     layout.addWidget(channel_checkbox)
-		#     channel_checkbox.setEnabled(False)
-		# step_box=QHBoxLayout()
-		# self.step_lbl=QLabel("Step size (in px)")
-		# self.step_size=QLineEdit()
-		# self.step_lbl.setEnabled(False)
-		# self.step_size.setEnabled(False)
-		# step_box.addWidget(self.step_lbl)
-		# step_box.addWidget(self.step_size)
-		# layout.addLayout(step_box)
-		# self.feat_sep4 = QHSeperationLine()
-		# layout.addWidget(self.feat_sep4)
 
 		# Haralick features parameters
 		self.activate_haralick_btn = QCheckBox('Measure Haralick texture features')
@@ -496,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
@@ -511,16 +495,6 @@ class ConfigMeasurements(QMainWindow, Styles):
 		if not border_distances:
 			border_distances = None
 		measurement_options.update({'border_distances': border_distances})
-		# radial_intensity = {}
-		# radial_step = int(self.step_size.text())
-		# radial_channels = []
-		# for checkbox in self.channel_chechkboxes:
-		#     if checkbox.isChecked():
-		#         radial_channels.append(checkbox.text())
-		# radial_intensity={'radial_step': radial_step, 'radial_channels': radial_channels}
-		# if not self.radial_intensity_btn.isChecked():
-		#     radial_intensity = None
-		# measurement_options.update({'radial_intensity' : radial_intensity})
 
 		self.extract_haralick_options()
 		measurement_options.update({'haralick_options': self.haralick_options})
@@ -537,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
@@ -547,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:
@@ -618,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']
@@ -915,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)
 
@@ -969,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,
@@ -981,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

@@ -174,7 +174,7 @@ class ConfigNeighborhoods(QWidget, Styles):
 		self.attr_parent.locate_image()
 		if self.attr_parent.current_stack is not None:
 			self.viewer = CellEdgeVisualizer(
-										  cell_type='effectors',
+										  cell_type=self.reference_population_cb.currentText(),
 										  edge_range=(1,30),
 										  invert=True,
 										  initial_edge=3,

celldetective/gui/plot_signals_ui.py

@@ -19,6 +19,7 @@ import pandas as pd
 import math
 from celldetective.gui import Styles
 from matplotlib import colormaps
+import matplotlib.cm
 
 
 class ConfigSignalPlot(QWidget, Styles):
@@ -110,10 +111,8 @@ class ConfigSignalPlot(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())
 
 		self.cbs[0].setCurrentIndex(1)
 		self.cbs[0].setCurrentIndex(0)

celldetective/gui/process_block.py

@@ -9,7 +9,7 @@ from PyQt5.QtGui import QDoubleValidator, QIntValidator
 from celldetective.gui.signal_annotator import MeasureAnnotator
 from celldetective.gui.signal_annotator2 import SignalAnnotator2
 from celldetective.io import get_segmentation_models_list, control_segmentation_napari, get_signal_models_list, \
-	control_tracking_btrack, load_experiment_tables, get_pair_signal_models_list
+	control_tracks, load_experiment_tables, get_pair_signal_models_list
 from celldetective.io import locate_segmentation_model, fix_missing_labels, auto_load_number_of_frames, load_frames, locate_signal_model
 from celldetective.gui import SegmentationModelLoader, ClassifierWidget, ConfigNeighborhoods, ConfigSegmentationModelTraining, ConfigTracking, SignalAnnotator, ConfigSignalModelTraining, ConfigMeasurements, ConfigSignalAnnotator, TableUI
 from celldetective.gui.gui_utils import QHSeperationLine
@@ -291,7 +291,7 @@ class ProcessPanel(QFrame, Styles):
 		self.track_action.setStyleSheet(self.menu_check_style)
 		self.track_action.setIcon(icon(MDI6.chart_timeline_variant,color="black"))
 		self.track_action.setIconSize(QSize(20, 20))
-		self.track_action.setToolTip("Track the target cells using bTrack.")
+		self.track_action.setToolTip(f"Track the {self.mode[:-1]} cells.")
 		grid_track.addWidget(self.track_action, 75)
 
 		self.delete_tracks_btn = QPushButton()
@@ -307,7 +307,7 @@ class ProcessPanel(QFrame, Styles):
 		self.check_tracking_result_btn = QPushButton()
 		self.check_tracking_result_btn.setIcon(icon(MDI6.eye_check_outline,color="black"))
 		self.check_tracking_result_btn.setIconSize(QSize(20, 20))
-		self.check_tracking_result_btn.setToolTip("View raw bTrack output in napari.")
+		self.check_tracking_result_btn.setToolTip("View tracking output in napari.")
 		self.check_tracking_result_btn.setStyleSheet(self.button_select_all)
 		self.check_tracking_result_btn.clicked.connect(self.open_napari_tracking)
 		self.check_tracking_result_btn.setEnabled(False)
@@ -845,14 +845,16 @@ class ProcessPanel(QFrame, Styles):
 
 			# self.stack = None
 		self.parent_window.update_position_options()
-		if self.segment_action.isChecked():
-			self.segment_action.setChecked(False)
+
+		for action in [self.segment_action, self.track_action, self.measure_action, self.signal_analysis_action]:
+			if action.isChecked():
+				action.setChecked(False)
 
 		self.cellpose_calibrated = False
 
 	def open_napari_tracking(self):
 		print(f'View the tracks before post-processing for position {self.parent_window.pos} in napari...')
-		control_tracking_btrack(self.parent_window.pos, prefix=self.parent_window.movie_prefix, population=self.mode, threads=self.parent_window.parent_window.n_threads)
+		control_tracks(self.parent_window.pos, prefix=self.parent_window.movie_prefix, population=self.mode, threads=self.parent_window.parent_window.n_threads)
 
 	def view_table_ui(self):
 

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
@@ -457,8 +457,10 @@ class SignalAnnotator(QMainWindow, Styles):
 		cols = np.array(self.df_tracks.columns)
 		self.class_cols = np.array([c.startswith('class') for c in list(self.df_tracks.columns)])
 		self.class_cols = list(cols[self.class_cols])
-		self.class_cols.remove('class_id')
-		self.class_cols.remove('class_color')
+		if 'class_id' in self.class_cols:
+			self.class_cols.remove('class_id')
+		if 'class_color' in self.class_cols:
+			self.class_cols.remove('class_color')
 		self.class_choice_cb.addItems(self.class_cols)
 		idx = self.class_choice_cb.findText(self.target_class)
 		self.class_choice_cb.setCurrentIndex(idx)
@@ -779,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])