lazylabel-gui 1.3.1__py3-none-any.whl → 1.3.3__py3-none-any.whl

lazylabel/ui/main_window.py

@@ -1176,6 +1176,8 @@ class MainWindow(QMainWindow):
         # Right panel connections
         self.right_panel.open_folder_requested.connect(self._open_folder_dialog)
         self.right_panel.image_selected.connect(self._load_selected_image)
+        # Connect new path-based signal from FastFileManager
+        self.right_panel.image_path_selected.connect(self._load_image_from_path)
         self.right_panel.merge_selection_requested.connect(
             self._assign_selected_to_class
         )
@@ -1625,6 +1627,13 @@ class MainWindow(QMainWindow):
             self._start_background_image_discovery()
         self.viewer.setFocus()
 
+    def _load_image_from_path(self, file_path: Path):
+        """Load image from a Path object (used by FastFileManager)."""
+        if file_path.is_file() and self.file_manager.is_image_file(str(file_path)):
+            # Convert Path to QModelIndex for compatibility
+            # This allows existing code to work while using the new file manager
+            self._load_image_by_path(str(file_path))
+
     def _load_selected_image(self, index):
         """Load the selected image. Auto-saves previous work if enabled."""
 
@@ -1686,6 +1695,112 @@ class MainWindow(QMainWindow):
 
         self._show_success_notification(f"Loaded: {Path(self.current_image_path).name}")
 
+    def _load_image_by_path(self, path: str):
+        """Load image by file path directly (for FastFileManager)."""
+        # Check if we're in multi-view mode
+        if hasattr(self, "view_mode") and self.view_mode == "multi":
+            # For multi-view, we need to handle differently
+            # Load the selected image and consecutive ones
+            self._load_multi_view_from_path(path)
+            return
+
+        if path == self.current_image_path:  # Only reset if loading a new image
+            return
+
+        # Auto-save if enabled and we have a current image (not the first load)
+        if self.current_image_path and self.control_panel.get_settings().get(
+            "auto_save", True
+        ):
+            self._save_output_to_npz()
+
+        self.segment_manager.clear()
+        # Remove all scene items except the pixmap
+        items_to_remove = [
+            item
+            for item in self.viewer.scene().items()
+            if item is not self.viewer._pixmap_item
+        ]
+        for item in items_to_remove:
+            self.viewer.scene().removeItem(item)
+        self.current_image_path = path
+
+        # Load the image
+        original_image = cv2.imread(path)
+        if original_image is None:
+            logger.error(f"Failed to load image: {path}")
+            return
+
+        # Convert BGR to RGB
+        if len(original_image.shape) == 3:
+            original_image = cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB)
+        self.original_image = original_image
+
+        # Convert to QImage and display
+        height, width = original_image.shape[:2]
+        bytes_per_line = 3 * width if len(original_image.shape) == 3 else width
+
+        if len(original_image.shape) == 3:
+            q_image = QImage(
+                original_image.data.tobytes(),
+                width,
+                height,
+                bytes_per_line,
+                QImage.Format.Format_RGB888,
+            )
+        else:
+            q_image = QImage(
+                original_image.data.tobytes(),
+                width,
+                height,
+                bytes_per_line,
+                QImage.Format.Format_Grayscale8,
+            )
+
+        pixmap = QPixmap.fromImage(q_image)
+        self.viewer.set_photo(pixmap)
+
+        # Load existing segments and class aliases
+        self.file_manager.load_class_aliases(path)
+        self.file_manager.load_existing_mask(path)
+
+        # Update UI lists to reflect loaded segments
+        self._update_all_lists()
+
+        # Update display if we have an update method
+        if hasattr(self, "_update_display"):
+            self._update_display()
+        self._show_success_notification(f"Loaded: {Path(path).name}")
+
+        # Update file selection in the file manager
+        self.right_panel.select_file(Path(path))
+
+    def _load_multi_view_from_path(self, path: str):
+        """Load multi-view starting from a specific path using FastFileManager."""
+        config = self._get_multi_view_config()
+        num_viewers = config["num_viewers"]
+
+        # Auto-save if enabled
+        if (
+            hasattr(self, "multi_view_images")
+            and self.multi_view_images
+            and self.multi_view_images[0]
+            and self.control_panel.get_settings().get("auto_save", True)
+        ):
+            self._save_multi_view_output()
+
+        # Get surrounding files in current sorted/filtered order
+        file_manager = self.right_panel.file_manager
+        surrounding_files = file_manager.getSurroundingFiles(Path(path), num_viewers)
+
+        # Convert to strings for loading
+        images_to_load = [str(p) if p else None for p in surrounding_files]
+
+        # Load the images
+        self._load_multi_view_images(images_to_load)
+
+        # Update file manager selection
+        self.right_panel.select_file(Path(path))
+
     def _load_selected_image_multi_view(self, index, path):
         """Load selected image in multi-view mode starting from the selected file."""
         # Auto-save if enabled and we have current images (not the first load)
