PyImageLabeling 1.0.0__py3-none-any.whl

PyImageLabeling/old_version/models/tools/MagicPenTool.py

@@ -0,0 +1,199 @@
+from PyQt6.QtCore import Qt, QPointF
+from PyQt6.QtGui import QColor
+from PyQt6.QtWidgets import QProgressDialog, QMessageBox, QApplication
+from models.ProcessWorker import ProcessWorker
+from models.PointItem import PointItem
+import time
+
+class MagicPenTool:
+    def fill_shape(self, scene_pos):
+        """Fill a shape with points using magic pen"""
+        if not self.base_pixmap:
+            return
+            
+        # Create progress dialog
+        progress = QProgressDialog("Processing magic pen fill...", "Cancel", 0, 0, self)
+        progress.setWindowModality(Qt.WindowModality.WindowModal)
+        progress.show()
+        
+        # Create worker thread for fill operation
+        self.worker = ProcessWorker(
+            self._fill_shape_worker, 
+            args=[scene_pos], 
+            timeout=self.process_timeout
+        )
+        self.worker.finished.connect(
+            lambda points: self._handle_fill_complete(points, progress)
+        )
+        self.worker.error.connect(
+            lambda error: self._handle_fill_error(error, progress)
+        )
+        self.worker.start()
+
+    def _fill_shape_worker(self, scene_pos):
+        """Worker function to fill shape (runs in separate thread, with hard limits)"""
+        if not self.raw_image:
+            return []
+            
+        image_x = int(scene_pos.x())
+        image_y = int(scene_pos.y())
+    
+        width, height = self.raw_image.width(), self.raw_image.height()
+    
+        if not (0 <= image_x < width and 0 <= image_y < height):
+            return []
+            
+        # Obtenir la couleur cible
+        target_color = QColor(self.raw_image.pixel(image_x, image_y))
+        target_hue = target_color.hue()
+        target_sat = target_color.saturation()
+        target_val = target_color.value()
+        tolerance = self.magic_pen_tolerance
+    
+        points_to_create = []
+        visited = set()
+        start_time = time.time()
+    
+        MAX_POINTS_LIMIT = self.max_points_limite
+        directions = [
+            (1, 0), (-1, 0), (0, 1), (0, -1),
+            (1, 1), (-1, -1), (1, -1), (-1, 1)
+        ]
+    
+        from collections import deque
+        queue = deque([(image_x, image_y)])
+    
+        try:
+            while queue:
+                if time.time() - start_time > self.process_timeout:
+                    print(f"Timeout atteint ({self.process_timeout}s). Annulation du remplissage.")
+                    return []  # Retourne une liste vide → pas de remplissage
+
+                if len(points_to_create) >= MAX_POINTS_LIMIT:
+                    print(f"Trop de points ({MAX_POINTS_LIMIT}). Annulation du remplissage.")
+                    return []  # Retourne une liste vide → pas de remplissage
+    
+                x, y = queue.popleft()
+                if (x, y) in visited:
+                    continue
+    
+                visited.add((x, y))
+    
+                if not (0 <= x < width and 0 <= y < height):
+                    continue
+    
+                # Vérification de la couleur avec la tolérance
+                current_color = QColor(self.raw_image.pixel(x, y))
+                current_hue = current_color.hue()
+                current_sat = current_color.saturation()
+                current_val = current_color.value()
+    
+                if target_hue == -1 or current_hue == -1:
+                    if abs(current_val - target_val) > tolerance:
+                        continue
+                else:
+                    hue_diff = min(abs(current_hue - target_hue), 
+                                  360 - abs(current_hue - target_hue))
+    
+                    if (hue_diff > tolerance or
+                        abs(current_sat - target_sat) > tolerance or
+                        abs(current_val - target_val) > tolerance):
+                        continue
+    
+                # Ajouter le point
+                points_to_create.append((x, y))
+    
+                # Ajouter les voisins
+                for dx, dy in directions:
+                    new_x, new_y = x + dx, y + dy
+                    if (new_x, new_y) not in visited:
+                        queue.append((new_x, new_y))
+    
+        except Exception as e:
+            print(f"Erreur pendant le remplissage : {e}")
+    
+        return points_to_create
+    
+    def _handle_fill_complete(self, point_coords, progress):
+        """Handle completion of fill operation"""
+        if not progress:
+            return
+            
+        progress.close()
+        
+        if not point_coords:
+            return
+            
+        # Prepare for UI update and point creation
+        QApplication.setOverrideCursor(Qt.CursorShape.WaitCursor)
+        
+        try:
+            # Capture point parameters IMMEDIATELY at the time of fill
+            current_point_radius = self.point_radius
+            current_point_color = self.point_color
+            current_point_opacity = self.point_opacity
+            current_point_label = self.point_label
+            
+            # Create a batch of points
+            chunk_size = 5000  # Process in larger batches for efficiency
+            all_new_points = []
+            
+            for i in range(0, len(point_coords), chunk_size):
+                chunk = point_coords[i:i + chunk_size]
+                batch_points = []
+                
+                # Update progress dialog
+                if progress and not progress.wasCanceled():
+                    progress.setValue(i)
+                    progress.setMaximum(len(point_coords))
+                    progress.setLabelText(f"Creating points: {i}/{len(point_coords)}")
+                    QApplication.processEvents()
+                
+                for x, y in chunk:
+                    try:
+                        point_item = PointItem(
+                            current_point_label,
+                            x, y, 
+                            current_point_radius,   # Use captured radius
+                            current_point_color,    # Use captured color
+                            current_point_opacity   # Use captured opacity
+                        )
+                        self.scene.addItem(point_item)
+                        self.points.append(point_item)
+                        batch_points.append(point_item)
+                    except Exception as e:
+                        print(f"Error creating point at ({x}, {y}): {e}")
+                        continue
+                
+                all_new_points.extend(batch_points)
+                
+                # Allow UI to update between chunks
+                QApplication.processEvents()
+            
+            # Store for undo history
+            if all_new_points:
+                self.points_history.append(all_new_points)
+                
+            # Update the points overlay
+            self.update_points_overlay()
+        except Exception as e:
+            print(f"Error during fill completion: {e}")
+        finally:
+            QApplication.restoreOverrideCursor()
+
+    def _handle_fill_error(self, error, progress):
+        """Handle errors during fill operation"""
+        if progress:
+            progress.close()
+        QMessageBox.warning(self, "Error", f"Magic pen fill operation failed: {error}")
+
+
+    def toggle_magic_pen(self, enabled):
+        """Toggle magic pen mode on/off"""
+        self.magic_pen_mode = enabled
+        if enabled:
+            self.paint_mode = False
+            self.erase_mode = False
+            self.setCursor(Qt.CursorShape.CrossCursor)
+        else:
+            self.setCursor(Qt.CursorShape.ArrowCursor)

