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

lazylabel/core/file_manager.py

@@ -24,16 +24,48 @@ class FileManager:
         crop_coords: tuple[int, int, int, int] | None = None,
     ) -> str:
         """Save segments as NPZ file."""
+        logger.debug(f"Saving NPZ for image: {image_path}")
+        logger.debug(f"Image size: {image_size}, Class order: {class_order}")
+
+        # Validate inputs
+        if not class_order:
+            raise ValueError("No classes defined for saving")
+
         final_mask_tensor = self.segment_manager.create_final_mask_tensor(
             image_size, class_order
         )
 
+        # Validate mask tensor
+        if final_mask_tensor.size == 0:
+            raise ValueError("Empty mask tensor generated")
+
+        logger.debug(f"Final mask tensor shape: {final_mask_tensor.shape}")
+
         # Apply crop if coordinates are provided
         if crop_coords:
             final_mask_tensor = self._apply_crop_to_mask(final_mask_tensor, crop_coords)
+            logger.debug(f"Applied crop: {crop_coords}")
 
         npz_path = os.path.splitext(image_path)[0] + ".npz"
-        np.savez_compressed(npz_path, mask=final_mask_tensor.astype(np.uint8))
+
+        # Create parent directory if it doesn't exist
+        parent_dir = os.path.dirname(npz_path)
+        if parent_dir:  # Only create if there's actually a parent directory
+            os.makedirs(parent_dir, exist_ok=True)
+            logger.debug(f"Ensured directory exists: {parent_dir}")
+
+        # Save the NPZ file
+        try:
+            np.savez_compressed(npz_path, mask=final_mask_tensor.astype(np.uint8))
+            logger.debug(f"Saved NPZ file: {npz_path}")
+        except Exception as e:
+            raise OSError(f"Failed to save NPZ file {npz_path}: {str(e)}") from e
+
+        # Verify the file was actually created
+        if not os.path.exists(npz_path):
+            raise OSError(f"NPZ file was not created: {npz_path}")
+
+        logger.info(f"Successfully saved NPZ: {os.path.basename(npz_path)}")
         return npz_path
 
     def save_yolo_txt(

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
         )
@@ -1601,14 +1603,19 @@ class MainWindow(QMainWindow):
             if self.current_image_path:
                 self._mark_sam_dirty()
 
-            # Handle multi view mode - mark models as dirty so they get updated with adjusted images
+            # Handle multi view mode - use fast updates for adjusted images instead of marking dirty
             elif self.view_mode == "multi" and hasattr(self, "multi_view_models"):
+                changed_indices = []
                 for i in range(len(self.multi_view_models)):
                     if (
                         self.multi_view_images[i]
                         and self.multi_view_models[i] is not None
                     ):
-                        self._mark_multi_view_sam_dirty(i)
+                        changed_indices.append(i)
+
+                # Use fast updates instead of marking all models dirty
+                if changed_indices:
+                    self._fast_update_multi_view_images(changed_indices)
 
     # File management methods
     def _open_folder_dialog(self):
@@ -1620,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."""
 
@@ -1681,6 +1695,131 @@ 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 all files from the FastFileManager model
+        file_manager_model = self.right_panel.file_manager._model
+        all_files = []
+        current_idx = -1
+
+        # 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)
+
+        # 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)
@@ -1805,17 +1944,28 @@ class MainWindow(QMainWindow):
         while len(self._last_multi_view_images) < num_viewers:
             self._last_multi_view_images.append(None)
 
-        # Check and update SAM models for all viewers
+        # Check and update SAM models for all viewers - USE FAST UPDATES for existing models
+        changed_indices = []
         for i in range(num_viewers):
             image_path = (
                 self.multi_view_images[i] if i < len(self.multi_view_images) else None
             )
-            if (
-                i < len(self.multi_view_models)
-                and self._last_multi_view_images[i] != image_path
-            ):
+            if self._last_multi_view_images[i] != image_path:
                 self._last_multi_view_images[i] = image_path
-                self._mark_multi_view_sam_dirty(i)
+
+                # Only mark dirty if model doesn't exist yet (needs initialization)
+                if (
+                    i >= len(self.multi_view_models)
+                    or self.multi_view_models[i] is None
+                ):
+                    self._mark_multi_view_sam_dirty(i)
+                else:
+                    # Model exists - use fast image update instead of recreation
+                    changed_indices.append(i)
+
+        # Perform fast batch updates for existing models
+        if changed_indices:
+            self._fast_update_multi_view_images(changed_indices)
 
         # Load existing segments for all loaded images
         valid_image_paths = [path for path in image_paths if path is not None]
@@ -2125,17 +2275,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."""
@@ -2144,17 +2286,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):
@@ -2807,20 +2941,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()
@@ -3182,7 +3330,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.updateNpzStatus(
+                                        Path(image_path)
+                                    )
                             except Exception as e:
                                 self._show_error_notification(
                                     f"Error deleting {file_path}: {e}"
@@ -3197,20 +3351,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:
+            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))
             # Clear the tracking list for next save
             self._saved_file_paths = []
 
