celldetective 1.4.2__py3-none-any.whl → 1.5.0b0__py3-none-any.whl

celldetective/gui/plot_measurements.py

@@ -1,23 +1,41 @@
-from PyQt5.QtWidgets import QMessageBox, QScrollArea, QButtonGroup, QComboBox, \
-    QCheckBox, QVBoxLayout, QLabel, QHBoxLayout, QPushButton, \
-    QRadioButton, QSizePolicy
+from PyQt5.QtWidgets import (
+    QMessageBox,
+    QScrollArea,
+    QButtonGroup,
+    QComboBox,
+    QCheckBox,
+    QVBoxLayout,
+    QLabel,
+    QHBoxLayout,
+    QPushButton,
+    QRadioButton,
+    QSizePolicy,
+)
 from PyQt5.QtCore import Qt, QRect
 from PyQt5.QtGui import QDoubleValidator
 
-from celldetective.gui import CelldetectiveWidget
-from celldetective.gui.gui_utils import center_window, FigureCanvas
+from celldetective.gui.base.components import CelldetectiveWidget
+from celldetective.gui.base.figure_canvas import FigureCanvas
+from celldetective.gui.base.utils import center_window
 
 from superqt.fonticon import icon
 from fonticon_mdi6 import MDI6
-from celldetective.utils import get_software_location, _extract_labels_from_config
-from celldetective.io import load_experiment_tables, get_experiment_antibodies, get_experiment_cell_types, get_experiment_concentrations, \
-    get_positions_in_well, get_experiment_wells
+from celldetective import get_software_location
+from celldetective.utils.parsing import _extract_labels_from_config
+from celldetective.utils.data_loaders import load_experiment_tables
+from celldetective.utils.experiment import (
+    get_experiment_wells,
+    get_experiment_concentrations,
+    get_experiment_cell_types,
+    get_experiment_antibodies,
+    get_positions_in_well,
+)
 import numpy as np
 import json
 import os
 import matplotlib.pyplot as plt
 
-plt.rcParams['svg.fonttype'] = 'none'
+plt.rcParams["svg.fonttype"] = "none"
 from glob import glob
 import pandas as pd
 from matplotlib.cm import tab10
@@ -52,15 +70,21 @@ class ConfigMeasurementsPlot(CelldetectiveWidget):
         # sns.color_palette("cubehelix", as_cmap=True)
         # sns.color_palette("ch:s=-.2,r=.6", as_cmap=True)
 
-        print('Parent wells: ', self.wells)
+        print("Parent wells: ", self.wells)
 
-        self.well_option = self.parent_window.parent_window.well_list.getSelectedIndices()
-        self.position_option = self.parent_window.parent_window.position_list.getSelectedIndices()
+        self.well_option = (
+            self.parent_window.parent_window.well_list.getSelectedIndices()
+        )
+        self.position_option = (
+            self.parent_window.parent_window.position_list.getSelectedIndices()
+        )
         self.interpret_pos_location()
         # self.load_available_tables()
         # self.config_path = self.exp_dir + self.config_name
 
-        self.screen_height = self.parent_window.parent_window.parent_window.screen_height
+        self.screen_height = (
+            self.parent_window.parent_window.parent_window.screen_height
+        )
         center_window(self)
         # self.setMinimumHeight(int(0.8*self.screen_height))
         # self.setMaximumHeight(int(0.8*self.screen_height))
@@ -71,7 +95,6 @@ class ConfigMeasurementsPlot(CelldetectiveWidget):
         self.hue_colors = {0: self.palette[0], 1: self.palette[3]}
 
     def interpret_pos_location(self):
-
         """
         Read the well/position selection from the control panel to decide which data to load
         Set position_indices to None if all positions must be taken
@@ -89,7 +112,6 @@ class ConfigMeasurementsPlot(CelldetectiveWidget):
             self.position_indices = np.array([self.position_option], dtype=int)
 
     def populate_widget(self):
-
         """
         Create the multibox design.
 
@@ -99,15 +121,25 @@ class ConfigMeasurementsPlot(CelldetectiveWidget):
         main_layout = QVBoxLayout()
         self.setLayout(main_layout)
         main_layout.setContentsMargins(30, 30, 30, 30)
-        panel_title = QLabel('Options')
-        panel_title.setStyleSheet("""
+        panel_title = QLabel("Options")
+        panel_title.setStyleSheet(
+            """
 			font-weight: bold;
 			padding: 0px;
-			""")
+			"""
+        )
         main_layout.addWidget(panel_title, alignment=Qt.AlignCenter)
 
-        labels = [QLabel('population: '), QLabel('class: '), QLabel('group: ')]  # , QLabel('time of\ninterest: ')]
-        self.cb_options = [self.parent_window.parent_window.populations, ['class'], ['group']]  # , ['t0','first detection']]
+        labels = [
+            QLabel("population: "),
+            QLabel("class: "),
+            QLabel("group: "),
+        ]  # , QLabel('time of\ninterest: ')]
+        self.cb_options = [
+            self.parent_window.parent_window.populations,
+            ["class"],
+            ["group"],
+        ]  # , ['t0','first detection']]
         self.cbs = [QComboBox() for i in range(len(labels))]
         self.cbs[0].currentIndexChanged.connect(self.set_classes_and_times)
 
@@ -164,7 +196,7 @@ class ConfigMeasurementsPlot(CelldetectiveWidget):
         # #time_calib_layout.addWidget(QLabel(' min'))
         # main_layout.addLayout(time_calib_layout)
 
-        self.submit_btn = QPushButton('Submit')
+        self.submit_btn = QPushButton("Submit")
         self.submit_btn.setStyleSheet(self.button_style_sheet)
         self.submit_btn.clicked.connect(self.process_signal)
         main_layout.addWidget(self.submit_btn)
@@ -189,31 +221,34 @@ class ConfigMeasurementsPlot(CelldetectiveWidget):
             self.cbs[2].setEnabled(False)
 
     def set_classes_and_times(self):
-        ext = 'csv'
+        ext = "csv"
         # Look for all classes and times
-        tables = glob(self.exp_dir + os.sep.join(['W*', '*', 'output', 'tables', f'trajectories_*{ext}']))
+        tables = glob(
+            self.exp_dir
+            + os.sep.join(["W*", "*", "output", "tables", f"trajectories_*{ext}"])
+        )
         self.all_columns = []
         for tab in tables:
             cols = pd.read_csv(tab, nrows=1).columns.tolist()
             self.all_columns.extend(cols)
         self.all_columns = np.unique(self.all_columns)
-        class_idx = np.array([s.startswith('class_') for s in self.all_columns])
-        group_idx = np.array([s.startswith('group_') for s in self.all_columns])
+        class_idx = np.array([s.startswith("class_") for s in self.all_columns])
+        group_idx = np.array([s.startswith("group_") for s in self.all_columns])
 
-        print(f'{class_idx=} {group_idx=} {self.all_columns=}')
+        print(f"{class_idx=} {group_idx=} {self.all_columns=}")
         # time_idx = np.array([s.startswith('t_') for s in self.all_columns])
         try:
-            if len(class_idx)>0:
+            if len(class_idx) > 0:
                 class_columns = list(self.all_columns[class_idx])
             else:
                 class_columns = []