@@ -2141,17 +2256,9 @@ class MainWindow(QMainWindow):
             self._load_next_multi_batch()
             return
 
-        if not self.current_file_index.isValid():
-            return
-        parent = self.current_file_index.parent()
-        row = self.current_file_index.row()
-        # Find next valid image file
-        for next_row in range(row + 1, self.file_model.rowCount(parent)):
-            next_index = self.file_model.index(next_row, 0, parent)
-            path = self.file_model.filePath(next_index)
-            if os.path.isfile(path) and self.file_manager.is_image_file(path):
-                self._load_selected_image(next_index)
-                return
+        # Use new file manager navigation
+        self.right_panel.navigate_next_image()
+        return
 
     def _load_previous_image(self):
         """Load previous image in the file list."""
@@ -2160,17 +2267,9 @@ class MainWindow(QMainWindow):
             self._load_previous_multi_batch()
             return
 
-        if not self.current_file_index.isValid():
-            return
-        parent = self.current_file_index.parent()
-        row = self.current_file_index.row()
-        # Find previous valid image file
-        for prev_row in range(row - 1, -1, -1):
-            prev_index = self.file_model.index(prev_row, 0, parent)
-            path = self.file_model.filePath(prev_index)
-            if os.path.isfile(path) and self.file_manager.is_image_file(path):
-                self._load_selected_image(prev_index)
-                return
+        # Use new file manager navigation
+        self.right_panel.navigate_previous_image()
+        return
 
     # Segment management methods
     def _assign_selected_to_class(self):
@@ -2823,20 +2922,34 @@ class MainWindow(QMainWindow):
 
     def _handle_enter_press(self):
         """Handle enter key press."""
