lazylabel-gui 1.3.2__tar.gz → 1.3.3__tar.gz

{lazylabel_gui-1.3.2 → lazylabel_gui-1.3.3}/PKG-INFO

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

{lazylabel_gui-1.3.2 → lazylabel_gui-1.3.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lazylabel-gui"
-version = "1.3.2"
+version = "1.3.3"
 authors = [
   { name="Deniz N. Cakan", email="deniz.n.cakan@gmail.com" },
 ]

{lazylabel_gui-1.3.2 → lazylabel_gui-1.3.3}/src/lazylabel/ui/main_window.py

@@ -1788,31 +1788,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)
@@ -3320,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)
@@ -3334,7 +3327,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 +3346,13 @@ 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)
             # Clear the tracking list for next save
             self._saved_file_paths = []
 
@@ -3395,7 +3388,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:
@@ -3445,6 +3438,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,21 +3453,38 @@ 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 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
+                (npz_path or txt_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(
+                # Update the file status in the FastFileManager
+                self.right_panel.file_manager.updateFileStatus(
                     Path(self.current_image_path)
                 )
         except Exception as e:
@@ -7236,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)
@@ -7262,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 = []
@@ -7278,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)
@@ -7319,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:
@@ -7331,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."""

{lazylabel_gui-1.3.2 → lazylabel_gui-1.3.3}/src/lazylabel/utils/fast_file_manager.py

@@ -136,6 +136,7 @@ class FastFileModel(QAbstractTableModel):
     def __init__(self):
         super().__init__()
         self._files: list[FileInfo] = []
+        self._path_to_index: dict[str, int] = {}  # For O(1) lookups
         self._scanner: FileScanner | None = None
 
     def rowCount(self, parent=QModelIndex()):
@@ -218,6 +219,7 @@ class FastFileModel(QAbstractTableModel):
         # Clear current files
         self.beginResetModel()
         self._files.clear()
+        self._path_to_index.clear()
         self.endResetModel()
 
         # Start new scan
@@ -231,7 +233,13 @@ class FastFileModel(QAbstractTableModel):
         start_row = len(self._files)
         end_row = start_row + len(files) - 1
         self.beginInsertRows(QModelIndex(), start_row, end_row)
-        self._files.extend(files)
+
+        # Add files and update path-to-index mapping
+        for i, file_info in enumerate(files):
+            idx = start_row + i
+            self._files.append(file_info)
+            self._path_to_index[str(file_info.path)] = idx
+
         self.endInsertRows()
 
     def _on_scan_complete(self, total: int):
@@ -262,12 +270,80 @@ class FastFileModel(QAbstractTableModel):
                     self.dataChanged.emit(index, index)
                 break
 
+    def updateFileStatus(self, image_path: Path):
+        """Update both NPZ and TXT status for a specific image file"""
+        image_path_str = str(image_path)
+        npz_path = image_path.with_suffix(".npz")
+        txt_path = image_path.with_suffix(".txt")
+        has_npz = npz_path.exists()
+        has_txt = txt_path.exists()
+
+        # O(1) lookup using path-to-index mapping
+        if image_path_str not in self._path_to_index:
+            return  # File not in current view
+
+        i = self._path_to_index[image_path_str]
+        file_info = self._files[i]
+
+        # Update status and emit changes only if needed
+        old_has_npz = file_info.has_npz
+        old_has_txt = file_info.has_txt
+        file_info.has_npz = has_npz
+        file_info.has_txt = has_txt
+
+        # Emit dataChanged for NPZ column if status changed
+        if old_has_npz != has_npz:
+            index = self.index(i, 3)  # NPZ column
+            self.dataChanged.emit(index, index)
+
+        # Emit dataChanged for TXT column if status changed
+        if old_has_txt != has_txt:
+            index = self.index(i, 4)  # TXT column
+            self.dataChanged.emit(index, index)
+
     def getFileIndex(self, path: Path) -> int:
         """Get index of file by path"""
-        for i, file_info in enumerate(self._files):
-            if file_info.path == path:
-                return i
-        return -1
+        return self._path_to_index.get(str(path), -1)
+
+    def batchUpdateFileStatus(self, image_paths: list[Path]):
+        """Batch update file status for multiple files"""
+        if not image_paths:
+            return
+
+        changed_indices = []
+
+        for image_path in image_paths:
+            image_path_str = str(image_path)
+
+            # O(1) lookup using path-to-index mapping
+            if image_path_str not in self._path_to_index:
+                continue  # File not in current view
+
+            i = self._path_to_index[image_path_str]
+            file_info = self._files[i]
+
+            # Check file existence
+            npz_path = image_path.with_suffix(".npz")
+            txt_path = image_path.with_suffix(".txt")
+            has_npz = npz_path.exists()
+            has_txt = txt_path.exists()
+
+            # Update status and track changes
+            old_has_npz = file_info.has_npz
+            old_has_txt = file_info.has_txt
+            file_info.has_npz = has_npz
+            file_info.has_txt = has_txt
+
+            # Track changed indices for batch emission
+            if old_has_npz != has_npz:
+                changed_indices.append((i, 3))  # NPZ column
+            if old_has_txt != has_txt:
+                changed_indices.append((i, 4))  # TXT column
+
+        # Batch emit dataChanged signals
+        for i, col in changed_indices:
+            index = self.index(i, col)
+            self.dataChanged.emit(index, index)
 
 
 class FileSortProxyModel(QSortFilterProxyModel):
@@ -551,9 +627,88 @@ class FastFileManager(QWidget):
         """Update NPZ status for a specific image file"""
         self._model.updateNpzStatus(image_path)
 
+    def updateFileStatus(self, image_path: Path):
+        """Update both NPZ and TXT status for a specific image file"""
+        self._model.updateFileStatus(image_path)
+
     def refreshFile(self, image_path: Path):
-        """Refresh status for a specific file (alias for updateNpzStatus)"""
-        self.updateNpzStatus(image_path)
+        """Refresh status for a specific file"""
+        self.updateFileStatus(image_path)
+
+    def batchUpdateFileStatus(self, image_paths: list[Path]):
+        """Batch update file status for multiple files"""
+        self._model.batchUpdateFileStatus(image_paths)
+
+    def getSurroundingFiles(self, current_path: Path, count: int) -> list[Path]:
+        """Get files in current sorted/filtered order surrounding the given path"""
+        files = []
+
+        # Find current file in proxy model order
+        current_index = -1
+        for row in range(self._proxy_model.rowCount()):
+            proxy_index = self._proxy_model.index(row, 0)
+            source_index = self._proxy_model.mapToSource(proxy_index)
+            file_info = self._model.getFileInfo(source_index.row())
+            if file_info and file_info.path == current_path:
+                current_index = row
+                break
+
+        if current_index == -1:
+            return []  # File not found in current view
+
+        # Get surrounding files in proxy order
+        for i in range(count):
+            row = current_index + i
+            if row < self._proxy_model.rowCount():
+                proxy_index = self._proxy_model.index(row, 0)
+                source_index = self._proxy_model.mapToSource(proxy_index)
+                file_info = self._model.getFileInfo(source_index.row())
+                if file_info:
+                    files.append(file_info.path)
+                else:
+                    files.append(None)
+            else:
+                files.append(None)
+
+        return files
+
+    def getPreviousFiles(self, current_path: Path, count: int) -> list[Path]:
+        """Get previous files in current sorted/filtered order before the given path"""
+        files = []
+
+        # Find current file in proxy model order
+        current_index = -1
+        for row in range(self._proxy_model.rowCount()):
+            proxy_index = self._proxy_model.index(row, 0)
+            source_index = self._proxy_model.mapToSource(proxy_index)
+            file_info = self._model.getFileInfo(source_index.row())
+            if file_info and file_info.path == current_path:
+                current_index = row
+                break
+
+        if current_index == -1:
+            return []  # File not found in current view
+
+        # Get previous files going backward from current position
+        start_row = current_index - count
+        if start_row < 0:
+            start_row = 0
+
+        # Get consecutive files starting from start_row
+        for i in range(count):
+            row = start_row + i
+            if row < current_index and row >= 0:
+                proxy_index = self._proxy_model.index(row, 0)
+                source_index = self._proxy_model.mapToSource(proxy_index)
+                file_info = self._model.getFileInfo(source_index.row())
+                if file_info:
+                    files.append(file_info.path)
+                else:
+                    files.append(None)
+            else:
+                files.append(None)
+
+        return files
 
     def _on_item_clicked(self, index: QModelIndex):
         """Handle item click"""

{lazylabel_gui-1.3.2 → lazylabel_gui-1.3.3}/src/lazylabel_gui.egg-info/PKG-INFO

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