-            if len(group_idx)>0:
+            if len(group_idx) > 0:
                 group_columns = list(self.all_columns[group_idx])
             else:
                 group_columns = []
         # time_columns = list(self.all_columns[time_idx])
         except Exception as e:
-            print(f'L210 columns not found {e}')
+            print(f"L210 columns not found {e}")
             self.auto_close = True
             return None
 
@@ -238,11 +273,11 @@ class ConfigMeasurementsPlot(CelldetectiveWidget):
         self.feature_cb = QComboBox()
         self.feature_cb.addItems(feats)
         hbox = QHBoxLayout()
-        hbox.addWidget(QLabel('feature: '), 33)
+        hbox.addWidget(QLabel("feature: "), 33)
         hbox.addWidget(self.feature_cb, 66)
         layout.addLayout(hbox)
 
-        self.set_feature_btn = QPushButton('set')
+        self.set_feature_btn = QPushButton("set")
         self.set_feature_btn.clicked.connect(self.compute_signals)
         layout.addWidget(self.set_feature_btn)
         self.feature_choice_widget.show()
@@ -261,7 +296,7 @@ class ConfigMeasurementsPlot(CelldetectiveWidget):
         self.feature_cb = QComboBox()
         self.feature_cb.addItems(feats)
         hbox = QHBoxLayout()
-        hbox.addWidget(QLabel('feature: '), 33)
+        hbox.addWidget(QLabel("feature: "), 33)
         hbox.addWidget(self.feature_cb, 66)
         # hbox.addWidget((QLabel('Plot two features')))
         layout.addLayout(hbox)
@@ -282,7 +317,7 @@ class ConfigMeasurementsPlot(CelldetectiveWidget):
         # hbox_two.addWidget(self.feature_two_cb, 66)
         # layout.addLayout(hbox_two)
 
-        self.set_feature_btn = QPushButton('set')
+        self.set_feature_btn = QPushButton("set")
         self.set_feature_btn.clicked.connect(self.compute_signals)
         layout.addWidget(self.set_feature_btn)
         self.feature_choice_widget.show()
@@ -306,32 +341,34 @@ class ConfigMeasurementsPlot(CelldetectiveWidget):
             self.survivalWidget = CelldetectiveWidget()
             self.scroll = QScrollArea()
             self.survivalWidget.setMinimumHeight(int(0.8 * self.screen_height))
-            self.survivalWidget.setWindowTitle('signals')
+            self.survivalWidget.setWindowTitle("signals")
             self.plotvbox = QVBoxLayout(self.survivalWidget)
             self.plotvbox.setContentsMargins(30, 30, 30, 30)
-            self.survival_title = QLabel('Signal function')
-            self.survival_title.setStyleSheet("""
+            self.survival_title = QLabel("Signal function")
+            self.survival_title.setStyleSheet(
+                """
 				font-weight: bold;
 				padding: 0px;
-				""")
+				"""
+            )
             self.plotvbox.addWidget(self.survival_title, alignment=Qt.AlignCenter)
 
             plot_buttons_hbox = QHBoxLayout()
-            plot_buttons_hbox.addWidget(QLabel(''), 80, alignment=Qt.AlignLeft)
+            plot_buttons_hbox.addWidget(QLabel(""), 80, alignment=Qt.AlignLeft)
 
-            self.legend_btn = QPushButton('')
+            self.legend_btn = QPushButton("")
             self.legend_btn.setIcon(icon(MDI6.text_box, color="black"))
             self.legend_btn.setStyleSheet(self.button_select_all)
-            self.legend_btn.setToolTip('Show or hide the legend')
+            self.legend_btn.setToolTip("Show or hide the legend")
             self.legend_visible = True
             self.legend_btn.clicked.connect(self.show_hide_legend)
             plot_buttons_hbox.addWidget(self.legend_btn, 5, alignment=Qt.AlignRight)
 
-            self.log_btn = QPushButton('')
+            self.log_btn = QPushButton("")
             self.log_btn.setIcon(icon(MDI6.math_log, color="black"))
             self.log_btn.setStyleSheet(self.button_select_all)
             self.log_btn.clicked.connect(self.switch_to_log)
-            self.log_btn.setToolTip('Enable or disable log scale')
+            self.log_btn.setToolTip("Enable or disable log scale")
             plot_buttons_hbox.addWidget(self.log_btn, 5, alignment=Qt.AlignRight)
 
             # self.ci_btn = QPushButton('')
@@ -341,11 +378,11 @@ class ConfigMeasurementsPlot(CelldetectiveWidget):
             # self.ci_btn.setToolTip('Show or hide confidence intervals.')
             # plot_buttons_hbox.addWidget(self.ci_btn, 5, alignment=Qt.AlignRight)
 
-            self.cell_lines_btn = QPushButton('')
+            self.cell_lines_btn = QPushButton("")
             self.cell_lines_btn.setIcon(icon(MDI6.view_headline, color="black"))
             self.cell_lines_btn.setStyleSheet(self.button_select_all)
             self.cell_lines_btn.clicked.connect(self.switch_cell_lines)
-            self.cell_lines_btn.setToolTip('Show or hide individual cell signals.')
+            self.cell_lines_btn.setToolTip("Show or hide individual cell signals.")
             plot_buttons_hbox.addWidget(self.cell_lines_btn, 5, alignment=Qt.AlignRight)
 
             self.fig, self.ax = plt.subplots(1, 1, figsize=(10, 10))  # ,figsize=(10,10)
@@ -356,22 +393,22 @@ class ConfigMeasurementsPlot(CelldetectiveWidget):
                 self.initialize_axis()
             plt.tight_layout()
 
-            self.fig.set_facecolor('none')  # or 'None'
+            self.fig.set_facecolor("none")  # or 'None'
             self.fig.canvas.setStyleSheet("background-color: transparent;")
             self.survival_window.canvas.draw()
 
             # self.survival_window.layout.addWidget(QLabel('WHAAAAATTT???'))
 
             self.plot_options = [QRadioButton() for i in range(3)]
-            self.radio_labels = ['well', 'pos', 'both']
+            self.radio_labels = ["well", "pos", "both"]
             radio_hbox = QHBoxLayout()
-            radio_hbox.setContentsMargins(30,30,30,30)
+            radio_hbox.setContentsMargins(30, 30, 30, 30)
             self.plot_btn_group = QButtonGroup()
             for i in range(3):
-            	self.plot_options[i].setText(self.radio_labels[i])
-            	#self.plot_options[i].toggled.connect(self.plot_survivals)
-            	self.plot_btn_group.addButton(self.plot_options[i])
-            	radio_hbox.addWidget(self.plot_options[i], 33, alignment=Qt.AlignCenter)
+                self.plot_options[i].setText(self.radio_labels[i])
+                # self.plot_options[i].toggled.connect(self.plot_survivals)
+                self.plot_btn_group.addButton(self.plot_options[i])
+                radio_hbox.addWidget(self.plot_options[i], 33, alignment=Qt.AlignCenter)
             self.plot_btn_group.buttonClicked[int].connect(self.plot_survivals)
 
             if self.position_indices is not None:
@@ -427,11 +464,13 @@ class ConfigMeasurementsPlot(CelldetectiveWidget):
             # class_selection_hbox.addWidget(self.no_event_btn, 33, alignment=Qt.AlignRight)
             # self.plotvbox.addLayout(class_selection_hbox)
 
