PyImageLabeling 1.0.0__py3-none-any.whl

PyImageLabeling/old_version/models/EraseSettingsDialog.py

@@ -0,0 +1,51 @@
+import cv2
+import numpy as np
+import sys
+import os
+import time
+from PyQt6.QtWidgets import (
+    QGraphicsEllipseItem, QComboBox, QGraphicsRectItem, QInputDialog, QGraphicsItem, QGraphicsItemGroup, QGraphicsPixmapItem, QGraphicsOpacityEffect, QGraphicsView, QGraphicsScene, QApplication, QMainWindow, QLabel, QVBoxLayout, QPushButton, 
+    QFileDialog, QWidget, QMessageBox, QHBoxLayout, QColorDialog, QDialog, QSlider, QFormLayout, QDialogButtonBox, QGridLayout, QProgressDialog, QCheckBox, QSpinBox, QSplashScreen, QMenu
+)
+from PyQt6.QtGui import QPixmap, QMouseEvent, QImage, QPainter, QColor, QPen, QBrush, QCursor, QIcon, QPainterPath, QFont
+from PyQt6.QtCore import Qt, QPoint, QPointF, QTimer,  QThread, pyqtSignal, QSize, QRectF, QObject, QLineF
+import gc
+import math
+import traceback
+
+class EraseSettingsDialog(QDialog):
+    def __init__(self, parent=None, current_eraser_size=None, absolute_mode=False):
+        super().__init__(parent)
+        self.setWindowTitle("Eraser Settings")
+        self.eraser_size = current_eraser_size or 10
+        self.absolute_mode = absolute_mode
+        
+        layout = QFormLayout()
+        
+        # Eraser size slider
+        self.eraser_slider = QSlider(Qt.Orientation.Horizontal)
+        self.eraser_slider.setRange(1, 100)
+        self.eraser_slider.setValue(self.eraser_size)
+        layout.addRow("Eraser Size:", self.eraser_slider)
+        self.eraser_spinbox = QSpinBox()
+        
+        self.eraser_spinbox.setRange(1, 100)
+        self.eraser_spinbox.setValue(self.eraser_size)
+        self.eraser_spinbox.valueChanged.connect(self.eraser_slider.setValue)
+        self.eraser_slider.valueChanged.connect(self.eraser_spinbox.setValue)
+        layout.addRow("", self.eraser_spinbox)
+        
+        # Add absolute mode checkbox
+        self.absolute_checkbox = QCheckBox("Absolute Mode")
+        self.absolute_checkbox.setChecked(self.absolute_mode)
+        layout.addRow("", self.absolute_checkbox)
+        
+        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 get_settings(self):
+        return self.eraser_slider.value(), self.absolute_checkbox.isChecked()

PyImageLabeling/old_version/models/LabeledRectangle.py

