celldetective 1.3.9.post5__py3-none-any.whl → 1.4.1__py3-none-any.whl

celldetective/gui/{retrain_signal_model_options.py → settings/_settings_event_model_training.py}

@@ -1,12 +1,9 @@
-from PyQt5.QtWidgets import QMainWindow, QApplication, QDialog, QMessageBox, QScrollArea, QComboBox, QFrame, QCheckBox, QFileDialog, QGridLayout, QLineEdit, QVBoxLayout, QWidget, QLabel, QHBoxLayout, QPushButton
+from PyQt5.QtWidgets import QMessageBox, QComboBox, QFrame, QCheckBox, QFileDialog, QGridLayout, QLineEdit, QVBoxLayout, QLabel, QHBoxLayout, QPushButton
 from PyQt5.QtCore import Qt, QSize
-from PyQt5.QtGui import QDoubleValidator, QIntValidator, QIcon
-from celldetective.gui.gui_utils import center_window
 from celldetective.gui.layouts import ChannelNormGenerator
 from superqt import QLabeledDoubleSlider, QLabeledSlider, QSearchableComboBox
 from superqt.fonticon import icon
 from fonticon_mdi6 import MDI6
-from celldetective.utils import get_software_location
 from celldetective.io import locate_signal_dataset, get_signal_datasets_list, load_experiment_tables
 from celldetective.signals import train_signal_model
 import numpy as np
@@ -14,12 +11,12 @@ import json
 import os
 from glob import glob
 from datetime import datetime
-from celldetective.gui import Styles
 from pandas.api.types import is_numeric_dtype
 from celldetective.gui.processes.train_signal_model import TrainSignalModelProcess
 from celldetective.gui.workers import ProgressWindow
+from celldetective.gui.settings._settings_base import CelldetectiveSettingsPanel
 