-            self.select_pos_label = QLabel('Select positions')
-            self.select_pos_label.setStyleSheet("""
+            self.select_pos_label = QLabel("Select positions")
+            self.select_pos_label.setStyleSheet(
+                """
 				font-weight: bold;
 				padding: 0px;
-				""")
+				"""
+            )
             self.plotvbox.addWidget(self.select_pos_label, alignment=Qt.AlignCenter)
             #
             # self.select_option = [QRadioButton() for i in range(2)]
@@ -454,14 +493,14 @@ class ConfigMeasurementsPlot(CelldetectiveWidget):
                 self.load_coordinates()
                 self.plot_spatial_location()
                 # self.plot_positions()
-                self.ax_scatter.spines['top'].set_visible(False)
-                self.ax_scatter.spines['right'].set_visible(False)
-                self.ax_scatter.set_aspect('equal')
+                self.ax_scatter.spines["top"].set_visible(False)
+                self.ax_scatter.spines["right"].set_visible(False)
+                self.ax_scatter.set_aspect("equal")
                 self.ax_scatter.set_xticks([])
                 self.ax_scatter.set_yticks([])
                 plt.tight_layout()
 
-                self.fig_scatter.set_facecolor('none')  # or 'None'
+                self.fig_scatter.set_facecolor("none")  # or 'None'
                 self.fig_scatter.canvas.setStyleSheet("background-color: transparent;")
                 self.plotvbox.addWidget(self.position_scatter)
 
@@ -476,14 +515,16 @@ class ConfigMeasurementsPlot(CelldetectiveWidget):
             self.scroll.setWidget(self.survivalWidget)
 
             self.scroll.setMinimumHeight(int(0.8 * self.screen_height))
-            self.survivalWidget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
+            self.survivalWidget.setSizePolicy(
+                QSizePolicy.Expanding, QSizePolicy.Expanding
+            )
             self.scroll.show()
 
     def process_signal(self):
 
-        print('you clicked!!')
+        print("you clicked!!")
         # self.FrameToMin = float(self.time_calibration_le.text().replace(',','.'))
-        print(self.FrameToMin, 'set')
+        print(self.FrameToMin, "set")
 
         # read instructions from combobox options
         self.load_available_tables()
@@ -494,51 +535,68 @@ class ConfigMeasurementsPlot(CelldetectiveWidget):
 
     def generate_pos_selection_widget(self):
 
-        self.well_names = self.df['well_name'].unique()
+        self.well_names = self.df["well_name"].unique()
         self.pos_names = self.df_pos_info[
-            'pos_name'].unique()  # pd.DataFrame(self.ks_estimators_per_position)['position_name'].unique()
-        print(f'POSITION NAMES: ', self.pos_names)
+            "pos_name"
+        ].unique()  # pd.DataFrame(self.ks_estimators_per_position)['position_name'].unique()
+        print(f"POSITION NAMES: ", self.pos_names)
         self.usable_well_labels = []
         for name in self.well_names:
             for lbl in self.well_labels:
-                if name + ':' in lbl:
+                if name + ":" in lbl:
                     self.usable_well_labels.append(lbl)
 
         self.line_choice_widget = CelldetectiveWidget()
         self.line_check_vbox = QVBoxLayout()
         self.line_choice_widget.setLayout(self.line_check_vbox)
         if len(self.well_indices) > 1:
-            self.well_display_options = [QCheckBox(self.usable_well_labels[i]) for i in
-                                         range(len(self.usable_well_labels))]
+            self.well_display_options = [
+                QCheckBox(self.usable_well_labels[i])
+                for i in range(len(self.usable_well_labels))
+            ]
             for i in range(len(self.well_names)):
-                self.line_check_vbox.addWidget(self.well_display_options[i], alignment=Qt.AlignLeft)
+                self.line_check_vbox.addWidget(
+                    self.well_display_options[i], alignment=Qt.AlignLeft
+                )
                 self.well_display_options[i].setChecked(True)
                 self.well_display_options[i].toggled.connect(self.select_survival_lines)
         else:
-            self.pos_display_options = [QCheckBox(self.pos_names[i]) for i in range(len(self.pos_names))]
+            self.pos_display_options = [
+                QCheckBox(self.pos_names[i]) for i in range(len(self.pos_names))
+            ]
             for i in range(len(self.pos_names)):
-                self.line_check_vbox.addWidget(self.pos_display_options[i], alignment=Qt.AlignLeft)
+                self.line_check_vbox.addWidget(
+                    self.pos_display_options[i], alignment=Qt.AlignLeft
+                )
                 self.pos_display_options[i].setChecked(True)
                 self.pos_display_options[i].toggled.connect(self.select_survival_lines)
 
         self.plotvbox.addWidget(self.line_choice_widget, alignment=Qt.AlignCenter)
 
     def load_available_tables(self):
-
         """
         Load the tables of the selected wells/positions from the control Panel for the population of interest
 
         """
 
-        self.well_option = self.parent_window.parent_window.well_list.getSelectedIndices()
-        self.position_option = self.parent_window.parent_window.position_list.getSelectedIndices()
-
-        self.df, self.df_pos_info = load_experiment_tables(self.exp_dir, well_option=self.well_option, position_option=self.position_option,
-                                                           population=self.cbs[0].currentText(), return_pos_info=True)
+        self.well_option = (
+            self.parent_window.parent_window.well_list.getSelectedIndices()
+        )
+        self.position_option = (
+            self.parent_window.parent_window.position_list.getSelectedIndices()
+        )
+
+        self.df, self.df_pos_info = load_experiment_tables(
+            self.exp_dir,
+            well_option=self.well_option,
+            position_option=self.position_option,
+            population=self.cbs[0].currentText(),
+            return_pos_info=True,
+        )
 
         if self.df is None:
 
-            print('No table could be found...')
+            print("No table could be found...")
             msgBox = QMessageBox()
             msgBox.setIcon(QMessageBox.Warning)
             msgBox.setText("No table could be found to compute survival...")
@@ -552,21 +610,25 @@ class ConfigMeasurementsPlot(CelldetectiveWidget):
                 self.close()
                 return None
         else:
-            self.df_well_info = self.df_pos_info.loc[:,
-                                ['well_path', 'well_index', 'well_name', 'well_number', 'well_alias']].drop_duplicates()
+            self.df_well_info = self.df_pos_info.loc[
+                :, ["well_path", "well_index", "well_name", "well_number", "well_alias"]
+            ].drop_duplicates()
 
     def compute_signal_functions(self):
         wells = get_experiment_wells(self.exp_dir)
         antibodies = get_experiment_antibodies(self.exp_dir)
         cell_types = get_experiment_cell_types(self.exp_dir)
         concentrations = get_experiment_concentrations(self.exp_dir)
-        well_name = [' '.join([s1, '+', s2, s3, 'pM']) for s1, s2, s3 in zip(cell_types, antibodies, concentrations)]
+        well_name = [
+            " ".join([s1, "+", s2, s3, "pM"])
+            for s1, s2, s3 in zip(cell_types, antibodies, concentrations)
+        ]
 
         data = []
         full_data = []
         print(self.well_option)
         if self.well_option > 1:
-            self.plot_mode = 'wells'
+            self.plot_mode = "wells"
             for z, well in enumerate(wells):  # loop over wells
                 # print(well)
                 if z not in self.well_indices:
