PyImageLabeling 1.0.0__py3-none-any.whl

PyImageLabeling/controller/LabelEvents.py

@@ -0,0 +1,219 @@
+
+from  controller.Events import Events
+
+from PyQt6.QtWidgets import QMessageBox, QFileDialog, QDialog, QColorDialog
+from PyQt6.QtGui import QPixmap, QImage
+
+from PyImageLabeling.controller.settings.OpacitySetting import OpacitySetting
+from PyImageLabeling.controller.settings.LabelSetting import LabelSetting
+from PyImageLabeling.model.Utils import Utils
+
+class LabelEvents(Events):
+    def __init__(self):
+        super().__init__()
+
+        
+    def new_label(self):
+        self.all_events(self.new_label.__name__)
+        label_setting = LabelSetting(self.view.zoomable_graphics_view)   
+        
+        if label_setting.exec():
+            if self.model.name_already_exists(label_setting.name):
+                    self.error_message("Error", f"The label name '{label_setting.name}' already exists!")
+                    return
+
+            # Uncheck all activation buttons
+            for label_id in self.view.buttons_label_bar_temporary:
+                self.view.buttons_label_bar_temporary[label_id]["activation"].setChecked(False)
+
+            # Create a new label
+            label = self.model.new_label(label_setting.name, label_setting.labeling_mode, label_setting.color) 
+
+            # Display the new label bar 
+            self.view.builder.build_new_layer_label_bar(label.get_label_id(), label_setting.name, label_setting.labeling_mode, label_setting.color)
+            
+            # Update the model with the new labal
+            self.model.update_labeling_overlays(label.get_label_id())        
+            
+            # Put the good labeling buttons according to the mode 
+            self.view.update_labeling_buttons(label_setting.labeling_mode)
+            
+    def select_label(self, label_id):
+        self.all_events(label_id)
+        
+        # Uncheck all activation buttons except the selected label
+        for id in self.view.buttons_label_bar_temporary:
+            if id == label_id:
+                self.view.buttons_label_bar_temporary[id]["activation"].setChecked(True)
+            else:
+                self.view.buttons_label_bar_temporary[id]["activation"].setChecked(False)
+        
+
+        # Active or deactivate the good labeling buttons 
+        self.view.update_labeling_buttons(self.model.get_label_items()[label_id].get_labeling_mode())
+        
+        label_item = self.model.get_label_items()[label_id]
+        if not label_item.get_visible():
+            # Set the label as visible
+            label_item.set_visible(True)
+            
+        # Call the model part to change the labeling overlay
+        self.model.update_labeling_overlays(label_id)      
+        #self.model.select_labeling_overlay(label_id) 
+
+        # Ensure that the visibility button of this label is checked
+        self.view.buttons_label_bar_temporary[label_id]["visibility"].setChecked(True)
+
+    def color(self, label_id):
+        self.all_events(self.color.__name__)
+        label_item = self.model.get_label_items()[label_id]
+
+        color = QColorDialog.getColor(label_item.get_color())
+        if label_item.get_color() != color:
+            label_item.set_color(color)
+            self.model.update_color(label_id)
+            print("label_id:", label_id)
+            print("color:", color)
+            print("color:", type(color))
+            
+            self.view.buttons_label_bar_temporary[label_id]["color"].setStyleSheet(Utils.color_to_stylesheet(color))
+            
+    def visibility(self, label_id):
+        self.all_events(self.visibility.__name__)
+        
+        if self.model.get_current_label_item().get_label_id() == label_id:
+            # Do nothing 
+            self.view.buttons_label_bar_temporary[label_id]["visibility"].setChecked(True)
+        else:
+            # Get the label visibility state
+            label_item = self.model.get_label_items()[label_id]
+            new_visibility = not label_item.get_visible() 
+            label_item.set_visible(new_visibility)
+            self.model.get_current_image_item().update_scene()
+            # Apply to all loaded images
+            # image_items = self.model.get_image_items()
+            # for file_path, image_item in image_items.items():
+            #     if image_item is not None and label_id in image_item.labeling_overlays:
+            #         overlay = image_item.labeling_overlays[label_id]
+            #         if overlay.is_displayed_in_scene:
+            #             overlay.set_visible(new_visibility)
+        
+    def opacity(self):
+        self.all_events(self.opacity.__name__)
+        opacity_setting = OpacitySetting(self.view.zoomable_graphics_view)
+        if opacity_setting.exec():
+            self.model.set_opacity(opacity_setting.opacity/100) # To normalize
+
+
+    def label_setting(self, label_id):
+        self.all_events(self.label_setting.__name__)
+        
+        label_item = self.model.get_label_items()[label_id]
+        #name = self.model.labeling_overlays[label_id].get_name()
+        #labeling_mode = self.model.labeling_overlays[label_id].get_labeling_mode() 
+        #color = self.model.labeling_overlays[label_id].get_color()   
+        
+        label_setting = LabelSetting(self.view.zoomable_graphics_view, 
+                                     label_item.get_name(), 
+                                     label_item.get_labeling_mode(), 
+                                     label_item.get_color())
+
+        if label_setting.exec():
+            if label_item.get_name() != label_setting.name:
+                if self.model.name_already_exists(label_setting.name):
+                    self.error_message("Error", f"The label name '{label_setting.name}' already exists!")
+                    return
+
+                # Change the name in the model 
+                label_item.set_name(label_setting.name)
+                
+                # Change the name in the view 
+                self.view.buttons_label_bar_temporary[label_id]["activation"].setText(label_setting.name) 
+                
+            if label_item.get_labeling_mode() != label_setting.labeling_mode:
+                msgBox = QMessageBox(self.view.zoomable_graphics_view)
+                msgBox.setWindowTitle("Labeling Mode")
+                msgBox.setText("Are you sure you want to change the labeling mode ?")
+                msgBox.setInformativeText("All previous works done with this label will be erased.")
+                msgBox.setStandardButtons(QMessageBox.StandardButton.No | QMessageBox.StandardButton.Yes)
+                msgBox.setDefaultButton(QMessageBox.StandardButton.No)
+                msgBox.setModal(True)
+                result = msgBox.exec()
+                if result == QMessageBox.StandardButton.Yes:
+                    # Change in the model 
+                    label_item.set_labeling_mode(label_setting.labeling_mode)
+
+                    # Reset the labeling overlay 
+                    for file_path in self.model.file_paths:
+                        image_item = self.model.image_items[file_path]
+                        if image_item is not None and label_id in image_item.labeling_overlays:
+                            image_item.labeling_overlays[label_id].reset()
+
+                    # Put the good labeling buttons according to the mode 
+                    self.view.update_labeling_buttons(label_setting.labeling_mode)
+            
+            if label_item.get_color() != label_setting.color:
+                label_item.set_color(label_setting.color)
+                self.model.update_color(label_id)
+                self.view.buttons_label_bar_temporary[label_id]["color"].setStyleSheet(Utils.color_to_stylesheet(label_setting.color))
+            
+
+    def remove_label(self, label_id):
+        self.all_events(self.remove_label.__name__)
+        msgBox = QMessageBox(self.view.zoomable_graphics_view)
+        msgBox.setWindowTitle("Remove Label")
+        msgBox.setText("Are you sure you want to delete this label ?")
+        msgBox.setInformativeText("All previous works done with this label will be erased on all images.")
+        msgBox.setStandardButtons(QMessageBox.StandardButton.No | QMessageBox.StandardButton.Yes)
+        msgBox.setDefaultButton(QMessageBox.StandardButton.No)
+        for button in msgBox.buttons():
+            button.setObjectName("dialog")
+
+        msgBox.setModal(True)
+        result = msgBox.exec()
+        if result == QMessageBox.StandardButton.Yes:
+            # Remove from all images (replace the old single overlay removal)
+            image_items = self.model.get_image_items()
+            for file_path, image_item in image_items.items():
+                if image_item is not None and label_id in image_item.labeling_overlays:
+                    image_item.labeling_overlays[label_id].remove()
+                    del image_item.labeling_overlays[label_id]
+
+            # Remove from the model's label_items
+            if label_id in self.model.get_label_items():
+                del self.model.get_label_items()[label_id]
+
+            # Remove from the view
+            if label_id in self.view.container_label_bar_temporary:
+                widget, separator = self.view.container_label_bar_temporary[label_id]
+                
+                widget.hide()
+                self.view.label_bar_layout.removeWidget(widget)
+                separator.hide()
+                self.view.label_bar_layout.removeWidget(separator)
+                
+                # Clean up the view dictionaries
+                del self.view.container_label_bar_temporary[label_id]
+                if label_id in self.view.buttons_label_bar_temporary:
+                    del self.view.buttons_label_bar_temporary[label_id]
+
+            # Check if there are no more labels
+            if len(self.model.get_label_items()) == 0:
+                for button_key in self.view.buttons_labeling_bar.keys():
+                    self.view.buttons_labeling_bar[button_key].setEnabled(False)
+                self.move_image()  # To deactivate the last used tool, we active the move button :)  
+                self.model.remove_contour()
+                self.model.set_current_label_item(None)
+            # Select another label if the deleted one was selected (this condition should never be true now)
+            elif self.model.get_current_label_item() is not None and self.model.get_current_label_item().get_label_id() == label_id:
+                first_id = list(self.model.get_label_items().keys())[0]
+                self.select_label(first_id)
+            
+   
+
+
+
+
+
+
+        

