PyImageLabeling 1.0.0__py3-none-any.whl

PyImageLabeling/old_version/models/tools/ContourTool.py

@@ -0,0 +1,279 @@
+from PyQt6.QtWidgets import QMessageBox, QProgressDialog
+from PyQt6.QtCore import Qt, QPointF, QPoint
+from PyQt6.QtGui import QPixmap, QImage
+from models.ProcessWorker import ProcessWorker
+from models.PointItem import PointItem
+import numpy as np
+import cv2
+import traceback
+
+class ContourTool:
+    def apply_contour(self):
+        """Detects contours from the base image and applies the contour layer with improved parameters."""
+        if not hasattr(self, 'base_pixmap') or self.base_pixmap is None:
+            msg_box = QMessageBox(self)
+            msg_box.setWindowTitle("Error")
+            msg_box.setText("No image loaded.")
+            msg_box.setStyleSheet("""
+                QMessageBox {
+                    background-color: #000000;  /* Pure black background */
+                    color: white;  /* White text */
+                    font-size: 14px;
+                    border: 1px solid #444444;
+                }
+                QLabel {
+                    color: white;  /* Ensures the message text is white */
+                    background-color: #000000;
+                }
+                QPushButton {
+                    background-color: #000000;  /* Black buttons */
+                    color: white;
+                    border: 1px solid #555555;
+                    border-radius: 5px;
+                    padding: 5px 10px;
+                }
+                QPushButton:hover {
+                    background-color: #222222;  /* Slightly lighter on hover */
+                }
+            """)
+            msg_box.exec() 
+            return
+    
+        # Get the pixmap data
+        image = self.base_pixmap.toImage()
+        width, height = image.width(), image.height()
+    
+        # Convert QImage to NumPy array
+        buffer = image.constBits()
+        buffer.setsize(height * width * 4)  # 4 channels (RGBA)
+        img_array = np.frombuffer(buffer, dtype=np.uint8).reshape((height, width, 4))
+    
+        # Convert to grayscale (use OpenCV)
+        gray = cv2.cvtColor(img_array, cv2.COLOR_RGBA2GRAY)
+        
+        # Apply Gaussian blur to reduce noise
+        blurred = cv2.GaussianBlur(gray, (5, 5), 0)
+    
+        # Apply Canny edge detection with adjusted parameters
+        edges = cv2.Canny(blurred, 50, 150)  # Lower thresholds for more sensitive detection
+        
+        # Apply slight dilation to connect nearby edges
+        kernel = np.ones((2, 2), np.uint8)
+        edges = cv2.dilate(edges, kernel, iterations=1)
+    
+        # Find contours with hierarchy to better handle nested shapes
+        contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_TC89_L1)
+        
+        # Filter out very small contours that might be noise
+        min_contour_area = 10  # Adjust based on your needs
+        contours = [cnt for cnt in contours if cv2.contourArea(cnt) > min_contour_area]
+    
+        # Save contours in image_label for later use
+        self.contours = contours
+    
+        # Create a transparent layer to visualize the contours (Blue lines)
+        contour_layer = np.zeros((height, width, 4), dtype=np.uint8)
+        cv2.drawContours(contour_layer, contours, -1, (0, 0, 255, 255), 1)
+    
+        # Convert NumPy array to QImage
+        contour_qimage = QImage(contour_layer.data, width, height, width * 4, QImage.Format.Format_RGBA8888)
+    
+        # Set the overlay in the image viewer
+        overlay_pixmap = QPixmap.fromImage(contour_qimage)
+        self.add_overlay(overlay_pixmap)
+    
+        # Mark that the contour layer is applied
+        self.contour_layer_applied = True
+    
+        msg_box = QMessageBox(self)
+        msg_box.setWindowTitle("Contour")
+        msg_box.setText("Contour layer applied successfully.")
+        msg_box.setStyleSheet("""
+            QMessageBox {
+                background-color: #000000;  /* Pure black background */
+                color: white;  /* White text */
+                font-size: 14px;
+                border: 1px solid #444444;
+            }
+            QLabel {
+                color: white;  /* Ensures the message text is white */
+                background-color: #000000;
+            }
+            QPushButton {
+                background-color: #000000;  /* Black buttons */
+                color: white;
+                border: 1px solid #555555;
+                border-radius: 5px;
+                padding: 5px 10px;
+            }
+            QPushButton:hover {
+                background-color: #222222;  /* Slightly lighter on hover */
+            }
+        """)
+        msg_box.exec() 
+
+    def fill_contour(self):
+        """Fill the contour clicked by the user."""
+        if not hasattr(self, "contour_layer_applied") or not self.contour_layer_applied:
+            QMessageBox.warning(self, "Error", "Contour layer is not applied.")
+            return
+    
+        if not hasattr(self, 'base_pixmap') or self.base_pixmap is None:
+            QMessageBox.warning(self, "Error", "No image loaded.")
+            return
+    
+        if not hasattr(self, "last_mouse_pos") or not self.last_mouse_pos:
+            QMessageBox.warning(self, "Error", "No position to fill. Click on an area first.")
+            return
+    
+        # Create progress dialog
+        progress = QProgressDialog("Processing...", "Cancel", 0, 0, self)
+        progress.setWindowModality(Qt.WindowModality.WindowModal)
+        progress.show()
+    
+        # Create worker thread for fill operation
+        self.worker = ProcessWorker(self._fill_contour_worker, args=[self.last_mouse_pos], timeout=self.process_timeout)
+        self.worker.finished.connect(lambda points: self._handle_fill_contour_complete(points, progress))
+        self.worker.error.connect(lambda error: self._handle_fill_contour_error(error, progress))
+        self.worker.start()
+
+    def _fill_contour_worker(self, pos):
+        """Worker function to perform the contour fill with improved gap tolerance."""
+        try:
+            if isinstance(pos, QPointF):
+                scene_pos = QPoint(int(pos.x()), int(pos.y()))
+            else:
+                scene_pos = pos
+    
+            scene_pos = self.mapToScene(scene_pos)
+    
+            item_pos = QPointF(0, 0)
+            if hasattr(self, 'pixmap_item') and self.pixmap_item:
+                item_pos = self.pixmap_item.pos()
+    
+            image_x = int(scene_pos.x() - item_pos.x())
+            image_y = int(scene_pos.y() - item_pos.y())
+    
+            if not hasattr(self, 'base_pixmap') or self.base_pixmap is None:
+                raise ValueError("No base pixmap available")
+    
+            width = self.base_pixmap.width()
+            height = self.base_pixmap.height()
+    
+            if not (0 <= image_x < width and 0 <= image_y < height):
+                raise ValueError("Click position outside image bounds")
+    
+            # Ensure contours are available
+            contours = self.contours
+            if not contours:
+                raise ValueError("No contours found")
+    
+            # Find the specific contour that contains the click position
+            target_contour = None
+            for contour in contours:
+                if cv2.pointPolygonTest(contour, (image_x, image_y), False) >= 0:
+                    target_contour = contour
+                    break
+    
+            if target_contour is None:
+                # If no direct contour contains the point, try nearby points within a tolerance
+                tolerance = 5  # Adjust this value based on desired gap tolerance
+                for dx in range(-tolerance, tolerance + 1):
+                    for dy in range(-tolerance, tolerance + 1):
+                        check_x = image_x + dx
+                        check_y = image_y + dy
+                        
+                        # Skip if out of bounds
+                        if not (0 <= check_x < width and 0 <= check_y < height):
+                            continue
+                            
+                        for contour in contours:
+                            if cv2.pointPolygonTest(contour, (check_x, check_y), False) >= 0:
+                                target_contour = contour
+                                break
+                        
+                        if target_contour is not None:
+                            break
+                            
+                    if target_contour is not None:
+                        break
+    
+            if target_contour is None:
+                raise ValueError("Click position is outside any detected contour (even with tolerance)")
+    
+            # Create a mask from the specific contour
+            mask = np.zeros((height, width), dtype=np.uint8)
+            cv2.drawContours(mask, [target_contour], 0, 255, -1)  # Fill the contour with white
+            
+            # Apply morphological closing to fill small gaps in the contour
+            kernel_size = 3  # Adjust based on the typical gap size
+            kernel = np.ones((kernel_size, kernel_size), np.uint8)
+            mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
+    
+            # Extract points inside the filled contour
+            filled_points = []
+            for y in range(height):
+                for x in range(width):
+                    if mask[y, x] == 255:
+                        filled_points.append(QPointF(float(x), float(y)))
+    
+            return filled_points
+    
+        except Exception as e:
+            print(f"Fill contour error: {type(e).__name__} - {str(e)}")
+            raise
+
+    def _handle_fill_contour_complete(self, new_points, progress):
+            """Handles the completion of the fill operation."""
+            try:
+                progress.close()
+        
+                if not new_points:
+                    QMessageBox.information(self, "Fill Complete", "No points were filled.")
+                    return
+        
+                # Ensure the ZoomableGraphicsView has the necessary attributes
+                if not hasattr(self, 'scene'):
+                    QMessageBox.warning(self, "Error", "Graphics view is not properly initialized.")
+                    return
+        
+                # Process points in chunks to avoid UI freezing
+                chunk_size = 10000
+                chunks = [new_points[i:i + chunk_size] for i in range(0, len(new_points), chunk_size)]
+        
+                # Ensure points and points_history attributes exist
+                if not hasattr(self, 'points'):
+                    self.image_label.points = []
+                if not hasattr(self, 'points_history'):
+                    self.image_label.points_history = []
+        
+                # Create point items and add to the image label
+                new_point_items = []
+                for chunk in chunks:
+                    chunk_items = []
+                    for point in chunk:
+                        point_item = PointItem(self.point_label, point.x(), point.y(), self.point_radius, self.point_color)
+                        chunk_items.append(point_item)
+        
+                    new_point_items.extend(chunk_items)
+        
+                # Add the new points to the existing points list
+                self.points.extend(new_point_items)
+        
+                # Add to points history for potential undo functionality
+                self.points_history.append(new_point_items)
+        
+                # Update the points overlay to reflect new points
+                if hasattr(self, 'update_points_overlay'):
+                    self.update_points_overlay()
+        
+                QMessageBox.information(self, "Fill Complete", f"Filled {len(new_points)} points.")
+        
+            except Exception as e:
+                QMessageBox.warning(self, "Rendering Error", f"Failed to render fill: {str(e)}")
+                print(f"Fill rendering error: {traceback.format_exc()}")
+        
+    def _handle_fill_contour_error(self, error, progress):
+        """Handles any errors that occur during the fill operation."""
+        progress.close()
+        QMessageBox.warning(self, "Error", f"Fill operation failed: {error}")