@@ -576,80 +638,114 @@ class ConfigMeasurementsPlot(CelldetectiveWidget):
                     for ind, pos in enumerate(positions):  # loop over positions
                         if self.position_indices is not None:
                             if ind + 1 in self.position_indices:
-                                print(f'Processing position {pos}...')
+                                print(f"Processing position {pos}...")
                                 tab_tc = pos + os.sep.join(
-                                    ['output', 'tables', f'trajectories_{self.cbs[0].currentText()}.csv'])
+                                    [
+                                        "output",
+                                        "tables",
+                                        f"trajectories_{self.cbs[0].currentText()}.csv",
+                                    ]
+                                )
                                 if not os.path.exists(tab_tc):
                                     return None
                                 else:
                                     data = pd.read_csv(tab_tc)
-                                    data['well_name'] = well_name[z]
+                                    data["well_name"] = well_name[z]
                                 full_data.append(data)
 
                         else:
-                            print(f'Processing position {pos}...')
+                            print(f"Processing position {pos}...")
                             tab_tc = pos + os.sep.join(
-                                ['output', 'tables', f'trajectories_{self.cbs[0].currentText()}.csv'])
+                                [
+                                    "output",
+                                    "tables",
+                                    f"trajectories_{self.cbs[0].currentText()}.csv",
+                                ]
+                            )
                             if not os.path.exists(tab_tc):
                                 return None
                             else:
                                 data = pd.read_csv(tab_tc)
-                                data['well_name'] = well_name[z]
+                                data["well_name"] = well_name[z]
                             full_data.append(data)
         else:
-            self.plot_mode = 'positions'
+            self.plot_mode = "positions"
             positions = get_positions_in_well(wells[self.well_indices[0]])
             for ind, pos in enumerate(positions):  # loop over positions
                 pos_name = pos.split(os.sep)[-2]
                 if self.position_indices is not None:
                     if ind + 1 in self.position_indices:
-                        print(f'Processing position {pos}...')
+                        print(f"Processing position {pos}...")
                         tab_tc = pos + os.sep.join(
-                            ['output', 'tables', f'trajectories_{self.cbs[0].currentText()}.csv'])
+                            [
+                                "output",
+                                "tables",
+                                f"trajectories_{self.cbs[0].currentText()}.csv",
+                            ]
+                        )
                         if not os.path.exists(tab_tc):
                             return None
                         else:
                             data = pd.read_csv(tab_tc)
-                            data['position'] = pos_name
+                            data["position"] = pos_name
                         full_data.append(data)
                 else:
-                    print(f'Processing position {pos}...')
-                    tab_tc = pos + os.sep.join(['output', 'tables', f'trajectories_{self.cbs[0].currentText()}.csv'])
+                    print(f"Processing position {pos}...")
+                    tab_tc = pos + os.sep.join(
+                        [
+                            "output",
+                            "tables",
+                            f"trajectories_{self.cbs[0].currentText()}.csv",
+                        ]
+                    )
                     if not os.path.exists(tab_tc):
                         return None
                     else:
                         data = pd.read_csv(tab_tc)
-                        data['position'] = pos_name
+                        data["position"] = pos_name
                     full_data.append(data)
         self.plot_data = pd.concat(full_data, ignore_index=True)
 
-    def generate_synchronized_matrix(self, well_group, feature_selected, cclass, max_time):
+    def generate_synchronized_matrix(
+        self, well_group, feature_selected, cclass, max_time
+    ):
 
         if isinstance(cclass, int):
             cclass = [cclass]
 
-        n_cells = len(well_group.groupby(['position', 'TRACK_ID']))
+        n_cells = len(well_group.groupby(["position", "TRACK_ID"]))
         depth = int(2 * max_time + 3)
         matrix = np.zeros((n_cells, depth))
         matrix[:, :] = np.nan
         mapping = np.arange(-max_time - 1, max_time + 2)
         cid = 0
-        for block, movie_group in well_group.groupby('position'):
-            for tid, track_group in movie_group.loc[movie_group[self.cbs[1].currentText()].isin(cclass)].groupby(
-                    'TRACK_ID'):
+        for block, movie_group in well_group.groupby("position"):
+            for tid, track_group in movie_group.loc[
+                movie_group[self.cbs[1].currentText()].isin(cclass)
+            ].groupby("TRACK_ID"):
                 try:
-                    timeline = track_group['FRAME'].to_numpy().astype(int)
+                    timeline = track_group["FRAME"].to_numpy().astype(int)
                     feature = track_group[feature_selected].to_numpy()
                     if self.checkBox_feature.isChecked():
-                        second_feature = track_group[self.second_feature_selected].to_numpy()
-                    if self.cbs[2].currentText().startswith('t') and not self.abs_time_checkbox.isChecked():
-                        t0 = math.floor(track_group[self.cbs[2].currentText()].to_numpy()[0])
+                        second_feature = track_group[
+                            self.second_feature_selected
+                        ].to_numpy()
+                    if (
+                        self.cbs[2].currentText().startswith("t")
+                        and not self.abs_time_checkbox.isChecked()
+                    ):
+                        t0 = math.floor(
+                            track_group[self.cbs[2].currentText()].to_numpy()[0]
+                        )
                         timeline -= t0
-                    elif self.cbs[2].currentText() == 'first detection' and not self.abs_time_checkbox.isChecked():
-
-                        if 'area' in list(track_group.columns):
-                            print('area in list')
-                            feat = track_group['area'].values
+                    elif (
+                        self.cbs[2].currentText() == "first detection"
+                        and not self.abs_time_checkbox.isChecked()
+                    ):
+
+                        if "area" in list(track_group.columns):
+                            print("area in list")
+                            feat = track_group["area"].values
                         else:
                             feat = feature
 
@@ -687,146 +783,318 @@ class ConfigMeasurementsPlot(CelldetectiveWidget):
         return mean_line, std_line
 
     def initialize_axis(self):
-        plt.rcParams['svg.fonttype'] = 'none'
+        plt.rcParams["svg.fonttype"] = "none"
         plt.rcParams["font.family"] = "sans-serif"
         SMALL_SIZE = 5
         MEDIUM_SIZE = 6
         BIGGER_SIZE = 7
 
-        plt.rc('font', size=SMALL_SIZE)  # controls default text sizes
-        plt.rc('axes', titlesize=SMALL_SIZE)  # fontsize of the axes title
-        plt.rc('axes', labelsize=MEDIUM_SIZE)  # fontsize of the x and y labels
-        plt.rc('xtick', labelsize=SMALL_SIZE)  # fontsize of the tick labels
-        plt.rc('ytick', labelsize=SMALL_SIZE)  # fontsize of the tick labels
-        plt.rc('legend', fontsize=SMALL_SIZE)  # legend fontsize
-        plt.rc('figure', titlesize=BIGGER_SIZE)  # fontsize of the figure title
+        plt.rc("font", size=SMALL_SIZE)  # controls default text sizes
+        plt.rc("axes", titlesize=SMALL_SIZE)  # fontsize of the axes title
+        plt.rc("axes", labelsize=MEDIUM_SIZE)  # fontsize of the x and y labels
+        plt.rc("xtick", labelsize=SMALL_SIZE)  # fontsize of the tick labels
+        plt.rc("ytick", labelsize=SMALL_SIZE)  # fontsize of the tick labels
+        plt.rc("legend", fontsize=SMALL_SIZE)  # legend fontsize
+        plt.rc("figure", titlesize=BIGGER_SIZE)  # fontsize of the figure title
 
         fig, ax = plt.subplots(1, 1, figsize=(10, 5))
         if self.well_option > 1:
             if self.check_class.isChecked():