-class ConfigSignalModelTraining(QMainWindow, Styles):
+class SettingsEventDetectionModelTraining(CelldetectiveSettingsPanel):
 	
 	"""
 	UI to set measurement instructions.
@@ -28,88 +25,62 @@ class ConfigSignalModelTraining(QMainWindow, Styles):
 
 	def __init__(self, parent_window=None, signal_mode='single-cells'):
 		
-		super().__init__()
 		self.parent_window = parent_window
-		self.setWindowTitle("Train signal model")
-		self.setWindowIcon(QIcon(os.sep.join(['celldetective','icons','mexican-hat.png'])))
 		self.mode = self.parent_window.mode
 		self.exp_dir = self.parent_window.exp_dir
-		self.soft_path = get_software_location()
-		self.pretrained_model = None 
+		self.pretrained_model = None
 		self.dataset_folder = None
 		self.current_neighborhood = None
 		self.reference_population = None
 		self.neighbor_population = None
 		self.signal_mode = signal_mode
+		
+		super().__init__(title="Train event detection model")
 
 		if self.signal_mode=='single-cells':
-			self.signal_models_dir = self.soft_path+os.sep+os.sep.join(['celldetective','models','signal_detection'])
+			self.signal_models_dir = self._software_path+os.sep+os.sep.join(['celldetective','models','signal_detection'])
 		elif self.signal_mode=='pairs':
-			self.signal_models_dir = self.soft_path+os.sep+os.sep.join(['celldetective','models','pair_signal_detection'])
+			self.signal_models_dir = self._software_path+os.sep+os.sep.join(['celldetective','models','pair_signal_detection'])
 			self.mode = 'pairs'
+		
+		self._add_to_layout()
+		self._load_previous_instructions()
+		
+		self._adjustSize()
+		new_width = int(self.width()*1.2)
+		self.resize(new_width, int(self._screen_height * 0.8))
+		self.setMinimumWidth(new_width)
+	
+	def _add_to_layout(self):
+		self._layout.addWidget(self.model_frame)
+		self._layout.addWidget(self.data_frame)
+		self._layout.addWidget(self.hyper_frame)
+		self._layout.addWidget(self.submit_btn)
 
-		self.onlyFloat = QDoubleValidator()
-		self.onlyInt = QIntValidator()
-
-		self.screen_height = self.parent_window.parent_window.parent_window.screen_height
-		center_window(self)
-
-		self.setMinimumWidth(500)
-		self.setMinimumHeight(int(0.3*self.screen_height))
-		self.setMaximumHeight(int(0.8*self.screen_height))
-		self.populate_widget()
-		#self.load_previous_measurement_instructions()
-
-	def populate_widget(self):
+	def _create_widgets(self):
 
 		"""
 		Create the multibox design.
 
 		"""
+		super()._create_widgets()
 		
-		# Create button widget and layout
-		self.scroll_area = QScrollArea(self)
-		self.button_widget = QWidget()
-		self.main_layout = QVBoxLayout()
-		self.button_widget.setLayout(self.main_layout)
-		self.main_layout.setContentsMargins(30,30,30,30)
-
 		# first frame for FEATURES
 		self.model_frame = QFrame()
 		self.model_frame.setFrameStyle(QFrame.StyledPanel | QFrame.Raised)
 		self.populate_model_frame()
-		self.main_layout.addWidget(self.model_frame)
 
 		self.data_frame = QFrame()
 		self.data_frame.setFrameStyle(QFrame.StyledPanel | QFrame.Raised)
 		self.populate_data_frame()
-		self.main_layout.addWidget(self.data_frame)
 
 		self.hyper_frame = QFrame()
 		self.hyper_frame.setFrameStyle(QFrame.StyledPanel | QFrame.Raised)
 		self.populate_hyper_frame()
-		self.main_layout.addWidget(self.hyper_frame)
 
-		self.submit_btn = QPushButton('Train')
-		self.submit_btn.setStyleSheet(self.button_style_sheet)
-		self.submit_btn.clicked.connect(self.prep_model)
-		self.main_layout.addWidget(self.submit_btn)
 		self.submit_btn.setEnabled(False)
+		self.submit_btn.setText("Train")
 
-		#self.populate_left_panel()
-		#grid.addLayout(self.left_side, 0, 0, 1, 1)
-		self.button_widget.adjustSize()
-
-		self.scroll_area.setAlignment(Qt.AlignCenter)
-		self.scroll_area.setWidget(self.button_widget)
-		self.scroll_area.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
-		self.scroll_area.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
-		self.scroll_area.setWidgetResizable(True)
-		self.setCentralWidget(self.scroll_area)
-		self.show()
-
-		QApplication.processEvents()
-		self.adjustScrollArea()
 
 	def populate_hyper_frame(self):
 
@@ -139,14 +110,14 @@ class ConfigSignalModelTraining(QMainWindow, Styles):
 		lr_layout = QHBoxLayout()
 		lr_layout.addWidget(QLabel('learning rate: '),30)
 		self.lr_le = QLineEdit('0,01')
-		self.lr_le.setValidator(self.onlyFloat)
+		self.lr_le.setValidator(self._floatValidator)
 		lr_layout.addWidget(self.lr_le, 70)
 		layout.addLayout(lr_layout)
 
 		bs_layout = QHBoxLayout()
 		bs_layout.addWidget(QLabel('batch size: '),30)
 		self.bs_le = QLineEdit('64')
-		self.bs_le.setValidator(self.onlyInt)
+		self.bs_le.setValidator(self._intValidator)
 		bs_layout.addWidget(self.bs_le, 70)
 		layout.addLayout(bs_layout)
 
@@ -156,7 +127,7 @@ class ConfigSignalModelTraining(QMainWindow, Styles):
 		self.epochs_slider.setRange(1,3000)
 		self.epochs_slider.setSingleStep(1)
 		self.epochs_slider.setTickInterval(1)		
-		self.epochs_slider.setOrientation(1)
+		self.epochs_slider.setOrientation(Qt.Horizontal)
 		self.epochs_slider.setValue(300)
 		epochs_layout.addWidget(self.epochs_slider, 70)
 		layout.addLayout(epochs_layout)
@@ -243,7 +214,7 @@ class ConfigSignalModelTraining(QMainWindow, Styles):
 		self.augmentation_slider = QLabeledDoubleSlider()
 		self.augmentation_slider.setSingleStep(0.01)
 		self.augmentation_slider.setTickInterval(0.01)		
-		self.augmentation_slider.setOrientation(1)
+		self.augmentation_slider.setOrientation(Qt.Horizontal)
 		self.augmentation_slider.setRange(1, 5)
 		self.augmentation_slider.setValue(2)
 
@@ -255,7 +226,7 @@ class ConfigSignalModelTraining(QMainWindow, Styles):
 		self.validation_slider = QLabeledDoubleSlider()
 		self.validation_slider.setSingleStep(0.01)
 		self.validation_slider.setTickInterval(0.01)		
-		self.validation_slider.setOrientation(1)
+		self.validation_slider.setOrientation(Qt.Horizontal)
 		self.validation_slider.setRange(0,0.9)
 		self.validation_slider.setValue(0.25)		
 		validation_split_layout.addWidget(self.validation_slider, 70)
@@ -332,7 +303,7 @@ class ConfigSignalModelTraining(QMainWindow, Styles):
 		self.model_length_slider.setSingleStep(1)
 		self.model_length_slider.setTickInterval(1)
 		self.model_length_slider.setSingleStep(1)
-		self.model_length_slider.setOrientation(1)
+		self.model_length_slider.setOrientation(Qt.Horizontal)
 		self.model_length_slider.setRange(0,1024)
 		self.model_length_slider.setValue(128)		
 		model_length_layout.addWidget(self.model_length_slider, 70)
@@ -341,25 +312,22 @@ class ConfigSignalModelTraining(QMainWindow, Styles):
 	def neighborhood_changed(self):
 
 		neigh = self.neighborhood_choice_cb.currentText()
-		self.current_neighborhood = neigh.replace('target_ref_','').replace('effector_ref_','')
-		self.reference_population = ['targets' if 'target' in neigh else 'effectors'][0]
-		if 'target' in neigh:
-			if 'self' in neigh:
-				self.neighbor_population = 'targets'
-			else:
-				self.neighbor_population = 'effectors'
+		self.current_neighborhood = neigh
+		for pop in self.dataframes.keys():
+			self.current_neighborhood = self.current_neighborhood.replace(f'{pop}_ref_', '')
+
+		self.reference_population = self.neighborhood_choice_cb.currentText().split('_')[0]
+		if '_(' in self.current_neighborhood and ')_' in self.current_neighborhood:
+			self.neighbor_population = self.current_neighborhood.split('_(')[-1].split(')_')[0].split('-')[-1]
+			self.reference_population = self.current_neighborhood.split('_(')[-1].split(')_')[0].split('-')[0]
 		else:
-			if 'self' in neigh:
-				self.neighbor_population = 'effectors'
-			else:
-				self.neighbor_population = 'targets'
-		
+			if 'self' in self.current_neighborhood:
+				self.neighbor_population = self.reference_population
+
 		print(f'Current neighborhood: {self.current_neighborhood}')
 		print(f'New reference population: {self.reference_population}')
 		print(f'New neighbor population: {self.neighbor_population}')
 
-		# reload reference signals / neighbor signals / pair signals
-		# fill the channel cbs
 		self.df_reference = self.dataframes[self.reference_population]
 		self.df_neighbor = self.dataframes[self.neighbor_population]
 		self.df_pairs = load_experiment_tables(self.parent_window.exp_dir, population='pairs', load_pickle=False)
@@ -374,45 +342,19 @@ class ConfigSignalModelTraining(QMainWindow, Styles):
 		self.signals = ['--'] + num_cols_pairs + num_cols_reference + num_cols_neighbor
 
 		for cb in self.ch_norm.channel_cbs:
-			# try:
-			# 	cb.disconnect()
-			# except:
-			# 	pass
 			cb.clear()
 			cb.addItems(self.signals)
 
 	def fill_available_neighborhoods(self):
-		
-		df_targets = load_experiment_tables(self.parent_window.exp_dir, population='targets', load_pickle=True)
-		df_effectors = load_experiment_tables(self.parent_window.exp_dir, population='effectors', load_pickle=True)
-
-		self.dataframes = {
-			'targets': df_targets,
-			'effectors': df_effectors,
-		}
 
+		self.dataframes = {}
 		self.neighborhood_cols = []
-		self.reference_populations = []
-		self.neighbor_populations = []
-		if df_targets is not None:
-			self.neighborhood_cols.extend(['target_ref_'+c for c in list(df_targets.columns) if c.startswith('neighborhood')])
-			self.reference_populations.extend(['targets' for c in list(df_targets.columns) if c.startswith('neighborhood')])
-			for c in list(df_targets.columns):
-				if c.startswith('neighborhood') and '_2_' in c:
-					self.neighbor_populations.append('effectors')
-				elif c.startswith('neighborhood') and 'self' in c:
-					self.neighbor_populations.append('targets')
-		
-		if df_effectors is not None:
-			self.neighborhood_cols.extend(['effector_ref_'+c for c in list(df_effectors.columns) if c.startswith('neighborhood')])
-			self.reference_populations.extend(['effectors' for c in list(df_effectors.columns) if c.startswith('neighborhood')])
-			for c in list(df_effectors.columns):
-				if c.startswith('neighborhood') and '_2_' in c:
-					self.neighbor_populations.append('targets')
-				elif c.startswith('neighborhood') and 'self' in c:
-					self.neighbor_populations.append('effectors')
-
-		print(f"The following neighborhoods were detected: {self.neighborhood_cols=} {self.reference_populations=} {self.neighbor_populations=}")
+		for population in self.parent_window.parent_window.populations:
+			df_pop = load_experiment_tables(self.parent_window.exp_dir, population=population, load_pickle=True)
+			self.dataframes.update({population: df_pop})
+			if df_pop is not None:
+				self.neighborhood_cols.extend(
+					[f'{population}_ref_' + c for c in list(df_pop.columns) if c.startswith('neighborhood')])
 
 		self.neighborhood_choice_cb.addItems(self.neighborhood_cols)
 
@@ -518,7 +460,7 @@ class ConfigSignalModelTraining(QMainWindow, Styles):
 		while self.scroll_area.verticalScrollBar().isVisible() and self.height() < self.maximumHeight():
 			self.resize(self.width(), self.height() + step)
 
-	def prep_model(self):
+	def _write_instructions(self):
 
 		model_name = self.modelname_le.text()
 		pretrained_model = self.pretrained_model
@@ -596,4 +538,7 @@ class ConfigSignalModelTraining(QMainWindow, Styles):
 		# 	return None	
 
 		train_signal_model(model_folder+"training_instructions.json")
-		self.parent_window.refresh_signal_models()
+		self.parent_window.refresh_signal_models()
+	
+	def _load_previous_instructions(self):
+		pass

celldetective/gui/{measurement_options.py → settings/_settings_measurements.py}

@@ -1,21 +1,19 @@
+from subprocess import Popen
 
-from PyQt5.QtWidgets import QMainWindow, QApplication, QMessageBox, QScrollArea, QComboBox, QFrame, QCheckBox, \
-	QGridLayout, QLineEdit, QVBoxLayout, QWidget, QLabel, QHBoxLayout, QPushButton
+from PyQt5.QtWidgets import QMessageBox, QComboBox, QFrame, QCheckBox, \
+	QGridLayout, QLineEdit, QVBoxLayout, QLabel, QHBoxLayout, QPushButton
 from PyQt5.QtCore import Qt, QSize
-from PyQt5.QtGui import QIcon, QDoubleValidator, QIntValidator
 
-from celldetective.gui.gui_utils import center_window, FeatureChoice, ListWidget, QHSeperationLine, FigureCanvas, \
+from celldetective.gui.gui_utils import FeatureChoice, ListWidget, QHSeperationLine, FigureCanvas, \
 	GeometryChoice, OperationChoice
 from superqt import QLabeledDoubleSlider
 from superqt.fonticon import icon
 from fonticon_mdi6 import MDI6
 
-#from celldetective.gui.thresholds_gui import ThresholdSpot
 from celldetective.utils import extract_experiment_channels, get_software_location
 from celldetective.io import load_frames, auto_load_number_of_frames
 from celldetective.measure import compute_haralick_features
 import numpy as np
-from tifffile import imread
 import json
 import os
 import matplotlib.pyplot as plt
@@ -27,11 +25,11 @@ 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, PreprocessingLayout2
-from celldetective.gui import Styles
+from celldetective.gui.gui_utils import PreprocessingLayout2
+from celldetective.gui.settings._settings_base import CelldetectiveSettingsPanel
 
 
-class ConfigMeasurements(QMainWindow, Styles):
+class SettingsMeasurements(CelldetectiveSettingsPanel):
 	"""
 	UI to set measurement instructions.
 