PyImageLabeling/controller/LabelingEvents.py

@@ -0,0 +1,123 @@
+from PyImageLabeling.controller.Events import Events
+from PyImageLabeling.controller.settings.MagicPenSetting import MagicPenSetting
+from PyImageLabeling.controller.settings.PaintBrushSetting import PaintBrushSetting
+from PyImageLabeling.controller.settings.EraserSetting import EraserSetting
+from PyImageLabeling.controller.settings.ContourFillinSetting import ContourFillingSetting
+from PyQt6.QtWidgets import QDialog
+
+class LabelingEvents(Events):
+    def __init__(self):
+        super().__init__()
+
+    ### Buttons events
+
+    def apply(self):
+        print("apply")
+
+    def cancel(self):
+        print("cancel")
+
+
+    def contour_filling(self):
+        self.model.remove_contour()
+        self.desactivate_buttons_labeling_image_bar(self.contour_filling.__name__)
+        self.all_events(self.contour_filling.__name__)
+        self.view.zoomable_graphics_view.change_cursor("filling")
+        self.model.contour_filling()
+        self.model.start_contour_filling()
+        
+    def paintbrush(self):
+        self.model.remove_contour()
+        
+        self.desactivate_buttons_labeling_image_bar(self.paintbrush.__name__)
+        self.all_events(self.paintbrush.__name__)
+        self.view.zoomable_graphics_view.change_cursor("paint")
+        self.model.paint_brush()
+    
+    def magic_pen(self):
+        self.model.remove_contour()
+        
+        self.desactivate_buttons_labeling_image_bar(self.magic_pen.__name__)
+        self.all_events(self.magic_pen.__name__)
+        self.view.zoomable_graphics_view.change_cursor("magic")
+        self.model.magic_pen()
+
+    def ellipse(self):
+        self.desactivate_buttons_labeling_image_bar(self.ellipse.__name__)
+        self.all_events(self.ellipse.__name__)
+        self.view.zoomable_graphics_view.change_cursor("ellipse")
+        self.model.ellipse()
+
+    def rectangle(self):
+        self.desactivate_buttons_labeling_image_bar(self.rectangle.__name__)
+        self.all_events(self.rectangle.__name__)
+        self.view.zoomable_graphics_view.change_cursor("rectangle")
+        self.model.rectangle()
+    
+    def polygon(self):
+        self.desactivate_buttons_labeling_image_bar(self.polygon.__name__)
+        self.all_events(self.polygon.__name__)
+        self.view.zoomable_graphics_view.change_cursor("polygon")
+        self.model.polygon()
+
+    def undo(self):
+        self.all_events(self.undo.__name__)
+        self.model.undo()
+        
+    def eraser(self):
+        self.model.remove_contour()
+        
+        self.desactivate_buttons_labeling_image_bar(self.eraser.__name__)
+        self.all_events(self.eraser.__name__)
+        self.view.zoomable_graphics_view.change_cursor("eraser")
+        self.model.eraser()
+    
+    def clear_all(self):
+        self.all_events(self.clear_all.__name__)
+        self.model.clear_all()
+
+    ### Setting Buttons events
+
+
+    def contour_filling_setting(self):
+        self.all_events(self.contour_filling_setting.__name__)
+        contourfillingsetting = ContourFillingSetting(self.view.zoomable_graphics_view)
+        if contourfillingsetting.exec():
+            self.view.desactivate_buttons(self.contour_filling.__name__, [self.view.buttons_labeling_bar, self.view.buttons_image_bar])
+            self.contour_filling()
+
+    def paintbrush_setting(self):
+        
+        self.all_events(self.paintbrush_setting.__name__)
+        paintbrushsetting = PaintBrushSetting(self.view.zoomable_graphics_view, self.model)
+        if paintbrushsetting.exec():
+            self.view.desactivate_buttons(self.paintbrush.__name__, [self.view.buttons_labeling_bar, self.view.buttons_image_bar])
+            self.paintbrush()
+    
+    def magic_pen_setting(self):
+        
+        self.all_events(self.magic_pen_setting.__name__)
+        magicpensetting = MagicPenSetting(self.view.zoomable_graphics_view)
+        if magicpensetting.exec():
+            self.view.desactivate_buttons(self.magic_pen.__name__, [self.view.buttons_labeling_bar, self.view.buttons_image_bar])
+            self.magic_pen()
+        
+    def ellipse_setting(self):
+        self.all_events(self.ellipse_setting.__name__)
+        print("ellipse_setting")
+
+    def rectangle_setting(self):
+        self.all_events(self.rectangle_setting.__name__)
+        print("rectangle_setting")
+    
+    def polygon_setting(self):
+        self.all_events(self.polygon_setting.__name__)
+        print("polygon_setting")
+   
+    def eraser_setting(self):
+        self.all_events(self.eraser_setting.__name__)
+        erasersetting = EraserSetting(self.view.zoomable_graphics_view)
+        if erasersetting.exec():
+            self.view.desactivate_buttons(self.eraser.__name__, [self.view.buttons_labeling_bar, self.view.buttons_image_bar])
+            self.eraser()
+   