+        logger.debug(f"Enter 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()
-            elif self.view_mode == "multi" and hasattr(
-                self, "multi_view_polygon_points"
-            ):
+            logger.debug(
+                f"Polygon mode - polygon_points: {len(self.polygon_points) if hasattr(self, 'polygon_points') and self.polygon_points else 0}"
+            )
+            if self.view_mode == "single":
+                # If there are pending polygon points, finalize them first
+                if self.polygon_points:
+                    logger.debug("Finalizing pending polygon")
+                    self._finalize_polygon()
+                # Always save after handling pending work to show checkmarks and notifications
+                logger.debug("Saving polygon segments to NPZ")
+                self._save_output_to_npz()
+            elif self.view_mode == "multi":
                 # 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)
+                if hasattr(self, "multi_view_polygon_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)
+                # Always save after handling pending work to show checkmarks and notifications
+                self._save_output_to_npz()
         else:
             # First accept any AI segments (same as spacebar), then save
             self._accept_ai_segment()
@@ -3188,6 +3301,18 @@ class MainWindow(QMainWindow):
                     # Restore original segments
                     self.segment_manager.segments = original_segments
 
+                # Save class aliases if enabled
+                if settings.get("save_class_aliases", False) and viewer_segments:
+                    # Temporarily set segments for this viewer to save correct aliases
+                    original_segments = self.segment_manager.segments
+                    self.segment_manager.segments = viewer_segments
+
+                    aliases_path = self.file_manager.save_class_aliases(image_path)
+                    saved_files.append(os.path.basename(aliases_path))
+
+                    # Restore original segments
+                    self.segment_manager.segments = original_segments
+
                 # If no segments for this viewer, delete associated files
                 if not viewer_segments:
                     base, _ = os.path.splitext(image_path)
@@ -3198,7 +3323,13 @@ class MainWindow(QMainWindow):
                             try:
                                 os.remove(file_path)
                                 deleted_files.append(os.path.basename(file_path))
-                                self.file_model.update_cache_for_path(file_path)
+                                # Update FastFileManager after file deletion
+                                if hasattr(self, "right_panel") and hasattr(
+                                    self.right_panel, "file_manager"
+                                ):
+                                    self.right_panel.file_manager.updateFileStatus(
+                                        Path(image_path)
+                                    )
                             except Exception as e:
                                 self._show_error_notification(
                                     f"Error deleting {file_path}: {e}"
@@ -3213,20 +3344,15 @@ class MainWindow(QMainWindow):
                     f"Error saving {os.path.basename(image_path)}: {str(e)}"
                 )
 
-        # Update file list with green flash and tick marks (like single view mode)
-        if hasattr(self, "_saved_file_paths") and self._saved_file_paths:
-            for path in self._saved_file_paths:
-                if path:
-                    self.file_model.update_cache_for_path(path)
-                    self.file_model.set_highlighted_path(path)
-                    QTimer.singleShot(
-                        1500,
-                        lambda p=path: (
-                            self.file_model.set_highlighted_path(None)
-                            if self.file_model.highlighted_path == p
-                            else None
-                        ),
-                    )
+        # Update FastFileManager to show NPZ checkmarks for multi-view
+        if hasattr(self, "multi_view_images") and self.multi_view_images:
+            if hasattr(self, "right_panel") and hasattr(
+                self.right_panel, "file_manager"
+            ):
+                # Batch update for better performance
+                valid_paths = [Path(img) for img in self.multi_view_images if img]
+                if valid_paths:
+                    self.right_panel.file_manager.batchUpdateFileStatus(valid_paths)
             # Clear the tracking list for next save
             self._saved_file_paths = []
 
@@ -3258,7 +3384,13 @@ class MainWindow(QMainWindow):
                     try:
                         os.remove(file_path)
                         deleted_files.append(file_path)
-                        self.file_model.update_cache_for_path(file_path)
+                        # Update FastFileManager after file deletion
+                        if hasattr(self, "right_panel") and hasattr(
+                            self.right_panel, "file_manager"
+                        ):
+                            self.right_panel.file_manager.updateFileStatus(
+                                Path(self.current_image_path)
+                            )
                     except Exception as e:
                         self._show_error_notification(
                             f"Error deleting {file_path}: {e}"
@@ -3276,25 +3408,38 @@ class MainWindow(QMainWindow):
         try:
             settings = self.control_panel.get_settings()
             npz_path = None
-            txt_path = None
+
+            # Debug logging
+            logger.debug(f"Starting save process for: {self.current_image_path}")
+            logger.debug(f"Number of segments: {len(self.segment_manager.segments)}")
+
             if settings.get("save_npz", True):
                 h, w = (
                     self.viewer._pixmap_item.pixmap().height(),
                     self.viewer._pixmap_item.pixmap().width(),
                 )
                 class_order = self.segment_manager.get_unique_class_ids()
+                logger.debug(f"Class order for saving: {class_order}")
+
                 if class_order:
+                    logger.debug(
+                        f"Attempting to save NPZ to: {os.path.splitext(self.current_image_path)[0]}.npz"
+                    )
                     npz_path = self.file_manager.save_npz(
                         self.current_image_path,
                         (h, w),
                         class_order,
                         self.current_crop_coords,
                     )
+                    logger.debug(f"NPZ save completed: {npz_path}")
                     self._show_success_notification(
                         f"Saved: {os.path.basename(npz_path)}"
                     )
                 else:
+                    logger.warning("No classes defined for saving")
                     self._show_warning_notification("No classes defined for saving.")
+            # Save TXT file if enabled
+            txt_path = None
             if settings.get("save_txt", True):
                 h, w = (
                     self.viewer._pixmap_item.pixmap().height(),
@@ -3315,20 +3460,35 @@ class MainWindow(QMainWindow):
                         class_labels,
                         self.current_crop_coords,
                     )
-            # Efficiently update file list tickboxes and highlight
-            for path in [npz_path, txt_path]:
-                if path:
-                    self.file_model.update_cache_for_path(path)
-                    self.file_model.set_highlighted_path(path)
-                    QTimer.singleShot(
-                        1500,
-                        lambda p=path: (
-                            self.file_model.set_highlighted_path(None)
-                            if self.file_model.highlighted_path == p
-                            else None
-                        ),
+                    if txt_path:
+                        logger.debug(f"TXT save completed: {txt_path}")
+                        self._show_success_notification(
+                            f"Saved: {os.path.basename(txt_path)}"
+                        )
+
+            # Save class aliases if enabled
+            if settings.get("save_class_aliases", False):
+                aliases_path = self.file_manager.save_class_aliases(
+                    self.current_image_path
+                )
+                if aliases_path:
+                    logger.debug(f"Class aliases saved: {aliases_path}")
+                    self._show_success_notification(
+                        f"Saved: {os.path.basename(aliases_path)}"
                     )
+
+            # Update FastFileManager to show NPZ/TXT checkmarks
+            if (
+                (npz_path or txt_path)
+                and hasattr(self, "right_panel")
+                and hasattr(self.right_panel, "file_manager")
+            ):
+                # Update the file status in the FastFileManager
+                self.right_panel.file_manager.updateFileStatus(
+                    Path(self.current_image_path)
+                )
         except Exception as e:
+            logger.error(f"Error saving file: {str(e)}", exc_info=True)
             self._show_error_notification(f"Error saving: {str(e)}")
 
     def _handle_merge_press(self):
@@ -7088,24 +7248,73 @@ class MainWindow(QMainWindow):
         self._load_multi_view_images(image_paths)
 
     def _load_next_multi_batch(self):
-        """Load the next batch of images using cached list."""
-        if not self.current_file_index.isValid():
-            return
-
-        # Auto-save if enabled and we have current images (not the first load)
-        if self.multi_view_images[0] and self.control_panel.get_settings().get(
-            "auto_save", True
+        """Load the next batch of images using fast file manager or cached list."""
+        # Auto-save if enabled and we have current images
+        if (
+            hasattr(self, "multi_view_images")
+            and self.multi_view_images
+            and self.multi_view_images[0]
+            and self.control_panel.get_settings().get("auto_save", True)
         ):
             self._save_multi_view_output()
 
-        # If cached list isn't ready, fall back to file model navigation
+        # Get current image path - look for any valid image in multi-view state
+        current_path = None
+        if hasattr(self, "multi_view_images") and self.multi_view_images:
+            # Find the first valid image path in the current multi-view state
+            for img_path in self.multi_view_images:
+                if img_path:
+                    current_path = img_path
+                    break
+
+        # Fallback to current_image_path if no valid multi-view images found
+        if (
+            not current_path
+            and hasattr(self, "current_image_path")
+            and self.current_image_path
+        ):
+            current_path = self.current_image_path
+
+        # If no valid path found, can't navigate forward
+        if not current_path:
+            return
+
+        # Get the number of viewers for multi-view mode
+        config = self._get_multi_view_config()
+        num_viewers = config["num_viewers"]
+
+        # Try to use fast file manager first (respects sorting/filtering)
+        try:
+            if (
+                hasattr(self, "right_panel")
+                and hasattr(self.right_panel, "file_manager")
+                and hasattr(self.right_panel.file_manager, "getSurroundingFiles")
+            ):
+                file_manager = self.right_panel.file_manager
+                surrounding_files = file_manager.getSurroundingFiles(
+                    Path(current_path), num_viewers * 2
+                )
+
+                if len(surrounding_files) > num_viewers:
+                    # Skip ahead by num_viewers to get the next batch
+                    next_batch = surrounding_files[num_viewers : num_viewers * 2]
+
+                    # Convert to strings and load
+                    images_to_load = [str(p) if p else None for p in next_batch]
+                    self._load_multi_view_images(images_to_load)
+
+                    # Update file manager selection to first image of new batch
+                    if next_batch and next_batch[0]:
+                        self.right_panel.select_file(next_batch[0])
+                    return
+        except Exception:
+            pass  # Fall back to cached list approach
+
+        # Fall back to cached list approach (for backward compatibility / tests)
         if not self.cached_image_paths:
             self._load_next_multi_batch_fallback()
             return
 
-        # Get current image path
-        current_path = self.file_model.filePath(self.current_file_index)
-
         # Find current position in cached list
         try:
             current_index = self.cached_image_paths.index(current_path)
@@ -7114,13 +7323,14 @@ class MainWindow(QMainWindow):
             self._load_next_multi_batch_fallback()
             return
 
-        # Get the number of viewers for multi-view mode
-        config = self._get_multi_view_config()
-        num_viewers = config["num_viewers"]
-
         # Skip num_viewers positions ahead in cached list
         target_index = current_index + num_viewers
 
+        # Check if we can navigate forward (at least one valid image at target position)
+        if target_index >= len(self.cached_image_paths):
+            return  # Can't navigate forward - at or past the end
+
+        # Check if we have at least one valid image at the target position
         if target_index < len(self.cached_image_paths):
             # Collect consecutive images
             image_paths = []
@@ -7130,39 +7340,88 @@ class MainWindow(QMainWindow):
                 else:
                     image_paths.append(None)
 
-            # Load all images
-            self._load_multi_view_images(image_paths)
-
-            # Update current file index to the first image of the new batch
-            # Find the file model index for this path
-            if image_paths and image_paths[0]:
-                parent_index = self.current_file_index.parent()
-                for row in range(self.file_model.rowCount(parent_index)):
-                    index = self.file_model.index(row, 0, parent_index)
-                    if self.file_model.filePath(index) == image_paths[0]:
-                        self.current_file_index = index
-                        self.right_panel.file_tree.setCurrentIndex(index)
-                        break
+            # Only proceed if we have at least one valid image (prevent all-None batches)
+            if any(path is not None for path in image_paths):
+                # Load all images
+                self._load_multi_view_images(image_paths)
+
+                # Update current file index to the first image of the new batch
+                # Find the file model index for this path
+                if image_paths and image_paths[0]:
+                    parent_index = self.current_file_index.parent()
+                    for row in range(self.file_model.rowCount(parent_index)):
+                        index = self.file_model.index(row, 0, parent_index)
+                        if self.file_model.filePath(index) == image_paths[0]:
+                            self.current_file_index = index
+                            self.right_panel.file_tree.setCurrentIndex(index)
+                            break
+            # If all would be None, don't navigate (stay at current position)
 
     def _load_previous_multi_batch(self):
-        """Load the previous batch of images using cached list."""
-        if not self.current_file_index.isValid():
-            return
-
-        # Auto-save if enabled and we have current images (not the first load)
-        if self.multi_view_images[0] and self.control_panel.get_settings().get(
-            "auto_save", True
+        """Load the previous batch of images using fast file manager or cached list."""
+        # Auto-save if enabled and we have current images
+        if (
+            hasattr(self, "multi_view_images")
+            and self.multi_view_images
+            and self.multi_view_images[0]
+            and self.control_panel.get_settings().get("auto_save", True)
         ):
             self._save_multi_view_output()
 
-        # If cached list isn't ready, fall back to file model navigation
+        # Get current image path - look for any valid image in multi-view state
+        current_path = None
+        if hasattr(self, "multi_view_images") and self.multi_view_images:
+            # Find the first valid image path in the current multi-view state
+            for img_path in self.multi_view_images:
+                if img_path:
+                    current_path = img_path
+                    break
+
+        # Fallback to current_image_path if no valid multi-view images found
+        if (
+            not current_path
+            and hasattr(self, "current_image_path")
+            and self.current_image_path
+        ):
+            current_path = self.current_image_path
+
+        # If no valid path found, can't navigate backward
+        if not current_path:
+            return
+
+        # Get the number of viewers for multi-view mode
+        config = self._get_multi_view_config()
+        num_viewers = config["num_viewers"]
+
+        # Try to use fast file manager first (respects sorting/filtering)
+        try:
+            if (
+                hasattr(self, "right_panel")
+                and hasattr(self.right_panel, "file_manager")
+                and hasattr(self.right_panel.file_manager, "getPreviousFiles")
+            ):
+                file_manager = self.right_panel.file_manager
+                previous_batch = file_manager.getPreviousFiles(
+                    Path(current_path), num_viewers
+                )
+
+                if previous_batch and any(previous_batch):
+                    # Convert to strings and load
+                    images_to_load = [str(p) if p else None for p in previous_batch]
+                    self._load_multi_view_images(images_to_load)
+
+                    # Update file manager selection to first image of new batch
+                    if previous_batch and previous_batch[0]:
+                        self.right_panel.select_file(previous_batch[0])
+                    return
+        except Exception:
+            pass  # Fall back to cached list approach
+
+        # Fall back to cached list approach (for backward compatibility / tests)
         if not self.cached_image_paths:
             self._load_previous_multi_batch_fallback()
             return
 
-        # Get current image path
-        current_path = self.file_model.filePath(self.current_file_index)
-
         # Find current position in cached list
         try:
             current_index = self.cached_image_paths.index(current_path)
@@ -7171,10 +7430,6 @@ class MainWindow(QMainWindow):
             self._load_previous_multi_batch_fallback()
             return
 
-        # Get the number of viewers for multi-view mode
-        config = self._get_multi_view_config()
-        num_viewers = config["num_viewers"]
-
         # Skip num_viewers positions back in cached list
         target_index = current_index - num_viewers
         if target_index < 0:
@@ -7183,24 +7438,30 @@ class MainWindow(QMainWindow):
         # Collect consecutive images
         image_paths = []
         for i in range(num_viewers):
-            if target_index + i < len(self.cached_image_paths):
+            if (
+                target_index + i < len(self.cached_image_paths)
+                and target_index + i >= 0
+            ):
                 image_paths.append(self.cached_image_paths[target_index + i])
             else:
                 image_paths.append(None)
 
-        # Load all images
-        self._load_multi_view_images(image_paths)
+        # Only proceed if we have at least one valid image (prevent all-None batches)
+        if any(path is not None for path in image_paths):
+            # Load all images
+            self._load_multi_view_images(image_paths)
 
-        # Update current file index to the first image of the new batch
-        # Find the file model index for this path
-        if image_paths and image_paths[0]:
-            parent_index = self.current_file_index.parent()
-            for row in range(self.file_model.rowCount(parent_index)):
-                index = self.file_model.index(row, 0, parent_index)
-                if self.file_model.filePath(index) == image_paths[0]:
-                    self.current_file_index = index
-                    self.right_panel.file_tree.setCurrentIndex(index)
-                    break
+            # Update current file index to the first image of the new batch
+            # Find the file model index for this path
+            if image_paths and image_paths[0]:
+                parent_index = self.current_file_index.parent()
+                for row in range(self.file_model.rowCount(parent_index)):
+                    index = self.file_model.index(row, 0, parent_index)
+                    if self.file_model.filePath(index) == image_paths[0]:
+                        self.current_file_index = index
+                        self.right_panel.file_tree.setCurrentIndex(index)
+                        break
+        # If all would be None, don't navigate (stay at current position)
 
     def _load_next_multi_batch_fallback(self):
         """Fallback navigation using file model when cached list isn't available."""