@@ -39,54 +37,33 @@ class ConfigMeasurements(QMainWindow, Styles):
 
 	def __init__(self, parent_window=None):
 
-		super().__init__()
-
 		self.parent_window = parent_window
-		self.setWindowTitle("Configure measurements")
-		self.setWindowIcon(QIcon(os.sep.join(['celldetective', 'icons', 'mexican-hat.png'])))
 		self.mode = self.parent_window.mode
 		self.exp_dir = self.parent_window.exp_dir
 		self.background_correction = []
-		if self.mode == "targets":
-			self.config_name = "btrack_config_targets.json"
-			self.measure_instructions_path = self.parent_window.exp_dir + "configs/measurement_instructions_targets.json"
-		elif self.mode == "effectors":
-			self.config_name = "btrack_config_effectors.json"
-			self.measure_instructions_path = self.parent_window.exp_dir + "configs/measurement_instructions_effectors.json"
-		self.soft_path = get_software_location()
+		self.config_name = f"btrack_config_{self.mode}.json"
+		self.measure_instructions_path = self.parent_window.exp_dir + f"configs/measurement_instructions_{self.mode}.json"
 		self.clear_previous = False
-
-		exp_config = self.exp_dir + "config.ini"
 		self.config_path = self.exp_dir + self.config_name
 		self.channel_names, self.channels = extract_experiment_channels(self.exp_dir)
 		self.channel_names = np.array(self.channel_names)
 		self.channels = np.array(self.channels)
