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

lazylabel/core/segment_manager.py

@@ -1,8 +1,9 @@
 """Segment management functionality."""
 
-import numpy as np
+from typing import Any
+
 import cv2
-from typing import List, Dict, Any, Optional, Tuple
+import numpy as np
 from PyQt6.QtCore import QPointF
 
 
@@ -10,10 +11,10 @@ class SegmentManager:
     """Manages image segments and classes."""
 
     def __init__(self):
-        self.segments: List[Dict[str, Any]] = []
-        self.class_aliases: Dict[int, str] = {}
+        self.segments: list[dict[str, Any]] = []
+        self.class_aliases: dict[int, str] = {}
         self.next_class_id: int = 0
-        self.active_class_id: Optional[int] = None  # Currently active/toggled class
+        self.active_class_id: int | None = None  # Currently active/toggled class
 
     def clear(self) -> None:
         """Clear all segments and reset state."""
@@ -22,7 +23,7 @@ class SegmentManager:
         self.next_class_id = 0
         self.active_class_id = None
 
-    def add_segment(self, segment_data: Dict[str, Any]) -> None:
+    def add_segment(self, segment_data: dict[str, Any]) -> None:
         """Add a new segment."""
         if "class_id" not in segment_data:
             # Use active class if available, otherwise use next class ID
@@ -33,14 +34,14 @@ class SegmentManager:
         self.segments.append(segment_data)
         self._update_next_class_id()
 
-    def delete_segments(self, indices: List[int]) -> None:
+    def delete_segments(self, indices: list[int]) -> None:
         """Delete segments by indices."""
         for i in sorted(indices, reverse=True):
             if 0 <= i < len(self.segments):
                 del self.segments[i]
         self._update_next_class_id()
 
-    def assign_segments_to_class(self, indices: List[int]) -> None:
+    def assign_segments_to_class(self, indices: list[int]) -> None:
         """Assign selected segments to a class."""
         if not indices:
             return
@@ -62,21 +63,19 @@ class SegmentManager:
 
         self._update_next_class_id()
 
-    def get_unique_class_ids(self) -> List[int]:
+    def get_unique_class_ids(self) -> list[int]:
         """Get sorted list of unique class IDs."""
         return sorted(
-            list(
-                {
-                    seg.get("class_id")
-                    for seg in self.segments
-                    if seg.get("class_id") is not None
-                }
-            )
+            {
+                seg.get("class_id")
+                for seg in self.segments
+                if seg.get("class_id") is not None
+            }
         )
 
     def rasterize_polygon(
-        self, vertices: List[QPointF], image_size: Tuple[int, int]
-    ) -> Optional[np.ndarray]:
+        self, vertices: list[QPointF], image_size: tuple[int, int]
+    ) -> np.ndarray | None:
         """Convert polygon vertices to binary mask."""
         if not vertices:
             return None
@@ -88,7 +87,7 @@ class SegmentManager:
         return mask.astype(bool)
 
     def create_final_mask_tensor(
-        self, image_size: Tuple[int, int], class_order: List[int]
+        self, image_size: tuple[int, int], class_order: list[int]
     ) -> np.ndarray:
         """Create final mask tensor for saving."""
         h, w = image_size
@@ -115,7 +114,7 @@ class SegmentManager:
 
         return final_mask_tensor
 
-    def reassign_class_ids(self, new_order: List[int]) -> None:
+    def reassign_class_ids(self, new_order: list[int]) -> None:
         """Reassign class IDs based on new order."""
         id_map = {old_id: new_id for new_id, old_id in enumerate(new_order)}
 
@@ -141,11 +140,11 @@ class SegmentManager:
         """Get alias for a class."""
         return self.class_aliases.get(class_id, str(class_id))
 
-    def set_active_class(self, class_id: Optional[int]) -> None:
+    def set_active_class(self, class_id: int | None) -> None:
         """Set the active class ID."""
         self.active_class_id = class_id
 
-    def get_active_class(self) -> Optional[int]:
+    def get_active_class(self) -> int | None:
         """Get the active class ID."""
         return self.active_class_id
 

lazylabel/main.py

@@ -1,6 +1,7 @@
 """Main entry point for LazyLabel application."""
 
 import sys
+
 import qdarktheme
 from PyQt6.QtWidgets import QApplication
 

lazylabel/models/__init__.py

@@ -2,4 +2,4 @@
 
 from .sam_model import SamModel
 
-__all__ = ['SamModel']
+__all__ = ["SamModel"]

lazylabel/models/sam_model.py

@@ -1,25 +1,26 @@
 import os
+
 import cv2
 import numpy as np
-import torch
 import requests
