celldetective 1.0.2__py3-none-any.whl

celldetective/gui/gui_utils.py

@@ -0,0 +1,495 @@
+import numpy as np
+from PyQt5.QtWidgets import QApplication, QFrame, QSizePolicy, QWidget, QLineEdit, QListWidget, QVBoxLayout, QComboBox, \
+    QPushButton, QLabel, QHBoxLayout, QCheckBox
+from PyQt5.QtCore import QEvent
+from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg
+from matplotlib.backends.backend_qt5agg import NavigationToolbar2QT
+import matplotlib.pyplot as plt
+import celldetective.extra_properties as extra_properties
+from inspect import getmembers, isfunction
+
+
+def center_window(window):
+    """
+    Center window in the middle of the screen.
+    """
+
+    frameGm = window.frameGeometry()
+    screen = QApplication.desktop().screenNumber(QApplication.desktop().cursor().pos())
+    centerPoint = QApplication.desktop().screenGeometry(screen).center()
+    frameGm.moveCenter(centerPoint)
+    window.move(frameGm.topLeft())
+
+
+class QHSeperationLine(QFrame):
+    '''
+    a horizontal seperation line\n
+    '''
+
+    def __init__(self):
+        super().__init__()
+        self.setMinimumWidth(1)
+        self.setFixedHeight(20)
+        self.setFrameShape(QFrame.HLine)
+        self.setFrameShadow(QFrame.Sunken)
+        self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Minimum)
+
+
+class FeatureChoice(QWidget):
+
+    def __init__(self, parent):
+        super().__init__()
+        self.parent = parent
+        self.setWindowTitle("Add feature")
+        # Create the QComboBox and add some items
+        self.combo_box = QComboBox(self)
+        center_window(self)
+
+        standard_measurements = ["area",
+                                 "area_bbox",
+                                 "area_convex",
+                                 "area_filled",
+                                 "major_axis_length",
+                                 "minor_axis_length",
+                                 "eccentricity",
+                                 "equivalent_diameter_area",
+                                 "euler_number",
+                                 "extent",
+                                 "feret_diameter_max",
+                                 "orientation",
+                                 "perimeter",
+                                 "perimeter_crofton",
+                                 "solidity",
+                                 "intensity_mean",
+                                 "intensity_max",
+                                 "intensity_min",
+                                 ]
+
+        extra_props = getmembers(extra_properties, isfunction)
+        extra_props = [extra_props[i][0] for i in range(len(extra_props))]
+        if len(extra_props) > 0:
+            standard_measurements.extend(extra_props)
+
+        self.combo_box.addItems(standard_measurements)
+
+        self.add_btn = QPushButton("Add")
+        self.add_btn.clicked.connect(self.add_current_feature)
+
+        # Create the layout
+        layout = QVBoxLayout(self)
+        layout.addWidget(self.combo_box)
+        layout.addWidget(self.add_btn)
+
+    def add_current_feature(self):
+        filtername = self.combo_box.currentText()
+        self.parent.list_widget.addItems([filtername])
+        self.close()
+
+
+class FilterChoice(QWidget):
+
+    def __init__(self, parent):
+
+        super().__init__()
+        self.parent = parent
+        self.setWindowTitle("Add filter")
+        # Create the QComboBox and add some items
+        center_window(self)
+
+        self.default_params = {
+            'gauss_filter': {'sigma': 2},
+            'median_filter': {'size': 4},
+            'maximum_filter': {'size': 4},
+            'minimum_filter': {'size': 4},
+            'percentile_filter': {'percentile': 99, 'size': 4},
+            'variance_filter': {'size': 4},
+            'std_filter': {'size': 4},
+            'laplace_filter': None,
+            'abs_filter': None,
+            'ln_filter': None,
+            'subtract_filter': {'value': 1},
+            'dog_filter': {'sigma_low': 0.8, 'sigma_high': 1.6},
+            'log_filter': {'sigma': 2},
+            'tophat_filter': {'size': 4, 'connectivity': 4},
+            'otsu_filter': None,
+            'local_filter': {'block_size': 73, 'method': 'mean', 'offset': 0},
+            'niblack_filter': {'window_size': 15, 'k': 0.2},
+            # 'sauvola_filter': {'window_size': 15, 'k': 0.2}
+        }
+
+        layout = QVBoxLayout(self)
+        self.combo_box = QComboBox(self)
+        self.combo_box.addItems(list(self.default_params.keys()))
+        self.combo_box.currentTextChanged.connect(self.update_arguments)
+        layout.addWidget(self.combo_box)
+
+        self.arguments_le = [QLineEdit() for i in range(3)]
+        self.arguments_labels = [QLabel('') for i in range(3)]
+        for i in range(2):
+            hbox = QHBoxLayout()
+            hbox.addWidget(self.arguments_labels[i], 20)
+            hbox.addWidget(self.arguments_le[i], 80)
+            layout.addLayout(hbox)
+
+        self.add_btn = QPushButton("Add")
+        self.add_btn.clicked.connect(self.add_current_feature)
+        layout.addWidget(self.add_btn)
+
+        self.combo_box.setCurrentIndex(0)
+        self.update_arguments()
+
+    def add_current_feature(self):
+
+        filtername = self.combo_box.currentText()
+        self.parent.list_widget.addItems([filtername])
+
+        filter_instructions = [filtername.split('_')[0]]
+        for a in self.arguments_le:
+            arg = a.text()
+            arg_num = arg
+            if (arg != '') and arg_num.replace('.', '').replace(',', '').isnumeric():
+                num = float(arg)
+                if num.is_integer():
+                    num = int(num)
+                filter_instructions.append(num)
+            elif arg != '':
+                filter_instructions.append(arg)
+
+        print(f'You added filter {filter_instructions}.')
+
+        self.parent.items.append(filter_instructions)
+        self.close()
+
+    def update_arguments(self):
+
+        selected_filter = self.combo_box.currentText()
+        arguments = self.default_params[selected_filter]
+        if arguments is not None:
+            args = list(arguments.keys())
+            for i in range(len(args)):
+                self.arguments_labels[i].setEnabled(True)
+                self.arguments_le[i].setEnabled(True)
+
+                self.arguments_labels[i].setText(args[i])
+                self.arguments_le[i].setText(str(arguments[args[i]]))
+
+            if len(args) < 2:
+                for i in range(len(args), 2):
+                    self.arguments_labels[i].setEnabled(False)
+                    self.arguments_labels[i].setText('')
+                    self.arguments_le[i].setEnabled(False)
+        else:
+            for i in range(2):
+                self.arguments_labels[i].setEnabled(False)
+                self.arguments_le[i].setEnabled(False)
+                self.arguments_labels[i].setText('')
+
+
+class OperationChoice(QWidget):
+    """
+    Mini window to select an operation from numpy to apply on the ROI.
+
+    """
+
+    def __init__(self, parent):
+        super().__init__()
+        self.parent = parent
+        self.setWindowTitle("Add feature")
+        # Create the QComboBox and add some items
+        self.combo_box = QComboBox(self)
+        center_window(self)
+
+        self.combo_box.addItems(["mean", "median", "average", "std", "var",
+                                 "nanmedian", "nanmean", "nanstd", "nanvar"])
+
+        self.add_btn = QPushButton("Add")
+        self.add_btn.clicked.connect(self.add_current_feature)
+
+        # Create the layout
+        layout = QVBoxLayout(self)
+        layout.addWidget(self.combo_box)
+        layout.addWidget(self.add_btn)
+
+    def add_current_feature(self):
+        filtername = self.combo_box.currentText()
+        self.parent.list_widget.addItems([filtername])
+        self.close()
+
+
+class GeometryChoice(QWidget):
+
+    def __init__(self, parent):
+
+        super().__init__()
+        self.parent = parent
+        self.setWindowTitle("Set distances")
+        center_window(self)
+
+        # Create the QComboBox and add some items
+
+        self.dist_label = QLabel('Distance [px]: ')
+        self.dist_le = QLineEdit('10')
+
+        self.dist_outer_label = QLabel('Max distance [px]')
+        self.dist_outer_le = QLineEdit('100')
+        self.outer_to_hide = [self.dist_outer_le, self.dist_outer_label]
+
+        self.outer_btn = QCheckBox('outer distance')
+        self.outer_btn.clicked.connect(self.activate_outer_value)
+
+        self.add_btn = QPushButton("Add")
+        self.add_btn.clicked.connect(self.add_current_feature)
+
+        # Create the layout
+        layout = QVBoxLayout(self)
+        dist_layout = QHBoxLayout()
+        dist_layout.addWidget(self.dist_label, 30)
+        dist_layout.addWidget(self.dist_le, 70)
+
+        self.dist_outer_layout = QHBoxLayout()
+        self.dist_outer_layout.addWidget(self.dist_outer_label, 30)
+        self.dist_outer_layout.addWidget(self.dist_outer_le, 70)
+
+        layout.addLayout(dist_layout)
+        layout.addLayout(self.dist_outer_layout)
+        layout.addWidget(self.outer_btn)
+        layout.addWidget(self.add_btn)
+
+        for el in self.outer_to_hide:
+            el.hide()
+
+    def activate_outer_value(self):
+        if self.outer_btn.isChecked():
+            self.dist_label.setText('Min distance [px]: ')
+            for el in self.outer_to_hide:
+                el.show()
+        else:
+            self.dist_label.setText('Distance [px]: ')
+            for el in self.outer_to_hide:
+                el.hide()
+
+    def add_current_feature(self):
+
+        value = self.dist_le.text()
+        if self.outer_btn.isChecked():
+            value2 = self.dist_outer_le.text()
+            values = [value + '-' + value2]
+        else:
+            values = [value]
+        self.parent.list_widget.addItems(values)
+        self.close()
+
+
+class DistanceChoice(QWidget):
+
+    def __init__(self, parent):
+        super().__init__()
+        self.parent = parent
+        self.setWindowTitle("Set distances")
+        center_window(self)
+
+        # Create the QComboBox and add some items
+
+        self.dist_label = QLabel('Distance [px]: ')
+        self.dist_le = QLineEdit('10')
+
+        self.add_btn = QPushButton("Add")
+        self.add_btn.clicked.connect(self.add_current_feature)
+
+        # Create the layout
+        layout = QVBoxLayout(self)
+        dist_layout = QHBoxLayout()
+        dist_layout.addWidget(self.dist_label, 30)
+        dist_layout.addWidget(self.dist_le, 70)
+
+        layout.addLayout(dist_layout)
+        layout.addWidget(self.add_btn)
+
+    def add_current_feature(self):
+        value = self.dist_le.text()
+        values = [value]
+        self.parent.list_widget.addItems(values)
+        self.close()
+
+
+class ListWidget(QWidget):
+    """
+    Generic list widget.
+    """
+
+    def __init__(self, parent, choiceWidget, initial_features, dtype=str, channel_names=None):
+
+        super().__init__()
+        self.parent = parent
+        self.initial_features = initial_features
+        self.choiceWidget = choiceWidget
+        self.dtype = dtype
+        self.items = []
+        self.channel_names=channel_names
+
+        self.setFixedHeight(80)
+
+        # Initialize list widget
+        self.list_widget = QListWidget()
+        self.list_widget.addItems(initial_features)
+
+        # Set up layout
+        main_layout = QVBoxLayout()
+        main_layout.addWidget(self.list_widget)
+        self.setLayout(main_layout)
+
+    def addItem(self):
+
+        """
+        Add a new item.
+        """
+
+        self.addItemWindow = self.choiceWidget(self)
+        self.addItemWindow.show()
+
+    def getItems(self):
+
+        """
+        Get all the items as a list.
+        """
+
+        items = []
+        for x in range(self.list_widget.count()):
+            if len(self.list_widget.item(x).text().split('-')) == 2:
+                if self.list_widget.item(x).text()[0] == '-':
+                    items.append(self.dtype(self.list_widget.item(x).text()))
+                else:
+                    minn, maxx = self.list_widget.item(x).text().split('-')
+                    to_add = [self.dtype(minn), self.dtype(maxx)]
+                    items.append(to_add)
+            else:
+                items.append(self.dtype(self.list_widget.item(x).text()))
+        return items
+
+
+
+    def removeSel(self):
+
+        """
+        Remove selected items.
+        """
+
+        listItems = self.list_widget.selectedItems()
+        if not listItems: return
+        for item in listItems:
+            idx = self.list_widget.row(item)
+            self.list_widget.takeItem(idx)
+            if self.items:
+                del self.items[idx]
+
+
+class FigureCanvas(QWidget):
+    """
+    Generic figure canvas.
+    """
+
+    def __init__(self, fig, title="", interactive=True):
+        super().__init__()
+        self.fig = fig
+        self.setWindowTitle(title)
+        center_window(self)
+        self.canvas = FigureCanvasQTAgg(self.fig)
+        self.canvas.setStyleSheet("background-color: transparent;")
+        if interactive:
+            self.toolbar = NavigationToolbar2QT(self.canvas)
+        self.layout = QVBoxLayout(self)
+        self.layout.addWidget(self.canvas)
+        if interactive:
+            self.layout.addWidget(self.toolbar)
+
+    def closeEvent(self, event):
+        """ Delete figure on closing window. """
+        # self.canvas.ax.cla() # ****
+        self.fig.clf()  # ****
+        plt.close(self.fig)
+        super(FigureCanvas, self).closeEvent(event)
+
+
+def color_from_status(status, recently_modified=False):
+    if not recently_modified:
+        if status == 0:
+            return 'tab:blue'
+        elif status == 1:
+            return 'tab:red'
+        elif status == 2:
+            return 'yellow'
+        else:
+            return 'k'
+    else:
+        if status == 0:
+            return 'tab:cyan'
+        elif status == 1:
+            return 'tab:orange'
+        elif status == 2:
+            return 'tab:olive'
+        else:
+            return 'k'
+
+def color_from_state(state, recently_modified=False):
+    unique_values = np.unique(state)
+    color_map={}
+    for value in unique_values:
+        color_map[value] = plt.cm.tab10(value)
+        if value == 99:
+            color_map[value] = 'k'
+    # colors = plt.cm.tab10(len(unique_values))
+    # color_map = dict(zip(unique_values, colors))
+    # print(color_map)
+    return color_map
+
+
+
+
+def color_from_class(cclass, recently_modified=False):
+    if not recently_modified:
+        if cclass == 0:
+            return 'tab:red'
+        elif cclass == 1:
+            return 'tab:blue'
+        elif cclass == 2:
+            return 'yellow'
+        else:
+            return 'k'
+    else:
+        if cclass == 0:
+            return 'tab:orange'
+        elif cclass == 1:
+            return 'tab:cyan'
+        elif cclass == 2:
+            return 'tab:olive'
+        else:
+            return 'k'
+
+
+class ChannelChoice(QWidget):
+
+    def __init__(self, parent):
+        super().__init__()
+        self.parent = parent
+        #self.channel_names = channel_names
+        self.setWindowTitle("Choose target channel")
+        # Create the QComboBox and add some items
+        self.combo_box = QComboBox(self)
+        center_window(self)
+
+        channels = parent.channel_names
+
+        self.combo_box.addItems(channels)
+
+        self.add_btn = QPushButton("Add")
+        self.add_btn.clicked.connect(self.add_current_channel)
+
+        # Create the layout
+        layout = QVBoxLayout(self)
+        layout.addWidget(self.combo_box)
+        layout.addWidget(self.add_btn)
+
+    def add_current_channel(self):
+        filtername = self.combo_box.currentText()
+        self.parent.list_widget.addItems([filtername])
+        self.close()