+		
+		super().__init__("Configure measurements")
 
-		self.screen_height = self.parent_window.parent_window.parent_window.screen_height
-		center_window(self)
-
-		self.onlyFloat = QDoubleValidator()
-		self.onlyInt = QIntValidator()
-
-		self.setMinimumWidth(500)
-		self.setMinimumHeight(int(0.3 * self.screen_height))
-		self.setMaximumHeight(int(0.8 * self.screen_height))
-		self.populate_widget()
-		self.load_previous_measurement_instructions()
-
-	def populate_widget(self):
+		self._add_to_layout()
+		self._load_previous_instructions()
+		
+		self._adjustSize()
+		self.resize(int(self.width()), int(self._screen_height * 0.8))
+	
+	def _create_widgets(self):
 
 		"""
 		Create the multibox design.
 
 		"""
-
-		# Create button widget and layout
-		self.scroll_area = QScrollArea(self)
-		self.button_widget = QWidget()
-		main_layout = QVBoxLayout()
-		self.button_widget.setLayout(main_layout)
-		main_layout.setContentsMargins(30, 30, 30, 30)
+		super()._create_widgets()
 
 		self.normalisation_frame = QFrame()
 		self.normalisation_frame.setFrameStyle(QFrame.StyledPanel | QFrame.Raised)
