lazylabel-gui 1.3.2__py3-none-any.whl → 1.3.4__py3-none-any.whl

lazylabel/ui/main_window.py

@@ -19,12 +19,14 @@ from PyQt6.QtGui import (
     QShortcut,
 )
 from PyQt6.QtWidgets import (
+    QApplication,
     QDialog,
     QFileDialog,
     QGraphicsEllipseItem,
     QGraphicsLineItem,
     QGraphicsPolygonItem,
     QGraphicsRectItem,
+    QGridLayout,
     QHBoxLayout,
     QLabel,
     QMainWindow,
@@ -772,6 +774,7 @@ class MainWindow(QMainWindow):
         logger.info("Step 5/8: Discovering available models...")
         self._setup_model_manager()  # Just setup manager, don't load model
         self._setup_connections()
+        self._fix_fft_connection()  # Workaround for FFT signal connection issue
         self._setup_shortcuts()
         self._load_settings()
 
@@ -877,12 +880,7 @@ class MainWindow(QMainWindow):
         grid_widget = QWidget()
 
         # Use grid layout for 4-view, horizontal layout for 2-view
-        if use_grid:
-            from PyQt6.QtWidgets import QGridLayout
-
-            grid_layout = QGridLayout(grid_widget)
-        else:
-            grid_layout = QHBoxLayout(grid_widget)
+        grid_layout = QGridLayout(grid_widget) if use_grid else QHBoxLayout(grid_widget)
         grid_layout.setSpacing(5)
 
         self.multi_view_viewers = []
@@ -951,29 +949,30 @@ class MainWindow(QMainWindow):
         grid_mode_label = QLabel("View Mode:")
         controls_layout.addWidget(grid_mode_label)
 
-        from PyQt6.QtWidgets import QComboBox
+        from lazylabel.ui.widgets.model_selection_widget import CustomDropdown
 
-        self.grid_mode_combo = QComboBox()
+        self.grid_mode_combo = CustomDropdown()
+        self.grid_mode_combo.setText("View Mode")  # Default text
         self.grid_mode_combo.addItem("2 Views (1x2)", "2_view")
         self.grid_mode_combo.addItem("4 Views (2x2)", "4_view")
 
         # Set current selection based on settings
         current_mode = self.settings.multi_view_grid_mode
-        for i in range(self.grid_mode_combo.count()):
+        for i in range(len(self.grid_mode_combo.items)):
             if self.grid_mode_combo.itemData(i) == current_mode:
                 self.grid_mode_combo.setCurrentIndex(i)
                 break
 
-        self.grid_mode_combo.currentTextChanged.connect(self._on_grid_mode_changed)
+        self.grid_mode_combo.activated.connect(self._on_grid_mode_changed)
         controls_layout.addWidget(self.grid_mode_combo)
 
         controls_layout.addStretch()
 
         layout.addWidget(controls_widget)
 
-    def _on_grid_mode_changed(self):
+    def _on_grid_mode_changed(self, index):
         """Handle grid mode change from combo box."""
-        current_data = self.grid_mode_combo.currentData()
+        current_data = self.grid_mode_combo.itemData(index)
         if current_data and current_data != self.settings.multi_view_grid_mode:
             # Update settings
             self.settings.multi_view_grid_mode = current_data
@@ -1062,8 +1061,7 @@ class MainWindow(QMainWindow):
                 layout.deleteLater()
             except Exception as e:
                 # If layout clearing fails, just reset the viewer lists
-                print(f"Layout clearing failed: {e}")
-                pass
+                logger.error(f"Layout clearing failed: {e}")
 
     def _clear_multi_view_layout(self):
         """Clear the existing multi-view layout."""
@@ -1121,6 +1119,48 @@ class MainWindow(QMainWindow):
             # Switch to polygon mode if SAM is disabled and we're in SAM/AI mode
             self.set_polygon_mode()
 
+    def _fix_fft_connection(self):
+        """Fix FFT signal connection issue - workaround for connection timing problem."""
+        try:
+            # Get the FFT widget directly and connect to its signal
+            fft_widget = self.control_panel.get_fft_threshold_widget()
+            if fft_widget:
+                # Direct connection bypass - connect FFT widget directly to main window handler
+                # This bypasses the control panel signal forwarding which has timing issues
+                # Use a wrapper to ensure the connection works reliably
+                def fft_signal_wrapper():
+                    self._handle_fft_threshold_changed()
+
+                fft_widget.fft_threshold_changed.connect(fft_signal_wrapper)
+
+                logger.info("FFT signal connection bypass established successfully")
+            else:
+                logger.warning("FFT widget not found during connection fix")
+        except Exception as e:
+            logger.warning(f"Failed to establish FFT connection bypass: {e}")
+
+        # Also fix channel threshold connection for RGB images
+        try:
+            channel_widget = self.control_panel.get_channel_threshold_widget()
+            if channel_widget:
+                # Direct connection bypass for channel threshold widget too
+                def channel_signal_wrapper():
+                    self._handle_channel_threshold_changed()
+
+                channel_widget.thresholdChanged.connect(channel_signal_wrapper)
+
+                logger.info(
+                    "Channel threshold signal connection bypass established successfully"
+                )
+            else:
+                logger.warning(
+                    "Channel threshold widget not found during connection fix"
+                )
+        except Exception as e:
+            logger.warning(
+                f"Failed to establish channel threshold connection bypass: {e}"
+            )
+
     def _setup_connections(self):
         """Setup signal connections."""
         # Control panel connections
@@ -1169,9 +1209,13 @@ class MainWindow(QMainWindow):
         )
 
         # FFT threshold connections