@@ -0,0 +1,80 @@
+
+import cv2
+import numpy as np
+import sys
+import os
+import time
+from PyQt6.QtWidgets import (
+    QGraphicsEllipseItem, QComboBox, QGraphicsRectItem, QInputDialog, QGraphicsItem, QGraphicsItemGroup, QGraphicsPixmapItem, QGraphicsOpacityEffect, QGraphicsView, QGraphicsScene, QApplication, QMainWindow, QLabel, QVBoxLayout, QPushButton, 
+    QFileDialog, QWidget, QMessageBox, QHBoxLayout, QColorDialog, QDialog, QSlider, QFormLayout, QDialogButtonBox, QGridLayout, QProgressDialog, QCheckBox, QSpinBox, QSplashScreen, QMenu, QGraphicsTextItem
+)
+from PyQt6.QtGui import QPixmap, QMouseEvent, QImage, QPainter, QColor, QPen, QBrush, QCursor, QIcon, QPainterPath, QFont
+from PyQt6.QtCore import Qt, QPoint, QPointF, QTimer,  QThread, pyqtSignal, QSize, QRectF, QObject, QLineF
+import gc
+import math
+import traceback
+
+class LabeledRectangle(QGraphicsRectItem):
+    def __init__(self, x, y, width, height, label="", color = None):
+        super().__init__(x, y, width, height)
+        self.label = label
+        self.color = color if color else QColor(255, 0, 0)   # Red outline
+
+        self.setPen(QPen(QColor(self.color), 2))
+        
+        # Create label text item
+        self.text_item = QGraphicsTextItem(self.label, self)
+        self.text_item.setDefaultTextColor(QColor(255, 255, 255))
+        self.text_item.setFont(QFont("Arial", 10, QFont.Weight.Bold))
+        
+        # Position the text at the top-left corner of the rectangle
+        self.text_item.setPos(x, y - 20)  # Slightly above the rectangle
+        
+        # Make the rectangle selectable and movable
+        self.setFlag(QGraphicsRectItem.GraphicsItemFlag.ItemIsSelectable, True)
+        self.setFlag(QGraphicsRectItem.GraphicsItemFlag.ItemIsMovable, True)
+    
+    def set_color(self, color):
+        """Update the rectangle color"""
+        self.color = color
+        self.setPen(QPen(QColor(self.color), 2))
+    
+    def set_label(self, label):
+        """Update the rectangle label"""
+        self.label = label
+        if hasattr(self, 'text_item'):
+            self.text_item.setPlainText(label)
+            
+    def set_thickness(self, thickness):
+        """Update the rectangle thickness"""
+        self.thickness = thickness
+        self.setPen(QPen(QColor(self.color), self.thickness))
+    
+    def get_color(self):
+        """Get the current color"""
+        return self.color
+    
+    def get_label(self):
+        """Get the current label"""
+        return self.label
+    
+    def boundingRect(self):
+        """Return the bounding rectangle including the text"""
+        rect = super().boundingRect()
+        if hasattr(self, 'text_item'):
+            text_rect = self.text_item.boundingRect()
+            text_rect.translate(self.text_item.pos())
+            rect = rect.united(text_rect)
+        return rect
+    
+    def contains(self, point):
+        """Check if point is within the rectangle (for click detection)"""
+        return super().contains(point)
+    
+    def itemChange(self, change, value):
+        """Handle item changes (like position changes)"""
+        if change == QGraphicsRectItem.GraphicsItemChange.ItemPositionChange and hasattr(self, 'text_item'):
+            # Update text position when rectangle moves
+            new_pos = value
+            self.text_item.setPos(new_pos.x(), new_pos.y() - 20)
+        return super().itemChange(change, value)

PyImageLabeling/old_version/models/MagicSettingsDialog.py