celldetective/gui/json_readers.py

@@ -0,0 +1,113 @@
+import sys
+import configparser
+from PyQt5.QtWidgets import QWidget, QVBoxLayout, QScrollArea, QLabel, QHBoxLayout, QLineEdit, QPushButton
+from PyQt5.QtCore import Qt
+import sys
+import configparser
+
+class ConfigEditor(QWidget):
+    
+    def __init__(self, parent):
+
+        """
+        Load and edit the experiment config.
+        """
+
+        super().__init__()
+
+        self.parent = parent
+        self.config_path = self.parent.exp_config
+
+        self.setGeometry(500,200,400,700)
+
+        self.setWindowTitle("Configuration")
+
+        # Create the main layout
+        self.layout = QVBoxLayout()
+
+        # Create a scroll area to contain the main layout
+        scroll = QScrollArea()
+        scroll.setWidgetResizable(True)
+        scroll_content = QWidget()
+        self.scroll_layout = QVBoxLayout(scroll_content)
+        scroll_content.setLayout(self.scroll_layout)
+        scroll.setWidget(scroll_content)
+
+        # Add a label for each section of the config file
+        self.labels = []
+        self.edit_boxes = []
+        self.save_button = None
+        self.sections = {}
+
+        # Set the main layout
+        self.scroll_layout.addStretch()
+        self.layout.addWidget(scroll)
+        self.setLayout(self.layout)
+
+        self.load_config()
+
+    def load_config(self):
+        file_name = self.config_path
+        #self.file_edit.setText(file_name)
+
+        config = configparser.ConfigParser()
+        config.read(file_name)
+
+        # Create a layout for each section of the config file
+        for section in config.sections():
+            section_layout = QVBoxLayout()
+            section_label = QLabel('[{}]'.format(section))
+            self.labels.append(section_label)
+
+            # Create an editor box for each parameter in the section
+            for key, value in config.items(section):
+                edit_box_layout = QHBoxLayout()
+                label = QLabel(key)
+                edit_box = QLineEdit(value)
+                edit_box_layout.addWidget(label)
+                edit_box_layout.addWidget(edit_box)
+                section_layout.addLayout(edit_box_layout)
+
+                self.edit_boxes.append(edit_box)
+                self.sections[key] = (section, edit_box)
+
+            # Add the section label and editor boxes to the main layout
+            self.scroll_layout.addWidget(section_label)
+            self.scroll_layout.addLayout(section_layout)
+
+        # Add a save button
+        save_layout = QHBoxLayout()
+        save_button = QPushButton('Save')
+        save_button.setStyleSheet(self.parent.parent.button_style_sheet)
+        save_button.clicked.connect(self.save_config)
+        save_button.setShortcut("Return")
+        #save_button.setIcon(QIcon_from_svg(self.parent.abs_path+f"/icons/save.svg", color='white'))
+
+        #save_layout.addStretch()
+        save_layout.addWidget(save_button, alignment=Qt.AlignTop)
+
+        # Add the save button to the main layout
+        self.layout.addLayout(save_layout)
+        self.save_button = save_button
+
+    def save_config(self):
+        # Save the configuration to the file
+        file_name = self.config_path
+            
+        config = configparser.ConfigParser()
+
+        # Update the values in the config object
+
+
+
+        for key, (section, edit_box) in self.sections.items():
+            if not config.has_section(section):
+                config.add_section(section)
+            config.set(section, key, edit_box.text())
+
+        # Write the config object to the file
+        with open(file_name, 'w') as f:
+            config.write(f)
+
+        self.parent.load_configuration()
+        self.close()