-        self.control_panel.fft_threshold_changed.connect(
-            self._handle_fft_threshold_changed
-        )
+        try:
+            self.control_panel.fft_threshold_changed.connect(
+                self._handle_fft_threshold_changed
+            )
+            logger.debug("FFT threshold connection established in _setup_connections")
+        except Exception as e:
+            logger.error(f"Failed to establish FFT threshold connection: {e}")
 
         # Right panel connections
         self.right_panel.open_folder_requested.connect(self._open_folder_dialog)
@@ -1774,6 +1818,9 @@ class MainWindow(QMainWindow):
         # Update file selection in the file manager
         self.right_panel.select_file(Path(path))
 
+        # Update threshold widgets for new image (this was missing!)
+        self._update_channel_threshold_for_image(pixmap)
+
     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()
@@ -1788,31 +1835,12 @@ class MainWindow(QMainWindow):
         ):
             self._save_multi_view_output()
 
-        # Get all files from the FastFileManager model
-        file_manager_model = self.right_panel.file_manager._model
-        all_files = []
-        current_idx = -1
+        # Get surrounding files in current sorted/filtered order
+        file_manager = self.right_panel.file_manager
+        surrounding_files = file_manager.getSurroundingFiles(Path(path), num_viewers)
 
-        # Collect all files from the model
-        for i in range(file_manager_model.rowCount()):
-            file_info = file_manager_model.getFileInfo(i)
-            if file_info:
-                all_files.append(str(file_info.path))
-                if str(file_info.path) == path:
-                    current_idx = i
-
-        if current_idx == -1:
-            # File not found in current list
-            return
-
-        # Load consecutive images
-        images_to_load = []
-        for i in range(num_viewers):
-            idx = current_idx + i
-            if idx < len(all_files):
-                images_to_load.append(all_files[idx])
-            else:
-                images_to_load.append(None)
+        # 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)
@@ -1967,6 +1995,9 @@ class MainWindow(QMainWindow):
         if changed_indices:
             self._fast_update_multi_view_images(changed_indices)
 
+        # Update threshold widgets for the loaded images
+        self._update_multi_view_channel_threshold_for_images()
+
         # Load existing segments for all loaded images
         valid_image_paths = [path for path in image_paths if path is not None]
         if valid_image_paths:
@@ -2024,7 +2055,9 @@ class MainWindow(QMainWindow):
                         all_segments.extend(viewer_segments)
                         self.segment_manager.segments.clear()
                     except Exception as e:
-                        print(f"Error loading segments for viewer {viewer_index}: {e}")
+                        logger.error(
+                            f"Error loading segments for viewer {viewer_index}: {e}"
+                        )
 
             # Set all segments at once
             self.segment_manager.segments = all_segments
@@ -2044,7 +2077,7 @@ class MainWindow(QMainWindow):
                 self._update_all_lists()
 
         except Exception as e:
-            print(f"Error in _load_multi_view_segments: {e}")
+            logger.error(f"Error in _load_multi_view_segments: {e}")
             self.segment_manager.segments.clear()
 
     def _cancel_multi_view_sam_loading(self):
@@ -3320,6 +3353,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)
@@ -3334,7 +3379,7 @@ class MainWindow(QMainWindow):
                                 if hasattr(self, "right_panel") and hasattr(
                                     self.right_panel, "file_manager"
                                 ):
-                                    self.right_panel.file_manager.updateNpzStatus(
+                                    self.right_panel.file_manager.updateFileStatus(
                                         Path(image_path)
                                     )
                             except Exception as e:
@@ -3353,13 +3398,15 @@ class MainWindow(QMainWindow):
 
         # Update FastFileManager to show NPZ checkmarks for multi-view
         if hasattr(self, "multi_view_images") and self.multi_view_images:
-            for image_path in self.multi_view_images:
-                if (
-                    image_path
-                    and hasattr(self, "right_panel")
-                    and hasattr(self.right_panel, "file_manager")
-                ):
-                    self.right_panel.file_manager.updateNpzStatus(Path(image_path))
+            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)
+                    # Force immediate GUI update
+                    QApplication.processEvents()
             # Clear the tracking list for next save
             self._saved_file_paths = []
 