@@ -0,0 +1,119 @@
+import cv2
+import numpy as np
+import sys
+import os
+import time
+from PyQt6.QtWidgets import (
+    QGraphicsEllipseItem, QComboBox, QGraphicsRectItem, QInputDialog, QGraphicsItem, QGraphicsItemGroup, QGraphicsPixmapItem, QGraphicsOpacityEffect, QGraphicsView, QGraphicsScene, QApplication, QMainWindow, QLabel, QVBoxLayout, QPushButton, 
+    QFileDialog, QWidget, QMessageBox, QHBoxLayout, QColorDialog, QDialog, QSlider, QFormLayout, QDialogButtonBox, QGridLayout, QProgressDialog, QCheckBox, QSpinBox, QSplashScreen, QMenu
+)
+from PyQt6.QtGui import QPixmap, QMouseEvent, QImage, QPainter, QColor, QPen, QBrush, QCursor, QIcon, QPainterPath, QFont
+from PyQt6.QtCore import Qt, QPoint, QPointF, QTimer,  QThread, pyqtSignal, QSize, QRectF, QObject, QLineF
+import gc
+import math
+import traceback
+
+class MagicSettingsDialog(QDialog):
+    def __init__(self, parent=None, current_tolerance=20, current_timeout=5, current_max_points=100000):
+        super().__init__(parent)
+        self.setWindowTitle("Magic Pen Settings")
+        self.tolerance = current_tolerance
+        self.max_point = current_max_points
+        layout = QVBoxLayout()
+        
+        # Create a form layout for the controls
+        form_layout = QFormLayout()
+        
+        # Tolerance slider
+        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)
+        form_layout.addRow("Tolerance:", self.tolerance_slider)
+        
+        # Tolerance spinbox
+        self.tolerance_spinbox = QSpinBox()
+        self.tolerance_spinbox.setRange(0, 100)
+        self.tolerance_spinbox.setValue(self.tolerance)
+        
+        # Connect slider and spinbox
+        self.tolerance_spinbox.valueChanged.connect(self.tolerance_slider.setValue)
+        self.tolerance_slider.valueChanged.connect(self.tolerance_spinbox.setValue)
+        
+        form_layout.addRow("Value:", self.tolerance_spinbox)
+        
+        # Add a description of what different tolerance values mean
+        tolerance_help = QLabel("Lower values = more precise color matching\nHigher values = more inclusive fill")
+        tolerance_help.setStyleSheet("color: #666; font-style: italic;")
+        form_layout.addRow("", tolerance_help)
+        
+        # Add form layout to main layout
+        layout.addLayout(form_layout)
+        
+        # Add timeout setting
+        timeout_layout = QHBoxLayout()
+        timeout_label = QLabel("Timeout (seconds):")
+        self.timeout_spinbox = QSpinBox()
+        self.timeout_spinbox.setRange(1, 60)
+        self.timeout_spinbox.setValue(current_timeout)
+        timeout_layout.addWidget(timeout_label)
+        timeout_layout.addWidget(self.timeout_spinbox)
+        layout.addLayout(timeout_layout)
+        
+        # Add MAX_POINTS_LIMIT setting
+        layout.addSpacing(10)
+        points_limit_layout = QVBoxLayout()
+        
+        points_limit_label = QLabel("Maximum Points Limit:")
+        points_limit_layout.addWidget(points_limit_label)
+        
+        points_slider_layout = QHBoxLayout()
+        
+        # Points limit slider
+        self.points_limit_slider = QSlider(Qt.Orientation.Horizontal)
+        self.points_limit_slider.setRange(5000, 500000)
+        self.points_limit_slider.setValue(self.max_point)
+        self.points_limit_slider.setTickPosition(QSlider.TickPosition.TicksBelow)
+        self.points_limit_slider.setTickInterval(50000)
+        
+        # Points limit spinbox
+        self.points_limit_spinbox = QSpinBox()
+        self.points_limit_spinbox.setRange(5000, 500000)
+        self.points_limit_spinbox.setValue(self.max_point)
+        self.points_limit_spinbox.setSingleStep(5000)
+        
+        # Connect slider and spinbox
+        self.points_limit_spinbox.valueChanged.connect(self.points_limit_slider.setValue)
+        self.points_limit_slider.valueChanged.connect(self.points_limit_spinbox.setValue)
+        
+        points_slider_layout.addWidget(self.points_limit_slider)
+        points_slider_layout.addWidget(self.points_limit_spinbox)
+        points_limit_layout.addLayout(points_slider_layout)
+        
+        # Add description for points limit
+        points_limit_help = QLabel("Higher values allow filling larger areas but may use more memory")
+        points_limit_help.setStyleSheet("color: #666; font-style: italic;")
+        points_limit_layout.addWidget(points_limit_help)
+        
+        layout.addLayout(points_limit_layout)
+        
+        # Add spacer
+        layout.addSpacing(10)
+        
+        # Add 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 get_tolerance(self):
+        return self.tolerance_slider.value()
+        
+    def get_timeout(self):
+        return self.timeout_spinbox.value()
+        
+    def get_max_points_limit(self):
+        return self.points_limit_spinbox.value()

PyImageLabeling/old_version/models/OverlayOpacityDialog.py

