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

celldetective/__init__.py

@@ -1,4 +1 @@
 from ._version import __version__
-#from .tracking import track, clean_trajectories
-#from .measure import contour_of_instance_segmentation
-

celldetective/_version.py

@@ -1 +1 @@
-__version__ = "1.3.9.post5"
+__version__ = "1.4.1"

celldetective/events.py

@@ -52,7 +52,7 @@ def switch_to_events(classes, event_times, max_times, origin_times=None, left_ce
 	>>> event_times = [5, 10, 15]
 	>>> max_times = [20, 20, 20]
 	>>> origin_times = [0, 0, 5]
-	>>> events, survival_times = switch_to_events_v2(classes, event_times, max_times, origin_times, FrameToMin=0.5)
+	>>> events, survival_times = switch_to_events(classes, event_times, max_times, origin_times, FrameToMin=0.5)
 	# This would process the events considering left censorship and convert survival times to minutes.
 	
 	"""
@@ -189,6 +189,7 @@ def compute_survival(df, class_of_interest, t_event, t_reference=None, FrameToMi
 	assert class_of_interest in cols,"The requested class cannot be found in the dataframe..."
 	assert t_event in cols,"The event time cannot be found in the dataframe..."
 	left_censored = False
+	first_detections = None
 
 	if not pairs:
 		groupby_cols = ['position','TRACK_ID']
@@ -209,10 +210,7 @@ def compute_survival(df, class_of_interest, t_event, t_reference=None, FrameToMi
 		assert t_reference in cols,"The reference time cannot be found in the dataframe..."
 		first_detections = df.groupby(groupby_cols)[t_reference].max().values
 	
-
-	print(f"{classes=} {event_times=} {max_times=} {first_detections=}")
 	events, survival_times = switch_to_events(classes, event_times, max_times, origin_times=first_detections, left_censored=left_censored, FrameToMin=FrameToMin, cut_observation_time=cut_observation_time)
-	print(f"{events=} {survival_times=}")
 
 	ks = KaplanMeierFitter()
 	if len(events)>0:

celldetective/exceptions.py

@@ -0,0 +1,11 @@
+class QueryError(Exception):
+    """Base class for query-related errors."""
+
+class EmptyQueryError(QueryError):
+    pass
+
+class MissingColumnsError(QueryError):
+    def __init__(self, missing_cols):
+        msg = f"The following columns are missing from the DataFrame: {missing_cols}"
+        super().__init__(msg)
+        self.missing_cols = missing_cols

celldetective/extra_properties.py

@@ -245,6 +245,138 @@ def fraction_of_area_dark_intensity(regionmask, intensity_image, target_channel=
 	return float(np.sum(subregion)) / float(np.sum(regionmask))
 
 
+def area_dark_intensity_nintyfive(regionmask, intensity_image, target_channel='adhesion_channel', fill_holes=True): #, target_channel='adhesion_channel'
+	
+	subregion = (intensity_image < 0.95)*regionmask # under one, under 0.8, under 0.6, whatever value!
+	if fill_holes:
+		subregion = skm.label(subregion, connectivity=2, background=0)
+		subregion = fill_label_holes(subregion)
+		subregion[subregion>0] = 1
+	
+	return float(np.sum(subregion))
+
+def area_dark_intensity_ninty(regionmask, intensity_image, target_channel='adhesion_channel', fill_holes=True): #, target_channel='adhesion_channel'
+	
+	subregion = (intensity_image < 0.90)*regionmask # under one, under 0.8, under 0.6, whatever value!
+	if fill_holes:
+		subregion = skm.label(subregion, connectivity=2, background=0)
+		subregion = fill_label_holes(subregion)
+		subregion[subregion>0] = 1
+	
+	return float(np.sum(subregion))
+
+def mean_dark_intensity_nintyfive(regionmask, intensity_image, target_channel='adhesion_channel', fill_holes=True):
+    """
+    Calculate the mean intensity in a dark subregion below 95, handling NaN values.
+    
+    """
+    subregion = (intensity_image < 0.95) * regionmask
+    
+    if fill_holes:
+        subregion = skm.label(subregion, connectivity=2, background=0)
+        subregion = fill_label_holes(subregion)
+        subregion[subregion > 0] = 1
+    
+    
+    masked_intensity = intensity_image[subregion == 1]
+    
+    return float(np.nanmean(masked_intensity))
+
+
+def mean_dark_intensity_nintyfive_fillhole_false(regionmask, intensity_image, target_channel='adhesion_channel'):
+    """
+    Calculate the mean intensity in a dark subregion below 95, handling NaN values.
+    """
+    subregion = (intensity_image < 0.95) * regionmask  # Select dark regions within the mask
+
+    masked_intensity = intensity_image[subregion == 1]  # Extract pixel values from the selected region
+
+    return float(np.nanmean(masked_intensity))  # Compute mean, ignoring NaNs
+
+def mean_dark_intensity_ninty_fillhole_false(regionmask, intensity_image, target_channel='adhesion_channel'):
+    """
+    Calculate the mean intensity in a dark subregion, handling NaN values.
+    """
+    subregion = (intensity_image < 0.90) * regionmask  # Select dark regions within the mask
+
+    masked_intensity = intensity_image[subregion == 1]  # Extract pixel values from the selected region
+
+    return float(np.nanmean(masked_intensity))  # Compute mean, ignoring NaNs
+
+
+def mean_dark_intensity_ninty(regionmask, intensity_image, target_channel='adhesion_channel', fill_holes=True):
+    """
+    Calculate the mean intensity in a dark subregion below 90, handling NaN values.
+    
+    """
+    subregion = (intensity_image < 0.90) * regionmask
+    
+    if fill_holes:
+        subregion = skm.label(subregion, connectivity=2, background=0)
+        subregion = fill_label_holes(subregion)
+        subregion[subregion > 0] = 1
+    
+    
+    masked_intensity = intensity_image[subregion == 1]
+    
+    return float(np.nanmean(masked_intensity))
+
+def mean_dark_intensity_eight_five(regionmask, intensity_image, target_channel='adhesion_channel', fill_holes=True):
+    """
+    Calculate the mean intensity in a dark subregion below 85, handling NaN values.
+    
+    """
+    subregion = (intensity_image < 0.85) * regionmask
+    
+    if fill_holes:
+        subregion = skm.label(subregion, connectivity=2, background=0)
+        subregion = fill_label_holes(subregion)
+        subregion[subregion > 0] = 1
+    
+    
+    masked_intensity = intensity_image[subregion == 1]
+    
+    return float(np.nanmean(masked_intensity))
+
+
+def mean_dark_intensity_eight_five_fillhole_false(regionmask, intensity_image, target_channel='adhesion_channel'):
+
+    subregion = (intensity_image < 0.85) * regionmask  # Select dark regions within the mask
+
+    masked_intensity = intensity_image[subregion == 1]  # Extract pixel values from the selected region
+
+    return float(np.nanmean(masked_intensity))  # Compute mean, ignoring NaNs
+
+def percentile_zero_one_dark_intensity_ninty(regionmask, intensity_image, target_channel='adhesion_channel'):
+
+    subregion = (intensity_image < 0.95) * regionmask
+    return float(np.nanpercentile(intensity_image[subregion],0.1))
+
+
+def percentile_one_dark_intensity_ninty(regionmask, intensity_image, target_channel='adhesion_channel'):
+
+    subregion = (intensity_image < 0.95) * regionmask
+    return float(np.nanpercentile(intensity_image[subregion],1))
+
+
+def percentile_five_dark_intensity_ninty(regionmask, intensity_image, target_channel='adhesion_channel'):
+
+    subregion = (intensity_image < 0.95) * regionmask
+    return float(np.nanpercentile(intensity_image[subregion],5))
+
+
+def percentile_ten_dark_intensity_ninty(regionmask, intensity_image, target_channel='adhesion_channel'):
+
+    subregion = (intensity_image < 0.95) * regionmask
+    return float(np.nanpercentile(intensity_image[subregion],10))
+
+
+def percentile_ninty_five_dark_intensity_ninty(regionmask, intensity_image, target_channel='adhesion_channel'):
+
+    subregion = (intensity_image < 0.95) * regionmask
+    return float(np.nanpercentile(intensity_image[subregion],95))
+   
+
 def intensity_percentile_ninety_nine(regionmask, intensity_image):
 	return np.nanpercentile(intensity_image[regionmask],99)
 

celldetective/filters.py

@@ -1,4 +1,5 @@
-from skimage.filters import difference_of_gaussians, threshold_otsu, threshold_local, threshold_niblack, threshold_sauvola
+from skimage.filters import difference_of_gaussians, threshold_multiotsu, threshold_otsu, threshold_local, \
+	threshold_niblack, threshold_sauvola
 from celldetective.utils import interpolate_nan
 import scipy.ndimage as snd
 import numpy as np
@@ -102,6 +103,11 @@ def otsu_filter(img, *kwargs):
 	binary = img >= thresh
 	return binary.astype(float)
 
+def multiotsu_filter(img, classes=3, *kwargs):
+	thresholds = threshold_multiotsu(img, classes=classes)
+	regions = np.digitize(img, bins=thresholds)
+	return regions.astype(float)
+	
 def local_filter(img, *kwargs):
 	thresh = threshold_local(img.astype(float), *kwargs)
 	binary = img >= thresh

celldetective/gui/InitWindow.py

@@ -1,29 +1,27 @@
+import gc
+import json
 import os
-
-from PyQt5.QtWidgets import QApplication, QMainWindow
-from PyQt5.QtWidgets import QFileDialog, QDialog, QWidget, QVBoxLayout, QCheckBox, QHBoxLayout, QLabel, QLineEdit, QPushButton, QMessageBox, QMenu, QAction
-from PyQt5.QtCore import Qt, QUrl
-from PyQt5.QtGui import QIcon, QDesktopServices, QIntValidator
-
 from glob import glob
-from superqt.fonticon import icon
-from fonticon_mdi6 import MDI6
-
-from celldetective.gui.about import AboutWidget
-from celldetective.io import correct_annotation
-from celldetective.utils import download_zenodo_file
-from celldetective.gui.gui_utils import center_window
-from celldetective.gui import Styles, ControlPanel, ConfigNewExperiment
+from subprocess import Popen, check_output
 
-import gc
-from subprocess import check_output, Popen
+from PyQt5.QtCore import QUrl, Qt
+from PyQt5.QtGui import QDesktopServices, QIntValidator
+from PyQt5.QtWidgets import QAction, QApplication, QCheckBox, QDialog, QFileDialog, QHBoxLayout, QLabel, QLineEdit, \
+	QMenu, QPushButton, QVBoxLayout
+from fonticon_mdi6 import MDI6
 from psutil import cpu_count
-import json
+from superqt.fonticon import icon
 
+from celldetective.gui import ConfigNewExperiment, ControlPanel, CelldetectiveMainWindow, CelldetectiveWidget
+from celldetective.gui.about import AboutWidget
+from celldetective.gui.gui_utils import center_window, generic_message
 from celldetective.gui.processes.downloader import DownloadProcess
 from celldetective.gui.workers import ProgressWindow
+from celldetective.io import correct_annotation, extract_well_name_and_number
+from celldetective.utils import download_zenodo_file, pretty_table
 
-class AppInitWindow(QMainWindow, Styles):
+
+class AppInitWindow(CelldetectiveMainWindow):
 
 	"""
 	Initial window to set the experiment folder or create a new one.
@@ -36,7 +34,7 @@ class AppInitWindow(QMainWindow, Styles):
 		self.parent_window = parent_window
 		self.setWindowTitle("celldetective")
 
-		self.n_threads = min([1,cpu_count()])
+		self.n_threads = min([1, cpu_count()])
 
 		try:
 			check_output('nvidia-smi')
@@ -48,7 +46,6 @@ class AppInitWindow(QMainWindow, Styles):
 
 		self.soft_path = software_location
 		self.onlyInt = QIntValidator()
-		self.setWindowIcon(QIcon(os.sep.join([self.soft_path,'celldetective','icons','logo.png'])))
 
 		self._createActions()
 		self._createMenuBar()
@@ -58,9 +55,9 @@ class AppInitWindow(QMainWindow, Styles):
 		self.geometry = self.screen.availableGeometry()
 		self.screen_width, self.screen_height = self.geometry.getRect()[-2:]
 
-		central_widget = QWidget()
+		central_widget = CelldetectiveWidget()
 		self.vertical_layout = QVBoxLayout(central_widget)
-		self.vertical_layout.setContentsMargins(15,15,15,15)
+		self.vertical_layout.setContentsMargins(15, 15, 15, 15)
 		self.vertical_layout.addWidget(QLabel("Experiment folder:"))
 		self.create_locate_exp_hbox()
 		self.create_buttons_hbox()
@@ -79,14 +76,17 @@ class AppInitWindow(QMainWindow, Styles):
 	def create_locate_exp_hbox(self):
 
 		self.locate_exp_layout = QHBoxLayout()
-		self.locate_exp_layout.setContentsMargins(0,5,0,0)
+		self.locate_exp_layout.setContentsMargins(0, 5, 0, 0)
 		self.experiment_path_selection = QLineEdit()
 		self.experiment_path_selection.setAlignment(Qt.AlignLeft)	
 		self.experiment_path_selection.setEnabled(True)
 		self.experiment_path_selection.setDragEnabled(True)
 		self.experiment_path_selection.setFixedWidth(430)
 		self.experiment_path_selection.textChanged[str].connect(self.check_path_and_enable_opening)
-		self.foldername = os.getcwd()
+		try:
+			self.foldername = os.getcwd()
+		except FileNotFoundError as e:
+			self.foldername = ""
 		self.experiment_path_selection.setPlaceholderText('/path/to/experiment/folder/')
 		self.locate_exp_layout.addWidget(self.experiment_path_selection, 90)
 
@@ -266,7 +266,7 @@ class AppInitWindow(QMainWindow, Styles):
 		
 		print('setting memory and threads')
 
-		self.ThreadsWidget = QWidget()
+		self.ThreadsWidget = CelldetectiveWidget()
 		self.ThreadsWidget.setWindowTitle("Threads")
 		layout = QVBoxLayout()
 		self.ThreadsWidget.setLayout(layout)
@@ -382,24 +382,21 @@ class AppInitWindow(QMainWindow, Styles):
 		wells = glob(os.sep.join([self.exp_dir,"W*"]))
 		self.number_of_wells = len(wells)
 		if self.number_of_wells==0:
-			msgBox = QMessageBox()
-			msgBox.setIcon(QMessageBox.Critical)
-			msgBox.setText("No well was found in the experiment folder.\nPlease respect the W*/ nomenclature...")
-			msgBox.setWindowTitle("Error")
-			msgBox.setStandardButtons(QMessageBox.Ok)
-			returnValue = msgBox.exec()
-			if returnValue == QMessageBox.Ok:
-				return None
+			generic_message("No well was found in the experiment folder.\nPlease respect the W*/ nomenclature...", msg_type="critical")
+			return None
 		else:
 			if self.number_of_wells==1:
 				print(f"Found {self.number_of_wells} well...")
 			elif self.number_of_wells>1:
 				print(f"Found {self.number_of_wells} wells...")
-			number_pos = []
+
+			number_pos = {}
 			for w in wells:
-				position_folders = glob(os.sep.join([w,f"{w.split(os.sep)[-1][1]}*", os.sep]))
-				number_pos.append(len(position_folders))
-			print(f"Number of positions per well: {number_pos}")
+				well_name, well_nbr = extract_well_name_and_number(w)
+				position_folders = glob(os.sep.join([w,f"{well_nbr}*", os.sep]))
+				number_pos.update({well_name: len(position_folders)})
+			print(f"Number of positions per well:")
+			pretty_table(number_pos)
 			
 			with open(os.sep.join([self.soft_path,'celldetective','recent.txt']), 'a+') as f:
 				f.write(self.exp_dir+'\n')
@@ -423,12 +420,6 @@ class AppInitWindow(QMainWindow, Styles):
 		else:
 			return None
 		if not os.path.exists(os.sep.join([self.foldername,"config.ini"])):
-			msgBox = QMessageBox()
-			msgBox.setIcon(QMessageBox.Warning)
-			msgBox.setText("No configuration can be found in the selected folder...")
-			msgBox.setWindowTitle("Warning")
-			msgBox.setStandardButtons(QMessageBox.Ok)
-			returnValue = msgBox.exec()
-			if returnValue == QMessageBox.Ok:
-				self.experiment_path_selection.setText('')
-				return None
+			generic_message("No configuration can be found in the selected folder...", msg_type="warning")
+			self.experiment_path_selection.setText('')
+			return None

celldetective/gui/__init__.py

@@ -1,21 +1,15 @@
 from .styles import Styles
-from .btrack_options import ConfigTracking
+from .base_components import CelldetectiveWidget, CelldetectiveMainWindow
 from .json_readers import ConfigEditor
 from .tableUI import TableUI
-from .measurement_options import ConfigMeasurements
-from .neighborhood_options import ConfigNeighborhoods
 from .classifier_widget import ClassifierWidget
 from .survival_ui import ConfigSurvival
 from .plot_signals_ui import ConfigSignalPlot
-from .signal_annotator_options import ConfigSignalAnnotator
-from .signal_annotator import SignalAnnotator
-from .signal_annotator2 import SignalAnnotator2
-from .retrain_signal_model_options import ConfigSignalModelTraining
-from .retrain_segmentation_model_options import ConfigSegmentationModelTraining
+from .event_annotator import EventAnnotator
+from .pair_event_annotator import PairEventAnnotator
 from .thresholds_gui import ThresholdConfigWizard
 from .seg_model_loader import SegmentationModelLoader
 from .process_block import ProcessPanel, NeighPanel, PreprocessingPanel
 from .analyze_block import AnalysisPanel
 from .control_panel import ControlPanel
 from .configure_new_exp import ConfigNewExperiment
-

celldetective/gui/about.py

@@ -1,44 +1,48 @@
-from PyQt5.QtWidgets import QWidget, QVBoxLayout, QLabel
+from PyQt5.QtWidgets import QVBoxLayout, QLabel
 from PyQt5.QtGui import QPixmap
 from PyQt5.QtCore import Qt
+
+from celldetective.gui import CelldetectiveWidget
 from celldetective.utils import get_software_location
 import os
 from celldetective.gui.gui_utils import center_window
 from celldetective._version import __version__
 
-class AboutWidget(QWidget):
 
+class AboutWidget(CelldetectiveWidget):
+	
 	def __init__(self):
-
 		super().__init__()
 		self.setWindowTitle("About celldetective")
-		self.setMinimumWidth(300)
+		self.setMaximumWidth(320)
 		center_window(self)
-		logo = QPixmap(os.sep.join([get_software_location(),'celldetective','icons','logo.png']))
-
+		
+		logo = QPixmap(self.celldetective_logo_path)
+		
 		# Create the layout
 		layout = QVBoxLayout(self)
 		img_label = QLabel('')
 		img_label.setPixmap(logo)
 		layout.addWidget(img_label, alignment=Qt.AlignCenter)
-
+		
 		self.soft_name = QLabel('celldetective')
 		self.soft_name.setStyleSheet("""font-weight: bold;
 										font-size: 18px;
 									""")
 		layout.addWidget(self.soft_name, alignment=Qt.AlignCenter)
-
-		self.version_lbl = QLabel(f"Version {__version__} <a href=\"https://github.com/remyeltorro/celldetective/releases\">(release notes)</a>")
+		
+		self.version_lbl = QLabel(f"Version {__version__} <a href=\"https://github.com/celldetective/celldetective"
+								  f"/releases\">(release notes)</a>")
 		self.version_lbl.setOpenExternalLinks(True)
 		layout.addWidget(self.version_lbl, alignment=Qt.AlignCenter)
-
+		
 		self.lab_lbl = QLabel("Developed at Laboratoire Adhésion et Inflammation (LAI) INSERM U1067 CNRS UMR 7333")
 		self.lab_lbl.setWordWrap(True)
 		layout.addWidget(self.lab_lbl, alignment=Qt.AlignCenter)
-
-		self.centuri_mention = QLabel("The project leading to this publication has received funding from France 2030, the French Government program managed by the French National Research Agency (ANR-16-CONV-0001) and from Excellence Initiative of Aix-Marseille University - A*MIDEX')")
+		
+		self.centuri_mention = QLabel(
+			"The project leading to this publication has received funding from France 2030, the French Government "
+			"program managed by the French National Research Agency (ANR-16-CONV-0001) and from Excellence Initiative "
+			"of Aix-Marseille University - A*MIDEX')")
 		self.centuri_mention.setWordWrap(True)
 		layout.addWidget(self.centuri_mention, alignment=Qt.AlignCenter)
-
-
-

celldetective/gui/analyze_block.py

@@ -1,11 +1,14 @@
 from PyQt5.QtWidgets import QFrame, QLabel, QPushButton, QVBoxLayout, \
-    QSpacerItem, QSizePolicy
+	QSpacerItem, QSizePolicy
 from PyQt5.QtCore import Qt, QSize
 from PyQt5.QtGui import QIcon
-from celldetective.gui.plot_measurements import ConfigMeasurementsPlot
 from celldetective.gui import ConfigSurvival, ConfigSignalPlot
 import os
 from celldetective.gui import Styles
+from glob import glob
+
+from celldetective.gui.gui_utils import generic_message
+
 
 class AnalysisPanel(QFrame, Styles):
 	def __init__(self, parent_window, title=None):
@@ -14,10 +17,11 @@ class AnalysisPanel(QFrame, Styles):
 		self.parent_window = parent_window
 		self.title = title
 		if self.title is None:
-			self.title=''
+			self.title = ''
 		self.exp_channels = self.parent_window.exp_channels
 		self.exp_dir = self.parent_window.exp_dir
 		self.soft_path = self.parent_window.parent_window.soft_path
+		self.pop_exists = False
 
 		self.setFrameStyle(QFrame.StyledPanel | QFrame.Raised)
 		self.grid = QVBoxLayout(self)
@@ -40,7 +44,7 @@ class AnalysisPanel(QFrame, Styles):
 		self.grid.addWidget(panel_title, alignment=Qt.AlignCenter)
 
 		self.survival_btn = QPushButton("plot survival")
-		self.survival_btn.setIcon(QIcon(QIcon(os.sep.join([self.soft_path,'celldetective','icons','survival2.png']))))
+		self.survival_btn.setIcon(QIcon(QIcon(os.sep.join([self.soft_path, 'celldetective', 'icons', 'survival2.png']))))
 		self.survival_btn.setStyleSheet(self.button_style_sheet_2)
 		self.survival_btn.setIconSize(QSize(35, 35))
 		self.survival_btn.clicked.connect(self.configure_survival)
@@ -55,27 +59,38 @@ class AnalysisPanel(QFrame, Styles):
 		self.grid.addWidget(signal_lbl, alignment=Qt.AlignCenter)
 
 		self.plot_signal_btn = QPushButton("plot signals")
-		self.plot_signal_btn.setIcon(QIcon(QIcon(os.sep.join([self.soft_path,'celldetective','icons','signals_icon.png']))))
+		self.plot_signal_btn.setIcon(QIcon(QIcon(os.sep.join([self.soft_path, 'celldetective', 'icons', 'signals_icon.png']))))
 		self.plot_signal_btn.setStyleSheet(self.button_style_sheet_2)
 		self.plot_signal_btn.setIconSize(QSize(35, 35))
 		self.plot_signal_btn.clicked.connect(self.configure_plot_signals)
 		self.grid.addWidget(self.plot_signal_btn)
 
-		verticalSpacer = QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding)
-		self.grid.addItem(verticalSpacer)
+		vertical_spacer = QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding)
+		self.grid.addItem(vertical_spacer)
 