@@ -3395,7 +3442,7 @@ class MainWindow(QMainWindow):
                         if hasattr(self, "right_panel") and hasattr(
                             self.right_panel, "file_manager"
                         ):
-                            self.right_panel.file_manager.updateNpzStatus(
+                            self.right_panel.file_manager.updateFileStatus(
                                 Path(self.current_image_path)
                             )
                     except Exception as e:
@@ -3408,6 +3455,8 @@ class MainWindow(QMainWindow):
                 )
                 # Update UI immediately when files are deleted
                 self._update_all_lists()
+                # Force immediate GUI update
+                QApplication.processEvents()
             else:
                 self._show_warning_notification("No segments to save.")
             return
@@ -3445,6 +3494,8 @@ class MainWindow(QMainWindow):
                 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(),
@@ -3458,23 +3509,41 @@ class MainWindow(QMainWindow):
                 else:
                     class_labels = [str(cid) for cid in class_order]
                 if class_order:
-                    self.file_manager.save_yolo_txt(
+                    txt_path = self.file_manager.save_yolo_txt(
                         self.current_image_path,
                         (h, w),
                         class_order,
                         class_labels,
                         self.current_crop_coords,
                     )
-            # Update FastFileManager to show NPZ checkmarks
-            if (
-                npz_path
-                and hasattr(self, "right_panel")
-                and hasattr(self.right_panel, "file_manager")
+                    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
+            # Always update file status after save attempt (regardless of what was saved)
+            if hasattr(self, "right_panel") and hasattr(
+                self.right_panel, "file_manager"
             ):
-                # Update the NPZ status in the FastFileManager
-                self.right_panel.file_manager.updateNpzStatus(
+                # Update the file status in the FastFileManager
+                self.right_panel.file_manager.updateFileStatus(
                     Path(self.current_image_path)
                 )
+                # Force immediate GUI update
+                QApplication.processEvents()
         except Exception as e:
             logger.error(f"Error saving file: {str(e)}", exc_info=True)
             self._show_error_notification(f"Error saving: {str(e)}")
@@ -5702,27 +5771,50 @@ class MainWindow(QMainWindow):
 
     def _update_channel_threshold_for_image(self, pixmap):
         """Update channel threshold widget for the given image pixmap."""
-        if pixmap.isNull():
+        if pixmap.isNull() or not self.current_image_path:
             self.control_panel.update_channel_threshold_for_image(None)
             return
 
-        # Convert pixmap to numpy array
-        qimage = pixmap.toImage()
-        ptr = qimage.constBits()
-        ptr.setsize(qimage.bytesPerLine() * qimage.height())
-        image_np = np.array(ptr).reshape(qimage.height(), qimage.width(), 4)
-        # Convert from BGRA to RGB, ignore alpha
-        image_rgb = image_np[:, :, [2, 1, 0]]
+        # Use cv2.imread for more robust loading instead of QPixmap conversion
+        try:
+            import cv2
 
-        # Check if image is grayscale (all channels are the same)
-        if np.array_equal(image_rgb[:, :, 0], image_rgb[:, :, 1]) and np.array_equal(
-            image_rgb[:, :, 1], image_rgb[:, :, 2]
-        ):
-            # Convert to single channel grayscale
-            image_array = image_rgb[:, :, 0]
-        else:
-            # Keep as RGB
-            image_array = image_rgb
+            image_array = cv2.imread(self.current_image_path)
+            if image_array is None:
+                self.control_panel.update_channel_threshold_for_image(None)
+                return
+
+            # Convert from BGR to RGB
+            if len(image_array.shape) == 3 and image_array.shape[2] == 3:
+                image_array = cv2.cvtColor(image_array, cv2.COLOR_BGR2RGB)
+
+            # Check if image is grayscale (all channels are the same)
+            if (
+                len(image_array.shape) == 3
+                and np.array_equal(image_array[:, :, 0], image_array[:, :, 1])
+                and np.array_equal(image_array[:, :, 1], image_array[:, :, 2])
+            ):
+                # Convert to single channel grayscale
+                image_array = image_array[:, :, 0]
+
+        except Exception:
+            # Fallback to QPixmap conversion if cv2 fails
+            qimage = pixmap.toImage()
+            ptr = qimage.constBits()
+            ptr.setsize(qimage.bytesPerLine() * qimage.height())
+            image_np = np.array(ptr).reshape(qimage.height(), qimage.width(), 4)
+            # Convert from BGRA to RGB, ignore alpha
+            image_rgb = image_np[:, :, [2, 1, 0]]
+
+            # Check if image is grayscale (all channels are the same)
+            if np.array_equal(
+                image_rgb[:, :, 0], image_rgb[:, :, 1]
+            ) and np.array_equal(image_rgb[:, :, 1], image_rgb[:, :, 2]):
+                # Convert to single channel grayscale
+                image_array = image_rgb[:, :, 0]
+            else:
+                # Keep as RGB
+                image_array = image_rgb
 
         # Update the channel threshold widget
         self.control_panel.update_channel_threshold_for_image(image_array)
@@ -5750,29 +5842,51 @@ class MainWindow(QMainWindow):
             self.control_panel.update_channel_threshold_for_image(None)
             return
 
-        # Load and convert the first image to update the widget
-        pixmap = QPixmap(first_image_path)
-        if pixmap.isNull():
-            self.control_panel.update_channel_threshold_for_image(None)
-            return
+        # Use cv2.imread for more robust loading instead of QPixmap conversion
+        try:
+            import cv2
 
-        # Convert pixmap to numpy array
-        qimage = pixmap.toImage()
-        ptr = qimage.constBits()
-        ptr.setsize(qimage.bytesPerLine() * qimage.height())
-        image_np = np.array(ptr).reshape(qimage.height(), qimage.width(), 4)
-        # Convert from BGRA to RGB, ignore alpha
-        image_rgb = image_np[:, :, [2, 1, 0]]
+            image_array = cv2.imread(first_image_path)
+            if image_array is None:
+                self.control_panel.update_channel_threshold_for_image(None)
+                return
 
-        # Check if image is grayscale (all channels are the same)
-        if np.array_equal(image_rgb[:, :, 0], image_rgb[:, :, 1]) and np.array_equal(
-            image_rgb[:, :, 1], image_rgb[:, :, 2]
-        ):
-            # Convert to single channel grayscale
-            image_array = image_rgb[:, :, 0]
-        else:
-            # Keep as RGB
-            image_array = image_rgb
+            # Convert from BGR to RGB
+            if len(image_array.shape) == 3 and image_array.shape[2] == 3:
+                image_array = cv2.cvtColor(image_array, cv2.COLOR_BGR2RGB)
+
+            # Check if image is grayscale (all channels are the same)
+            if (
+                len(image_array.shape) == 3
+                and np.array_equal(image_array[:, :, 0], image_array[:, :, 1])
+                and np.array_equal(image_array[:, :, 1], image_array[:, :, 2])
+            ):
+                # Convert to single channel grayscale
+                image_array = image_array[:, :, 0]
+
+        except Exception:
+            # Fallback to QPixmap conversion if cv2 fails
+            pixmap = QPixmap(first_image_path)
+            if pixmap.isNull():
+                self.control_panel.update_channel_threshold_for_image(None)
+                return
+
+            qimage = pixmap.toImage()
+            ptr = qimage.constBits()
+            ptr.setsize(qimage.bytesPerLine() * qimage.height())
+            image_np = np.array(ptr).reshape(qimage.height(), qimage.width(), 4)
+            # Convert from BGRA to RGB, ignore alpha
+            image_rgb = image_np[:, :, [2, 1, 0]]
+
+            # Check if image is grayscale (all channels are the same)
+            if np.array_equal(
+                image_rgb[:, :, 0], image_rgb[:, :, 1]
+            ) and np.array_equal(image_rgb[:, :, 1], image_rgb[:, :, 2]):
+                # Convert to single channel grayscale
+                image_array = image_rgb[:, :, 0]
+            else:
+                # Keep as RGB
+                image_array = image_rgb
 
         # Update the channel threshold widget
         self.control_panel.update_channel_threshold_for_image(image_array)
@@ -7085,7 +7199,6 @@ class MainWindow(QMainWindow):
                 )
 
                 # Load existing segments for the current image
-                print(f"Loading segments for single-view: {self.current_image_path}")
                 try:
                     # Clear any leftover multi-view segments first
                     self.segment_manager.clear()
@@ -7102,7 +7215,7 @@ class MainWindow(QMainWindow):
                     self._update_all_lists()
 
                 except Exception as e:
-                    print(f"Error loading segments for single-view: {e}")
+                    logger.error(f"Error loading segments for single-view: {e}")
 
                 # Redisplay segments for single view
                 if hasattr(self, "single_view_mode_handler"):
@@ -7236,24 +7349,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)
@@ -7262,13 +7424,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 = []
@@ -7278,39 +7441,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)
@@ -7319,10 +7531,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:
@@ -7331,24 +7539,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."""