PyImageLabeling/controller/settings/ContourFillinSetting.py

@@ -0,0 +1,93 @@
+from PyQt6.QtWidgets import QDialog, QSlider, QFormLayout, QDialogButtonBox, QSpinBox, QLabel, QVBoxLayout
+from PyQt6.QtCore import Qt
+
+from PyImageLabeling.model.Utils import Utils
+
+class ContourFillingSetting(QDialog):
+    def __init__(self, parent):
+        super().__init__(parent)
+        self.setWindowTitle("Contour Filling Settings")
+        self.resize(500, 100)
+
+        self.tolerance = Utils.load_parameters()["contour_filling"]["tolerance"] 
+
+        layout = QVBoxLayout()
+        form_layout = QFormLayout()
+
+        # Tolerance slider and spinbox
+        self.tolerance_slider = QSlider(Qt.Orientation.Horizontal)
+        self.tolerance_slider.setRange(1, 10)
+        self.tolerance_slider.setValue(self.tolerance)
+        self.tolerance_slider.setTickPosition(QSlider.TickPosition.TicksBelow)
+        self.tolerance_slider.setTickInterval(1)
+
+        self.tolerance_spinbox = QSpinBox()
+        self.tolerance_spinbox.setRange(1, 10)
+        self.tolerance_spinbox.setValue(self.tolerance)
+
+        # Connect both ways to keep them synchronized
+        self.tolerance_spinbox.valueChanged.connect(self.tolerance_slider.setValue)
+        self.tolerance_slider.valueChanged.connect(self.tolerance_spinbox.setValue)
+
+        # Update internal values when sliders change
+        self.tolerance_slider.valueChanged.connect(self.update_tolerance)
+        self.tolerance_spinbox.valueChanged.connect(self.update_tolerance)
+
+        form_layout.addRow("Tolerance:", self.tolerance_slider)
+        form_layout.addRow("Value:", self.tolerance_spinbox)
+
+        # Label to display the tolerance description
+        self.tolerance_description_label = QLabel()
+        self.update_tolerance_description()
+        form_layout.addRow("Description:", self.tolerance_description_label)
+
+        layout.addLayout(form_layout)
+
+        # Buttons
+        self.buttons = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
+        self.buttons.accepted.connect(self.accept)
+        self.buttons.rejected.connect(self.reject)
+        layout.addWidget(self.buttons)
+
+        self.setLayout(layout)
+
+    def update_tolerance(self, value):
+        """Update internal tolerance value when slider changes"""
+        self.tolerance = value
+        self.update_tolerance_description()
+
+    def update_tolerance_description(self):
+        """Update the tolerance description label based on the current tolerance level"""
+        descriptions = {
+            1: "Most Precise - Only very clear, well-defined contours",
+            2: "Very Precise - Clear contours with minimal noise",
+            3: "Precise - Well-defined contours, some fine details",
+            4: "Moderately Precise - Good balance, cleaner results",
+            5: "Balanced - Default setting, good for most images",
+            6: "Moderately Tolerant - Captures more subtle edges",
+            7: "Tolerant - Finds more contours, including faint ones",
+            8: "Very Tolerant - Detects subtle features and textures",
+            9: "Highly Tolerant - Captures most edge information",
+            10: "Most Tolerant - Maximum sensitivity, may include noise"
+        }
+        description = descriptions.get(self.tolerance, "Unknown tolerance level")
+        self.tolerance_description_label.setText(description)
+
+    def get_settings(self):
+        """Return current settings from the UI controls"""
+        # Get values directly from the controls to ensure we have the latest values
+        tolerance = self.tolerance_slider.value()
+
+        # Also update internal variables for consistency
+        self.tolerance = tolerance
+        return tolerance
+
+    def accept(self):
+        """Override accept to ensure settings are updated before closing"""
+        # Update internal values one final time
+        self.tolerance = self.tolerance_slider.value()
+        data = Utils.load_parameters()
+        data["contour_filling"]["tolerance"] = self.tolerance
+        Utils.save_parameters(data) 
+        return super().accept()
+    