@@ -3242,7 +3391,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.updateNpzStatus(
+                                Path(self.current_image_path)
+                            )
                     except Exception as e:
                         self._show_error_notification(
                             f"Error deleting {file_path}: {e}"
@@ -3260,24 +3415,35 @@ 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.")
             if settings.get("save_txt", True):
                 h, w = (
@@ -3292,27 +3458,25 @@ class MainWindow(QMainWindow):
                 else:
                     class_labels = [str(cid) for cid in class_order]
                 if class_order:
-                    txt_path = self.file_manager.save_yolo_txt(
+                    self.file_manager.save_yolo_txt(
                         self.current_image_path,
                         (h, w),
                         class_order,
                         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
-                        ),
-                    )
+            # Update FastFileManager to show NPZ checkmarks
+            if (
+                npz_path
+                and hasattr(self, "right_panel")
+                and hasattr(self.right_panel, "file_manager")
+            ):
+                # Update the NPZ status in the FastFileManager
+                self.right_panel.file_manager.updateNpzStatus(
+                    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):
@@ -4944,11 +5108,19 @@ class MainWindow(QMainWindow):
             if hasattr(self, "multi_view_images") and any(self.multi_view_images):
                 self._apply_multi_view_image_processing_fast()
 
-                # Mark multi-view SAM models as dirty if needed
+                # Use fast updates for multi-view SAM models instead of marking dirty
                 if self.settings.operate_on_view:
+                    changed_indices = []
                     for i in range(len(self.multi_view_images)):
-                        if self.multi_view_images[i]:
-                            self._mark_multi_view_sam_dirty(i)
+                        if (
+                            self.multi_view_images[i]
+                            and i < len(self.multi_view_models)
+                            and self.multi_view_models[i] is not None
+                        ):
+                            changed_indices.append(i)
+
+                    if changed_indices:
+                        self._fast_update_multi_view_images(changed_indices)
             return
 
         # Handle single-view mode
@@ -4972,11 +5144,19 @@ class MainWindow(QMainWindow):
             if hasattr(self, "multi_view_images") and any(self.multi_view_images):
                 self._apply_multi_view_image_processing_fast()
 
-                # Mark multi-view SAM models as dirty if needed
+                # Use fast updates for multi-view SAM models instead of marking dirty
                 if self.settings.operate_on_view:
+                    changed_indices = []
                     for i in range(len(self.multi_view_images)):
-                        if self.multi_view_images[i]:
-                            self._mark_multi_view_sam_dirty(i)
+                        if (
+                            self.multi_view_images[i]
+                            and i < len(self.multi_view_models)
+                            and self.multi_view_models[i] is not None
+                        ):
+                            changed_indices.append(i)
+
+                    if changed_indices:
+                        self._fast_update_multi_view_images(changed_indices)
             return
 
         # Handle single-view mode
@@ -6511,10 +6691,58 @@ class MainWindow(QMainWindow):
             )
 
     def _mark_multi_view_sam_dirty(self, viewer_index):
-        """Mark multi-view SAM model as dirty (needs image update)."""
+        """Mark multi-view SAM model as dirty (needs model recreation)."""
         if 0 <= viewer_index < len(self.multi_view_models_dirty):
             self.multi_view_models_dirty[viewer_index] = True
 
+    def _update_multi_view_model_image(self, viewer_index, image_path):
+        """Fast update: Set new image in existing model without recreating model."""
+        if (
+            viewer_index >= len(self.multi_view_models)
+            or self.multi_view_models[viewer_index] is None
+            or not image_path
+        ):
+            return False
+
+        model = self.multi_view_models[viewer_index]
+
+        try:
+            # Get current modified image if operate_on_view is enabled
+            if self.settings.operate_on_view:
+                current_image = self._get_multi_view_modified_image(viewer_index)
+                if current_image is not None:
+                    return model.set_image_from_array(current_image)
+
+            # Use original image path
+            return model.set_image_from_path(image_path)
+
+        except Exception as e:
+            logger.error(f"Failed to update image for model {viewer_index}: {e}")
+            return False
+
+    def _fast_update_multi_view_images(self, changed_indices):
+        """Fast batch update of images in existing models without recreation."""
+        if not changed_indices:
+            return
+
+        logger.debug(f"Fast updating images for viewers: {changed_indices}")
+
+        for viewer_index in changed_indices:
+            if viewer_index >= len(self.multi_view_images):
+                continue
+
+            image_path = self.multi_view_images[viewer_index]
+            if image_path:
+                success = self._update_multi_view_model_image(viewer_index, image_path)
+                if success:
+                    logger.debug(f"Fast updated model {viewer_index} with new image")
+                else:
+                    # Fall back to full model update if fast update fails
+                    logger.warning(
+                        f"Fast update failed for viewer {viewer_index}, marking dirty"
+                    )
+                    self._mark_multi_view_sam_dirty(viewer_index)
+
     def _ensure_multi_view_sam_updated(self, viewer_index):
         """Ensure multi-view SAM model is updated for the given viewer."""
         config = self._get_multi_view_config()

lazylabel/ui/right_panel.py

@@ -1,5 +1,7 @@
 """Right panel with file explorer and segment management."""
 
+from pathlib import Path
+
 from PyQt6.QtCore import Qt, pyqtSignal
 from PyQt6.QtWidgets import (
     QComboBox,
@@ -14,6 +16,7 @@ from PyQt6.QtWidgets import (
     QWidget,
 )
 
+from ..utils.fast_file_manager import FastFileManager
 from .reorderable_class_table import ReorderableClassTable
 
 
@@ -23,6 +26,7 @@ class RightPanel(QWidget):
     # Signals
     open_folder_requested = pyqtSignal()
     image_selected = pyqtSignal("QModelIndex")
+    image_path_selected = pyqtSignal(Path)  # New signal for path-based selection
     merge_selection_requested = pyqtSignal()
     delete_selection_requested = pyqtSignal()
     segments_selection_changed = pyqtSignal()
@@ -109,8 +113,13 @@ class RightPanel(QWidget):
         self.btn_open_folder.setToolTip("Open a directory of images")
         layout.addWidget(self.btn_open_folder)
 
-        self.file_tree = QTreeView()
-        layout.addWidget(self.file_tree)
+        # Use new FastFileManager instead of QTreeView
+        self.file_manager = FastFileManager()
+        layout.addWidget(self.file_manager)
+
+        # Keep file_tree reference for compatibility
+        self.file_tree = QTreeView()  # Hidden, for backward compatibility
+        self.file_tree.hide()
 
         splitter.addWidget(file_explorer_widget)
 
@@ -195,6 +204,8 @@ class RightPanel(QWidget):
         """Connect internal signals."""
         self.btn_open_folder.clicked.connect(self.open_folder_requested)
         self.file_tree.doubleClicked.connect(self.image_selected)
+        # Connect new file manager signal
+        self.file_manager.fileSelected.connect(self.image_path_selected)
         self.btn_merge_selection.clicked.connect(self.merge_selection_requested)
         self.btn_delete_selection.clicked.connect(self.delete_selection_requested)
         self.segment_table.itemSelectionChanged.connect(self.segments_selection_changed)
@@ -276,12 +287,28 @@ class RightPanel(QWidget):
 
     def setup_file_model(self, file_model):
         """Setup the file model for the tree view."""
+        # Keep for backward compatibility
         self.file_tree.setModel(file_model)
         self.file_tree.setColumnWidth(0, 200)
 
     def set_folder(self, folder_path, file_model):
         """Set the folder for file browsing."""
+        # Keep old tree view for compatibility
         self.file_tree.setRootIndex(file_model.setRootPath(folder_path))
+        # Use new file manager
+        self.file_manager.setDirectory(Path(folder_path))
+
+    def navigate_next_image(self):
+        """Navigate to next image in the file manager."""
+        self.file_manager.navigateNext()
+
+    def navigate_previous_image(self):
+        """Navigate to previous image in the file manager."""
+        self.file_manager.navigatePrevious()
+
+    def select_file(self, file_path: Path):
+        """Select a specific file in the file manager."""
+        self.file_manager.selectFile(file_path)
 
     def get_selected_segment_indices(self):
         """Get indices of selected segments."""