+import torch
+from segment_anything import SamPredictor, sam_model_registry
 from tqdm import tqdm
-from segment_anything import sam_model_registry, SamPredictor
 
 
 def download_model(url, download_path):
     """Downloads file with a progress bar."""
-    print(f"[10/20] SAM model not found. Downloading from Meta's repository...")
+    print("[10/20] SAM model not found. Downloading from Meta's repository...")
     print(f"        Downloading to: {download_path}")
     try:
-        print(f"[10/20] Connecting to download server...")
+        print("[10/20] Connecting to download server...")
         response = requests.get(url, stream=True, timeout=30)
         response.raise_for_status()
         total_size_in_bytes = int(response.headers.get("content-length", 0))
         block_size = 1024  # 1 Kibibyte
 
         print(
-            f"[10/20] Starting download ({total_size_in_bytes / (1024*1024*1024):.1f} GB)..."
+            f"[10/20] Starting download ({total_size_in_bytes / (1024 * 1024 * 1024):.1f} GB)..."
         )
         progress_bar = tqdm(total=total_size_in_bytes, unit="iB", unit_scale=True)
         with open(download_path, "wb") as file:
@@ -35,30 +36,34 @@ def download_model(url, download_path):
 
     except requests.exceptions.ConnectionError as e:
         raise RuntimeError(
-            f"[10/20] Network connection failed: Check your internet connection"
-        )
+            "[10/20] Network connection failed: Check your internet connection"
+        ) from e
     except requests.exceptions.Timeout as e:
-        raise RuntimeError(f"[10/20] Download timeout: Server took too long to respond")
+        raise RuntimeError(
+            "[10/20] Download timeout: Server took too long to respond"
+        ) from e
     except requests.exceptions.HTTPError as e:
         raise RuntimeError(
             f"[10/20] HTTP error {e.response.status_code}: Server rejected request"
-        )
+        ) from e
     except requests.exceptions.RequestException as e:
-        raise RuntimeError(f"[10/20] Network error during download: {e}")
+        raise RuntimeError(f"[10/20] Network error during download: {e}") from e
     except PermissionError as e:
         raise RuntimeError(
             f"[10/20] Permission denied: Cannot write to {download_path}"
-        )
+        ) from e
     except OSError as e:
-        raise RuntimeError(f"[10/20] Disk error: {e} (check available disk space)")
+        raise RuntimeError(
+            f"[10/20] Disk error: {e} (check available disk space)"
+        ) from e
     except Exception as e:
         # Clean up partial download
         if os.path.exists(download_path):
-            try:
+            import contextlib
+
+            with contextlib.suppress(OSError):
                 os.remove(download_path)
-            except:
-                pass
-        raise RuntimeError(f"[10/20] Download failed: {e}")
+        raise RuntimeError(f"[10/20] Download failed: {e}") from e
 
 
 class SamModel:
@@ -102,7 +107,7 @@ class SamModel:
 
                 if os.path.exists(old_model_path) and not os.path.exists(model_path):
                     print(
-                        f"[10/20] Moving existing model from cache to models folder..."
+                        "[10/20] Moving existing model from cache to models folder..."
                     )
                     import shutil
 
@@ -118,14 +123,14 @@ class SamModel:
                 self.device
             )
 
-            print(f"[12/20] Setting up predictor...")
+            print("[12/20] Setting up predictor...")
             self.predictor = SamPredictor(self.model)
             self.is_loaded = True
             print("[13/20] SAM model loaded successfully.")
 
         except Exception as e:
             print(f"[8/20] Failed to load SAM model: {e}")
-            print(f"[8/20] SAM point functionality will be disabled.")
+            print("[8/20] SAM point functionality will be disabled.")
             self.is_loaded = False
 
     def load_custom_model(self, model_path, model_type="vit_h"):

lazylabel/ui/__init__.py

@@ -1,8 +1,8 @@
 """UI components for LazyLabel."""
 
-from .main_window import MainWindow
 from .control_panel import ControlPanel
-from .right_panel import RightPanel
 from .hotkey_dialog import HotkeyDialog
+from .main_window import MainWindow
+from .right_panel import RightPanel
 
-__all__ = ['MainWindow', 'ControlPanel', 'RightPanel', 'HotkeyDialog']
+__all__ = ["MainWindow", "ControlPanel", "RightPanel", "HotkeyDialog"]

lazylabel/ui/control_panel.py

@@ -1,20 +1,16 @@
 """Left control panel with mode controls and settings."""
 