PyImageLabeling/controller/settings/CoutourFillingApplyCancel.py

@@ -0,0 +1,37 @@
+from PyQt6.QtWidgets import QDialog, QSlider, QFormLayout, QDialogButtonBox, QSpinBox, QLabel, QVBoxLayout
+from PyQt6.QtCore import Qt, QRect, QPoint
+
+from PyImageLabeling.model.Utils import Utils
+
+class ContourFillingApplyCancel(QDialog):
+    def __init__(self, parent):
+        super().__init__(parent)
+        self.setWindowFlag(Qt.WindowType.FramelessWindowHint)
+        #self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
+        self.setObjectName("apply_cancel_bar")
+        #self.setGeometry(QRect(100,100, 300, 70))
+        self.move(parent.mapToGlobal(QPoint(10,10)))
+        layout = QVBoxLayout()
+        form_layout = QFormLayout()
+
+        # Help text
+        tolerance_help = QLabel("Click on the area to fill and apply")
+        form_layout.addRow("", tolerance_help)
+
+        layout.addLayout(form_layout)
+
+        # Buttons
+        self.buttons = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
+        for button in self.buttons.buttons():
+            button.setObjectName("dialog")
+        self.buttons.accepted.connect(self.accept)
+        self.buttons.rejected.connect(self.reject)
+        layout.addWidget(self.buttons)
+
+        self.setLayout(layout)
+
+    def accept(self):
+        """Override accept to ensure settings are updated before closing"""
+        # Update internal values one final time
+        return super().accept()
+    