@@ -0,0 +1,63 @@
+import cv2
+import numpy as np
+import sys
+import os
+import time
+from PyQt6.QtWidgets import (
+    QGraphicsEllipseItem, QComboBox, QGraphicsRectItem, QInputDialog, QGraphicsItem, QGraphicsItemGroup, QGraphicsPixmapItem, QGraphicsOpacityEffect, QGraphicsView, QGraphicsScene, QApplication, QMainWindow, QLabel, QVBoxLayout, QPushButton, 
+    QFileDialog, QWidget, QMessageBox, QHBoxLayout, QColorDialog, QDialog, QSlider, QFormLayout, QDialogButtonBox, QGridLayout, QProgressDialog, QCheckBox, QSpinBox, QSplashScreen, QMenu
+)
+from PyQt6.QtGui import QPixmap, QMouseEvent, QImage, QPainter, QColor, QPen, QBrush, QCursor, QIcon, QPainterPath, QFont
+from PyQt6.QtCore import Qt, QPoint, QPointF, QTimer,  QThread, pyqtSignal, QSize, QRectF, QObject, QLineF
+import gc
+import math
+import traceback
+
+class OverlayOpacityDialog(QDialog):
+    def __init__(self, parent=None, current_opacity=255):
+        super().__init__(parent)
+        self.setWindowTitle("Overlay Opacity")
+        
+        layout = QFormLayout()
+
+        # Opacity slider
+        self.slider = QSlider(Qt.Orientation.Horizontal)
+        self.slider.setRange(0, 255)
+        self.slider.setValue(current_opacity)
+        self.slider.setTickPosition(QSlider.TickPosition.TicksBelow)
+        self.slider.setTickInterval(25)
+        layout.addRow("Opacity:", self.slider)
+        
+        # Opacity spinbox
+        self.opacity_spinbox = QSpinBox()
+        self.opacity_spinbox.setRange(0, 255)
+        self.opacity_spinbox.setValue(current_opacity)
+        layout.addRow("", self.opacity_spinbox)
+        
+        # Sync slider and spinbox
+        self.opacity_spinbox.valueChanged.connect(self.slider.setValue)
+        self.slider.valueChanged.connect(self.opacity_spinbox.setValue)
+
+        # Preset buttons layout
+        preset_layout = QHBoxLayout()
+        presets = [(25, "25%"), (50, "50%"), (75, "75%"), (100, "100%")]
+        for value, label in presets:
+            btn = QPushButton(label)
+            btn.setFixedHeight(25)
+            btn.setProperty("class", "preset")
+            btn.clicked.connect(lambda checked, v=value: self.set_preset(v))
+            preset_layout.addWidget(btn)
+        layout.addRow("", preset_layout)
+        
+        # Buttons
+        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 set_preset(self, percentage):
+        """Set opacity to a preset percentage value"""
+        value = int((percentage / 100) * 255)
+        self.slider.setValue(value)

PyImageLabeling/old_version/models/PaintSettingsDialog.py