@@ -104,48 +81,31 @@ class ConfigMeasurements(QMainWindow, Styles):
 		self.normalisation_frame.setLayout(self.protocol_layout)
 
 		#self.populate_normalisation_tabs()
-		main_layout.addWidget(self.normalisation_frame)
 
 		# first frame for FEATURES
 		self.features_frame = QFrame()
 		self.features_frame.setFrameStyle(QFrame.StyledPanel | QFrame.Raised)
 		self.populate_features_frame()
-		main_layout.addWidget(self.features_frame)
 
 		# second frame for ISOTROPIC MEASUREMENTS
 		self.iso_frame = QFrame()
 		self.iso_frame.setFrameStyle(QFrame.StyledPanel | QFrame.Raised)
 		self.populate_iso_frame()
-		main_layout.addWidget(self.iso_frame)
 
 		self.spot_detection_frame = QFrame()
 		self.spot_detection_frame.setFrameStyle(QFrame.StyledPanel | QFrame.Raised)
 		self.populate_spot_detection()
-		main_layout.addWidget(self.spot_detection_frame)
 
 		self.clear_previous_btn = QCheckBox('clear previous measurements')
-		main_layout.addWidget(self.clear_previous_btn)
-
-		self.submit_btn = QPushButton('Save')
-		self.submit_btn.setStyleSheet(self.button_style_sheet)
-		self.submit_btn.clicked.connect(self.write_instructions)
-		main_layout.addWidget(self.submit_btn)
-
-		# self.populate_left_panel()
-		# grid.addLayout(self.left_side, 0, 0, 1, 1)
-		self.button_widget.adjustSize()
-
-		self.scroll_area.setAlignment(Qt.AlignCenter)
-		self.scroll_area.setWidget(self.button_widget)
-		self.scroll_area.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
-		self.scroll_area.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
-		self.scroll_area.setWidgetResizable(True)
-		self.setCentralWidget(self.scroll_area)
-		self.show()
-
-		QApplication.processEvents()
-		self.adjustScrollArea()
 