PyImageLabeling/old_version/models/tools/EraserTool.py

@@ -0,0 +1,290 @@
+from PyQt6.QtCore import QRectF, QPointF, QTimer, Qt
+from PyQt6.QtGui import QPainter
+
+class EraserTool:
+    def erase_point(self, scene_pos):
+        """
+        Highly optimized erase function that minimizes redraws for improved performance
+        with enhanced smoothness.
+        """
+        # Check if there are any points to erase or if we're in absolute erase mode
+        if not self.points and not (self.absolute_erase_mode and self.overlay_pixmap_item):
+            return
+        
+        # Calculate the eraser's squared radius (faster comparison)
+        eraser_size_squared = self.eraser_size ** 2
+        
+        # Track if we've made changes that require updates
+        needs_update = False
+        
+        # OPTIMIZATION: Batch erase operations without updating the display for each point
+        # Store the current eraser position for batch processing
+        if not hasattr(self, 'erase_positions'):
+            self.erase_positions = []
+        
+        # Add this position to the batch
+        self.erase_positions.append(scene_pos)
+        
+        # Create the current eraser rectangle for update tracking
+        eraser_rect = QRectF(
+            scene_pos.x() - self.eraser_size, 
+            scene_pos.y() - self.eraser_size,
+            self.eraser_size * 2, 
+            self.eraser_size * 2
+        )
+        
+        # Initialize or update the cumulative erase area
+        if not hasattr(self, 'current_erase_update_rect') or self.current_erase_update_rect is None:
+            self.current_erase_update_rect = QRectF(eraser_rect)
+        else:
+            self.current_erase_update_rect = self.current_erase_update_rect.united(eraser_rect)
+        
+        # Handle absolute erase mode immediately for better visual feedback
+        if self.absolute_erase_mode and self.overlay_pixmap_item:
+            overlay_pixmap = self.overlay_pixmap_item.pixmap()
+            painter = QPainter(overlay_pixmap)
+            painter.setRenderHint(QPainter.RenderHint.Antialiasing, True)
+            painter.setCompositionMode(QPainter.CompositionMode.CompositionMode_Clear)
+            painter.setPen(Qt.PenStyle.NoPen)
+            painter.setBrush(Qt.GlobalColor.black)
+            
+            # Draw with softer edges for smoother erasing
+            painter.drawEllipse(scene_pos, self.eraser_size, self.eraser_size)
+            painter.end()
+            
+            self.overlay_pixmap_item.setPixmap(overlay_pixmap)
+            self.scene.update(eraser_rect)
+        
+        # Process points immediately for normal mode as well
+        if not self.absolute_erase_mode:
+            if self.overlay_pixmap_item is not None:
+                overlay_pixmap = self.overlay_pixmap_item.pixmap()
+                painter = QPainter(overlay_pixmap)
+                painter.setRenderHint(QPainter.RenderHint.Antialiasing, True)
+                painter.setCompositionMode(QPainter.CompositionMode.CompositionMode_Clear)
+                painter.setPen(Qt.PenStyle.NoPen)
+                painter.setBrush(Qt.GlobalColor.black)
+                
+                # Draw with softer edges for smoother erasing
+                painter.drawEllipse(scene_pos, self.eraser_size, self.eraser_size)
+                painter.end()
+                
+                self.overlay_pixmap_item.setPixmap(overlay_pixmap)
+                self.scene.update(eraser_rect)
+        
+        # IMPROVEMENT: Process points in smaller batches for more responsive updates
+        # Only process points when we have enough positions or timer triggers
+        batch_size = 3  # Reduced from 5 for more frequent updates
+        if len(self.erase_positions) < batch_size:
+            # Start the erase timer if it's not active
+            if not self.erase_timer.isActive():
+                self.erase_timer.start(50)  # Reduced timer for smoother updates
+                
+            # Provide immediate visual feedback by updating the area
+            self.scene.update(eraser_rect)
+            return  # Skip point processing until we have a batch
+        
+        # IMPROVEMENT: Use interpolation for smoother erasing between points
+        interpolated_positions = []
+        if len(self.erase_positions) >= 2:
+            for i in range(len(self.erase_positions) - 1):
+                start_pos = self.erase_positions[i]
+                end_pos = self.erase_positions[i + 1]
+                
+                # Calculate distance between points
+                dx = end_pos.x() - start_pos.x()
+                dy = end_pos.y() - start_pos.y()
+                distance = (dx**2 + dy**2)**0.5
+                
+                # Only interpolate if points are far enough apart
+                if distance > self.eraser_size / 2:
+                    # Number of interpolation steps based on distance
+                    steps = max(2, min(10, int(distance / (self.eraser_size / 3))))
+                    
+                    for step in range(1, steps):
+                        t = step / steps
+                        interp_x = start_pos.x() + dx * t
+                        interp_y = start_pos.y() + dy * t
+                        interpolated_positions.append(QPointF(interp_x, interp_y))
+        
+        # Combine original and interpolated positions
+        positions_to_check = self.erase_positions.copy() + interpolated_positions
+        
+        # Create a single large update rect covering all erase positions
+        full_update_rect = None
+        for pos in positions_to_check:
+            current_rect = QRectF(
+                pos.x() - self.eraser_size, 
+                pos.y() - self.eraser_size,
+                self.eraser_size * 2, 
+                self.eraser_size * 2
+            )
+            
+            if full_update_rect is None:
+                full_update_rect = QRectF(current_rect)
+            else:
+                full_update_rect = full_update_rect.united(current_rect)
+        
+        # Reset the batch
+        self.erase_positions = []
+        
+        # Process the accumulated erase positions
+        all_erased_points = []
+        
+        # OPTIMIZATION: Create a fast lookup for points to be removed
+        points_to_remove = set()
+        
+        # OPTIMIZATION: Use spatial partitioning approach for large point sets
+        if len(self.points) > 1000:
+            # Only check points that could be within the eraser area
+            for index, point_item in enumerate(self.points):
+                try:
+                    # Get point position using the most likely method
+                    if hasattr(point_item, 'get_position'):
+                        point_center = point_item.get_position()
+                    elif hasattr(point_item, '_pos'):
+                        point_center = point_item._pos
+                    elif hasattr(point_item, 'x') and hasattr(point_item, 'y'):
+                        point_center = QPointF(point_item.x(), point_item.y())
+                    elif hasattr(point_item, 'scenePos'):
+                        point_center = point_item.scenePos()
+                    else:
+                        continue
+                    
+                    # Quick bounding box test first (much faster than distance calculation)
+                    if (point_center.x() >= full_update_rect.left() and 
+                        point_center.x() <= full_update_rect.right() and
+                        point_center.y() >= full_update_rect.top() and
+                        point_center.y() <= full_update_rect.bottom()):
+                        
+                        # Now check actual distance to any erase position
+                        for pos in positions_to_check:
+                            distance_squared = (point_center.x() - pos.x())**2 + (point_center.y() - pos.y())**2
+                            if distance_squared <= eraser_size_squared:
+                                points_to_remove.add(index)
+                                all_erased_points.append(point_item)
+                                break
+                except Exception:
+                    pass
+        else:
+            # For smaller point sets, just check each point against all positions
+            for index, point_item in enumerate(self.points):
+                try:
+                    if hasattr(point_item, 'get_position'):
+                        point_center = point_item.get_position()
+                    elif hasattr(point_item, '_pos'):
+                        point_center = point_item._pos
+                    elif hasattr(point_item, 'x') and hasattr(point_item, 'y'):
+                        point_center = QPointF(point_item.x(), point_item.y())
+                    elif hasattr(point_item, 'scenePos'):
+                        point_center = point_item.scenePos()
+                    else:
+                        continue
+                    
+                    # Check against all erase positions
+                    for pos in positions_to_check:
+                        distance_squared = (point_center.x() - pos.x())**2 + (point_center.y() - pos.y())**2
+                        if distance_squared <= eraser_size_squared:
+                            points_to_remove.add(index)
+                            all_erased_points.append(point_item)
+                            break
+                except Exception:
+                    pass
+        
+        # OPTIMIZATION: Remove points in reverse order to avoid index shifting
+        if points_to_remove:
+            # Sort indices in descending order
+            indices_list = sorted(points_to_remove, reverse=True)
+            
+            # Remove points from the scene
+            for point_item in all_erased_points:
+                try:
+                    self.scene.removeItem(point_item)
+                except Exception:
+                    pass
+            
+            # Remove from the points list (in reverse order)
+            for index in indices_list:
+                if 0 <= index < len(self.points):
+                    del self.points[index]
+            
+            # Store erased points for undo functionality
+            if all_erased_points:
+                self.erased_points_history.append(all_erased_points)
+                self.current_stroke.extend([('erase', point) for point in all_erased_points])
+                needs_update = True
+        
+        # OPTIMIZATION: Force a full redraw of the points overlay after batch erasing
+        # This is more efficient than incremental updates for large erasing operations
+        if needs_update:
+            # Signal that we need a complete redraw
+            if hasattr(self, 'last_rendered_points_count'):
+                self.last_rendered_points_count = 0
+                
+            # Set the current update rect to the full area affected
+            if full_update_rect is not None:
+                self.current_erase_update_rect = full_update_rect
+            
+            # Flag that we need to update the points overlay
+            self.points_overlay_needs_update = True
+            
+            # IMPROVEMENT: Progressive rendering for smoother updates
+            # Set up timer for delayed overlay update with progressive timing
+            if not hasattr(self, 'batch_update_timer'):
+                self.batch_update_timer = QTimer()
+                self.batch_update_timer.timeout.connect(self.process_erase_batch_update)
+                self.batch_update_timer.setSingleShot(True)
+            
+            # Immediate visual feedback with a shorter delay for better responsiveness
+            if full_update_rect is not None:
+                self.scene.update(full_update_rect)
+            
+            # IMPROVEMENT: Adjust delay based on the number of points for smoother experience
+            point_count = len(self.points)
+            if point_count > 20000:
+                delay = 16  
+            elif point_count > 10000:
+                delay = 10  
+            elif point_count > 5000:
+                delay = 8 
+            else:
+                delay = 4  
+            
+            # Reset the timer for batched updates
+            self.batch_update_timer.start(delay)
+        
+        self.scene.update()
+
+    def process_erase_batch_update(self):
+        """Process batched updates from erasing operations"""
+        # Update the scene for the entire affected area if needed
+        if hasattr(self, 'current_erase_update_rect') and self.current_erase_update_rect is not None:
+            # Add a small margin
+            update_rect = QRectF(self.current_erase_update_rect)
+            update_rect.adjust(-2, -2, 2, 2)
+            self.scene.update(update_rect)
+            self.current_erase_update_rect = None
+        
+        # Check if we need to update the points overlay
+        if hasattr(self, 'points_overlay_needs_update') and self.points_overlay_needs_update:
+            # Reset the points pixmap to force a full redraw
+            if hasattr(self, 'points_pixmap'):
+                self.points_pixmap = None
+            if hasattr(self, 'last_rendered_points_count'):
+                self.last_rendered_points_count = 0
+            self.update_points_overlay()
+            self.points_overlay_needs_update = False
+            
+    def end_erase_operation(self):
+        self.process_erase_batch_update()
+
+    def toggle_erase_mode(self, enabled):
+        self.erase_mode = enabled
+        if enabled:
+            self.paint_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)