lazylabel-gui 1.3.7__py3-none-any.whl → 1.3.9__py3-none-any.whl

lazylabel/config/hotkeys.py

@@ -57,6 +57,12 @@ class HotkeyManager:
             HotkeyAction(
                 "save_segment", "Save Current Segment", "Space", category="Actions"
             ),
+            HotkeyAction(
+                "erase_segment",
+                "Erase with Current Segment",
+                "Shift+Space",
+                category="Actions",
+            ),
             HotkeyAction("save_output", "Save Output", "Return", category="Actions"),
             HotkeyAction(
                 "save_output_alt", "Save Output (Alt)", "Enter", category="Actions"
@@ -68,6 +74,9 @@ class HotkeyManager:
             HotkeyAction(
                 "escape", "Cancel/Clear Selection", "Escape", category="Actions"
             ),
+            HotkeyAction(
+                "toggle_ai_filter", "Toggle AI Filter", "Z", category="Actions"
+            ),
             # Segments
             HotkeyAction(
                 "merge_segments", "Merge Selected Segments", "M", category="Segments"
@@ -84,6 +93,10 @@ class HotkeyManager:
             HotkeyAction(
                 "select_all", "Select All Segments", "Ctrl+A", category="Segments"
             ),
+            # Classes
+            HotkeyAction(
+                "toggle_recent_class", "Toggle Recent Class", "X", category="Classes"
+            ),
             # View
             HotkeyAction("zoom_in", "Zoom In", "Ctrl+Plus", category="View"),
             HotkeyAction("zoom_out", "Zoom Out", "Ctrl+Minus", category="View"),

lazylabel/config/settings.py

@@ -45,6 +45,10 @@ class Settings:
     # Multi-view Settings
     multi_view_grid_mode: str = "2_view"  # "2_view" or "4_view"
 
+    # Pixel Priority Settings
+    pixel_priority_enabled: bool = False
+    pixel_priority_ascending: bool = True
+
     def save_to_file(self, filepath: str) -> None:
         """Save settings to JSON file."""
         os.makedirs(os.path.dirname(filepath), exist_ok=True)

lazylabel/core/file_manager.py

@@ -22,6 +22,8 @@ class FileManager:
         image_size: tuple[int, int],
         class_order: list[int],
         crop_coords: tuple[int, int, int, int] | None = None,
+        pixel_priority_enabled: bool = False,
+        pixel_priority_ascending: bool = True,
     ) -> str:
         """Save segments as NPZ file."""
         logger.debug(f"Saving NPZ for image: {image_path}")
@@ -32,7 +34,7 @@ class FileManager:
             raise ValueError("No classes defined for saving")
 
         final_mask_tensor = self.segment_manager.create_final_mask_tensor(
-            image_size, class_order
+            image_size, class_order, pixel_priority_enabled, pixel_priority_ascending
         )
 
         # Validate mask tensor
@@ -75,10 +77,12 @@ class FileManager:
         class_order: list[int],
         class_labels: list[str],
         crop_coords: tuple[int, int, int, int] | None = None,
+        pixel_priority_enabled: bool = False,
+        pixel_priority_ascending: bool = True,
     ) -> str | None:
         """Save segments as YOLO format TXT file."""
         final_mask_tensor = self.segment_manager.create_final_mask_tensor(
-            image_size, class_order
+            image_size, class_order, pixel_priority_enabled, pixel_priority_ascending
         )
 
         # Apply crop if coordinates are provided

lazylabel/core/segment_manager.py

@@ -15,6 +15,7 @@ class SegmentManager:
         self.class_aliases: dict[int, str] = {}
         self.next_class_id: int = 0
         self.active_class_id: int | None = None  # Currently active/toggled class
+        self.last_toggled_class_id: int | None = None  # Most recently toggled class
 
     def clear(self) -> None:
         """Clear all segments and reset state."""
@@ -22,6 +23,7 @@ class SegmentManager:
         self.class_aliases.clear()
         self.next_class_id = 0
         self.active_class_id = None