PyImageLabeling/old_version/models/tools/OverlayTool.py

@@ -0,0 +1,179 @@
+from PyQt6.QtCore import Qt, QRectF
+from PyQt6.QtGui import QPixmap, QBrush, QPainter, QColor
+from models.OverlayOpacityDialog import OverlayOpacityDialog
+
+class OverlayTool:
+    def add_overlay(self, overlay_pixmap):
+        """
+        Add an overlay layer on top of the base image.
+        
+        Parameters:
+        overlay_pixmap (QPixmap): The overlay image to be added
+        """
+        # Remove any existing overlay first
+        self.remove_overlay()
+        
+        # Scale the overlay to match the base image size if needed
+        if self.base_pixmap and overlay_pixmap.size() != self.base_pixmap.size():
+            overlay_pixmap = overlay_pixmap.scaled(
+                self.base_pixmap.size(),
+                Qt.AspectRatioMode.IgnoreAspectRatio,
+                Qt.TransformationMode.SmoothTransformation
+            )
+        
+        # Create a pixmap item for the overlay and add it to the scene
+        self.overlay_pixmap_item = self.scene.addPixmap(overlay_pixmap)
+        
+        # Position the overlay to align with the base image
+        if self.pixmap_item:
+            self.overlay_pixmap_item.setPos(self.pixmap_item.pos())
+        
+        # Set the overlay above the base image
+        self.overlay_pixmap_item.setZValue(1)  # Base image is typically at Z=0
+        
+        # Set default overlay opacity (semi-transparent)
+        self.overlay_opacity = 128  # 0-255 range, 128 is 50% opacity
+        self.overlay_pixmap_item.setOpacity(self.overlay_opacity / 255.0)
+        
+        # Store a reference to the original overlay pixmap
+        self.overlay_original_pixmap = overlay_pixmap
+        
+        # Update the scene
+        self.scene.update()
+        
+        return True
+
+    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
+            return True
+        return False
+
+    def show_opacity_dialog(self):
+        """Show or create the opacity dialog"""
+        # Only show if there's an overlay or points
+        if not (self.overlay_pixmap_item or self.points):
+            return
+                
+        # Always create a fresh dialog with the current opacity value
+        # This ensures the dialog always shows the current value
+        current_opacity = self.points_opacity
+        
+        # Close any existing dialog
+        if hasattr(self, "opacity_dialog") and self.opacity_dialog:
+            self.opacity_dialog.close()
+            
+        # Create new dialog with current opacity value
+        self.opacity_dialog = OverlayOpacityDialog(self, current_opacity)
+        self.opacity_dialog.show()
+
+    def update_overlay_opacity(self, value):
+        """Updates the opacity for all points and overlay with consistent rendering for overlapping points"""
+        
+        self.points_opacity = value  # Store the opacity value
+        
+        # If there are no points, just update the overlay opacity if it exists
+        if not self.points:
+            if self.overlay_pixmap_item:
+                self.overlay_opacity = value
+                self.overlay_pixmap_item.setOpacity(value / 255.0)
+            return
+        
+        # Update the unified point overlay
+        self.update_points_overlay()
+
+    def update_points_overlay(self):
+        """Creates or updates the unified points overlay using batched rendering with improved synchronization"""
+        # Skip if no base pixmap
+        if not self.base_pixmap:
+            return
+        
+        # Get the base image dimensions
+        width = self.base_pixmap.width()
+        height = self.base_pixmap.height()
+        
+        # Create a transparent pixmap for the points if it doesn't exist already
+        if not hasattr(self, 'points_pixmap') or self.points_pixmap is None:
+            self.points_pixmap = QPixmap(width, height)
+            self.points_pixmap.fill(Qt.GlobalColor.transparent)
+            self.last_rendered_points_count = 0
+        
+        # Handle undo operations - rebuild the pixmap if points were removed
+        if hasattr(self, 'last_rendered_points_count') and self.last_rendered_points_count > len(self.points):
+            # Reset the pixmap and force full redraw
+            self.points_pixmap.fill(Qt.GlobalColor.transparent)
+            self.last_rendered_points_count = 0
+        
+        # Always render all points when last_rendered_points_count is 0
+        if self.last_rendered_points_count == 0:
+            points_to_render = self.points
+        else:
+            # Only render the new points that haven't been rendered yet
+            points_to_render = self.points[self.last_rendered_points_count:]
+        
+        # Create a painter even if there are no new points to render
+        # This ensures the pixmap is properly updated when undoing to empty state
+        painter = QPainter(self.points_pixmap)
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing, True)
+        painter.setCompositionMode(QPainter.CompositionMode.CompositionMode_Source)
+        
+        # Store the last used color and brush to avoid unnecessary brush changes
+        last_color = None
+        
+        # Draw only the new points onto the unified pixmap
+        for point_item in points_to_render:
+            pos = point_item.get_position()
+            radius = point_item._fixed_radius  # Use the stored radius
+            
+            # Get the point's individual color (if points can have different colors)
+            if hasattr(point_item, '_color'):
+                current_color = point_item._color
+            else:
+                current_color = self.point_color
+                
+            # Only change the brush if the color changes
+            if current_color != last_color:
+                color = QColor(current_color)
+                painter.setBrush(QBrush(color))
+                painter.setPen(Qt.PenStyle.NoPen)  # No outline, just filled circles
+                last_color = current_color
+                
+            painter.drawEllipse(pos, radius, radius)
+            
+            # Ensure point is properly hidden
+            point_item.setVisible(False)
+    
+        painter.end()
+        
+        # Update our count of rendered points
+        self.last_rendered_points_count = len(self.points)
+        
+        # Create or update the overlay item rather than removing and recreating
+        if not hasattr(self, 'points_overlay_item') or self.points_overlay_item is None:
+            # Create new overlay item with the unified points
+            self.points_overlay_item = self.scene.addPixmap(self.points_pixmap)
+            self.points_overlay_item.setZValue(1)  # Above base image, below any other overlays
+        else:
+            # Update existing overlay with new pixmap
+            self.points_overlay_item.setPixmap(self.points_pixmap)
+        
+        # Apply current opacity
+        self.points_overlay_item.setOpacity(self.points_opacity / 255.0)
+        
+        # Calculate the region that needs updating
+        update_rect = QRectF()
+        for point in points_to_render:
+            pos = point.get_position()
+            r = point._fixed_radius
+            point_rect = QRectF(pos.x() - r, pos.y() - r, r * 2, r * 2)
+            if update_rect.isEmpty():
+                update_rect = point_rect
+            else:
+                update_rect = update_rect.united(point_rect)
+        
+        # Add a small margin and update only the changed area
+        if not update_rect.isEmpty():
+            update_rect.adjust(-2, -2, 2, 2)
+            self.scene.update(update_rect)