-                sns.boxenplot(ax=self.ax, data=self.plot_data, y=self.feature_selected, x='well_name',
-                              hue=self.cbs[1].currentText(),
-                              dodge=True, palette=self.palette)
+                sns.boxenplot(
+                    ax=self.ax,
+                    data=self.plot_data,
+                    y=self.feature_selected,
+                    x="well_name",
+                    hue=self.cbs[1].currentText(),
+                    dodge=True,
+                    palette=self.palette,
+                )
                 if self.show_cell_lines:
-                    sns.stripplot(ax=self.ax, data=self.plot_data, y=self.feature_selected, x='well_name',
-                                  hue=self.cbs[1].currentText(),
-                                  dodge=True, alpha=0.3, linewidth=0.5, size=3, palette=self.palette)
+                    sns.stripplot(
+                        ax=self.ax,
+                        data=self.plot_data,
+                        y=self.feature_selected,
+                        x="well_name",
+                        hue=self.cbs[1].currentText(),
+                        dodge=True,
+                        alpha=0.3,
+                        linewidth=0.5,
+                        size=3,
+                        palette=self.palette,
+                    )
             elif self.check_group.isChecked():
-                sns.boxenplot(ax=self.ax, data=self.plot_data, y=self.feature_selected, x='well_name',
-                              hue=self.cbs[2].currentText(),
-                              dodge=True, palette=self.hue_colors)
+                sns.boxenplot(
+                    ax=self.ax,
+                    data=self.plot_data,
+                    y=self.feature_selected,
+                    x="well_name",
+                    hue=self.cbs[2].currentText(),
+                    dodge=True,
+                    palette=self.hue_colors,
+                )
                 if self.show_cell_lines:
-                    sns.stripplot(ax=self.ax, data=self.plot_data, y=self.feature_selected, x='well_name',
-                                  hue=self.cbs[2].currentText(),
-                                  dodge=True, alpha=0.3, linewidth=0.5, size=3, palette=self.hue_colors)
+                    sns.stripplot(
+                        ax=self.ax,
+                        data=self.plot_data,
+                        y=self.feature_selected,
+                        x="well_name",
+                        hue=self.cbs[2].currentText(),
+                        dodge=True,
+                        alpha=0.3,
+                        linewidth=0.5,
+                        size=3,
+                        palette=self.hue_colors,
+                    )
             else:
-                sns.boxenplot(ax=self.ax, data=self.plot_data, y=self.feature_selected, x='well_name',
-                              color=self.palette[0],
-                              dodge=True)
+                sns.boxenplot(
+                    ax=self.ax,
+                    data=self.plot_data,
+                    y=self.feature_selected,
+                    x="well_name",
+                    color=self.palette[0],
+                    dodge=True,
+                )
                 if self.show_cell_lines:
-                    sns.stripplot(ax=self.ax, data=self.plot_data, y=self.feature_selected, x='well_name',
-                                  color=self.palette[0],
-                                  dodge=True, alpha=0.3, linewidth=0.5, size=3)
+                    sns.stripplot(
+                        ax=self.ax,
+                        data=self.plot_data,
+                        y=self.feature_selected,
+                        x="well_name",
+                        color=self.palette[0],
+                        dodge=True,
+                        alpha=0.3,
+                        linewidth=0.5,
+                        size=3,
+                    )
         else:
             if self.check_class.isChecked():
-                sns.boxenplot(ax=self.ax, data=self.plot_data, y=self.feature_selected, x='position',
-                              hue=self.cbs[1].currentText(),
-                              dodge=True, palette=self.palette)
+                sns.boxenplot(
+                    ax=self.ax,
+                    data=self.plot_data,
+                    y=self.feature_selected,
+                    x="position",
+                    hue=self.cbs[1].currentText(),
+                    dodge=True,
+                    palette=self.palette,
+                )
                 if self.show_cell_lines:
-                    sns.stripplot(ax=self.ax, data=self.plot_data, y=self.feature_selected, x='position',
-                                  hue=self.cbs[1].currentText(),
-                                  dodge=True, alpha=0.3, linewidth=0.5, size=3, palette=self.palette)
+                    sns.stripplot(
+                        ax=self.ax,
+                        data=self.plot_data,
+                        y=self.feature_selected,
+                        x="position",
+                        hue=self.cbs[1].currentText(),
+                        dodge=True,
+                        alpha=0.3,
+                        linewidth=0.5,
+                        size=3,
+                        palette=self.palette,
+                    )
             elif self.check_group.isChecked():
-                sns.boxenplot(ax=self.ax, data=self.plot_data, y=self.feature_selected, x='position',
-                              hue=self.cbs[2].currentText(),
-                              dodge=True, palette=self.hue_colors)
+                sns.boxenplot(
+                    ax=self.ax,
+                    data=self.plot_data,
+                    y=self.feature_selected,
+                    x="position",
+                    hue=self.cbs[2].currentText(),
+                    dodge=True,
+                    palette=self.hue_colors,
+                )
                 if self.show_cell_lines:
-                    sns.stripplot(ax=self.ax, data=self.plot_data, y=self.feature_selected, x='position',
-                                  hue=self.cbs[2].currentText(),
-                                  dodge=True, alpha=0.3, linewidth=0.5, size=3, palette=self.hue_colors)
+                    sns.stripplot(
+                        ax=self.ax,
+                        data=self.plot_data,
+                        y=self.feature_selected,
+                        x="position",
+                        hue=self.cbs[2].currentText(),
+                        dodge=True,
+                        alpha=0.3,
+                        linewidth=0.5,
+                        size=3,
+                        palette=self.hue_colors,
+                    )
             else:
-                sns.boxenplot(ax=self.ax, data=self.plot_data, y=self.feature_selected, x='position',
-                              color=self.palette[0],
-                              dodge=True)
+                sns.boxenplot(
+                    ax=self.ax,
+                    data=self.plot_data,
+                    y=self.feature_selected,
+                    x="position",
+                    color=self.palette[0],
+                    dodge=True,
+                )
                 if self.show_cell_lines:
-                    sns.stripplot(ax=self.ax, data=self.plot_data, y=self.feature_selected, x='position',
-                                  color=self.palette[0],
-                                  dodge=True, alpha=0.3, linewidth=0.5, size=3)
-        self.ax.spines['top'].set_visible(False)
-        self.ax.spines['right'].set_visible(False)
+                    sns.stripplot(
+                        ax=self.ax,
+                        data=self.plot_data,
+                        y=self.feature_selected,
+                        x="position",
+                        color=self.palette[0],
+                        dodge=True,
+                        alpha=0.3,
+                        linewidth=0.5,
+                        size=3,
+                    )
+        self.ax.spines["top"].set_visible(False)
+        self.ax.spines["right"].set_visible(False)
         self.ax.set_ylabel(self.feature_selected)
         # ax.set_ylim(0.95,1.3)
         plt.tight_layout()
 
     def plot_survivals(self, id):
         self.ax.clear()
-        plt.rcParams['svg.fonttype'] = 'none'
+        plt.rcParams["svg.fonttype"] = "none"
         plt.rcParams["font.family"] = "sans-serif"
         SMALL_SIZE = 5
         MEDIUM_SIZE = 6
         BIGGER_SIZE = 7
 