PyImageLabeling/controller/settings/EraserSetting.py

@@ -0,0 +1,73 @@
+from PyQt6.QtWidgets import QCheckBox, QDialog, QSlider, QFormLayout, QDialogButtonBox, QSpinBox, QLabel, QHBoxLayout, QVBoxLayout
+from PyQt6.QtCore import Qt
+
+from PyImageLabeling.model.Utils import Utils
+
+class EraserSetting(QDialog):
+    def __init__(self, parent):
+        super().__init__(parent)
+        self.setWindowTitle("Eraser Settings")
+        self.resize(500, 100)
+
+        self.radius = Utils.load_parameters()["eraser"]["size"] 
+        self.absolute_mode = Utils.load_parameters()["eraser"].get("absolute_mode", 0)
+
+        layout = QVBoxLayout()
+        form_layout = QFormLayout()
+
+        # Tolerance slider and spinbox
+        self.radius_slider = QSlider(Qt.Orientation.Horizontal)
+        self.radius_slider.setRange(0, 100)
+        self.radius_slider.setValue(self.radius)
+        self.radius_slider.setTickPosition(QSlider.TickPosition.TicksBelow)
+        self.radius_slider.setTickInterval(10)
+
+        self.radius_spinbox = QSpinBox()
+        self.radius_spinbox.setRange(0, 100)
+        self.radius_spinbox.setValue(self.radius)
+
+        self.absolute_checkbox = QCheckBox("Absolute mode")
+        self.absolute_checkbox.setChecked(self.absolute_mode == 1)
+        
+        # Connect both ways to keep them synchronized
+        self.radius_spinbox.valueChanged.connect(self.radius_slider.setValue)
+        self.radius_slider.valueChanged.connect(self.radius_spinbox.setValue)
+        
+        # Update internal values when sliders change
+        self.radius_slider.valueChanged.connect(self.update_radius)
+        self.radius_spinbox.valueChanged.connect(self.update_radius)
+        self.absolute_checkbox.stateChanged.connect(self.update_absolute_mode)
+
+        form_layout.addRow("Radius:", self.radius_slider)
+        form_layout.addRow("Value:", self.radius_spinbox)
+        form_layout.addRow("", self.absolute_checkbox)
+
+
+        layout.addLayout(form_layout)
+
+        # Buttons
+        self.buttons = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
+        self.buttons.accepted.connect(self.accept)
+        self.buttons.rejected.connect(self.reject)
+        layout.addWidget(self.buttons)
+
+        self.setLayout(layout)
+
+    def update_radius(self, value):
+        """Update internal tolerance value when slider changes"""
+        self.radius = value
+    
+    def update_absolute_mode(self, state):
+        """Update internal absolute mode value when checkbox changes"""
+        self.absolute_mode = 1 if state == Qt.CheckState.Checked.value else 0
+        
+    def accept(self):
+        """Override accept to ensure settings are updated before closing"""
+        # Update internal values one final time
+        self.radius= self.radius_slider.value()
+        self.radius = self.radius_slider.value()
+        data = Utils.load_parameters()
+        data["eraser"]["size"] = self.radius
+        data["eraser"]["absolute_mode"] = self.absolute_mode
+        Utils.save_parameters(data) 
+        return super().accept()