+	def _add_to_layout(self):
+		self._layout.addWidget(self.normalisation_frame)
+		self._layout.addWidget(self.features_frame)
+		self._layout.addWidget(self.iso_frame)
+		self._layout.addWidget(self.spot_detection_frame)
+		self._layout.addWidget(self.clear_previous_btn)
+		self._layout.addWidget(self.submit_btn)
+	
 	def populate_iso_frame(self):
 
 		"""
@@ -264,12 +224,21 @@ class ConfigMeasurements(QMainWindow, Styles):
 
 		self.features_list = ListWidget(FeatureChoice, initial_features=['area', 'intensity_mean', ])
 
+		self.create_feature_btn = QPushButton("")
+		self.create_feature_btn.setStyleSheet(self.button_select_all)
+		self.create_feature_btn.setIcon(icon(MDI6.file_cog, color="black"))
+		self.create_feature_btn.setToolTip("Create new feature")
+		self.create_feature_btn.setIconSize(QSize(20, 20))
+
 		self.del_feature_btn.clicked.connect(self.features_list.removeSel)
 		self.add_feature_btn.clicked.connect(self.features_list.addItem)
+		self.create_feature_btn.clicked.connect(self.go_to_extraprops)
 
 		feature_layout.addWidget(self.feature_lbl, 90)
 		feature_layout.addWidget(self.del_feature_btn, 5)
 		feature_layout.addWidget(self.add_feature_btn, 5)
+		feature_layout.addWidget(self.create_feature_btn, 5)
+
 		layout.addLayout(feature_layout)
 		layout.addWidget(self.features_list)
 
@@ -334,7 +303,7 @@ class ConfigMeasurements(QMainWindow, Styles):
 		self.haralick_scale_slider.setSingleStep(0.05)
 		self.haralick_scale_slider.setTickInterval(0.05)
 		self.haralick_scale_slider.setSingleStep(1)
-		self.haralick_scale_slider.setOrientation(1)
+		self.haralick_scale_slider.setOrientation(Qt.Horizontal)
 		self.haralick_scale_slider.setRange(0, 1)
 		self.haralick_scale_slider.setValue(0.5)
 		self.haralick_scale_lbl = QLabel('Scale: ')
@@ -426,6 +395,18 @@ class ConfigMeasurements(QMainWindow, Styles):
 		self.haralick_normalization_mode_btn.clicked.connect(self.switch_to_absolute_normalization_mode)
 		layout.addLayout(self.haralick_layout)
 
+	def go_to_extraprops(self):
+		
+		path = os.sep.join([self._software_path,'celldetective',os.sep,'extra_properties.py'])
+		try:
+			Popen(f'explorer {os.path.realpath(path)}')
+		except:
+
+			try:
+				os.system('xdg-open "%s"' % path)
+			except:
+				return None		
+
 	def switch_to_absolute_normalization_mode(self):
 
 		if self.percentile_mode:
@@ -472,7 +453,7 @@ class ConfigMeasurements(QMainWindow, Styles):
 		while self.scroll_area.verticalScrollBar().isVisible() and self.height() < self.maximumHeight():
 			self.resize(self.width(), self.height() + step)
 
-	def write_instructions(self):
+	def _write_instructions(self):
 
 		"""
 		Write the selected options in a json file for later reading by the software.