+	def check_for_tables(self):
+		
+		for population in self.parent_window.populations:
+			tables = glob(self.exp_dir + os.sep.join(['W*', '*', 'output', 'tables', f'trajectories_{population}.csv']))
+			if len(tables) > 0:
+				self.pop_exists = True
+	
 	def configure_survival(self):
-		print('survival analysis starting!!!')
-		self.configSurvival = ConfigSurvival(self)
-		self.configSurvival.show()
+		
+		self.check_for_tables()
+		if self.pop_exists:
+			self.configSurvival = ConfigSurvival(self)
+			self.configSurvival.show()
+		else:
+			generic_message("No population table could be found... Abort...")
+			return None
 
 	def configure_plot_signals(self):
-		print('Configure a signal collapse representation...')
-		self.ConfigSignalPlot = ConfigSignalPlot(self)
-		self.ConfigSignalPlot.show()
-
-	def configure_plot_measurements(self):
-
-		print('plot measurements analysis starting!!!')
-		self.ConfigMeasurementsPlot_wg = ConfigMeasurementsPlot(self)
-		self.ConfigMeasurementsPlot_wg.show()
+		
+		self.check_for_tables()
+		if self.pop_exists:
+			self.ConfigSignalPlot = ConfigSignalPlot(self)
+			self.ConfigSignalPlot.show()
+		else:
+			generic_message("No population table could be found... Abort...")
+			return None