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

lazylabel/ui/main_window.py

@@ -7,6 +7,7 @@ from PyQt6.QtWidgets import (
     QMainWindow,
     QWidget,
     QHBoxLayout,
+    QVBoxLayout,
     QFileDialog,
     QApplication,
     QGraphicsEllipseItem,
@@ -15,6 +16,8 @@ from PyQt6.QtWidgets import (
     QTableWidgetItem,
     QTableWidgetSelectionRange,
     QHeaderView,
+    QSplitter,
+    QDialog,
 )
 from PyQt6.QtGui import (
     QIcon,
@@ -27,7 +30,7 @@ from PyQt6.QtGui import (
     QPolygonF,
     QImage,
 )
-from PyQt6.QtCore import Qt, QTimer, QModelIndex, QPointF
+from PyQt6.QtCore import Qt, QTimer, QModelIndex, QPointF, pyqtSignal
 
 from .control_panel import ControlPanel
 from .right_panel import RightPanel
@@ -40,6 +43,36 @@ from ..core import SegmentManager, ModelManager, FileManager
 from ..config import Settings, Paths, HotkeyManager
 from ..utils import CustomFileSystemModel, mask_to_pixmap
 from .hotkey_dialog import HotkeyDialog
+from .widgets import StatusBar
+
+
+class PanelPopoutWindow(QDialog):
+    """Pop-out window for draggable panels."""
+
+    panel_closed = pyqtSignal(QWidget)  # Signal emitted when panel window is closed
+
+    def __init__(self, panel_widget, title="Panel", parent=None):
+        super().__init__(parent)
+        self.panel_widget = panel_widget
+        self.setWindowTitle(title)
+        self.setWindowFlags(Qt.WindowType.Window)  # Allow moving to other monitors
+
+        # Make window resizable
+        self.setMinimumSize(200, 300)
+        self.resize(400, 600)
+
+        # Set up layout
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(5, 5, 5, 5)
+        layout.addWidget(panel_widget)
+
+        # Store original parent for restoration
+        self.original_parent = parent
+
+    def closeEvent(self, event):
+        """Handle window close - emit signal to return panel to main window."""
+        self.panel_closed.emit(self.panel_widget)
+        super().closeEvent(event)
 
 
 class MainWindow(QMainWindow):
@@ -48,22 +81,33 @@ class MainWindow(QMainWindow):
     def __init__(self):
         super().__init__()
 
+        print("[3/20] Starting LazyLabel...")
+        print("[4/20] Loading configuration and settings...")
+
         # Initialize configuration
         self.paths = Paths()
         self.settings = Settings.load_from_file(str(self.paths.settings_file))
         self.hotkey_manager = HotkeyManager(str(self.paths.config_dir))
 
+        print("[5/20] Initializing core managers...")
+
         # Initialize managers
         self.segment_manager = SegmentManager()
         self.model_manager = ModelManager(self.paths)
         self.file_manager = FileManager(self.segment_manager)
 
+        print("[6/20] Setting up user interface...")
+
         # Initialize UI state
         self.mode = "sam_points"
         self.previous_mode = "sam_points"
         self.current_image_path = None
         self.current_file_index = QModelIndex()
 
+        # Panel pop-out state
+        self.left_panel_popout = None
+        self.right_panel_popout = None
+
         # Annotation state
         self.point_radius = self.settings.point_radius
         self.line_thickness = self.settings.line_thickness
@@ -83,12 +127,19 @@ class MainWindow(QMainWindow):
             {},
         )
 
+        # Update state flags to prevent recursion
+        self._updating_lists = False
+
         self._setup_ui()
         self._setup_model()
+
+        print("[17/20] Connecting UI signals and shortcuts...")
         self._setup_connections()
         self._setup_shortcuts()
         self._load_settings()
 
+        print("[18/20] LazyLabel initialization complete!")
+
     def _setup_ui(self):
         """Setup the user interface."""
         self.setWindowTitle("LazyLabel by DNC")
@@ -110,11 +161,37 @@ class MainWindow(QMainWindow):
         self.file_model = CustomFileSystemModel()
         self.right_panel.setup_file_model(self.file_model)
 
-        # Layout
-        main_layout = QHBoxLayout()
-        main_layout.addWidget(self.control_panel)
-        main_layout.addWidget(self.viewer, 1)
-        main_layout.addWidget(self.right_panel)
+        # Create status bar
+        self.status_bar = StatusBar()
+        self.setStatusBar(self.status_bar)
+
+        # Create horizontal splitter for main panels
+        self.main_splitter = QSplitter(Qt.Orientation.Horizontal)
+        self.main_splitter.addWidget(self.control_panel)
+        self.main_splitter.addWidget(self.viewer)
+        self.main_splitter.addWidget(self.right_panel)
+
+        # Set minimum sizes for panels to prevent shrinking below preferred width
+        self.control_panel.setMinimumWidth(self.control_panel.preferred_width)
+        self.right_panel.setMinimumWidth(self.right_panel.preferred_width)
+
+        # Set splitter sizes - give most space to viewer
+        self.main_splitter.setSizes([250, 800, 350])
+        self.main_splitter.setStretchFactor(0, 0)  # Control panel doesn't stretch
+        self.main_splitter.setStretchFactor(1, 1)  # Viewer stretches
+        self.main_splitter.setStretchFactor(2, 0)  # Right panel doesn't stretch
+
+        # Set splitter child sizes policy
+        self.main_splitter.setChildrenCollapsible(True)
+
+        # Connect splitter signals for intelligent expand/collapse
+        self.main_splitter.splitterMoved.connect(self._handle_splitter_moved)
+
+        # Main vertical layout to accommodate status bar
+        main_layout = QVBoxLayout()
+        main_layout.setContentsMargins(0, 0, 0, 0)
+        main_layout.setSpacing(0)
+        main_layout.addWidget(self.main_splitter, 1)
 
         central_widget = QWidget()
         central_widget.setLayout(main_layout)
@@ -122,17 +199,29 @@ class MainWindow(QMainWindow):
 
     def _setup_model(self):
         """Setup the SAM model."""
+        print("[7/20] Initializing SAM model (this may take a moment)...")
+
         sam_model = self.model_manager.initialize_default_model(
             self.settings.default_model_type
         )
 
         if sam_model and sam_model.is_loaded:
-            self.control_panel.set_device_text(str(sam_model.device))
+            device_text = str(sam_model.device).upper()
+            print(f"[14/20] SAM model loaded successfully on {device_text}")
+            self.status_bar.set_permanent_message(f"Device: {device_text}")
             self._enable_sam_functionality(True)
+        elif sam_model is None:
+            print(
+                "[14/20] SAM model initialization failed. Point mode will be disabled."
+            )
+            self.status_bar.set_permanent_message("Model initialization failed")
+            self._enable_sam_functionality(False)
         else:
-            self.control_panel.set_device_text("No model loaded")
+            print("[14/20] SAM model failed to load. Point mode will be disabled.")
+            self.status_bar.set_permanent_message("Model loading failed")
             self._enable_sam_functionality(False)
-            print("SAM model failed to load. Point mode will be disabled.")
+
+        print("[15/20] Scanning available models...")
 
         # Setup model change callback
         self.model_manager.on_model_changed = self.control_panel.set_current_model
@@ -141,6 +230,9 @@ class MainWindow(QMainWindow):
         models = self.model_manager.get_available_models(str(self.paths.models_dir))
         self.control_panel.populate_models(models)
 
+        if models:
+            print(f"[16/20] Found {len(models)} model(s) in models directory")
+
     def _enable_sam_functionality(self, enabled: bool):
         """Enable or disable SAM point functionality."""
         self.control_panel.set_sam_mode_enabled(enabled)
@@ -183,14 +275,11 @@ class MainWindow(QMainWindow):
         self.right_panel.class_alias_changed.connect(self._handle_alias_change)
         self.right_panel.reassign_classes_requested.connect(self._reassign_class_ids)
         self.right_panel.class_filter_changed.connect(self._update_segment_table)
+        self.right_panel.class_toggled.connect(self._handle_class_toggle)
 
-        # Panel visibility
-        self.control_panel.btn_toggle_visibility.clicked.connect(
-            self.control_panel.toggle_visibility
-        )
-        self.right_panel.btn_toggle_visibility.clicked.connect(
-            self.right_panel.toggle_visibility
-        )
+        # Panel pop-out functionality
+        self.control_panel.pop_out_requested.connect(self._pop_out_left_panel)
+        self.right_panel.pop_out_requested.connect(self._pop_out_right_panel)
 
         # Mouse events (will be implemented in a separate handler)
         self._setup_mouse_events()
@@ -355,9 +444,9 @@ class MainWindow(QMainWindow):
         if folder and os.path.exists(folder):
             models = self.model_manager.get_available_models(folder)
             self.control_panel.populate_models(models)
-            self._show_notification("Models list refreshed.")
+            self._show_success_notification("Models list refreshed.")
         else:
-            self._show_notification("No models folder selected.")
+            self._show_warning_notification("No models folder selected.")
 
     def _load_selected_model(self, model_text):
         """Load the selected model."""
@@ -367,7 +456,7 @@ class MainWindow(QMainWindow):
 
         model_path = self.control_panel.model_widget.get_selected_model_path()
         if not model_path or not os.path.exists(model_path):
-            self._show_notification("Selected model file not found.")
+            self._show_error_notification("Selected model file not found.")
             return
 
         self.control_panel.set_current_model("Loading model...")
@@ -379,17 +468,18 @@ class MainWindow(QMainWindow):
                 # Re-enable SAM functionality if model loaded successfully
                 self._enable_sam_functionality(True)
                 if self.model_manager.sam_model:
-                    self.control_panel.set_device_text(
-                        str(self.model_manager.sam_model.device)
-                    )
+                    device_text = str(self.model_manager.sam_model.device).upper()
+                    self.status_bar.set_permanent_message(f"Device: {device_text}")
             else:
                 self.control_panel.set_current_model("Current: Default SAM Model")
-                self._show_notification("Failed to load selected model. Using default.")
+                self._show_error_notification(
+                    "Failed to load selected model. Using default."
+                )
                 self.control_panel.model_widget.reset_to_default()
                 self._enable_sam_functionality(False)
         except Exception as e:
             self.control_panel.set_current_model("Current: Default SAM Model")
-            self._show_notification(f"Error loading model: {str(e)}")
+            self._show_error_notification(f"Error loading model: {str(e)}")
             self.control_panel.model_widget.reset_to_default()
             self._enable_sam_functionality(False)
 
@@ -539,6 +629,8 @@ class MainWindow(QMainWindow):
 
     def _handle_alias_change(self, class_id, alias):
         """Handle class alias change."""
+        if self._updating_lists:
+            return  # Prevent recursion
         self.segment_manager.set_class_alias(class_id, alias)
         self._update_all_lists()
 
@@ -624,16 +716,27 @@ class MainWindow(QMainWindow):
         table.blockSignals(False)
         self.viewer.setFocus()
 
+        # Update active class display
+        active_class = self.segment_manager.get_active_class()
+        self.right_panel.update_active_class_display(active_class)
+
     def _update_all_lists(self):
         """Update all UI lists."""
-        self._update_class_list()
-        self._update_segment_table()
-        self._update_class_filter()
-        self._display_all_segments()
-        if self.mode == "edit":
-            self._display_edit_handles()
-        else:
-            self._clear_edit_handles()
+        if self._updating_lists:
+            return  # Prevent recursion
+
+        self._updating_lists = True
+        try:
+            self._update_class_list()
+            self._update_segment_table()
+            self._update_class_filter()
+            self._display_all_segments()
+            if self.mode == "edit":
+                self._display_edit_handles()
+            else:
+                self._clear_edit_handles()
+        finally:
+            self._updating_lists = False
 
     def _update_class_list(self):
         """Update the class list in the right panel."""
@@ -658,6 +761,10 @@ class MainWindow(QMainWindow):
             class_table.setItem(row, 0, alias_item)
             class_table.setItem(row, 1, id_item)
 
+        # Update active class display BEFORE re-enabling signals
+        active_class = self.segment_manager.get_active_class()
+        self.right_panel.update_active_class_display(active_class)
+
         class_table.blockSignals(False)
 
     def _update_class_filter(self):
@@ -790,7 +897,7 @@ class MainWindow(QMainWindow):
     def _save_output_to_npz(self):
         """Save output to NPZ and TXT files as enabled, and update file list tickboxes/highlight. If no segments, delete associated files."""
         if not self.current_image_path:
-            self._show_notification("No image loaded.")
+            self._show_warning_notification("No image loaded.")
             return
 
         # If no segments, delete associated files
@@ -805,13 +912,15 @@ class MainWindow(QMainWindow):
                         deleted_files.append(file_path)
                         self.file_model.update_cache_for_path(file_path)
                     except Exception as e:
-                        self._show_notification(f"Error deleting {file_path}: {e}")
+                        self._show_error_notification(
+                            f"Error deleting {file_path}: {e}"
+                        )
             if deleted_files:
                 self._show_notification(
                     f"Deleted: {', '.join(os.path.basename(f) for f in deleted_files)}"
                 )
             else:
-                self._show_notification("No segments to save.")
+                self._show_warning_notification("No segments to save.")
             return
 
         try:
@@ -828,9 +937,11 @@ class MainWindow(QMainWindow):
                     npz_path = self.file_manager.save_npz(
                         self.current_image_path, (h, w), class_order
                     )
-                    self._show_notification(f"Saved: {os.path.basename(npz_path)}")
+                    self._show_success_notification(
+                        f"Saved: {os.path.basename(npz_path)}"
+                    )
                 else:
-                    self._show_notification("No classes defined for saving.")
+                    self._show_warning_notification("No classes defined for saving.")
             if settings.get("save_txt", True):
                 h, w = (
                     self.viewer._pixmap_item.pixmap().height(),
@@ -861,7 +972,7 @@ class MainWindow(QMainWindow):
                         ),
                     )
         except Exception as e:
-            self._show_notification(f"Error saving: {str(e)}")
+            self._show_error_notification(f"Error saving: {str(e)}")
 
     def _handle_merge_press(self):
         """Handle merge key press."""
@@ -897,8 +1008,19 @@ class MainWindow(QMainWindow):
 
     def _show_notification(self, message, duration=3000):
         """Show notification message."""
-        self.control_panel.show_notification(message)
-        QTimer.singleShot(duration, self.control_panel.clear_notification)
+        self.status_bar.show_message(message, duration)
+
+    def _show_error_notification(self, message, duration=8000):
+        """Show error notification message."""
+        self.status_bar.show_error_message(message, duration)
+
+    def _show_success_notification(self, message, duration=3000):
+        """Show success notification message."""
+        self.status_bar.show_success_message(message, duration)
+
+    def _show_warning_notification(self, message, duration=5000):
+        """Show warning notification message."""
+        self.status_bar.show_warning_message(message, duration)
 
     def _show_hotkey_dialog(self):
         """Show the hotkey configuration dialog."""
@@ -945,6 +1067,12 @@ class MainWindow(QMainWindow):
 
     def closeEvent(self, event):
         """Handle application close."""
+        # Close any popped-out panels first
+        if self.left_panel_popout is not None:
+            self.left_panel_popout.close()
+        if self.right_panel_popout is not None:
+            self.right_panel_popout.close()
+
         # Save settings
         self.settings.save_to_file(str(self.paths.settings_file))
         super().closeEvent(event)