PyImageLabeling/controller/settings/LabelSetting.py

@@ -0,0 +1,91 @@
+from PyQt6.QtWidgets import QComboBox, QPushButton, QHBoxLayout, QColorDialog, QDialog, QSlider, QFormLayout, QDialogButtonBox, QSpinBox
+
+from PyQt6.QtGui import QColor
+from PyQt6.QtCore import Qt
+import random
+
+class LabelSetting(QDialog):
+
+    def __init__(self, parent, name=None, labeling_mode=None, color=None):
+        super().__init__(parent)
+
+        labeling_mode_pixel = parent.view.config["labeling_bar"]["pixel"]["name_view"]
+        labeling_mode_geometric = parent.view.config["labeling_bar"]["geometric"]["name_view"]
+        automatic_name = "label "+str(parent.view.controller.model.get_static_label_id()+1)
+
+        self.name = automatic_name if name is None else name
+        self.color = QColor(random.choice(QColor.colorNames())) if color is None else color
+        self.labeling_mode = labeling_mode_pixel if labeling_mode is None else labeling_mode
+
+        self.setWindowTitle("Label Setting")
+        
+        layout = QFormLayout()
+        
+        label_layout = QHBoxLayout()
+        
+        self.label_combo = QComboBox()
+        self.label_combo.setEditable(True)
+        self.label_combo.setPlaceholderText("Enter new label or select existing")
+        
+        # Populate combo box with saved labels
+        self.label_combo.addItem("")  # Empty option for new labels
+        #for label in self.label_manager.get_all_labels():
+        #    self.label_combo.addItem(label)
+            
+        # Set current label if provided
+        #if self.label:
+        #    index = self.label_combo.findText(self.label)
+        #    if index >= 0:
+        #        self.label_combo.setCurrentIndex(index)
+        #    else:
+        #        self.label_combo.setCurrentText(self.label)
+        self.label_combo.setCurrentText(self.name)
+
+        self.label_combo.currentTextChanged.connect(self.name_update)
+        label_layout.addWidget(self.label_combo)
+        
+        layout.addRow("Label:", label_layout)
+
+        self.mode_combo = QComboBox()
+        self.mode_combo.addItems([labeling_mode_pixel]) #add later:  labeling_mode_geometric
+        self.mode_combo.setCurrentText(self.labeling_mode)
+        self.mode_combo.currentTextChanged.connect(self.mode_update)
+        layout.addRow("Labeling Mode:", self.mode_combo)
+
+        # Color selection
+        self.color_button = QPushButton("Choose Color")
+        self.color_button.clicked.connect(self.select_color)
+        self.color_update(self.color)  
+        layout.addRow("Color:", self.color_button)
+        
+        self.buttons = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
+        self.buttons.accepted.connect(self.accept) 
+        self.buttons.rejected.connect(self.reject)
+        layout.addRow(self.buttons)
+        
+        self.setLayout(layout)
+
+    def name_update(self, name):
+        self.name = name
+
+    def mode_update(self, labeling_mode):
+        self.labeling_mode = labeling_mode
+
+    def color_update(self, color):
+        """Update color button appearance to show current color"""
+        self.color = color
+        color_style = f"background-color: rgb({self.color.red()}, {self.color.green()}, {self.color.blue()}); color: {'white' if self.color.lightness() < 128 else 'black'};"
+        self.color_button.setStyleSheet(color_style)
+        self.color_button.setText(f"Color: {self.color.name()}")
+        
+    def select_color(self):
+        color = QColorDialog.getColor(initial=self.color)
+        if color.isValid(): self.color_update(color)
+
+    def accept(self):
+        """Override accept to ensure settings are updated before closing"""
+        self.name = self.label_combo.currentText()
+        self.labeling_mode = self.mode_combo.currentText()
+        return super().accept()
+
+