@@ -551,7 +532,7 @@ class ConfigMeasurements(QMainWindow, Styles):
 		else:
 			self.haralick_options = None
 
-	def load_previous_measurement_instructions(self):
+	def _load_previous_instructions(self):
 
 		"""
 		Read the measurmeent options from a previously written json file and format properly for the UI.
@@ -670,18 +651,6 @@ class ConfigMeasurements(QMainWindow, Styles):
 					else:
 						self.operations_list.list_widget.clear()
 
-				# if 'radial_intensity' in measurement_instructions:
-				#     radial_intensity = measurement_instructions['radial_intensity']
-				#     if radial_intensity is not None:
-				#         self.radial_intensity_btn.setChecked(True)
-				#         self.step_size.setText(str(radial_intensity['radial_step']))
-				#         self.step_size.setEnabled(True)
-				#         self.step_lbl.setEnabled(True)
-				#         for checkbox in self.channel_chechkboxes:
-				#             checkbox.setEnabled(True)
-				#             if checkbox.text() in radial_intensity['radial_channels']:
-				#                 checkbox.setChecked(True)
-
 				if 'clear_previous' in measurement_instructions:
 					self.clear_previous = measurement_instructions['clear_previous']
 					self.clear_previous_btn.setChecked(self.clear_previous)
@@ -703,6 +672,7 @@ class ConfigMeasurements(QMainWindow, Styles):
 			returnValue = msgBox.exec()
 			if returnValue == QMessageBox.Ok:
 				self.current_stack = None
+				self.test_frame = None
 				return None
 		else:
 			self.current_stack = movies[0]
@@ -931,7 +901,7 @@ class ConfigMeasurements(QMainWindow, Styles):
 		diam_hbox = QHBoxLayout()
 		self.diameter_lbl = QLabel('Spot diameter: ')
 		self.diameter_value = QLineEdit()
-		self.diameter_value.setValidator(self.onlyFloat)
+		self.diameter_value.setValidator(self._floatValidator)
 		self.diameter_value.setText('7')
 		self.diameter_value.textChanged.connect(self.enable_spot_preview)
 
@@ -942,7 +912,7 @@ class ConfigMeasurements(QMainWindow, Styles):
 		thresh_hbox = QHBoxLayout()
 		self.threshold_lbl = QLabel('Spot threshold: ')
 		self.threshold_value = QLineEdit()
-		self.threshold_value.setValidator(self.onlyFloat)
+		self.threshold_value.setValidator(self._floatValidator)
 		self.threshold_value.setText('0')
 		self.threshold_value.textChanged.connect(self.enable_spot_preview)
 
@@ -950,14 +920,6 @@ class ConfigMeasurements(QMainWindow, Styles):
 		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,

celldetective/gui/{neighborhood_options.py → settings/_settings_neighborhood.py}

@@ -1,6 +1,5 @@
-from PyQt5.QtWidgets import QApplication, QComboBox, QFrame, QCheckBox, QVBoxLayout, QWidget, QLabel, QHBoxLayout, QPushButton
+from PyQt5.QtWidgets import QApplication, QComboBox, QFrame, QCheckBox, QVBoxLayout, QLabel, QHBoxLayout, QPushButton
 from PyQt5.QtCore import Qt, QSize
-from PyQt5.QtGui import QIcon
 from celldetective.gui.gui_utils import center_window, ListWidget, DistanceChoice
 from superqt.fonticon import icon
 from fonticon_mdi6 import MDI6
@@ -10,9 +9,10 @@ import os
 from glob import glob
 import pandas as pd
 from celldetective.gui.viewers import CellSizeViewer, CellEdgeVisualizer
-from celldetective.gui import Styles
+from celldetective.gui import CelldetectiveWidget
 
-class ConfigNeighborhoods(QWidget, Styles):
+
+class SettingsNeighborhood(CelldetectiveWidget):
 	
 	"""
 	Widget to configure neighborhood measurements.