@@ -1262,3 +1390,157 @@ class MainWindow(QMainWindow):
                     QPolygonF(self.segment_manager.segments[segment_index]["vertices"])
                 )
                 return
+
+    def _handle_class_toggle(self, class_id):
+        """Handle class toggle."""
+        is_active = self.segment_manager.toggle_active_class(class_id)
+
+        if is_active:
+            self._show_notification(f"Class {class_id} activated for new segments")
+            # Update visual display
+            self.right_panel.update_active_class_display(class_id)
+        else:
+            self._show_notification(
+                "No active class - new segments will create new classes"
+            )
+            # Update visual display to clear active class
+            self.right_panel.update_active_class_display(None)
+
+    def _pop_out_left_panel(self):
+        """Pop out the left control panel into a separate window."""
+        if self.left_panel_popout is not None:
+            # Panel is already popped out, return it to main window
+            self._return_left_panel(self.control_panel)
+            return
+
+        # Remove panel from main splitter
+        self.control_panel.setParent(None)
+
+        # Create pop-out window
+        self.left_panel_popout = PanelPopoutWindow(
+            self.control_panel, "Control Panel", self
+        )
+        self.left_panel_popout.panel_closed.connect(self._return_left_panel)
+        self.left_panel_popout.show()
+
+        # Update panel's pop-out button
+        self.control_panel.set_popout_mode(True)
+
+        # Make pop-out window resizable
+        self.left_panel_popout.setMinimumSize(200, 400)
+        self.left_panel_popout.resize(self.control_panel.preferred_width + 20, 600)
+
+    def _pop_out_right_panel(self):
+        """Pop out the right panel into a separate window."""
+        if self.right_panel_popout is not None:
+            # Panel is already popped out, return it to main window
+            self._return_right_panel(self.right_panel)
+            return
+
+        # Remove panel from main splitter
+        self.right_panel.setParent(None)
+
+        # Create pop-out window
+        self.right_panel_popout = PanelPopoutWindow(
+            self.right_panel, "File Explorer & Segments", self
+        )
+        self.right_panel_popout.panel_closed.connect(self._return_right_panel)
+        self.right_panel_popout.show()
+
+        # Update panel's pop-out button
+        self.right_panel.set_popout_mode(True)
+
+        # Make pop-out window resizable
+        self.right_panel_popout.setMinimumSize(250, 400)
+        self.right_panel_popout.resize(self.right_panel.preferred_width + 20, 600)
+
+    def _return_left_panel(self, panel_widget):
+        """Return the left panel to the main window."""
+        if self.left_panel_popout is not None:
+            # Close the pop-out window
+            self.left_panel_popout.close()
+
+            # Return panel to main splitter
+            self.main_splitter.insertWidget(0, self.control_panel)
+            self.left_panel_popout = None
+
+            # Update panel's pop-out button
+            self.control_panel.set_popout_mode(False)
+
+            # Restore splitter sizes
+            self.main_splitter.setSizes([250, 800, 350])
+
+    def _handle_splitter_moved(self, pos, index):
+        """Handle splitter movement for intelligent expand/collapse behavior."""
+        sizes = self.main_splitter.sizes()
+
+        # Left panel (index 0) - expand/collapse logic
+        if index == 1:  # Splitter between left panel and viewer
+            left_size = sizes[0]
+            # Only snap to collapsed if user drags very close to collapse
+            if left_size < 50:  # Collapsed threshold
+                # Panel is being collapsed, snap to collapsed state
+                new_sizes = [0] + sizes[1:]
+                new_sizes[1] = new_sizes[1] + left_size  # Give space back to viewer
+                self.main_splitter.setSizes(new_sizes)
+                # Temporarily override minimum width to allow collapsing
+                self.control_panel.setMinimumWidth(0)
+
+        # Right panel (index 2) - expand/collapse logic
+        elif index == 2:  # Splitter between viewer and right panel
+            right_size = sizes[2]
+            # Only snap to collapsed if user drags very close to collapse
+            if right_size < 50:  # Collapsed threshold
+                # Panel is being collapsed, snap to collapsed state
+                new_sizes = sizes[:-1] + [0]
+                new_sizes[1] = new_sizes[1] + right_size  # Give space back to viewer
+                self.main_splitter.setSizes(new_sizes)
+                # Temporarily override minimum width to allow collapsing
+                self.right_panel.setMinimumWidth(0)
+
+    def _expand_left_panel(self):
+        """Expand the left panel to its preferred width."""
+        sizes = self.main_splitter.sizes()
+        if sizes[0] < 50:  # Only expand if currently collapsed
+            # Restore minimum width first
+            self.control_panel.setMinimumWidth(self.control_panel.preferred_width)
+
+            space_needed = self.control_panel.preferred_width
+            viewer_width = sizes[1] - space_needed
+            if viewer_width > 400:  # Ensure viewer has minimum space
+                new_sizes = [self.control_panel.preferred_width, viewer_width] + sizes[
+                    2:
+                ]
+                self.main_splitter.setSizes(new_sizes)
+
+    def _expand_right_panel(self):
+        """Expand the right panel to its preferred width."""
+        sizes = self.main_splitter.sizes()
+        if sizes[2] < 50:  # Only expand if currently collapsed
+            # Restore minimum width first
+            self.right_panel.setMinimumWidth(self.right_panel.preferred_width)
+
+            space_needed = self.right_panel.preferred_width
+            viewer_width = sizes[1] - space_needed
+            if viewer_width > 400:  # Ensure viewer has minimum space
+                new_sizes = sizes[:-1] + [
+                    viewer_width,
+                    self.right_panel.preferred_width,
+                ]
+                self.main_splitter.setSizes(new_sizes)
+
+    def _return_right_panel(self, panel_widget):
+        """Return the right panel to the main window."""
+        if self.right_panel_popout is not None:
+            # Close the pop-out window
+            self.right_panel_popout.close()
+
+            # Return panel to main splitter
+            self.main_splitter.addWidget(self.right_panel)
+            self.right_panel_popout = None
+
+            # Update panel's pop-out button
+            self.right_panel.set_popout_mode(False)
+
+            # Restore splitter sizes
+            self.main_splitter.setSizes([250, 800, 350])