PyImageLabeling/old_version/models/tools/PaintTool.py

@@ -0,0 +1,68 @@
+from PyQt6.QtCore import Qt
+from models.PointItem import PointItem
+import numpy as np
+
+class PaintTool:
+    def add_point(self, scene_pos):
+        current_radius = self.point_radius
+        current_color = self.point_color
+        current_opacity = self.point_opacity
+        current_label = self.point_label
+        point_item = PointItem(
+            current_label,
+            scene_pos.x(), scene_pos.y(),
+            current_radius,
+            current_color,
+            current_opacity
+        )
+        self.scene.addItem(point_item)
+        point_item.setVisible(False)
+        self.points.append(point_item)
+        self.current_stroke.append(point_item)
+        self.update_points_overlay()
+
+    def draw_continuous_line(self, start_pos, end_pos):
+        if not start_pos or not end_pos:
+            return
+        current_point_radius = self.point_radius
+        current_point_color = self.point_color
+        current_point_opacity = self.point_opacity
+        current_point_label = self.point_label
+        distance = ((end_pos.x() - start_pos.x()) ** 2 + (end_pos.y() - start_pos.y()) ** 2) ** 0.5
+        num_steps = max(int(distance * 2), 1)
+        t_values = np.linspace(0, 1, num_steps + 1)
+        for t in t_values:
+            x = start_pos.x() + t * (end_pos.x() - start_pos.x())
+            y = start_pos.y() + t * (end_pos.y() - start_pos.y())
+            point_item = PointItem(
+                current_point_label,
+                x, y,
+                current_point_radius,
+                current_point_color,
+                current_point_opacity
+            )
+            self.scene.addItem(point_item)
+            point_item.setVisible(self.drawn_points_visible)
+            self.points.append(point_item)
+            self.current_stroke.append(point_item)
+        self.update_points_overlay()
+
+    def toggle_paint_mode(self, enabled):
+        self.paint_mode = enabled
+        if enabled:
+            self.erase_mode = False
+            self.magic_pen_mode = False
+            self.setCursor(Qt.CursorShape.CrossCursor)
+            self.setDragMode(self.DragMode.NoDrag)
+        else:
+            self.setCursor(Qt.CursorShape.ArrowCursor)
+            self.setDragMode(self.DragMode.ScrollHandDrag)
+
+    def clear_points(self):
+        self.points_history.append(self.points[:])
+        self.points = []
+        if hasattr(self, 'points_overlay_item') and self.points_overlay_item:
+            self.scene.removeItem(self.points_overlay_item)
+            self.points_overlay_item = None
+        self.points_pixmap = None
+        self.last_rendered_points_count = 0