PyImageLabeling 1.0.0__py3-none-any.whl

PyImageLabeling/controller/settings/MagicPenSetting.py

@@ -0,0 +1,125 @@
+from PyQt6.QtWidgets import QDialog, QSlider, QFormLayout, QDialogButtonBox, QSpinBox, QLabel, QHBoxLayout, QVBoxLayout, QComboBox
+from PyQt6.QtCore import Qt
+
+from PyImageLabeling.model.Utils import Utils
+
+class MagicPenSetting(QDialog):
+    def __init__(self, parent):
+        super().__init__(parent)
+        self.setWindowTitle("Magic Pen Settings")
+        self.resize(500, 500)
+
+        self.tolerance = Utils.load_parameters()["magic_pen"]["tolerance"] 
+        self.max_pixels = Utils.load_parameters()["magic_pen"]["max_pixels"]
+        self.method = Utils.load_parameters()["magic_pen"]["method"]
+
+        layout = QVBoxLayout()
+        
+        
+        #########################################################################################################
+        
+        form_layout = QHBoxLayout()
+        tolerance_label = QLabel("Tolerance (percentage):")
+        layout.addWidget(tolerance_label)
+        layout.setSpacing(10)
+        # Tolerance slider and spinbox
+        self.tolerance_slider = QSlider(Qt.Orientation.Horizontal)
+        self.tolerance_slider.setRange(0, 100)
+        self.tolerance_slider.setValue(self.tolerance)
+        self.tolerance_slider.setTickPosition(QSlider.TickPosition.TicksBelow)
+        self.tolerance_slider.setTickInterval(10)
+
+        self.tolerance_spinbox = QSpinBox()
+        self.tolerance_spinbox.setRange(0, 100)
+        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.addWidget(self.tolerance_slider)
+        form_layout.addWidget(self.tolerance_spinbox)
+
+        layout.addLayout(form_layout)
+        
+        #########################################################################################################
+
+        # Points limit setting
+        points_limit_label = QLabel("Maximum number of pixels (integer):")
+        layout.addWidget(points_limit_label)
+
+        points_slider_layout = QHBoxLayout()
+        self.points_limit_slider = QSlider(Qt.Orientation.Horizontal)
+        self.points_limit_slider.setRange(5000, 500000)
+        self.points_limit_slider.setTickInterval(50000)
+        self.points_limit_slider.setValue(self.max_pixels)
+
+        self.points_limit_spinbox = QSpinBox()
+        self.points_limit_spinbox.setRange(5000, 500000)
+        self.points_limit_spinbox.setValue(self.max_pixels)
+        self.points_limit_spinbox.setSingleStep(5000)
+
+        # Connect both ways to keep them synchronized
+        self.points_limit_slider.valueChanged.connect(self.points_limit_spinbox.setValue)
+        self.points_limit_spinbox.valueChanged.connect(self.points_limit_slider.setValue)
+        
+        # Update internal values when sliders change
+        self.points_limit_slider.valueChanged.connect(self.update_max_pixels)
+        self.points_limit_spinbox.valueChanged.connect(self.update_max_pixels)
+
+        points_slider_layout.addWidget(self.points_limit_slider)
+        points_slider_layout.addWidget(self.points_limit_spinbox)
+
+        layout.addLayout(points_slider_layout)
+        
+        #########################################################################################################
+
+        method_label = QLabel("Method:")
+        layout.addWidget(method_label)
+        
+        self.method_combobox = QComboBox()
+        self.method_combobox.addItem('RGB')
+        self.method_combobox.addItem('HSV')
+        
+        self.method_combobox.setCurrentText(self.method)
+        self.method_combobox.currentTextChanged.connect(self.update_method)
+
+        layout.addWidget(self.method_combobox)
+        
+        
+        #########################################################################################################
+        method_label = QLabel(None)
+        layout.addWidget(method_label)
+
+        # 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
+
+    def update_max_pixels(self, value):
+        """Update internal max points value when slider changes"""
+        self.max_pixels = value
+
+    def update_method(self, value):
+        """Update method when the combobox changes"""
+        self.method = value
+
+    def accept(self):
+        """Override accept to ensure settings are updated before closing"""
+        # Update internal values one final time
+        self.tolerance, self.max_pixels, self.method = self.tolerance_slider.value(), self.points_limit_slider.value(), self.method_combobox.currentText()
+        data = Utils.load_parameters()
+        data["magic_pen"]["tolerance"], data["magic_pen"]["max_pixels"], data["magic_pen"]["method"] = self.tolerance, self.max_pixels, self.method
+        Utils.save_parameters(data)    
+        return super().accept()

PyImageLabeling/controller/settings/OpacitySetting.py