@@ -24,7 +24,6 @@ class ConfigNeighborhoods(QWidget, Styles):
 		super().__init__(*args, **kwargs)
 		self.parent_window = parent_window
 		self.attr_parent = self.parent_window.parent_window
-		self.setWindowIcon(QIcon(os.sep.join(['celldetective','icons','logo.png'])))
 
 		self.neighborhood_type = neighborhood_type
 		self.neighborhood_parameter_name = neighborhood_parameter_name
@@ -43,7 +42,6 @@ class ConfigNeighborhoods(QWidget, Styles):
 		self.generate_main_layout()
 		self.load_previous_neighborhood_instructions()
 		center_window(self)
-		self.setAttribute(Qt.WA_DeleteOnClose)
 
 	def generate_main_layout(self):
 
@@ -140,7 +138,7 @@ class ConfigNeighborhoods(QWidget, Styles):
 
 		layout.addLayout(list_header_layout)
 
-		self.measurements_list = ListWidget(DistanceChoice, initial_features=["60"], dtype=int)
+		self.measurements_list = ListWidget(DistanceChoice, initial_features=[], dtype=int)
 		self.measurements_list.setToolTip('Neighborhoods to compute.')
 		layout.addWidget(self.measurements_list)
 
@@ -211,7 +209,7 @@ class ConfigNeighborhoods(QWidget, Styles):
 		population_layout = QHBoxLayout()
 		population_layout.addWidget(QLabel('population: '),30)
 		self.reference_population_cb = QComboBox()
-		self.reference_population_cb.addItems(['targets','effectors'])
+		self.reference_population_cb.addItems(self.parent_window.parent_window.populations)
 		self.reference_population_cb.setToolTip('Select a reference population.')
 		population_layout.addWidget(self.reference_population_cb,70)
 		layout.addLayout(population_layout)
@@ -271,7 +269,7 @@ class ConfigNeighborhoods(QWidget, Styles):
 		population_layout = QHBoxLayout()
 		population_layout.addWidget(QLabel('population: '),30)
 		self.neighbor_population_cb = QComboBox()
-		self.neighbor_population_cb.addItems(['targets','effectors'])
+		self.neighbor_population_cb.addItems(self.parent_window.parent_window.populations)
 		self.neighbor_population_cb.setToolTip('Select a neighbor population.')
 		population_layout.addWidget(self.neighbor_population_cb,70)
 		layout.addLayout(population_layout)
@@ -315,15 +313,14 @@ class ConfigNeighborhoods(QWidget, Styles):
 		population = self.neighbor_population_cb.currentText()
 		class_cols, status_cols, group_cols, time_cols = self.locate_population_specific_columns(population)
 		self.neighbor_population_status_cb.clear()
-		self.neighbor_population_status_cb.addItems(['--','class', 'status']+class_cols+status_cols+group_cols)
+		self.neighbor_population_status_cb.addItems(list(np.unique(['--','class', 'status']+class_cols+status_cols+group_cols)))
 
 	def fill_cbs_of_reference_population(self):
 
 		population = self.reference_population_cb.currentText()
 		class_cols, status_cols, group_cols, time_cols = self.locate_population_specific_columns(population)
-		self.reference_population_status_cb.clear()
-		self.reference_population_status_cb.addItems(['--','class', 'status']+class_cols+status_cols+group_cols)
-		self.event_time_cb.addItems(['--', 't0']+time_cols)
+		self.event_time_cb.clear()
+		self.event_time_cb.addItems(list(np.unique(['--', 't0']+time_cols)))
 
 	def switch_not_reference(self):