-        plt.rc('font', size=SMALL_SIZE)  # controls default text sizes
-        plt.rc('axes', titlesize=SMALL_SIZE)  # fontsize of the axes title
-        plt.rc('axes', labelsize=MEDIUM_SIZE)  # fontsize of the x and y labels
-        plt.rc('xtick', labelsize=SMALL_SIZE)  # fontsize of the tick labels
-        plt.rc('ytick', labelsize=SMALL_SIZE)  # fontsize of the tick labels
-        plt.rc('legend', fontsize=SMALL_SIZE)  # legend fontsize
-        plt.rc('figure', titlesize=BIGGER_SIZE)  # fontsize of the figure title
+        plt.rc("font", size=SMALL_SIZE)  # controls default text sizes
+        plt.rc("axes", titlesize=SMALL_SIZE)  # fontsize of the axes title
+        plt.rc("axes", labelsize=MEDIUM_SIZE)  # fontsize of the x and y labels
+        plt.rc("xtick", labelsize=SMALL_SIZE)  # fontsize of the tick labels
+        plt.rc("ytick", labelsize=SMALL_SIZE)  # fontsize of the tick labels
+        plt.rc("legend", fontsize=SMALL_SIZE)  # legend fontsize
+        plt.rc("figure", titlesize=BIGGER_SIZE)  # fontsize of the figure title
 
         fig, ax = plt.subplots(1, 1, figsize=(10, 5))
         if self.well_option > 1:
             if self.check_class.isChecked():
-                sns.boxenplot(ax=self.ax, data=self.plot_data, y=self.feature_selected, x='well_name',
-                              hue=self.cbs[1].currentText(),
-                              dodge=True, palette=self.palette)
+                sns.boxenplot(
+                    ax=self.ax,
+                    data=self.plot_data,
+                    y=self.feature_selected,
+                    x="well_name",
+                    hue=self.cbs[1].currentText(),
+                    dodge=True,
+                    palette=self.palette,
+                )
                 if self.show_cell_lines:
-                    sns.stripplot(ax=self.ax, data=self.plot_data, y=self.feature_selected, x='well_name',
-                                  hue=self.cbs[1].currentText(),
-                                  dodge=True, alpha=0.3, linewidth=0.5, size=3, palette=self.palette)
+                    sns.stripplot(
+                        ax=self.ax,
+                        data=self.plot_data,
+                        y=self.feature_selected,
+                        x="well_name",
+                        hue=self.cbs[1].currentText(),
+                        dodge=True,
+                        alpha=0.3,
+                        linewidth=0.5,
+                        size=3,
+                        palette=self.palette,
+                    )
             elif self.check_group.isChecked():
-                sns.boxenplot(ax=self.ax, data=self.plot_data, y=self.feature_selected, x='well_name',
-                              hue=self.cbs[2].currentText(),
-                              dodge=True, palette=self.hue_colors)
+                sns.boxenplot(
+                    ax=self.ax,
+                    data=self.plot_data,
+                    y=self.feature_selected,
+                    x="well_name",
+                    hue=self.cbs[2].currentText(),
+                    dodge=True,
+                    palette=self.hue_colors,
+                )
                 if self.show_cell_lines:
-                    sns.stripplot(ax=self.ax, data=self.plot_data, y=self.feature_selected, x='well_name',
-                                  hue=self.cbs[2].currentText(),
-                                  dodge=True, alpha=0.3, linewidth=0.5, size=3, palette=self.hue_colors)
+                    sns.stripplot(
+                        ax=self.ax,
+                        data=self.plot_data,
+                        y=self.feature_selected,
+                        x="well_name",
+                        hue=self.cbs[2].currentText(),
+                        dodge=True,
+                        alpha=0.3,
+                        linewidth=0.5,
+                        size=3,
+                        palette=self.hue_colors,
+                    )
             else:
-                sns.boxenplot(ax=self.ax, data=self.plot_data, y=self.feature_selected, x='well_name',
-                              color=self.palette[0],
-                              dodge=True)
+                sns.boxenplot(
+                    ax=self.ax,
+                    data=self.plot_data,
+                    y=self.feature_selected,
+                    x="well_name",
+                    color=self.palette[0],
+                    dodge=True,
+                )
                 if self.show_cell_lines:
-                    sns.stripplot(ax=self.ax, data=self.plot_data, y=self.feature_selected, x='well_name',
-                                  color=self.palette[0],
-                                  dodge=True, alpha=0.3, linewidth=0.5, size=3)
+                    sns.stripplot(
+                        ax=self.ax,
+                        data=self.plot_data,
+                        y=self.feature_selected,
+                        x="well_name",
+                        color=self.palette[0],
+                        dodge=True,
+                        alpha=0.3,
+                        linewidth=0.5,
+                        size=3,
+                    )
         else:
             if self.check_class.isChecked():
-                sns.boxenplot(ax=self.ax, data=self.plot_data, y=self.feature_selected, x='position',
-                              hue=self.cbs[1].currentText(),
-                              dodge=True, palette=self.palette)
+                sns.boxenplot(
+                    ax=self.ax,
+                    data=self.plot_data,
+                    y=self.feature_selected,
+                    x="position",
+                    hue=self.cbs[1].currentText(),
+                    dodge=True,
+                    palette=self.palette,
+                )
                 if self.show_cell_lines:
-                    sns.stripplot(ax=self.ax, data=self.plot_data, y=self.feature_selected, x='position',
-                                  hue=self.cbs[1].currentText(),
-                                  dodge=True, alpha=0.3, linewidth=0.5, size=3, palette=self.palette)
+                    sns.stripplot(
+                        ax=self.ax,
+                        data=self.plot_data,
+                        y=self.feature_selected,
+                        x="position",
+                        hue=self.cbs[1].currentText(),
+                        dodge=True,
+                        alpha=0.3,
+                        linewidth=0.5,
+                        size=3,
+                        palette=self.palette,
+                    )
             elif self.check_group.isChecked():
-                sns.boxenplot(ax=self.ax, data=self.plot_data, y=self.feature_selected, x='position',
-                              hue=self.cbs[2].currentText(),
-                              dodge=True, palette=self.hue_colors)
+                sns.boxenplot(
+                    ax=self.ax,
+                    data=self.plot_data,
+                    y=self.feature_selected,
+                    x="position",
+                    hue=self.cbs[2].currentText(),
+                    dodge=True,
+                    palette=self.hue_colors,
+                )
                 if self.show_cell_lines:
-                    sns.stripplot(ax=self.ax, data=self.plot_data, y=self.feature_selected, x='position',
-                                  hue=self.cbs[2].currentText(),
-                                  dodge=True, alpha=0.3, linewidth=0.5, size=3, palette=self.hue_colors)
+                    sns.stripplot(
+                        ax=self.ax,
+                        data=self.plot_data,
+                        y=self.feature_selected,
+                        x="position",
+                        hue=self.cbs[2].currentText(),
+                        dodge=True,
+                        alpha=0.3,
+                        linewidth=0.5,
+                        size=3,
+                        palette=self.hue_colors,
+                    )
             else:
-                sns.boxenplot(ax=self.ax, data=self.plot_data, y=self.feature_selected, x='position',
-                              color=self.palette[0],
-                              dodge=True)
+                sns.boxenplot(
+                    ax=self.ax,
+                    data=self.plot_data,
+                    y=self.feature_selected,
+                    x="position",
+                    color=self.palette[0],
+                    dodge=True,
+                )
                 if self.show_cell_lines:
-                    sns.stripplot(ax=self.ax, data=self.plot_data, y=self.feature_selected, x='position',
-                                  color=self.palette[0],
-                                  dodge=True, alpha=0.3, linewidth=0.5, size=3)
-        ax.spines['top'].set_visible(False)
-        ax.spines['right'].set_visible(False)
+                    sns.stripplot(
+                        ax=self.ax,
+                        data=self.plot_data,
+                        y=self.feature_selected,
+                        x="position",
+                        color=self.palette[0],
+                        dodge=True,
+                        alpha=0.3,
+                        linewidth=0.5,
+                        size=3,
+                    )
+        ax.spines["top"].set_visible(False)
+        ax.spines["right"].set_visible(False)
         ax.set_ylabel(self.feature_selected)
         plt.tight_layout()
         self.survival_window.setMinimumHeight(int(0.5 * self.screen_height))
@@ -835,53 +1103,84 @@ class ConfigMeasurementsPlot(CelldetectiveWidget):
 
         self.survival_window.canvas.draw()
 
-    def plot_line(self, line, color, label, mean_signal, ci_option=True, cell_lines_option=False, alpha_ci=0.5,
-                  alpha_cell_lines=0.5, std_signal=None, matrix=None):
+    def plot_line(
+        self,
+        line,
+        color,
+        label,
+        mean_signal,
+        ci_option=True,
+        cell_lines_option=False,
+        alpha_ci=0.5,
+        alpha_cell_lines=0.5,
+        std_signal=None,
+        matrix=None,
+    ):
         try:
-            if 'second' in str(mean_signal):
-                self.ax2.plot(line['timeline'] * self.FrameToMin, line[mean_signal], color=color, label=label)
+            if "second" in str(mean_signal):
+                self.ax2.plot(
+                    line["timeline"] * self.FrameToMin,
+                    line[mean_signal],
+                    color=color,
+                    label=label,
+                )
             else:
-                self.ax.plot(line['timeline'] * self.FrameToMin, line[mean_signal], color=color, label=label)
+                self.ax.plot(
+                    line["timeline"] * self.FrameToMin,
+                    line[mean_signal],
+                    color=color,
+                    label=label,
+                )
             if ci_option and std_signal is not None:
-                if 'second' in str(mean_signal):
-                    self.ax2.fill_between(line['timeline'] * self.FrameToMin,
-                                          [a - b for a, b in zip(line[mean_signal], line[std_signal])],
-                                          [a + b for a, b in zip(line[mean_signal], line[std_signal])],
-                                          color=color,
-                                          alpha=alpha_ci,
-                                          )
+                if "second" in str(mean_signal):
+                    self.ax2.fill_between(
+                        line["timeline"] * self.FrameToMin,
+                        [a - b for a, b in zip(line[mean_signal], line[std_signal])],
+                        [a + b for a, b in zip(line[mean_signal], line[std_signal])],
+                        color=color,
+                        alpha=alpha_ci,
+                    )
                 else:
-                    self.ax.fill_between(line['timeline'] * self.FrameToMin,
-                                         [a - b for a, b in zip(line[mean_signal], line[std_signal])],
-                                         [a + b for a, b in zip(line[mean_signal], line[std_signal])],
-                                         color=color,
-                                         alpha=alpha_ci,
-                                         )
+                    self.ax.fill_between(
+                        line["timeline"] * self.FrameToMin,
+                        [a - b for a, b in zip(line[mean_signal], line[std_signal])],
+                        [a + b for a, b in zip(line[mean_signal], line[std_signal])],
+                        color=color,
+                        alpha=alpha_ci,
+                    )
             if cell_lines_option and matrix is not None:
                 print(mean_signal)
                 mat = line[matrix]
-                if 'second' in str(mean_signal):
+                if "second" in str(mean_signal):
                     for i in range(mat.shape[0]):
-                        self.ax2.plot(line['timeline'] * self.FrameToMin, mat[i, :], color=color,
-                                      alpha=alpha_cell_lines)
+                        self.ax2.plot(
+                            line["timeline"] * self.FrameToMin,
+                            mat[i, :],
+                            color=color,
+                            alpha=alpha_cell_lines,
+                        )
                 else:
                     for i in range(mat.shape[0]):
-                        self.ax.plot(line['timeline'] * self.FrameToMin, mat[i, :], color=color, alpha=alpha_cell_lines)
+                        self.ax.plot(
+                            line["timeline"] * self.FrameToMin,
+                            mat[i, :],
+                            color=color,
+                            alpha=alpha_cell_lines,
+                        )
 
         except Exception as e:
-            print(f'Exception {e}')
+            print(f"Exception {e}")
 
     def switch_to_log(self):
-
         """
         Switch threshold histogram to log scale. Auto adjust.
         """
 
-        if self.ax.get_yscale() == 'linear':
-            self.ax.set_yscale('log')
+        if self.ax.get_yscale() == "linear":
+            self.ax.set_yscale("log")
         # self.ax.set_ylim(0.01,1.05)
         else:
-            self.ax.set_yscale('linear')
+            self.ax.set_yscale("linear")
         # self.ax.set_ylim(0.01,1.05)
 
         # self.ax.autoscale()
@@ -902,20 +1201,22 @@ class ConfigMeasurementsPlot(CelldetectiveWidget):
     def look_for_metadata(self):
 
         self.metadata_found = False
-        self.metafiles = glob(self.exp_dir + os.sep.join([f'W*', '*', 'movie', '*metadata.txt'])) \
-                         + glob(self.exp_dir + os.sep.join([f'W*', '*', '*metadata.txt'])) \
-                         + glob(self.exp_dir + os.sep.join([f'W*', '*metadata.txt'])) \
-                         + glob(self.exp_dir + '*metadata.txt')
-        print(f'Found {len(self.metafiles)} metadata files...')
+        self.metafiles = (
+            glob(self.exp_dir + os.sep.join([f"W*", "*", "movie", "*metadata.txt"]))
+            + glob(self.exp_dir + os.sep.join([f"W*", "*", "*metadata.txt"]))
+            + glob(self.exp_dir + os.sep.join([f"W*", "*metadata.txt"]))
+            + glob(self.exp_dir + "*metadata.txt")
+        )
+        print(f"Found {len(self.metafiles)} metadata files...")
         if len(self.metafiles) > 0:
             self.metadata_found = True
 
     def switch_selection_mode(self, id):
-        print(f'button {id} was clicked')
+        print(f"button {id} was clicked")
         for i in range(2):
             if self.select_option[i].isChecked():
                 self.selection_mode = self.select_label[i]
-        if self.selection_mode == 'name':
+        if self.selection_mode == "name":
             if len(self.metafiles) > 0:
                 self.position_scatter.hide()
             self.line_choice_widget.show()
@@ -925,36 +1226,35 @@ class ConfigMeasurementsPlot(CelldetectiveWidget):
             self.line_choice_widget.hide()
 
     def load_coordinates(self):
-
         """
         Read metadata and try to extract position coordinates
         """
 
         self.no_meta = False
         try:
-            with open(self.metafiles[0], 'r') as f:
+            with open(self.metafiles[0], "r") as f:
                 data = json.load(f)