+from PyQt6.QtCore import Qt, pyqtSignal
 from PyQt6.QtWidgets import (
-    QWidget,
-    QVBoxLayout,
-    QPushButton,
-    QLabel,
     QFrame,
     QHBoxLayout,
-    QCheckBox,
-    QSlider,
-    QGroupBox,
-    QComboBox,
+    QLabel,
+    QPushButton,
+    QVBoxLayout,
+    QWidget,
 )
-from PyQt6.QtCore import Qt, pyqtSignal
 
-from .widgets import ModelSelectionWidget, SettingsWidget, AdjustmentsWidget
+from .widgets import AdjustmentsWidget, ModelSelectionWidget, SettingsWidget
 
 
 class ControlPanel(QWidget):
@@ -159,20 +155,12 @@ class ControlPanel(QWidget):
         self.btn_hotkeys.clicked.connect(self.hotkeys_requested)
         self.btn_popout.clicked.connect(self.pop_out_requested)
 
-    def mouseDoubleClickEvent(self, event):
-        """Handle double-click to expand collapsed panel."""
-        if self.width() < 50:  # If panel is collapsed
-            # Request expansion by calling parent method
-            if self.parent() and hasattr(self.parent(), "_expand_left_panel"):
-                self.parent()._expand_left_panel()
-        super().mouseDoubleClickEvent(event)
-
         # Model widget signals
         self.model_widget.browse_requested.connect(self.browse_models_requested)
         self.model_widget.refresh_requested.connect(self.refresh_models_requested)
         self.model_widget.model_selected.connect(self.model_selected)
 
-        # Settings widget signals
+        # Adjustments widget signals
         self.adjustments_widget.annotation_size_changed.connect(
             self.annotation_size_changed
         )
@@ -181,6 +169,16 @@ class ControlPanel(QWidget):
             self.join_threshold_changed
         )
 
+    def mouseDoubleClickEvent(self, event):
+        """Handle double-click to expand collapsed panel."""
+        if (
+            self.width() < 50
+            and self.parent()
+            and hasattr(self.parent(), "_expand_left_panel")
+        ):
+            self.parent()._expand_left_panel()
+        super().mouseDoubleClickEvent(event)
+
     def show_notification(self, message: str, duration: int = 3000):
         """Show a notification message."""
         self.notification_label.setText(message)
@@ -219,6 +217,10 @@ class ControlPanel(QWidget):
         """Set annotation size."""
         self.adjustments_widget.set_annotation_size(value)
 
+    def set_join_threshold(self, value):
+        """Set join threshold."""
+        self.adjustments_widget.set_join_threshold(value)
+
     def set_sam_mode_enabled(self, enabled: bool):
         """Enable or disable the SAM mode button."""
         self.btn_sam_mode.setEnabled(enabled)

lazylabel/ui/editable_vertex.py

@@ -1,6 +1,6 @@
-from PyQt6.QtWidgets import QGraphicsEllipseItem, QGraphicsItem
 from PyQt6.QtCore import Qt
-from PyQt6.QtGui import QBrush, QPen, QColor
+from PyQt6.QtGui import QBrush, QColor, QPen
+from PyQt6.QtWidgets import QGraphicsEllipseItem, QGraphicsItem
 
 
 class EditableVertexItem(QGraphicsEllipseItem):
@@ -9,6 +9,7 @@ class EditableVertexItem(QGraphicsEllipseItem):
         self.main_window = main_window
         self.segment_index = segment_index
         self.vertex_index = vertex_index
+        self.initial_pos = None
 
         self.setZValue(200)
 
@@ -31,12 +32,13 @@ class EditableVertexItem(QGraphicsEllipseItem):
             new_pos = value
             if hasattr(self.main_window, "update_vertex_pos"):
                 self.main_window.update_vertex_pos(
-                    self.segment_index, self.vertex_index, new_pos
+                    self.segment_index, self.vertex_index, new_pos, record_undo=False
                 )
         return super().itemChange(change, value)
 
     def mousePressEvent(self, event):
         """Handle mouse press events."""
+        self.initial_pos = self.pos()
         super().mousePressEvent(event)
         event.accept()
 
@@ -47,5 +49,16 @@ class EditableVertexItem(QGraphicsEllipseItem):
 
     def mouseReleaseEvent(self, event):
         """Handle mouse release events."""
+        if self.initial_pos and self.initial_pos != self.pos():
+            self.main_window.action_history.append(
+                {
+                    "type": "move_vertex",
+                    "segment_index": self.segment_index,
+                    "vertex_index": self.vertex_index,
+                    "old_pos": self.initial_pos,
+                    "new_pos": self.pos(),
+                }
+            )
+        self.initial_pos = None
         super().mouseReleaseEvent(event)
         event.accept()