+        self.last_toggled_class_id = None
 
     def add_segment(self, segment_data: dict[str, Any]) -> None:
         """Add a new segment.
@@ -36,6 +38,9 @@ class SegmentManager:
             else:
                 segment_data["class_id"] = self.next_class_id
 
+        # Track the class used for this segment as the most recently used
+        self.last_toggled_class_id = segment_data["class_id"]
+
         # Convert QPointF to list for storage if it's a polygon and contains QPointF objects
         if (
             segment_data.get("type") == "Polygon"
@@ -103,7 +108,11 @@ class SegmentManager:
         return mask.astype(bool)
 
     def create_final_mask_tensor(
-        self, image_size: tuple[int, int], class_order: list[int]
+        self,
+        image_size: tuple[int, int],
+        class_order: list[int],
+        pixel_priority_enabled: bool = False,
+        pixel_priority_ascending: bool = True,
     ) -> np.ndarray:
         """Create final mask tensor for saving."""
         h, w = image_size
@@ -130,8 +139,59 @@ class SegmentManager:
                     final_mask_tensor[:, :, new_channel_idx], mask
                 )
 
+        # Apply pixel priority if enabled
+        if pixel_priority_enabled:
+            final_mask_tensor = self._apply_pixel_priority(
+                final_mask_tensor, pixel_priority_ascending
+            )
+
         return final_mask_tensor
 
+    def _apply_pixel_priority(
+        self, mask_tensor: np.ndarray, ascending: bool
+    ) -> np.ndarray:
+        """Apply pixel priority to mask tensor so only one class can occupy each pixel.
+
+        Args:
+            mask_tensor: 3D array of shape (height, width, num_classes)
+            ascending: If True, lower class indices have priority; if False, higher indices have priority
+
+        Returns:
+            Modified mask tensor with pixel priority applied
+        """
+        # Create a copy to avoid modifying the original
+        prioritized_mask = mask_tensor.copy()
+
+        # Find pixels with multiple class overlaps (sum > 1 across class dimension)
+        overlap_pixels = np.sum(mask_tensor, axis=2) > 1
+
+        if not np.any(overlap_pixels):
+            # No overlapping pixels, return original
+            return prioritized_mask
+
+        # Get coordinates of overlapping pixels
+        overlap_coords = np.where(overlap_pixels)
+
+        for y, x in zip(overlap_coords[0], overlap_coords[1], strict=False):
+            # Get all classes present at this pixel
+            classes_at_pixel = np.where(mask_tensor[y, x, :] > 0)[0]
+
+            if len(classes_at_pixel) <= 1:
+                continue  # No overlap, skip
+
+            # Determine priority class based on ascending/descending setting
+            if ascending:
+                priority_class = np.min(classes_at_pixel)  # Lowest index has priority
+            else:
+                priority_class = np.max(classes_at_pixel)  # Highest index has priority
+
+            # Set all classes to 0 at this pixel
+            prioritized_mask[y, x, :] = 0
+            # Set only the priority class to 1
+            prioritized_mask[y, x, priority_class] = 1
+
+        return prioritized_mask
+
     def reassign_class_ids(self, new_order: list[int]) -> None:
         """Reassign class IDs based on new order."""
         id_map = {old_id: new_id for new_id, old_id in enumerate(new_order)}
@@ -168,6 +228,9 @@ class SegmentManager:
 
     def toggle_active_class(self, class_id: int) -> bool:
         """Toggle a class as active. Returns True if now active, False if deactivated."""
+        # Track this as the last toggled class
+        self.last_toggled_class_id = class_id
+
         if self.active_class_id == class_id:
             self.active_class_id = None
             return False
@@ -175,6 +238,175 @@ class SegmentManager:
             self.active_class_id = class_id
             return True
 
+    def get_last_toggled_class(self) -> int | None:
+        """Get the most recently toggled class ID."""
+        return self.last_toggled_class_id
+
+    def get_class_to_toggle_with_hotkey(self) -> int | None:
+        """Get the class ID to toggle when using the hotkey.
+
+        Returns the most recent class used/toggled, or if no recent class
+        was used then returns the last class in the class list.
+        """
+        # If we have a recently toggled class, use that
+        if self.last_toggled_class_id is not None:
+            return self.last_toggled_class_id
+
+        # Otherwise, get the last class in the class list (highest ID)
+        unique_class_ids = self.get_unique_class_ids()
+        if unique_class_ids:
+            return unique_class_ids[-1]  # Last (highest) class ID
+
+        return None
+
+    def erase_segments_with_shape(
+        self, erase_vertices: list[QPointF], image_size: tuple[int, int]
+    ) -> list[int]:
+        """Erase segments that overlap with the given shape.
+
+        Args:
+            erase_vertices: Vertices of the erase shape
+            image_size: Size of the image (height, width)
+
+        Returns:
+            List of indices of segments that were removed
+        """
+        if not erase_vertices or not self.segments:
+            return [], []
+
+        # Create mask from erase shape
+        erase_mask = self.rasterize_polygon(erase_vertices, image_size)
+        if erase_mask is None:
+            return [], []
+
+        return self.erase_segments_with_mask(erase_mask, image_size)
+
+    def erase_segments_with_mask(
+        self, erase_mask: np.ndarray, image_size: tuple[int, int]
+    ) -> list[int]:
+        """Erase overlapping pixels from segments that overlap with the given mask.
+
+        Args:
+            erase_mask: Binary mask indicating pixels to erase
+            image_size: Size of the image (height, width)
+
+        Returns:
+            List of indices of segments that were modified or removed
+        """
+        if erase_mask is None or not self.segments:
+            return [], []
+
+        modified_indices = []
+        segments_to_remove = []
+        segments_to_add = []
+        removed_segments_data = []  # Store segment data for undo
+
+        # Iterate through all segments to find overlaps
+        for i, segment in enumerate(self.segments):
+            segment_mask = self._get_segment_mask(segment, image_size)
+            if segment_mask is None:
+                continue
+
+            # Check if there's any overlap between erase mask and segment mask
+            overlap = np.logical_and(erase_mask, segment_mask)
+            overlap_area = np.sum(overlap)
+
+            if overlap_area > 0:
+                modified_indices.append(i)
+
+                # Store original segment data before modification
+                removed_segments_data.append({"index": i, "segment": segment.copy()})
+
+                # Create new mask by removing erased pixels
+                new_mask = np.logical_and(segment_mask, ~erase_mask)
+                remaining_area = np.sum(new_mask)
+
+                if remaining_area == 0:
+                    # All pixels were erased, remove segment entirely
+                    segments_to_remove.append(i)
+                else:
+                    # Some pixels remain, check for disconnected components
+                    # Use connected component analysis to split into separate segments
+                    connected_segments = self._split_mask_into_components(
+                        new_mask, segment.get("class_id")
+                    )
+
+                    # Mark original for removal and add all connected components
+                    segments_to_remove.append(i)
+                    segments_to_add.extend(connected_segments)
+
+        # Remove segments in reverse order to maintain indices
+        for i in sorted(segments_to_remove, reverse=True):
+            del self.segments[i]
+
+        # Add new segments (modified versions)
+        for new_segment in segments_to_add:
+            self.segments.append(new_segment)
+
+        if modified_indices:
+            self._update_next_class_id()
+
+        return modified_indices, removed_segments_data
+
+    def _get_segment_mask(
+        self, segment: dict[str, Any], image_size: tuple[int, int]
+    ) -> np.ndarray | None:
+        """Get binary mask for a segment.
+
+        Args:
+            segment: Segment data
+            image_size: Size of the image (height, width)
+
+        Returns:
+            Binary mask for the segment or None if unable to create
+        """
+        if segment["type"] == "Polygon" and "vertices" in segment:
+            # Convert stored list of lists back to QPointF objects for rasterization
+            qpoints = [QPointF(p[0], p[1]) for p in segment["vertices"]]
+            return self.rasterize_polygon(qpoints, image_size)
+        elif "mask" in segment and segment["mask"] is not None:
+            return segment["mask"]
+        return None
+
+    def _split_mask_into_components(
+        self, mask: np.ndarray, class_id: int | None
+    ) -> list[dict[str, Any]]:
+        """Split a mask into separate segments for each connected component.
+
+        Args:
+            mask: Binary mask to split
+            class_id: Class ID to assign to all resulting segments
+
+        Returns:
+            List of segment dictionaries, one for each connected component
+        """
+        if mask is None or np.sum(mask) == 0:
+            return []
+
+        # Convert boolean mask to uint8 for OpenCV
+        mask_uint8 = mask.astype(np.uint8)
+
+        # Find connected components
+        num_labels, labels = cv2.connectedComponents(mask_uint8, connectivity=8)
+
+        segments = []
+
+        # Create a segment for each component (skip label 0 which is background)
+        for label in range(1, num_labels):
+            component_mask = labels == label
+
+            # Only create segment if component has significant size
+            if np.sum(component_mask) > 10:  # Minimum 10 pixels
+                new_segment = {
+                    "type": "AI",  # Convert to mask-based segment
+                    "mask": component_mask,
+                    "vertices": None,
+                    "class_id": class_id,
+                }
+                segments.append(new_segment)
+
+        return segments
+
     def _update_next_class_id(self) -> None:
         """Update the next available class ID."""
         all_ids = {

lazylabel/ui/main_window.py

@@ -182,6 +182,9 @@ class MainWindow(QMainWindow):
         self.pan_multiplier = self.settings.pan_multiplier
         self.polygon_join_threshold = self.settings.polygon_join_threshold
         self.fragment_threshold = self.settings.fragment_threshold
+        self.last_ai_filter_value = (
+            100 if self.fragment_threshold == 0 else self.fragment_threshold
+        )
 
         # Image adjustment state
         self.brightness = self.settings.brightness
@@ -776,7 +779,9 @@ class MainWindow(QMainWindow):
             "undo": self._undo_last_action,
             "redo": self._redo_last_action,
             "select_all": lambda: self.right_panel.select_all_segments(),
+            "toggle_recent_class": self._toggle_recent_class,
             "save_segment": self._handle_space_press,
+            "erase_segment": self._handle_shift_space_press,
             "save_output": self._handle_enter_press,
             "save_output_alt": self._handle_enter_press,
             "fit_view": self._handle_fit_view,
@@ -786,6 +791,7 @@ class MainWindow(QMainWindow):
             "pan_down": lambda: self._handle_pan_key("down"),
             "pan_left": lambda: self._handle_pan_key("left"),
             "pan_right": lambda: self._handle_pan_key("right"),
+            "toggle_ai_filter": self._toggle_ai_filter,
         }
 
         # Create shortcuts for each action
@@ -1054,6 +1060,8 @@ class MainWindow(QMainWindow):
 
     def _set_fragment_threshold(self, value):
         """Set fragment threshold for AI segment filtering."""
+        if value > 0:
+            self.last_ai_filter_value = value
         self.fragment_threshold = value
         self.settings.fragment_threshold = value
 
@@ -2524,7 +2532,7 @@ class MainWindow(QMainWindow):
 
         if self.mode == "polygon":
             if self.view_mode == "single" and self.polygon_points:
-                self._finalize_polygon()
+                self._finalize_polygon(erase_mode=False)
             elif self.view_mode == "multi" and hasattr(
                 self, "multi_view_polygon_points"
             ):
@@ -2536,12 +2544,65 @@ class MainWindow(QMainWindow):
                             self.multi_view_mode_handler._finalize_multi_view_polygon(i)
                         else:
                             self._finalize_multi_view_polygon(i)
+        elif self.mode == "ai":
+            # For AI mode, use accept method (normal mode)
+            if self.view_mode == "single":
+                self._accept_ai_segment(erase_mode=False)
+            elif self.view_mode == "multi":
+                # Handle multi-view AI acceptance (normal mode)
+                if (
+                    hasattr(self, "multi_view_mode_handler")
+                    and self.multi_view_mode_handler
+                ):
+                    self.multi_view_mode_handler.save_ai_predictions()
+                    self._show_notification("AI segment(s) accepted")
+                else:
+                    self._accept_ai_segment(erase_mode=False)
         else:
-            # For AI mode, use accept method, otherwise save current segment
-            if self.mode == "ai" and self.view_mode == "single":
-                self._accept_ai_segment()
-            else:
-                self._save_current_segment()
+            # For other modes, save current segment
+            self._save_current_segment()
+
+    def _handle_shift_space_press(self):
+        """Handle Shift+Space key press for erase functionality."""
+        logger.debug(
+            f"Shift+Space pressed - mode: {self.mode}, view_mode: {self.view_mode}"
+        )
+
+        if self.mode == "polygon":
+            if self.view_mode == "single" and self.polygon_points:
+                self._finalize_polygon(erase_mode=True)
+            elif self.view_mode == "multi" and hasattr(
+                self, "multi_view_polygon_points"
+            ):
+                # Complete polygons for all viewers that have points
+                for i, points in enumerate(self.multi_view_polygon_points):
+                    if points and len(points) >= 3:
+                        # Use the multi-view mode handler for proper pairing logic
+                        if hasattr(self, "multi_view_mode_handler"):
+                            self.multi_view_mode_handler._finalize_multi_view_polygon(i)
+                        else:
+                            self._finalize_multi_view_polygon(i)
+        elif self.mode == "ai":
+            # For AI mode, use accept method with erase mode
+            if self.view_mode == "single":
+                self._accept_ai_segment(erase_mode=True)
+            elif self.view_mode == "multi":
+                # Handle multi-view AI acceptance with erase mode
+                if (
+                    hasattr(self, "multi_view_mode_handler")
+                    and self.multi_view_mode_handler
+                ):
+                    logger.debug(
+                        "Shift+Space pressed in multi-view AI mode - erase not yet implemented"
+                    )
+                    self._show_notification(
+                        "Eraser not yet implemented for multi-view AI mode"
+                    )
+                else:
+                    self._accept_ai_segment(erase_mode=True)
+        else:
+            # For other modes, show notification that erase isn't available
+            self._show_notification(f"Erase mode not available in {self.mode} mode")
 
     def _handle_enter_press(self):
         """Handle enter key press."""
@@ -2721,6 +2782,13 @@ class MainWindow(QMainWindow):
                     "All segments filtered out by fragment threshold"
                 )
 
+    def _toggle_ai_filter(self):
+        """Toggle AI filter between 0 and last set value."""
+        new_value = self.last_ai_filter_value if self.fragment_threshold == 0 else 0
+
+        # Update the control panel widget
+        self.control_panel.set_fragment_threshold(new_value)
+
     def _apply_fragment_threshold(self, mask):
         """Apply fragment threshold filtering to remove small segments."""
         if self.fragment_threshold == 0:
@@ -2765,24 +2833,51 @@ class MainWindow(QMainWindow):
         # Convert back to boolean mask
         return (filtered_mask > 0).astype(bool)
 
-    def _finalize_polygon(self):
+    def _finalize_polygon(self, erase_mode=False):
         """Finalize polygon drawing."""
         if len(self.polygon_points) < 3:
             return
 
-        new_segment = {
-            "vertices": [[p.x(), p.y()] for p in self.polygon_points],
-            "type": "Polygon",
-            "mask": None,
-        }
-        self.segment_manager.add_segment(new_segment)
-        # Record the action for undo
-        self.action_history.append(
-            {
-                "type": "add_segment",
-                "segment_index": len(self.segment_manager.segments) - 1,
+        if erase_mode:
+            # Erase overlapping segments using polygon vertices
+            image_height = self.viewer._pixmap_item.pixmap().height()
+            image_width = self.viewer._pixmap_item.pixmap().width()
+            image_size = (image_height, image_width)
+            removed_indices, removed_segments_data = (
+                self.segment_manager.erase_segments_with_shape(
+                    self.polygon_points, image_size
+                )
+            )
+
+            if removed_indices:
+                # Record the action for undo
+                self.action_history.append(
+                    {
+                        "type": "erase_segments",
+                        "removed_segments": removed_segments_data,
+                    }
+                )
+                self._show_notification(
+                    f"Applied eraser to {len(removed_indices)} segment(s)"
+                )
+            else:
+                self._show_notification("No segments to erase")
+        else:
+            # Create new polygon segment (normal mode)
+            new_segment = {
+                "vertices": [[p.x(), p.y()] for p in self.polygon_points],
+                "type": "Polygon",
+                "mask": None,
             }
-        )
+            self.segment_manager.add_segment(new_segment)
+            # Record the action for undo
+            self.action_history.append(
+                {
+                    "type": "add_segment",
+                    "segment_index": len(self.segment_manager.segments) - 1,
+                }
+            )
+
         # Clear redo history when a new action is performed
         self.redo_history.clear()
 
@@ -2881,6 +2976,8 @@ class MainWindow(QMainWindow):
                             (h, w),
                             class_order,
                             crop_coords,  # Pass crop coordinates if available
+                            settings.get("pixel_priority_enabled", False),
+                            settings.get("pixel_priority_ascending", True),
                         )
                         saved_files.append(os.path.basename(npz_path))
                         # Track saved file for highlighting later
@@ -2915,6 +3012,8 @@ class MainWindow(QMainWindow):
                             class_order,
                             class_labels,
                             crop_coords,  # Pass crop coordinates if available
+                            settings.get("pixel_priority_enabled", False),
+                            settings.get("pixel_priority_ascending", True),
                         )
                         saved_files.append(os.path.basename(txt_path))
                         # Track saved file for highlighting later
@@ -3058,6 +3157,8 @@ class MainWindow(QMainWindow):
                         (h, w),
                         class_order,
                         self.current_crop_coords,
+                        settings.get("pixel_priority_enabled", False),
+                        settings.get("pixel_priority_ascending", True),
                     )
                     logger.debug(f"NPZ save completed: {npz_path}")
                     self._show_success_notification(
@@ -3087,6 +3188,8 @@ class MainWindow(QMainWindow):
                         class_order,
                         class_labels,
                         self.current_crop_coords,
+                        settings.get("pixel_priority_enabled", False),
+                        settings.get("pixel_priority_ascending", True),
                     )
                     if txt_path:
                         logger.debug(f"TXT save completed: {txt_path}")
@@ -3528,9 +3631,11 @@ class MainWindow(QMainWindow):
         """Clear notification from status bar."""
         self.status_bar.clear_message()
 
-    def _accept_ai_segment(self):
+    def _accept_ai_segment(self, erase_mode=False):
         """Accept the current AI segment preview (spacebar handler)."""
-        logger.debug(f"_accept_ai_segment called - view_mode: {self.view_mode}")
+        logger.debug(
+            f"_accept_ai_segment called - view_mode: {self.view_mode}, erase_mode: {erase_mode}"
+        )
 
         if self.view_mode == "single":
             # Single view mode - check for preview mask (both point-based and bbox)
@@ -3547,7 +3652,7 @@ class MainWindow(QMainWindow):
             )
 
             logger.debug(
-                f"Single view - has_preview_item: {has_preview_item}, has_preview_mask: {has_preview_mask}, has_bbox_preview: {has_bbox_preview}"
+                f"Single view - has_preview_item: {has_preview_item}, has_preview_mask: {has_preview_mask}, has_bbox_preview: {has_bbox_preview}, erase_mode: {erase_mode}"
             )
 
             # Handle bbox preview first
@@ -3556,21 +3661,56 @@ class MainWindow(QMainWindow):
                     self.ai_bbox_preview_mask
                 )
                 if filtered_mask is not None:
-                    # Create actual segment
-                    new_segment = {
-                        "type": "AI",
-                        "mask": filtered_mask,
-                        "vertices": None,
-                    }
-                    self.segment_manager.add_segment(new_segment)
+                    if erase_mode:
+                        # Erase overlapping segments
+                        logger.debug(
+                            "Erase mode active for bbox preview - applying eraser to AI segment"
+                        )
+                        image_height = self.viewer._pixmap_item.pixmap().height()
+                        image_width = self.viewer._pixmap_item.pixmap().width()
+                        image_size = (image_height, image_width)
+                        removed_indices, removed_segments_data = (
+                            self.segment_manager.erase_segments_with_mask(
+                                filtered_mask, image_size
+                            )
+                        )
+                        logger.debug(
+                            f"Bbox erase operation completed - modified {len(removed_indices)} segments"
+                        )
 
-                    # Record the action for undo
-                    self.action_history.append(
-                        {
-                            "type": "add_segment",
-                            "segment_index": len(self.segment_manager.segments) - 1,
+                        if removed_indices:
+                            # Record the action for undo
+                            self.action_history.append(
+                                {
+                                    "type": "erase_segments",
+                                    "removed_segments": removed_segments_data,
+                                }
+                            )
+                            self._show_success_notification(
+                                f"Erased {len(removed_indices)} segment(s)!"
+                            )
+                        else:
+                            self._show_notification("No segments to erase")
+                    else:
+                        # Create actual segment (normal mode)
+                        new_segment = {
+                            "type": "AI",
+                            "mask": filtered_mask,
+                            "vertices": None,
                         }
-                    )
+                        self.segment_manager.add_segment(new_segment)
+
+                        # Record the action for undo
+                        self.action_history.append(
+                            {
+                                "type": "add_segment",
+                                "segment_index": len(self.segment_manager.segments) - 1,
+                            }
+                        )
+                        self._show_success_notification(
+                            "AI bounding box segment saved!"
+                        )
+
                     # Clear redo history when a new action is performed
                     self.redo_history.clear()
 
@@ -3586,7 +3726,6 @@ class MainWindow(QMainWindow):
                     # Clear all points
                     self.clear_all_points()
                     self._update_all_lists()
-                    self._show_success_notification("AI bounding box segment saved!")
                 else:
                     self._show_warning_notification(
                         "All segments filtered out by fragment threshold"
@@ -3597,28 +3736,60 @@ class MainWindow(QMainWindow):
                     self.current_preview_mask
                 )
                 if filtered_mask is not None:
-                    # Create actual segment
-                    new_segment = {
-                        "type": "AI",
-                        "mask": filtered_mask,
-                        "vertices": None,
-                    }
-                    self.segment_manager.add_segment(new_segment)
+                    if erase_mode:
+                        # Erase overlapping segments
+                        logger.debug(
+                            "Erase mode active for regular AI preview - applying eraser to AI segment"
+                        )
+                        image_height = self.viewer._pixmap_item.pixmap().height()
+                        image_width = self.viewer._pixmap_item.pixmap().width()
+                        image_size = (image_height, image_width)
+                        removed_indices, removed_segments_data = (
+                            self.segment_manager.erase_segments_with_mask(
+                                filtered_mask, image_size
+                            )
+                        )
+                        logger.debug(
+                            f"Regular AI erase operation completed - modified {len(removed_indices)} segments"
+                        )
 
-                    # Record the action for undo
-                    self.action_history.append(
-                        {
-                            "type": "add_segment",
-                            "segment_index": len(self.segment_manager.segments) - 1,
+                        if removed_indices:
+                            # Record the action for undo
+                            self.action_history.append(
+                                {
+                                    "type": "erase_segments",
+                                    "removed_segments": removed_segments_data,
+                                }
+                            )
+                            self._show_notification(
+                                f"Applied eraser to {len(removed_indices)} segment(s)"
+                            )
+                        else:
+                            self._show_notification("No segments to erase")
+                    else:
+                        # Create actual segment (normal mode)
+                        new_segment = {
+                            "type": "AI",
+                            "mask": filtered_mask,
+                            "vertices": None,
                         }
-                    )
+                        self.segment_manager.add_segment(new_segment)
+
+                        # Record the action for undo
+                        self.action_history.append(
+                            {
+                                "type": "add_segment",
+                                "segment_index": len(self.segment_manager.segments) - 1,
+                            }
+                        )
+                        self._show_notification("AI segment accepted")
+
                     # Clear redo history when a new action is performed
                     self.redo_history.clear()
 
                     # Clear all points after accepting
                     self.clear_all_points()
                     self._update_all_lists()
-                    self._show_notification("AI segment accepted")
                 else:
                     self._show_warning_notification(
                         "All segments filtered out by fragment threshold"
@@ -3628,6 +3799,18 @@ class MainWindow(QMainWindow):
                         self.viewer.scene().removeItem(self.preview_mask_item)
                     self.preview_mask_item = None
                     self.current_preview_mask = None
+            else:
+                # No AI preview found in single view
+                if erase_mode:
+                    logger.debug(
+                        "No AI segment preview to erase - no preview mask found in single view"
+                    )
+                    self._show_notification("No AI segment preview to erase")
+                else:
+                    logger.debug(
+                        "No AI segment preview to accept - no preview mask found in single view"
+                    )
+                    self._show_notification("No AI segment preview to accept")
 
         elif self.view_mode == "multi":
             # Multi-view mode - use the multi-view mode handler to save AI predictions
@@ -3707,7 +3890,13 @@ class MainWindow(QMainWindow):
                 self._show_success_notification("AI segment(s) accepted")
                 self._update_all_lists()
             else:
-                self._show_notification("No AI segment preview to accept")
+                if erase_mode:
+                    logger.debug(
+                        "No AI segment preview to erase - no preview mask found"
+                    )
+                    self._show_notification("No AI segment preview to erase")
+                else:
+                    self._show_notification("No AI segment preview to accept")
 
     def _show_hotkey_dialog(self):
         """Show the hotkey configuration dialog."""
@@ -4068,28 +4257,64 @@ class MainWindow(QMainWindow):
             self.drag_start_pos = None
 
             if rect.width() >= 2 and rect.height() >= 2:
-                # Convert QRectF to QPolygonF
+                # Check if shift is pressed for erase functionality
+                modifiers = QApplication.keyboardModifiers()
+                shift_pressed = bool(modifiers & Qt.KeyboardModifier.ShiftModifier)
+
+                if shift_pressed:
+                    logger.debug("Shift+bbox release - activating erase mode")
+
+                # Convert QRectF to QPolygonF for vertex representation
                 polygon = QPolygonF()
                 polygon.append(rect.topLeft())
                 polygon.append(rect.topRight())
                 polygon.append(rect.bottomRight())
                 polygon.append(rect.bottomLeft())
 
-                new_segment = {
-                    "vertices": [[p.x(), p.y()] for p in list(polygon)],
-                    "type": "Polygon",  # Bounding boxes are stored as polygons
-                    "mask": None,
-                }
+                polygon_vertices = [QPointF(p.x(), p.y()) for p in list(polygon)]
 
-                self.segment_manager.add_segment(new_segment)
+                if shift_pressed:
+                    # Erase overlapping segments using bbox vertices
+                    image_height = self.viewer._pixmap_item.pixmap().height()
+                    image_width = self.viewer._pixmap_item.pixmap().width()
+                    image_size = (image_height, image_width)
+                    removed_indices, removed_segments_data = (
+                        self.segment_manager.erase_segments_with_shape(
+                            polygon_vertices, image_size
+                        )
+                    )
 
-                # Record the action for undo
-                self.action_history.append(
-                    {
-                        "type": "add_segment",
-                        "segment_index": len(self.segment_manager.segments) - 1,
+                    if removed_indices:
+                        # Record the action for undo
+                        self.action_history.append(
+                            {
+                                "type": "erase_segments",
+                                "removed_segments": removed_segments_data,
+                            }
+                        )
+                        self._show_notification(
+                            f"Applied eraser to {len(removed_indices)} segment(s)"
+                        )
+                    else:
+                        self._show_notification("No segments to erase")
+                else:
+                    # Create new bbox segment (normal mode)
+                    new_segment = {
+                        "vertices": [[p.x(), p.y()] for p in polygon_vertices],
+                        "type": "Polygon",  # Bounding boxes are stored as polygons
+                        "mask": None,
                     }
-                )
+
+                    self.segment_manager.add_segment(new_segment)
+
+                    # Record the action for undo
+                    self.action_history.append(
+                        {
+                            "type": "add_segment",
+                            "segment_index": len(self.segment_manager.segments) - 1,
+                        }
+                    )
+
                 # Clear redo history when a new action is performed
                 self.redo_history.clear()
                 self._update_all_lists()
@@ -4313,6 +4538,10 @@ class MainWindow(QMainWindow):
 
     def _handle_polygon_click(self, pos):
         """Handle polygon drawing clicks."""
+        # Check if shift is pressed for erase functionality
+        modifiers = QApplication.keyboardModifiers()
+        shift_pressed = bool(modifiers & Qt.KeyboardModifier.ShiftModifier)
+
         # Check if clicking near the first point to close polygon
         if self.polygon_points and len(self.polygon_points) > 2:
             first_point = self.polygon_points[0]
@@ -4320,7 +4549,11 @@ class MainWindow(QMainWindow):
                 pos.y() - first_point.y()
             ) ** 2
             if distance_squared < self.polygon_join_threshold**2:
-                self._finalize_polygon()
+                if shift_pressed:
+                    logger.debug(
+                        "Shift+click polygon completion - activating erase mode"
+                    )
+                self._finalize_polygon(erase_mode=shift_pressed)
                 return
 
         # Add new point to polygon
@@ -4612,6 +4845,14 @@ class MainWindow(QMainWindow):
             # Update visual display to clear active class
             self.right_panel.update_active_class_display(None)
 
+    def _toggle_recent_class(self):
+        """Toggle the most recent class used/toggled, or the last class in the list."""
+        class_id = self.segment_manager.get_class_to_toggle_with_hotkey()
+        if class_id is not None:
+            self._handle_class_toggle(class_id)
+        else:
+            self._show_notification("No classes available to toggle")
+
     def _pop_out_left_panel(self):
         """Pop out the left control panel into a separate window."""
         if self.left_panel_popout is not None:
@@ -6293,22 +6534,23 @@ class MainWindow(QMainWindow):
             )
 
     def _start_sequential_multi_view_sam_loading(self):
-        """Start loading images into SAM models sequentially to avoid resource conflicts."""
+        """Start loading images into SAM models in parallel for faster processing."""
         # Check if any loading is already in progress to prevent duplicate workers
         any_updating = any(self.multi_view_models_updating)
         if any_updating:
-            # Sequential loading already in progress, don't start another
+            # Loading already in progress, don't start another
             updating_indices = [
                 i
                 for i, updating in enumerate(self.multi_view_models_updating)
                 if updating
             ]
             logger.debug(
-                f"Sequential loading already in progress for viewers: {updating_indices}"
+                f"Parallel loading already in progress for viewers: {updating_indices}"
             )
             return
 
-        # Find the next dirty model that needs updating
+        # Find all dirty models that need updating and start them in parallel
+        models_to_update = []
         for i in range(len(self.multi_view_models)):
             if (
                 self.multi_view_images[i]
@@ -6316,15 +6558,24 @@ class MainWindow(QMainWindow):
                 and self.multi_view_models_dirty[i]
                 and not self.multi_view_models_updating[i]
             ):
-                # Start updating this model
-                self._ensure_multi_view_sam_updated(i)
-                return
+                models_to_update.append(i)
 
-        # If no more models to update, we're done
-        if self._multi_view_loading_step >= self._multi_view_total_steps:
-            self._show_success_notification(
-                "AI models ready for prompting", duration=3000
+        if models_to_update:
+            logger.debug(f"Starting parallel loading for viewers: {models_to_update}")
+            # Show notification about parallel loading
+            self._show_notification(
+                f"Loading embeddings for {len(models_to_update)} images in parallel...",
+                duration=0,
             )
+            # Start all workers in parallel
+            for i in models_to_update:
+                self._ensure_multi_view_sam_updated(i)
+        else:
+            # If no more models to update and none are running, we're done
+            if not any(self.multi_view_models_updating):
+                self._show_success_notification(
+                    "AI models ready for prompting", duration=3000
+                )
 
     def _on_multi_view_init_error(self, error_message):
         """Handle multi-view model initialization error."""
@@ -6466,14 +6717,8 @@ class MainWindow(QMainWindow):
 
         logger.debug(f"Starting SAM image loading worker for viewer {viewer_index + 1}")
 
-        # Show enumerated progress notification
-        image_name = Path(image_path).name if image_path else "unknown"
-        config = self._get_multi_view_config()
-        num_viewers = config["num_viewers"]
-        self._show_notification(
-            f"Computing embeddings for image {viewer_index + 1}/{num_viewers}: {image_name}",
-            duration=0,  # Persistent until completion
-        )
+        # Individual notifications are now handled by the parallel loading start
+        # No need for per-viewer notifications when loading in parallel
 
         # Get current modified image if operate_on_view is enabled
         current_image = None
@@ -6561,8 +6806,16 @@ class MainWindow(QMainWindow):
         if hasattr(self, "_multi_view_loading_step"):
             self._multi_view_loading_step += 1
 
-        # Continue sequential loading
-        self._start_sequential_multi_view_sam_loading()
+        # Check if all models are done (either loaded, failed, or timed out)
+        if not any(self.multi_view_models_updating) and not any(
+            self.multi_view_models_dirty
+        ):
+            # All models processed
+            self._show_success_notification("AI model loading complete", duration=3000)
+        elif not any(self.multi_view_models_updating):
+            # No models are currently updating but some may still be dirty
+            # Try to load remaining models
+            self._start_sequential_multi_view_sam_loading()
 
     def _on_multi_view_sam_update_finished(self, viewer_index):
         """Handle completion of multi-view SAM model update."""
@@ -6596,14 +6849,19 @@ class MainWindow(QMainWindow):
         # Update progress
         if hasattr(self, "_multi_view_loading_step"):
             self._multi_view_loading_step += 1
-            if self._multi_view_loading_step < self._multi_view_total_steps:
-                self._show_notification(
-                    f"Loading image {self._multi_view_loading_step + 1} of {self._multi_view_total_steps}...",
-                    duration=0,
-                )
 
-        # Continue sequential loading of the next SAM model
-        self._start_sequential_multi_view_sam_loading()
+        # Check if all models are done loading
+        if not any(self.multi_view_models_updating) and not any(
+            self.multi_view_models_dirty
+        ):
+            # All models loaded successfully
+            self._show_success_notification(
+                "AI models ready for prompting", duration=3000
+            )
+        elif not any(self.multi_view_models_updating):
+            # No models are currently updating but some may still be dirty
+            # This can happen if there was an error, try to load remaining models
+            self._start_sequential_multi_view_sam_loading()
 
     def _on_multi_view_sam_update_error(self, viewer_index, error_message):
         """Handle multi-view SAM model update error."""
@@ -6639,8 +6897,16 @@ class MainWindow(QMainWindow):
         if hasattr(self, "_multi_view_loading_step"):
             self._multi_view_loading_step += 1
 
-        # Continue sequential loading even if this model failed
-        self._start_sequential_multi_view_sam_loading()
+        # Check if all models are done (either loaded or failed)
+        if not any(self.multi_view_models_updating) and not any(
+            self.multi_view_models_dirty
+        ):
+            # All models processed (some may have failed)
+            self._show_success_notification("AI model loading complete", duration=3000)
+        elif not any(self.multi_view_models_updating):
+            # No models are currently updating but some may still be dirty
+            # Try to load remaining models
+            self._start_sequential_multi_view_sam_loading()
 
     def _cleanup_multi_view_models(self):
         """Clean up multi-view model instances."""

lazylabel/ui/widgets/settings_widget.py

@@ -4,6 +4,47 @@ from PyQt6.QtCore import pyqtSignal
 from PyQt6.QtWidgets import QCheckBox, QGroupBox, QVBoxLayout, QWidget
 
 
+class PixelPriorityCheckBox(QCheckBox):
+    """Custom tri-state checkbox for pixel priority settings."""
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._state = 0  # 0: disabled, 1: ascending, 2: descending
+        self._update_display()
+        self.clicked.connect(self._cycle_state)
+
+    def _cycle_state(self):
+        """Cycle through the three states."""
+        self._state = (self._state + 1) % 3
+        self._update_display()
+
+    def _update_display(self):
+        """Update checkbox text and check state based on current state."""
+        if self._state == 0:
+            self.setText("Pixel Priority Ascending")
+            self.setChecked(False)
+        elif self._state == 1:
+            self.setText("Pixel Priority Ascending")
+            self.setChecked(True)
+        else:  # state == 2
+            self.setText("Pixel Priority Descending")
+            self.setChecked(True)
+
+    def get_pixel_priority_settings(self):
+        """Get current pixel priority settings."""
+        return {"enabled": self._state != 0, "ascending": self._state == 1}
+
+    def set_pixel_priority_settings(self, enabled: bool, ascending: bool):
+        """Set pixel priority settings."""
+        if not enabled:
+            self._state = 0
+        elif ascending:
+            self._state = 1
+        else:
+            self._state = 2
+        self._update_display()
+
+
 class SettingsWidget(QWidget):
     """Widget for application settings."""
 
@@ -69,6 +110,16 @@ class SettingsWidget(QWidget):
         self.chk_operate_on_view.setChecked(False)
         layout.addWidget(self.chk_operate_on_view)
 
+        # Pixel Priority
+        self.chk_pixel_priority = PixelPriorityCheckBox()
+        self.chk_pixel_priority.setToolTip(
+            "Control pixel ownership when multiple classes overlap.\n"
+            "Click to cycle through: Off → Ascending → Descending → Off\n"
+            "Ascending: Lower class indices take priority\n"
+            "Descending: Higher class indices take priority"
+        )
+        layout.addWidget(self.chk_pixel_priority)
+
         # Main layout
         main_layout = QVBoxLayout(self)
         main_layout.setContentsMargins(0, 0, 0, 0)
@@ -90,6 +141,9 @@ class SettingsWidget(QWidget):
         ]:
             checkbox.stateChanged.connect(self.settings_changed)
 
+        # Connect pixel priority checkbox (uses clicked signal instead of stateChanged)
+        self.chk_pixel_priority.clicked.connect(self.settings_changed)
+
     def _handle_save_checkbox_change(self):
         """Ensure at least one save format is selected."""
         is_npz_checked = self.chk_save_npz.isChecked()
@@ -104,6 +158,7 @@ class SettingsWidget(QWidget):
 
     def get_settings(self):
         """Get current settings as dictionary."""
+        pixel_priority_settings = self.chk_pixel_priority.get_pixel_priority_settings()
         return {
             "auto_save": self.chk_auto_save.isChecked(),
             "save_npz": self.chk_save_npz.isChecked(),
@@ -111,6 +166,8 @@ class SettingsWidget(QWidget):
             "yolo_use_alias": self.chk_yolo_use_alias.isChecked(),
             "save_class_aliases": self.chk_save_class_aliases.isChecked(),
             "operate_on_view": self.chk_operate_on_view.isChecked(),
+            "pixel_priority_enabled": pixel_priority_settings["enabled"],
+            "pixel_priority_ascending": pixel_priority_settings["ascending"],
         }
 
     def set_settings(self, settings):
@@ -123,3 +180,7 @@ class SettingsWidget(QWidget):
             settings.get("save_class_aliases", False)
         )
         self.chk_operate_on_view.setChecked(settings.get("operate_on_view", False))
+        self.chk_pixel_priority.set_pixel_priority_settings(
+            settings.get("pixel_priority_enabled", False),
+            settings.get("pixel_priority_ascending", True),
+        )

{lazylabel_gui-1.3.7.dist-info → lazylabel_gui-1.3.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lazylabel-gui
-Version: 1.3.7
+Version: 1.3.9
 Summary: An image segmentation GUI for generating ML ready mask tensors and annotations.
 Author-email: "Deniz N. Cakan" <deniz.n.cakan@gmail.com>
 License: MIT License

{lazylabel_gui-1.3.7.dist-info → lazylabel_gui-1.3.9.dist-info}/RECORD

@@ -2,13 +2,13 @@ lazylabel/__init__.py,sha256=0yitHZYNNuF4Rqj7cqE0TrfDV8zhzKD3A5W1vOymHK4,199
 lazylabel/__main__.py,sha256=5IWklQrNkzeMH6rchzZxxoeSnZlkz-HRiPWXqjjj2yA,139
 lazylabel/main.py,sha256=g_QhEWNhgxp8LLFfxTXDMVTpdaHog_wrs5cv01xRL0Q,904
 lazylabel/config/__init__.py,sha256=TnDXH0yx0zy97FfjpiVPHleMgMrM5YwWrUbvevSNJjg,263
-lazylabel/config/hotkeys.py,sha256=PwxBUy7RvIUU3HCXT74NnexPbg2VFQrbR5FTGek31h8,8008
+lazylabel/config/hotkeys.py,sha256=kHGHbtMTh_VbGQlEnfT8pmhLsu7MOqZtSFnC7shjqLA,8465
 lazylabel/config/paths.py,sha256=ZVKbtaNOxmYO4l6JgsY-8DXaE_jaJfDg2RQJJn3-5nw,1275
-lazylabel/config/settings.py,sha256=myBqkgnYv_P1OomieXt8luCOSNjBiDVN-TybSqHkAgA,1990
+lazylabel/config/settings.py,sha256=FhRF3nja_nEgulO6Qt_ToHhy5qGXwghtTTCLCL-LC48,2104
 lazylabel/core/__init__.py,sha256=FmRjop_uIBSJwKMGhaZ-3Iwu34LkoxTuD-hnq5vbTSY,232
-lazylabel/core/file_manager.py,sha256=Fs4IJIm2hHvYXeDWR7mqEu2EE21o6qwSPpECv8CYQ3o,7283
+lazylabel/core/file_manager.py,sha256=bTsdBx1NzZzS9aG0f5toy9CGxp0Z_LXXBz_C_g3fgvw,7569
 lazylabel/core/model_manager.py,sha256=NmgnIrw9sb_vSwRVkBr2Z_Mc2kFfdFukFgUhqs2e-L0,6829
-lazylabel/core/segment_manager.py,sha256=M6kHcYeiub3WqL01NElCvKOc2GNmf72LUM1W8XwSaxc,6465
+lazylabel/core/segment_manager.py,sha256=43_BJ4CovXAAeuEq9wkuUD54mCFPuwkxkYUXHajZug4,15204
 lazylabel/models/__init__.py,sha256=fIlk_0DuZfiClcm0XlZdimeHzunQwBmTMI4PcGsaymw,91
 lazylabel/models/sam2_model.py,sha256=Z0UVs_m9VwUO4znZF5VA4-HQSF-oCT9RbKtK3EU20qU,21747
 lazylabel/models/sam_model.py,sha256=Q1GAaFG6n5JoZXhClcUZKN-gvA_wmtVuUYzELG7zhPg,8833
@@ -18,7 +18,7 @@ lazylabel/ui/editable_vertex.py,sha256=ofo3r8ZZ3b8oYV40vgzZuS3QnXYBNzE92ArC2wggJ
 lazylabel/ui/hotkey_dialog.py,sha256=U_B76HLOxWdWkfA4d2XgRUaZTJPAAE_m5fmwf7Rh-5Y,14743
 lazylabel/ui/hoverable_pixelmap_item.py,sha256=UbWVxpmCTaeae_AeA8gMOHYGUmAw40fZBFTS3sZlw48,1821
 lazylabel/ui/hoverable_polygon_item.py,sha256=gZalImJ_PJYM7xON0iiSjQ335ZBREOfSscKLVs-MSh8,2314
-lazylabel/ui/main_window.py,sha256=PFbVzZ1jbOuz2q8MNY3BHjWmJU6YoBqKiPwLvlDdsNI,383320
+lazylabel/ui/main_window.py,sha256=LfbGs41QoUzAj3NKYR_rRtyEF7PltB-sdBWS8ukQjfE,396744
 lazylabel/ui/numeric_table_widget_item.py,sha256=dQUlIFu9syCxTGAHVIlmbgkI7aJ3f3wmDPBz1AGK9Bg,283
 lazylabel/ui/photo_viewer.py,sha256=3o7Xldn9kJWvWlbpcHDRMk87dnB5xZKbfyAT3oBYlIo,6670
 lazylabel/ui/reorderable_class_table.py,sha256=sxHhQre5O_MXLDFgKnw43QnvXXoqn5xRKMGitgO7muI,2371
@@ -34,7 +34,7 @@ lazylabel/ui/widgets/channel_threshold_widget.py,sha256=DSYDOUTMXo02Fn5P4cjh2OqD
 lazylabel/ui/widgets/fft_threshold_widget.py,sha256=mcbkNoP0aj-Pe57sgIWBnmg4JiEbTikrwG67Vgygnio,20859
 lazylabel/ui/widgets/fragment_threshold_widget.py,sha256=YtToua1eAUtEuJ3EwdCMvI-39TRrFnshkty4tnR4OMU,3492
 lazylabel/ui/widgets/model_selection_widget.py,sha256=k4zyhWszi_7e-0TPa0Go1LLPZpTNGtrYSb-yT7uGiVU,8420
-lazylabel/ui/widgets/settings_widget.py,sha256=ShTaLJeXxwrSuTV4kmtV2JiWjfREil2D1nvPUIfAgDs,4859
+lazylabel/ui/widgets/settings_widget.py,sha256=-LUIZGSQEf51fIYscJ5dzIqTsE09Rt4wGz7kAS1KnNQ,7311
 lazylabel/ui/widgets/status_bar.py,sha256=wTbMQNEOBfmtNj8EVFZS_lxgaemu-CbRXeZzEQDaVz8,4014
 lazylabel/ui/workers/__init__.py,sha256=1pctFFvHiVW3meiaW5_-AUgQ0AKcvCF4J8-QHoWRtwI,529
 lazylabel/ui/workers/image_discovery_worker.py,sha256=mW4diqPnbyGgyX2DDKm_o9NnAq4V-Jywk_f7risVgS0,2405
@@ -47,9 +47,9 @@ lazylabel/utils/custom_file_system_model.py,sha256=-3EimlybvevH6bvqBE0qdFnLADVta
 lazylabel/utils/fast_file_manager.py,sha256=kzbWz_xKufG5bP6sjyZV1fmOKRWPPNeL-xLYZEu_8wE,44697
 lazylabel/utils/logger.py,sha256=R7z6ifgA-NY-9ZbLlNH0i19zzwXndJ_gkG2J1zpVEhg,1306
 lazylabel/utils/utils.py,sha256=sYSCoXL27OaLgOZaUkCAhgmKZ7YfhR3Cc5F8nDIa3Ig,414
-lazylabel_gui-1.3.7.dist-info/licenses/LICENSE,sha256=kSDEIgrWAPd1u2UFGGpC9X71dhzrlzBFs8hbDlENnGE,1092
-lazylabel_gui-1.3.7.dist-info/METADATA,sha256=Mo6GD0ppauY9CxGQVxIT3BzwEcryP6D_Gs3alvGu5Eg,7754
-lazylabel_gui-1.3.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lazylabel_gui-1.3.7.dist-info/entry_points.txt,sha256=Hd0WwEG9OPTa_ziYjiD0aRh7R6Fupt-wdQ3sspdc1mM,54
-lazylabel_gui-1.3.7.dist-info/top_level.txt,sha256=YN4uIyrpDBq1wiJaBuZLDipIzyZY0jqJOmmXiPIOUkU,10
-lazylabel_gui-1.3.7.dist-info/RECORD,,
+lazylabel_gui-1.3.9.dist-info/licenses/LICENSE,sha256=kSDEIgrWAPd1u2UFGGpC9X71dhzrlzBFs8hbDlENnGE,1092
+lazylabel_gui-1.3.9.dist-info/METADATA,sha256=MO2RNXV4Y62pLyuVezJdVFS-NcxmVfNJD8lpuPJQ20w,7754
+lazylabel_gui-1.3.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lazylabel_gui-1.3.9.dist-info/entry_points.txt,sha256=Hd0WwEG9OPTa_ziYjiD0aRh7R6Fupt-wdQ3sspdc1mM,54
+lazylabel_gui-1.3.9.dist-info/top_level.txt,sha256=YN4uIyrpDBq1wiJaBuZLDipIzyZY0jqJOmmXiPIOUkU,10
+lazylabel_gui-1.3.9.dist-info/RECORD,,