lazylabel-gui 1.0.9__py3-none-any.whl → 1.1.0__py3-none-any.whl

lazylabel/ui/right_panel.py

@@ -0,0 +1,239 @@
+"""Right panel with file explorer and segment management."""
+
+from PyQt6.QtWidgets import (
+    QWidget, QVBoxLayout, QPushButton, QLabel, QHBoxLayout,
+    QTableWidget, QTreeView, QComboBox, QSplitter, QSpacerItem, QHeaderView
+)
+from PyQt6.QtCore import Qt, pyqtSignal
+from PyQt6.QtGui import QBrush, QColor
+
+from .reorderable_class_table import ReorderableClassTable
+from .numeric_table_widget_item import NumericTableWidgetItem
+
+
+class RightPanel(QWidget):
+    """Right panel with file explorer and segment management."""
+    
+    # Signals
+    open_folder_requested = pyqtSignal()
+    image_selected = pyqtSignal('QModelIndex')
+    merge_selection_requested = pyqtSignal()
+    delete_selection_requested = pyqtSignal()
+    segments_selection_changed = pyqtSignal()
+    class_alias_changed = pyqtSignal(int, str)  # class_id, alias
+    reassign_classes_requested = pyqtSignal()
+    class_filter_changed = pyqtSignal()
+    
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setFixedWidth(350)
+        self._setup_ui()
+        self._connect_signals()
+    
+    def _setup_ui(self):
+        """Setup the UI layout."""
+        self.v_layout = QVBoxLayout(self)
+        
+        # Toggle button
+        toggle_layout = QHBoxLayout()
+        toggle_layout.addStretch()
+        self.btn_toggle_visibility = QPushButton("Hide >")
+        self.btn_toggle_visibility.setToolTip("Hide this panel")
+        toggle_layout.addWidget(self.btn_toggle_visibility)
+        self.v_layout.addLayout(toggle_layout)
+        
+        # Main controls widget
+        self.main_controls_widget = QWidget()
+        main_layout = QVBoxLayout(self.main_controls_widget)
+        main_layout.setContentsMargins(0, 0, 0, 0)
+        
+        # Vertical splitter for sections
+        v_splitter = QSplitter(Qt.Orientation.Vertical)
+        
+        # File explorer section
+        self._setup_file_explorer(v_splitter)
+        
+        # Segment management section
+        self._setup_segment_management(v_splitter)
+        
+        # Class management section
+        self._setup_class_management(v_splitter)
+        
+        main_layout.addWidget(v_splitter)
+        
+        # Status label
+        self.status_label = QLabel("")
+        self.status_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        main_layout.addWidget(self.status_label)
+        
+        self.v_layout.addWidget(self.main_controls_widget)
+    
+    def _setup_file_explorer(self, splitter):
+        """Setup file explorer section."""
+        file_explorer_widget = QWidget()
+        layout = QVBoxLayout(file_explorer_widget)
+        layout.setContentsMargins(0, 0, 0, 0)
+        
+        self.btn_open_folder = QPushButton("Open Image Folder")
+        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)
+        
+        splitter.addWidget(file_explorer_widget)
+    
+    def _setup_segment_management(self, splitter):
+        """Setup segment management section."""
+        segment_widget = QWidget()
+        layout = QVBoxLayout(segment_widget)
+        layout.setContentsMargins(0, 0, 0, 0)
+        
+        # Class filter
+        filter_layout = QHBoxLayout()
+        filter_layout.addWidget(QLabel("Filter Class:"))
+        self.class_filter_combo = QComboBox()
+        self.class_filter_combo.setToolTip("Filter segments list by class")
+        filter_layout.addWidget(self.class_filter_combo)
+        layout.addLayout(filter_layout)
+        
+        # Segment table
+        self.segment_table = QTableWidget()
+        self.segment_table.setColumnCount(3)
+        self.segment_table.setHorizontalHeaderLabels(["Segment ID", "Class ID", "Alias"])
+        self.segment_table.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.Stretch)
+        self.segment_table.setSelectionBehavior(QTableWidget.SelectionBehavior.SelectRows)
+        self.segment_table.setSortingEnabled(True)
+        self.segment_table.setEditTriggers(QTableWidget.EditTrigger.NoEditTriggers)
+        layout.addWidget(self.segment_table)
+        
+        # Action buttons
+        action_layout = QHBoxLayout()
+        self.btn_merge_selection = QPushButton("Merge to Class")
+        self.btn_merge_selection.setToolTip("Merge selected segments into a single class (M)")
+        self.btn_delete_selection = QPushButton("Delete")
+        self.btn_delete_selection.setToolTip("Delete selected segments (Delete/Backspace)")
+        action_layout.addWidget(self.btn_merge_selection)
+        action_layout.addWidget(self.btn_delete_selection)
+        layout.addLayout(action_layout)
+        
+        splitter.addWidget(segment_widget)
+    
+    def _setup_class_management(self, splitter):
+        """Setup class management section."""
+        class_widget = QWidget()
+        layout = QVBoxLayout(class_widget)
+        layout.setContentsMargins(0, 0, 0, 0)
+        
+        layout.addWidget(QLabel("Class Order:"))
+        
+        self.class_table = ReorderableClassTable()
+        self.class_table.setToolTip(
+            "Double-click to set class aliases and drag to reorder channels for saving."
+        )
+        self.class_table.setColumnCount(2)
+        self.class_table.setHorizontalHeaderLabels(["Alias", "Class ID"])
+        self.class_table.horizontalHeader().setSectionResizeMode(0, QHeaderView.ResizeMode.Stretch)
+        self.class_table.horizontalHeader().setSectionResizeMode(1, QHeaderView.ResizeMode.ResizeToContents)
+        self.class_table.setEditTriggers(QTableWidget.EditTrigger.DoubleClicked)
+        layout.addWidget(self.class_table)
+        
+        self.btn_reassign_classes = QPushButton("Reassign Class IDs")
+        self.btn_reassign_classes.setToolTip(
+            "Re-index class channels based on the current order in this table"
+        )
+        layout.addWidget(self.btn_reassign_classes)
+        
+        splitter.addWidget(class_widget)
+    
+    def _connect_signals(self):
+        """Connect internal signals."""
+        self.btn_open_folder.clicked.connect(self.open_folder_requested)
+        self.file_tree.doubleClicked.connect(self.image_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)
+        self.class_table.itemChanged.connect(self._handle_class_alias_change)
+        self.btn_reassign_classes.clicked.connect(self.reassign_classes_requested)
+        self.class_filter_combo.currentIndexChanged.connect(self.class_filter_changed)
+    
+    def _handle_class_alias_change(self, item):
+        """Handle class alias change in table."""
+        if item.column() != 0:  # Only handle alias column
+            return
+        
+        class_table = self.class_table
+        id_item = class_table.item(item.row(), 1)
+        if id_item:
+            try:
+                class_id = int(id_item.text())
+                self.class_alias_changed.emit(class_id, item.text())
+            except (ValueError, AttributeError):
+                pass
+    
+    def setup_file_model(self, file_model):
+        """Setup the file model for the tree view."""
+        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."""
+        self.file_tree.setRootIndex(file_model.setRootPath(folder_path))
+    
+    def toggle_visibility(self):
+        """Toggle panel visibility."""
+        is_visible = self.main_controls_widget.isVisible()
+        self.main_controls_widget.setVisible(not is_visible)
+        
+        if is_visible:  # Content is now hidden
+            self.v_layout.addStretch(1)
+            self.btn_toggle_visibility.setText("< Show")
+            self.setFixedWidth(self.btn_toggle_visibility.sizeHint().width() + 20)
+        else:  # Content is now visible
+            # Remove the stretch
+            for i in range(self.v_layout.count()):
+                item = self.v_layout.itemAt(i)
+                if isinstance(item, QSpacerItem):
+                    self.v_layout.removeItem(item)
+                    break
+            self.btn_toggle_visibility.setText("Hide >")
+            self.setFixedWidth(350)
+    
+    def get_selected_segment_indices(self):
+        """Get indices of selected segments."""
+        selected_items = self.segment_table.selectedItems()
+        selected_rows = sorted(list({item.row() for item in selected_items}))
+        return [
+            self.segment_table.item(row, 0).data(Qt.ItemDataRole.UserRole)
+            for row in selected_rows
+            if self.segment_table.item(row, 0)
+        ]
+    
+    def get_class_order(self):
+        """Get the current class order from the class table."""
+        ordered_ids = []
+        for row in range(self.class_table.rowCount()):
+            id_item = self.class_table.item(row, 1)
+            if id_item and id_item.text():
+                try:
+                    ordered_ids.append(int(id_item.text()))
+                except ValueError:
+                    continue
+        return ordered_ids
+    
+    def clear_selections(self):
+        """Clear all selections."""
+        self.segment_table.clearSelection()
+        self.class_table.clearSelection()
+    
+    def select_all_segments(self):
+        """Select all segments."""
+        self.segment_table.selectAll()
+    
+    def set_status(self, message):
+        """Set status message."""
+        self.status_label.setText(message)
+    
+    def clear_status(self):
+        """Clear status message."""
+        self.status_label.clear()

lazylabel/ui/widgets/__init__.py

@@ -0,0 +1,7 @@
+"""UI widgets for LazyLabel."""
+
+from .model_selection_widget import ModelSelectionWidget
+from .settings_widget import SettingsWidget
+from .adjustments_widget import AdjustmentsWidget
+
+__all__ = ['ModelSelectionWidget', 'SettingsWidget', 'AdjustmentsWidget']

lazylabel/ui/widgets/adjustments_widget.py

@@ -0,0 +1,107 @@
+"""Adjustments widget for sliders and controls."""
+
+from PyQt6.QtWidgets import QWidget, QVBoxLayout, QLabel, QSlider, QGroupBox
+from PyQt6.QtCore import Qt, pyqtSignal
+
+
+class AdjustmentsWidget(QWidget):
+    """Widget for adjustment controls."""
+    
+    annotation_size_changed = pyqtSignal(int)
+    pan_speed_changed = pyqtSignal(int)
+    join_threshold_changed = pyqtSignal(int)
+    
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._setup_ui()
+        self._connect_signals()
+    
+    def _setup_ui(self):
+        """Setup the UI layout."""
+        group = QGroupBox("Adjustments")
+        layout = QVBoxLayout(group)
+        
+        # Annotation size
+        self.size_label = QLabel("Annotation Size: 1.0x")
+        self.size_slider = QSlider(Qt.Orientation.Horizontal)
+        self.size_slider.setRange(1, 50)
+        self.size_slider.setValue(10)
+        self.size_slider.setToolTip("Adjusts the size of points and lines (Ctrl +/-)")
+        layout.addWidget(self.size_label)
+        layout.addWidget(self.size_slider)
+        
+        layout.addSpacing(10)
+        
+        # Pan speed
+        self.pan_label = QLabel("Pan Speed: 1.0x")
+        self.pan_slider = QSlider(Qt.Orientation.Horizontal)
+        self.pan_slider.setRange(1, 100)
+        self.pan_slider.setValue(10)
+        self.pan_slider.setToolTip(
+            "Adjusts the speed of WASD panning. Hold Shift for 5x boost."
+        )
+        layout.addWidget(self.pan_label)
+        layout.addWidget(self.pan_slider)
+        
+        layout.addSpacing(10)
+        
+        # Polygon join threshold
+        self.join_label = QLabel("Polygon Join Distance: 2px")
+        self.join_slider = QSlider(Qt.Orientation.Horizontal)
+        self.join_slider.setRange(1, 10)
+        self.join_slider.setValue(2)
+        self.join_slider.setToolTip("The pixel distance to 'snap' a polygon closed.")
+        layout.addWidget(self.join_label)
+        layout.addWidget(self.join_slider)
+        
+        # Main layout
+        main_layout = QVBoxLayout(self)
+        main_layout.setContentsMargins(0, 0, 0, 0)
+        main_layout.addWidget(group)
+    
+    def _connect_signals(self):
+        """Connect internal signals."""
+        self.size_slider.valueChanged.connect(self._on_size_changed)
+        self.pan_slider.valueChanged.connect(self._on_pan_changed)
+        self.join_slider.valueChanged.connect(self._on_join_changed)
+    
+    def _on_size_changed(self, value):
+        """Handle annotation size change."""
+        multiplier = value / 10.0
+        self.size_label.setText(f"Annotation Size: {multiplier:.1f}x")
+        self.annotation_size_changed.emit(value)
+    
+    def _on_pan_changed(self, value):
+        """Handle pan speed change."""
+        multiplier = value / 10.0
+        self.pan_label.setText(f"Pan Speed: {multiplier:.1f}x")
+        self.pan_speed_changed.emit(value)
+    
+    def _on_join_changed(self, value):
+        """Handle join threshold change."""
+        self.join_label.setText(f"Polygon Join Distance: {value}px")
+        self.join_threshold_changed.emit(value)
+    
+    def get_annotation_size(self):
+        """Get current annotation size value."""
+        return self.size_slider.value()
+    
+    def set_annotation_size(self, value):
+        """Set annotation size value."""
+        self.size_slider.setValue(value)
+    
+    def get_pan_speed(self):
+        """Get current pan speed value."""
+        return self.pan_slider.value()
+    
+    def set_pan_speed(self, value):
+        """Set pan speed value."""
+        self.pan_slider.setValue(value)
+    
+    def get_join_threshold(self):
+        """Get current join threshold value."""
+        return self.join_slider.value()
+    
+    def set_join_threshold(self, value):
+        """Set join threshold value."""
+        self.join_slider.setValue(value)

lazylabel/ui/widgets/model_selection_widget.py

@@ -0,0 +1,94 @@
+"""Model selection widget."""
+
+from PyQt6.QtWidgets import QWidget, QVBoxLayout, QHBoxLayout, QPushButton, QLabel, QComboBox, QGroupBox
+from PyQt6.QtCore import pyqtSignal
+from typing import List, Tuple
+
+
+class ModelSelectionWidget(QWidget):
+    """Widget for model selection and management."""
+    
+    browse_requested = pyqtSignal()
+    refresh_requested = pyqtSignal()
+    model_selected = pyqtSignal(str)
+    
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._setup_ui()
+        self._connect_signals()
+    
+    def _setup_ui(self):
+        """Setup the UI layout."""
+        group = QGroupBox("Model Selection")
+        layout = QVBoxLayout(group)
+        
+        # Buttons
+        button_layout = QHBoxLayout()
+        self.btn_browse = QPushButton("Browse Models")
+        self.btn_browse.setToolTip("Browse for a folder containing .pth model files")
+        self.btn_refresh = QPushButton("Refresh")
+        self.btn_refresh.setToolTip("Refresh the list of available models")
+        
+        button_layout.addWidget(self.btn_browse)
+        button_layout.addWidget(self.btn_refresh)
+        layout.addLayout(button_layout)
+        
+        # Model combo
+        layout.addWidget(QLabel("Available Models:"))
+        self.model_combo = QComboBox()
+        self.model_combo.setToolTip("Select a .pth model file to use")
+        self.model_combo.addItem("Default (vit_h)")
+        layout.addWidget(self.model_combo)
+        
+        # Current model label
+        self.current_model_label = QLabel("Current: Default SAM Model")
+        self.current_model_label.setWordWrap(True)
+        self.current_model_label.setStyleSheet("color: #90EE90; font-style: italic;")
+        layout.addWidget(self.current_model_label)
+        
+        # Main layout
+        main_layout = QVBoxLayout(self)
+        main_layout.setContentsMargins(0, 0, 0, 0)
+        main_layout.addWidget(group)
+    
+    def _connect_signals(self):
+        """Connect internal signals."""
+        self.btn_browse.clicked.connect(self.browse_requested)
+        self.btn_refresh.clicked.connect(self.refresh_requested)
+        self.model_combo.currentTextChanged.connect(self.model_selected)
+    
+    def populate_models(self, models: List[Tuple[str, str]]):
+        """Populate the models combo box.
+        
+        Args:
+            models: List of (display_name, full_path) tuples
+        """
+        self.model_combo.blockSignals(True)
+        self.model_combo.clear()
+        
+        # Add default option
+        self.model_combo.addItem("Default (vit_h)")
+        
+        # Add custom models
+        for display_name, full_path in models:
+            self.model_combo.addItem(display_name, full_path)
+        
+        self.model_combo.blockSignals(False)
+    
+    def set_current_model(self, model_name: str):
+        """Set the current model display."""
+        self.current_model_label.setText(model_name)
+    
+    def get_selected_model_path(self) -> str:
+        """Get the path of the currently selected model."""
+        current_index = self.model_combo.currentIndex()
+        if current_index <= 0:  # Default option
+            return ""
+        return self.model_combo.itemData(current_index) or ""
+    
+    def reset_to_default(self):
+        """Reset selection to default model."""
+        self.model_combo.blockSignals(True)
+        self.model_combo.setCurrentIndex(0)
+        self.model_combo.blockSignals(False)
+        self.set_current_model("Current: Default SAM Model")

lazylabel/ui/widgets/settings_widget.py

@@ -0,0 +1,106 @@
+"""Settings widget for save options."""
+
+from PyQt6.QtWidgets import QWidget, QVBoxLayout, QCheckBox, QGroupBox
+from PyQt6.QtCore import pyqtSignal
+
+
+class SettingsWidget(QWidget):
+    """Widget for application settings."""
+    
+    settings_changed = pyqtSignal()
+    
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._setup_ui()
+        self._connect_signals()
+    
+    def _setup_ui(self):
+        """Setup the UI layout."""
+        group = QGroupBox("Settings")
+        layout = QVBoxLayout(group)
+        
+        # Auto-save
+        self.chk_auto_save = QCheckBox("Auto-Save on Navigate")
+        self.chk_auto_save.setToolTip(
+            "Automatically save work when using arrow keys to change images."
+        )
+        self.chk_auto_save.setChecked(True)
+        layout.addWidget(self.chk_auto_save)
+        
+        # Save NPZ
+        self.chk_save_npz = QCheckBox("Save .npz")
+        self.chk_save_npz.setChecked(True)
+        self.chk_save_npz.setToolTip(
+            "Save the final mask as a compressed NumPy NPZ file."
+        )
+        layout.addWidget(self.chk_save_npz)
+        
+        # Save TXT
+        self.chk_save_txt = QCheckBox("Save .txt")
+        self.chk_save_txt.setChecked(True)
+        self.chk_save_txt.setToolTip(
+            "Save bounding box annotations in YOLO TXT format."
+        )
+        layout.addWidget(self.chk_save_txt)
+        
+        # YOLO with aliases
+        self.chk_yolo_use_alias = QCheckBox("Save YOLO with Class Aliases")
+        self.chk_yolo_use_alias.setToolTip(
+            "If checked, saves YOLO .txt files using class alias names instead of numeric IDs.\n"
+            "This is useful when a separate .yaml or .names file defines the classes."
+        )
+        self.chk_yolo_use_alias.setChecked(True)
+        layout.addWidget(self.chk_yolo_use_alias)
+        
+        # Save class aliases
+        self.chk_save_class_aliases = QCheckBox("Save Class Aliases (.json)")
+        self.chk_save_class_aliases.setToolTip(
+            "Save class aliases to a companion JSON file."
+        )
+        self.chk_save_class_aliases.setChecked(False)
+        layout.addWidget(self.chk_save_class_aliases)
+        
+        # Main layout
+        main_layout = QVBoxLayout(self)
+        main_layout.setContentsMargins(0, 0, 0, 0)
+        main_layout.addWidget(group)
+    
+    def _connect_signals(self):
+        """Connect internal signals."""
+        self.chk_save_npz.stateChanged.connect(self._handle_save_checkbox_change)
+        self.chk_save_txt.stateChanged.connect(self._handle_save_checkbox_change)
+        
+        # Connect all checkboxes to settings changed signal
+        for checkbox in [self.chk_auto_save, self.chk_save_npz, self.chk_save_txt,
+                        self.chk_yolo_use_alias, self.chk_save_class_aliases]:
+            checkbox.stateChanged.connect(self.settings_changed)
+    
+    def _handle_save_checkbox_change(self):
+        """Ensure at least one save format is selected."""
+        is_npz_checked = self.chk_save_npz.isChecked()
+        is_txt_checked = self.chk_save_txt.isChecked()
+        
+        if not is_npz_checked and not is_txt_checked:
+            sender = self.sender()
+            if sender == self.chk_save_npz:
+                self.chk_save_txt.setChecked(True)
+            else:
+                self.chk_save_npz.setChecked(True)
+    
+    def get_settings(self):
+        """Get current settings as dictionary."""
+        return {
+            'auto_save': self.chk_auto_save.isChecked(),
+            'save_npz': self.chk_save_npz.isChecked(),
+            'save_txt': self.chk_save_txt.isChecked(),
+            'yolo_use_alias': self.chk_yolo_use_alias.isChecked(),
+            'save_class_aliases': self.chk_save_class_aliases.isChecked(),
+        }
+    
+    def set_settings(self, settings):
+        """Set settings from dictionary."""
+        self.chk_auto_save.setChecked(settings.get('auto_save', True))
+        self.chk_save_npz.setChecked(settings.get('save_npz', True))
+        self.chk_save_txt.setChecked(settings.get('save_txt', True))
+        self.chk_yolo_use_alias.setChecked(settings.get('yolo_use_alias', True))
+        self.chk_save_class_aliases.setChecked(settings.get('save_class_aliases', False))

lazylabel/utils/__init__.py

@@ -0,0 +1,6 @@
+"""Utility modules."""
+
+from .utils import mask_to_pixmap
+from .custom_file_system_model import CustomFileSystemModel
+
+__all__ = ['mask_to_pixmap', 'CustomFileSystemModel']

lazylabel/{custom_file_system_model.py → utils/custom_file_system_model.py}

@@ -39,7 +39,7 @@ class CustomFileSystemModel(QFileSystemModel):
             pass
 
     def update_cache_for_path(self, saved_file_path: str):
-        """Incrementally updates the cache and the view for a newly saved file."""
+        """Incrementally updates the cache and the view for a newly saved or deleted file."""
         if not saved_file_path:
             return
 
@@ -47,9 +47,15 @@ class CustomFileSystemModel(QFileSystemModel):
         base_name = p.stem
 
         if p.suffix == ".npz":
-            self.npz_files.add(base_name)
+            if p.exists():
+                self.npz_files.add(base_name)
+            else:
+                self.npz_files.discard(base_name)
         elif p.suffix == ".txt":
-            self.txt_files.add(base_name)
+            if p.exists():
+                self.txt_files.add(base_name)
+            else:
+                self.txt_files.discard(base_name)
         else:
             return