@@ -0,0 +1,289 @@
+import cv2
+import numpy as np
+import sys
+import os
+import time
+from PyQt6.QtWidgets import (
+    QGraphicsEllipseItem, QComboBox, QGraphicsRectItem, QInputDialog, QGraphicsItem, QGraphicsItemGroup, QGraphicsPixmapItem, QGraphicsOpacityEffect, QGraphicsView, QGraphicsScene, QApplication, QMainWindow, QLabel, QVBoxLayout, QPushButton, 
+    QFileDialog, QWidget, QMessageBox, QHBoxLayout, QColorDialog, QDialog, QSlider, QFormLayout, QDialogButtonBox, QGridLayout, QProgressDialog, QCheckBox, QSpinBox, QSplashScreen, QMenu, QLineEdit
+)
+from PyQt6.QtGui import QPixmap, QMouseEvent, QImage, QPainter, QColor, QPen, QBrush, QCursor, QIcon, QPainterPath, QFont
+from PyQt6.QtCore import Qt, QPoint, QPointF, QTimer,  QThread, pyqtSignal, QSize, QRectF, QObject, QLineF
+import gc
+import math
+import traceback
+import json
+
+class LabelPaintPropertiesDialog(QDialog):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Label Properties")
+        self.setMinimumWidth(300)
+        self.setStyleSheet("""
+            QDialog {
+                background-color: #000000;
+                color: white;
+                border: 1px solid #444444;
+            }
+            QLabel {
+                color: white;
+                font-size: 14px;
+            }
+        """)
+
+        layout = QVBoxLayout()
+
+        self.label_name = QLabel("Label: ")
+        self.label_color = QLabel("Color: ")
+        self.label_radius = QLabel("Radius: ")
+        self.label_opacity = QLabel("Opacity: ")
+
+        layout.addWidget(self.label_name)
+        layout.addWidget(self.label_color)
+        layout.addWidget(self.label_radius)
+        layout.addWidget(self.label_opacity)
+
+        self.setLayout(layout)
+
+    def update_properties(self, label, color, radius, opacity):
+        self.label_name.setText(f"Label: {label}")
+        self.label_color.setText(f"Color: {color.name()}")
+        self.label_radius.setText(f"Radius: {radius}")
+        self.label_opacity.setText(f"Opacity: {opacity}")
+
+class LabelPropertiesManager:
+    """Manages saving and loading of label properties"""
+    
+    def __init__(self, properties_file="label_paint_properties.json"):
+        self.properties_file = properties_file
+        self.label_properties = {}
+        self.load_properties()
+    
+    def save_properties(self):
+        """Save label properties to JSON file"""
+        try:
+            # Convert QColor objects to serializable format
+            serializable_props = {}
+            for label, props in self.label_properties.items():
+                color = props['color']
+                if isinstance(color, str):
+                    color = QColor(color)  # Convert string to QColor if needed
+                serializable_props[label] = {
+                    'color': color.name(),  # Safely get hex color
+                    'radius': props['radius'],
+                    'opacity': props['opacity']
+                }
+            
+            with open(self.properties_file, 'w') as f:
+                json.dump(serializable_props, f, indent=2)
+            return True
+        except Exception as e:
+            print(f"Error saving label properties: {e}")
+            return False
+    
+    def load_properties(self):
+        """Load label properties from JSON file"""
+        try:
+            if os.path.exists(self.properties_file):
+                with open(self.properties_file, 'r') as f:
+                    data = json.load(f)
+                
+                # Convert hex strings back to QColor objects
+                for label, props in data.items():
+                    self.label_properties[label] = {
+                        'color': QColor(props['color']),
+                        'radius': props['radius'],
+                        'opacity': props['opacity']
+                    }
+            return True
+        except Exception as e:
+            print(f"Error loading label properties: {e}")
+            return False
+    
+    def add_label_property(self, label, color, radius, opacity):
+        """Add or update a label property"""
+        self.label_properties[label] = {
+            'color': color,
+            'radius': radius,
+            'opacity': opacity
+        }
+        self.save_properties()
+    
+    def get_label_property(self, label):
+        """Get properties for a specific label"""
+        return self.label_properties.get(label, None)
+    
+    def get_all_labels(self):
+        """Get all saved label names"""
+        return list(self.label_properties.keys())
+    
+    def remove_label_property(self, label):
+        """Remove a label property"""
+        if label in self.label_properties:
+            del self.label_properties[label]
+            self.save_properties()
+            return True
+        return False
+
+class PaintSettingsDialog(QDialog):
+    saved_labels = {}
+    label_manager = LabelPropertiesManager()
+    def __init__(self, parent=None, current_color=None, current_radius=None, current_opacity=None, current_label=None):
+        super().__init__(parent)
+        self.setWindowTitle("Paint Settings")
+        
+        # Initialize with current values or defaults
+        self.color = current_color if current_color else QColor(255, 0, 0)
+        self.radius = current_radius if current_radius else 3
+        self.opacity = current_opacity if current_opacity else 255
+        self.label = current_label if current_label else ""
+        
+        layout = QFormLayout()
+        
+        # Label selection/input - MODIFIED
+        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.currentTextChanged.connect(self.on_label_selected)
+        label_layout.addWidget(self.label_combo)
+        
+        layout.addRow("Label:", label_layout)
+
+        # Color selection
+        self.color_button = QPushButton("Choose Color")
+        self.color_button.clicked.connect(self.choose_color)
+        self.update_color_button()  # NEW METHOD CALL
+        layout.addRow("Color:", self.color_button)
+        
+        # Radius slider
+        self.radius_slider = QSlider(Qt.Orientation.Horizontal)
+        self.radius_slider.setRange(1, 100)
+        self.radius_slider.setValue(self.radius)
+        self.radius_slider.setTickPosition(QSlider.TickPosition.TicksBelow)
+        self.radius_slider.setTickInterval(10)
+        layout.addRow("Radius:", self.radius_slider)
+        
+        self.radius_spinbox = QSpinBox()
+        self.radius_spinbox.setRange(1, 100)
+        self.radius_spinbox.setValue(self.radius)
+        self.radius_spinbox.valueChanged.connect(self.radius_slider.setValue)
+        self.radius_slider.valueChanged.connect(self.radius_spinbox.setValue)
+        layout.addRow("", self.radius_spinbox)
+        
+        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 on_label_selected(self, text):
+        """Handle label selection from combo box"""
+        if text:
+            label_props = self.label_manager.get_label_property(text)
+            if label_props:
+                # Load saved settings for this label
+                self.color = label_props['color']
+                self.radius = label_props['radius']
+                self.opacity = label_props['opacity']
+                
+                # Update UI elements
+                self.radius_slider.setValue(self.radius)
+                self.radius_spinbox.setValue(self.radius)
+                self.update_color_button()
+    
+    def update_color_button(self):
+        """Update color button appearance to show current 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 choose_color(self):
+        color = QColorDialog.getColor(initial=self.color)
+        if color.isValid():
+            self.color = color
+            self.update_color_button()  # NEW METHOD CALL
+
+    def get_settings(self):
+        self.radius = self.radius_slider.value()
+        self.label = self.label_combo.currentText().strip()
+        
+        # Save label settings if label is not empty - NEW FUNCTIONALITY
+        if self.label:
+            self.label_manager.add_label_property(self.label, self.color, self.radius, self.opacity)
+        
+        return self.color, self.radius, self.opacity, self.label
+    
+    def add_overlay(self, overlay_pixmap):
+        """Add an overlay pixmap that stays aligned with the base image"""
+        if not self.base_pixmap:
+            return False
+            
+        # Remove existing overlay if any
+        self.remove_overlay()
+        
+        # Ensure overlay matches base image dimensions
+        base_size = self.base_pixmap.size()
+        if overlay_pixmap.size() != base_size:
+            overlay_pixmap = overlay_pixmap.scaled(
+                base_size, 
+                Qt.AspectRatioMode.IgnoreAspectRatio,
+                Qt.TransformationMode.SmoothTransformation
+            )
+        
+        # Create overlay pixmap item
+        self.overlay_pixmap_item = self.scene.addPixmap(overlay_pixmap)
+        self.overlay_pixmap_item.setZValue(1)  # Above base image
+        self.overlay_pixmap_item.setPos(0, 0)  # Same position as base image
+        
+        # Set opacity (default 50%)
+        if not hasattr(self, 'overlay_opacity'):
+            self.overlay_opacity = 128
+        self.overlay_pixmap_item.setOpacity(self.overlay_opacity / 255.0)
+        
+        # Update scene
+        self.scene.update()
+        return True
+    
+    def set_overlay_opacity(self, opacity):
+        """Set opacity of the overlay layer (0-255)"""
+        if self.overlay_pixmap_item:
+            self.overlay_opacity = max(0, min(255, opacity))
+            self.overlay_pixmap_item.setOpacity(self.overlay_opacity / 255.0)
+            self.scene.update()
+            return True
+        return False
+    
+    def toggle_overlay_visibility(self):
+        """Toggle visibility of the overlay"""
+        if self.overlay_pixmap_item:
+            is_visible = self.overlay_pixmap_item.isVisible()
+            self.overlay_pixmap_item.setVisible(not is_visible)
+            self.scene.update()
+            return not is_visible
+        return False
+    
+    def remove_overlay(self):
+        """Remove overlay if exists"""
+        if self.overlay_pixmap_item:
+            self.scene.removeItem(self.overlay_pixmap_item)
+            self.overlay_pixmap_item = None
+            self.scene.update()
+            return True
+        return False

PyImageLabeling/old_version/models/PointItem.py

@@ -0,0 +1,66 @@
+import cv2
+import numpy as np
+import sys
+import os
+import time
+from PyQt6.QtWidgets import (
+    QGraphicsEllipseItem, QComboBox, QGraphicsRectItem, QInputDialog, QGraphicsItem, QGraphicsItemGroup, QGraphicsPixmapItem, QGraphicsOpacityEffect, QGraphicsView, QGraphicsScene, QApplication, QMainWindow, QLabel, QVBoxLayout, QPushButton, 
+    QFileDialog, QWidget, QMessageBox, QHBoxLayout, QColorDialog, QDialog, QSlider, QFormLayout, QDialogButtonBox, QGridLayout, QProgressDialog, QCheckBox, QSpinBox, QSplashScreen, QMenu
+)
+from PyQt6.QtGui import QPixmap, QMouseEvent, QImage, QPainter, QColor, QPen, QBrush, QCursor, QIcon, QPainterPath, QFont
+from PyQt6.QtCore import Qt, QPoint, QPointF, QTimer,  QThread, pyqtSignal, QSize, QRectF, QObject, QLineF
+import gc
+import math
+import traceback
+
+class PointItem(QGraphicsEllipseItem):
+    """Custom graphics item for representing a point/dot with fixed size"""
+    def __init__(self, label, x, y, radius, color, opacity=100):
+        # Store properties
+        self.fixed_label = label
+        self.fixed_x = x
+        self.fixed_y = y
+        self._fixed_radius = radius 
+        self.fixed_color = QColor(color)
+        self.fixed_opacity = int(255 * opacity / 100)
+        
+        # Create the ellipse using the fixed radius
+        super().__init__(x - radius, y - radius, radius * 2, radius * 2)
+        
+        self.setPen(QPen(Qt.PenStyle.NoPen))
+        self.fixed_color.setAlpha(self.fixed_opacity)
+        self.setBrush(QBrush(self.fixed_color))
+        self.setZValue(10)  # Ensure it's drawn above the image
+        
+        # Disable any modifications
+        self.setFlag(QGraphicsItem.GraphicsItemFlag.ItemIsMovable, False)
+        self.setFlag(QGraphicsItem.GraphicsItemFlag.ItemIsSelectable, False)
+    
+    def get_position(self):
+        """Always return the original center point"""
+        return QPointF(self.fixed_x, self.fixed_y)
+    
+    def boundingRect(self):
+        """Always return the original bounding rect with fixed radius"""
+        return QRectF(self.fixed_x - self._fixed_radius, 
+                      self.fixed_y - self._fixed_radius, 
+                      self._fixed_radius * 2, 
+                      self._fixed_radius * 2)
+    
+    def shape(self):
+        """Ensure the shape remains fixed"""
+        path = QPainterPath()
+        path.addEllipse(QRectF(self.fixed_x - self._fixed_radius, 
+                                self.fixed_y - self._fixed_radius, 
+                                self._fixed_radius * 2, 
+                                self._fixed_radius * 2))
+        return path
+    
+    def paint(self, painter, option, widget=None):
+        """Recreate the original ellipse with fixed radius and color"""
+        painter.setBrush(QBrush(self.fixed_color))
+        painter.setPen(QPen(Qt.PenStyle.NoPen))
+        painter.drawEllipse(QRectF(self.fixed_x - self._fixed_radius, 
+                                   self.fixed_y - self._fixed_radius, 
+                                   self._fixed_radius * 2, 
+                                   self._fixed_radius * 2))