@@ -0,0 +1,66 @@
+from PyQt6.QtWidgets import QDialog, QSlider, QFormLayout, QDialogButtonBox, QSpinBox, QLabel, QHBoxLayout, QVBoxLayout
+from PyQt6.QtCore import Qt
+
+from PyImageLabeling.model.Utils import Utils
+
+class OpacitySetting(QDialog):
+    def __init__(self, zoomable_graphic_view):
+        super().__init__(zoomable_graphic_view)
+        self.setWindowTitle("Opacity Settings")
+        self.resize(500, 100)
+        self.min_opacity = 10
+        self.max_opacity = 100
+        
+        self.opacity = Utils.load_parameters()["labeling_opacity"] 
+        if not (self.min_opacity <= self.opacity <= self.max_opacity):
+            self.opacity = 50
+
+        layout = QVBoxLayout()
+        label = QLabel("Percentage (between 10 and 100):")
+        layout.addWidget(label)
+
+        slider_layout = QHBoxLayout()
+
+        # Tolerance slider and spinbox
+        self.opacity_slider = QSlider(Qt.Orientation.Horizontal)
+        self.opacity_slider.setRange(self.min_opacity, self.max_opacity)
+        self.opacity_slider.setValue(self.opacity)
+        self.opacity_slider.setTickPosition(QSlider.TickPosition.TicksBelow)
+        self.opacity_slider.setTickInterval(10)
+
+        self.opacity_spinbox = QSpinBox()
+        self.opacity_spinbox.setRange(self.min_opacity, self.max_opacity)
+        self.opacity_spinbox.setValue(self.opacity)
+
+        # Connect both ways to keep them synchronized
+        self.opacity_spinbox.valueChanged.connect(self.opacity_slider.setValue)
+        self.opacity_slider.valueChanged.connect(self.opacity_spinbox.setValue)
+        
+        # Update internal values when sliders change
+        self.opacity_slider.valueChanged.connect(self.update_opacity)
+        self.opacity_spinbox.valueChanged.connect(self.update_opacity)
+
+        slider_layout.addWidget(self.opacity_slider)
+        slider_layout.addWidget(self.opacity_spinbox)
+        layout.addLayout(slider_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_opacity(self, value):
+        """Update internal tolerance value when slider changes"""
+        self.opacity = value
+
+    def accept(self):
+        """Override accept to ensure settings are updated before closing"""
+        # Update internal values one final time
+        self.opacity = self.opacity_slider.value()
+        data = Utils.load_parameters()
+        data["labeling_opacity"] = self.opacity
+        Utils.save_parameters(data) 
+        return super().accept()

PyImageLabeling/controller/settings/PaintBrushSetting.py

@@ -0,0 +1,66 @@
+from PyQt6.QtWidgets import QDialog, QSlider, QFormLayout, QDialogButtonBox, QSpinBox, QLabel, QHBoxLayout, QVBoxLayout
+from PyQt6.QtCore import Qt
+
+from PyImageLabeling.model.Utils import Utils
+
+class PaintBrushSetting(QDialog):
+    def __init__(self, zoomable_graphic_view, model):
+        super().__init__(zoomable_graphic_view)
+        self.setWindowTitle("Paint brush Settings")
+        self.resize(500, 100)
+
+        self.size_paint_brush = Utils.load_parameters()["paint_brush"]["size"] 
+        self.max_size = min(model.image_qrect.width(), model.image_qrect.height())
+        self.min_size = 1
+        if not (self.min_size <= self.size_paint_brush <= self.max_size):
+            self.size_paint_brush = 5
+
+        layout = QVBoxLayout()
+        label = QLabel("Size of the brush in pixel:")
+        layout.addWidget(label)
+
+        slider_layout = QHBoxLayout()
+
+        # Tolerance slider and spinbox
+        self.size_paint_brush_slider = QSlider(Qt.Orientation.Horizontal)
+        self.size_paint_brush_slider.setRange(self.min_size, self.max_size)
+        self.size_paint_brush_slider.setValue(self.size_paint_brush)
+        self.size_paint_brush_slider.setTickPosition(QSlider.TickPosition.TicksBelow)
+        self.size_paint_brush_slider.setTickInterval(10)
+
+        self.size_paint_brush_spinbox = QSpinBox()
+        self.size_paint_brush_spinbox.setRange(self.min_size, self.max_size)
+        self.size_paint_brush_spinbox.setValue(self.size_paint_brush)
+
+        # Connect both ways to keep them synchronized
+        self.size_paint_brush_spinbox.valueChanged.connect(self.size_paint_brush_slider.setValue)
+        self.size_paint_brush_slider.valueChanged.connect(self.size_paint_brush_spinbox.setValue)
+        
+        # Update internal values when sliders change
+        self.size_paint_brush_slider.valueChanged.connect(self.update_size_paint_brush)
+        self.size_paint_brush_spinbox.valueChanged.connect(self.update_size_paint_brush)
+
+        slider_layout.addWidget(self.size_paint_brush_slider)
+        slider_layout.addWidget(self.size_paint_brush_spinbox)
+        layout.addLayout(slider_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_size_paint_brush(self, value):
+        """Update internal tolerance value when slider changes"""
+        self.size_paint_brush = value
+
+    def accept(self):
+        """Override accept to ensure settings are updated before closing"""
+        # Update internal values one final time
+        self.size_paint_brush = self.size_paint_brush_slider.value()
+        data = Utils.load_parameters()
+        data["paint_brush"]["size"] = self.size_paint_brush
+        Utils.save_parameters(data) 
+        return super().accept()

PyImageLabeling/icons/transparency.png:Zone.Identifier

@@ -0,0 +1,4 @@
+[ZoneTransfer]
+ZoneId=3
+ReferrerUrl=https://www.flaticon.com/search?word=opacity
+HostUrl=about:internet