-                positions = data['Summary']['InitialPositionList']
+                positions = data["Summary"]["InitialPositionList"]
         except Exception as e:
-            print(f'Trouble loading metadata: error {e}...')
+            print(f"Trouble loading metadata: error {e}...")
             return None
 
         for k in range(len(positions)):
-            pos_label = positions[k]['Label']
+            pos_label = positions[k]["Label"]
             try:
-                coords = positions[k]['DeviceCoordinatesUm']['XYStage']
+                coords = positions[k]["DeviceCoordinatesUm"]["XYStage"]
             except:
                 try:
-                    coords = positions[k]['DeviceCoordinatesUm']['PIXYStage']
+                    coords = positions[k]["DeviceCoordinatesUm"]["PIXYStage"]
                 except:
                     self.no_meta = True
 
             if not self.no_meta:
-                files = self.df_pos_info['stack_path'].values
+                files = self.df_pos_info["stack_path"].values
                 pos_loc = [pos_label in f for f in files]
-                self.df_pos_info.loc[pos_loc, 'x'] = coords[0]
-                self.df_pos_info.loc[pos_loc, 'y'] = coords[1]
-                self.df_pos_info.loc[pos_loc, 'metadata_tag'] = pos_label
+                self.df_pos_info.loc[pos_loc, "x"] = coords[0]
+                self.df_pos_info.loc[pos_loc, "y"] = coords[1]
+                self.df_pos_info.loc[pos_loc, "metadata_tag"] = pos_label
 
     def update_annot(self, ind):
 
@@ -962,7 +1262,7 @@ class ConfigMeasurementsPlot(CelldetectiveWidget):
         self.annot.xy = pos
         text = self.scat_labels[ind["ind"][0]]
         self.annot.set_text(text)
-        self.annot.get_bbox_patch().set_facecolor('k')
+        self.annot.get_bbox_patch().set_facecolor("k")
         self.annot.get_bbox_patch().set_alpha(0.4)
 
     def hover(self, event):
@@ -979,22 +1279,28 @@ class ConfigMeasurementsPlot(CelldetectiveWidget):
                     self.fig_scatter.canvas.draw_idle()
 
     def unselect_position(self, event):
-        print('unselecting position')
+        print("unselecting position")
         self.survival_window.canvas.clear()
         ind = event.ind  # index of selected position
-        well_idx = self.df_pos_info.iloc[ind]['well_index'].values[0]
-        selectedPos = self.df_pos_info.iloc[ind]['pos_path'].values[0]
-        currentSelState = self.df_pos_info.iloc[ind]['select'].values[0]
+        well_idx = self.df_pos_info.iloc[ind]["well_index"].values[0]
+        selectedPos = self.df_pos_info.iloc[ind]["pos_path"].values[0]
+        currentSelState = self.df_pos_info.iloc[ind]["select"].values[0]
         if self.plot_options[0].isChecked() or self.plot_options[2].isChecked():
-            self.df_pos_info.loc[self.df_pos_info['well_index'] == well_idx, 'select'] = not currentSelState
-            self.df_well_info.loc[self.df_well_info['well_index'] == well_idx, 'select'] = not currentSelState
+            self.df_pos_info.loc[
+                self.df_pos_info["well_index"] == well_idx, "select"
+            ] = not currentSelState
+            self.df_well_info.loc[
+                self.df_well_info["well_index"] == well_idx, "select"
+            ] = not currentSelState
             if len(self.well_indices) > 1:
                 self.well_display_options[well_idx].setChecked(not currentSelState)
             else:
                 for p in self.pos_display_options:
                     p.setChecked(not currentSelState)
         else:
-            self.df_pos_info.loc[self.df_pos_info['pos_path'] == selectedPos, 'select'] = not currentSelState
+            self.df_pos_info.loc[
+                self.df_pos_info["pos_path"] == selectedPos, "select"
+            ] = not currentSelState
             if len(self.well_indices) <= 1:
                 self.pos_display_options[ind[0]].setChecked(not currentSelState)
 
@@ -1003,17 +1309,19 @@ class ConfigMeasurementsPlot(CelldetectiveWidget):
         self.plot_survivals(0)
 
     def select_survival_lines(self):
-        if self.plot_mode == 'wells':
+        if self.plot_mode == "wells":
             selected_wells = []
             for i in range(len(self.well_display_options)):
                 if self.well_display_options[i].isChecked():
                     selected_wells.append(i)
-                self.df_well_info.loc[self.df_well_info['well_index'] == i, 'select'] = self.well_display_options[
-                    i].isChecked()
-                self.df_pos_info.loc[self.df_pos_info['well_index'] == i, 'select'] = self.well_display_options[
-                    i].isChecked()
+                self.df_well_info.loc[
+                    self.df_well_info["well_index"] == i, "select"
+                ] = self.well_display_options[i].isChecked()
+                self.df_pos_info.loc[self.df_pos_info["well_index"] == i, "select"] = (
+                    self.well_display_options[i].isChecked()
+                )
             if len(selected_wells) == 0:
-                print('No wells selected')
+                print("No wells selected")
                 self.ax.clear()
             else:
                 self.ax.clear()
@@ -1025,8 +1333,9 @@ class ConfigMeasurementsPlot(CelldetectiveWidget):
             for i in range(len(self.pos_display_options)):
                 if self.pos_display_options[i].isChecked():
                     selected_pos.append(i + 1)
-                self.df_pos_info.loc[self.df_pos_info['pos_index'] == i, 'select'] = self.pos_display_options[
-                    i].isChecked()
+                self.df_pos_info.loc[self.df_pos_info["pos_index"] == i, "select"] = (
+                    self.pos_display_options[i].isChecked()
+                )
             if len(selected_pos) == 0:
                 self.ax.clear()
             else:
@@ -1046,13 +1355,23 @@ class ConfigMeasurementsPlot(CelldetectiveWidget):
     def plot_spatial_location(self):
 
         try:
-            self.sc = self.ax_scatter.scatter(self.df_pos_info["x"].values, self.df_pos_info["y"].values, picker=True,
-                                              pickradius=1, color=self.select_color(self.df_pos_info["select"].values))
-            self.scat_labels = self.df_pos_info['metadata_tag'].values
+            self.sc = self.ax_scatter.scatter(
+                self.df_pos_info["x"].values,
+                self.df_pos_info["y"].values,
+                picker=True,
+                pickradius=1,
+                color=self.select_color(self.df_pos_info["select"].values),
+            )
+            self.scat_labels = self.df_pos_info["metadata_tag"].values
             self.ax_scatter.invert_xaxis()
-            self.annot = self.ax_scatter.annotate("", xy=(0, 0), xytext=(10, 10), textcoords="offset points",
-                                                  bbox=dict(boxstyle="round", fc="w"),
-                                                  arrowprops=dict(arrowstyle="->"))
+            self.annot = self.ax_scatter.annotate(
+                "",
+                xy=(0, 0),
+                xytext=(10, 10),
+                textcoords="offset points",
+                bbox=dict(boxstyle="round", fc="w"),
+                arrowprops=dict(arrowstyle="->"),
+            )
             self.annot.set_visible(False)
             self.fig_scatter.canvas.mpl_connect("motion_notify_event", self.hover)
             self.fig_scatter.canvas.mpl_connect("pick_event", self.unselect_position)