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

lazylabel/config/hotkeys.py

@@ -1,207 +1,208 @@
-"""Hotkey management system."""
-
-import json
-import os
-from dataclasses import dataclass
-
-from PyQt6.QtGui import QKeySequence
-
-
-@dataclass
-class HotkeyAction:
-    """Represents a hotkey action with primary and secondary keys."""
-
-    name: str
-    description: str
-    primary_key: str
-    secondary_key: str | None = None
-    category: str = "General"
-    mouse_related: bool = False  # Cannot be reassigned if True
-
-
-class HotkeyManager:
-    """Manages application hotkeys with persistence."""
-
-    def __init__(self, config_dir: str):
-        self.config_dir = config_dir
-        self.hotkeys_file = os.path.join(config_dir, "hotkeys.json")
-        self.actions: dict[str, HotkeyAction] = {}
-        self._initialize_default_hotkeys()
-        self.load_hotkeys()
-
-    def _initialize_default_hotkeys(self):
-        """Initialize default hotkey mappings."""
-        default_hotkeys = [
-            # Navigation
-            HotkeyAction(
-                "load_next_image", "Load Next Image", "Right", category="Navigation"
-            ),
-            HotkeyAction(
-                "load_previous_image",
-                "Load Previous Image",
-                "Left",
-                category="Navigation",
-            ),
-            HotkeyAction("fit_view", "Fit View", ".", category="Navigation"),
-            # Modes
-            HotkeyAction("sam_mode", "Point Mode (SAM)", "1", category="Modes"),
-            HotkeyAction("polygon_mode", "Polygon Mode", "2", category="Modes"),
-            HotkeyAction("selection_mode", "Selection Mode", "E", category="Modes"),
-            HotkeyAction("pan_mode", "Pan Mode", "Q", category="Modes"),
-            HotkeyAction("edit_mode", "Edit Mode", "R", category="Modes"),
-            # Actions
-            HotkeyAction(
-                "clear_points", "Clear Points/Vertices", "C", category="Actions"
-            ),
-            HotkeyAction(
-                "save_segment", "Save Current Segment", "Space", category="Actions"
-            ),
-            HotkeyAction("save_output", "Save Output", "Return", category="Actions"),
-            HotkeyAction(
-                "save_output_alt", "Save Output (Alt)", "Enter", category="Actions"
-            ),
-            HotkeyAction("undo", "Undo Last Action", "Ctrl+Z", category="Actions"),
-            HotkeyAction(
-                "redo", "Redo Last Action", "Ctrl+Y", "Ctrl+Shift+Z", category="Actions"
-            ),
-            HotkeyAction(
-                "escape", "Cancel/Clear Selection", "Escape", category="Actions"
-            ),
-            # Segments
-            HotkeyAction(
-                "merge_segments", "Merge Selected Segments", "M", category="Segments"
-            ),
-            HotkeyAction(
-                "delete_segments", "Delete Selected Segments", "V", category="Segments"
-            ),
-            HotkeyAction(
-                "delete_segments_alt",
-                "Delete Selected Segments (Alt)",
-                "Backspace",
-                category="Segments",
-            ),
-            HotkeyAction(
-                "select_all", "Select All Segments", "Ctrl+A", category="Segments"
-            ),
-            # View
-            HotkeyAction("zoom_in", "Zoom In", "Ctrl+Plus", category="View"),
-            HotkeyAction("zoom_out", "Zoom Out", "Ctrl+Minus", category="View"),
-            # Movement (WASD)
-            HotkeyAction("pan_up", "Pan Up", "W", category="Movement"),
-            HotkeyAction("pan_down", "Pan Down", "S", category="Movement"),
-            HotkeyAction("pan_left", "Pan Left", "A", category="Movement"),
-            HotkeyAction("pan_right", "Pan Right", "D", category="Movement"),
-            # Mouse-related (cannot be reassigned)
-            HotkeyAction(
-                "left_click",
-                "Add Positive Point / Select",
-                "Left Click",
-                category="Mouse",
-                mouse_related=True,
-            ),
-            HotkeyAction(
-                "right_click",
-                "Add Negative Point",
-                "Right Click",
-                category="Mouse",
-                mouse_related=True,
-            ),
-            HotkeyAction(
-                "mouse_drag",
-                "Drag/Pan",
-                "Mouse Drag",
-                category="Mouse",
-                mouse_related=True,
-            ),
-        ]
-
-        for action in default_hotkeys:
-            self.actions[action.name] = action
-
-    def get_action(self, action_name: str) -> HotkeyAction | None:
-        """Get hotkey action by name."""
-        return self.actions.get(action_name)
-
-    def get_actions_by_category(self) -> dict[str, list[HotkeyAction]]:
-        """Get actions grouped by category."""
-        categories = {}
-        for action in self.actions.values():
-            if action.category not in categories:
-                categories[action.category] = []
-            categories[action.category].append(action)
-        return categories
-
-    def set_primary_key(self, action_name: str, key: str) -> bool:
-        """Set primary key for an action."""
-        if action_name in self.actions and not self.actions[action_name].mouse_related:
-            self.actions[action_name].primary_key = key
-            return True
-        return False
-
-    def set_secondary_key(self, action_name: str, key: str | None) -> bool:
-        """Set secondary key for an action."""
-        if action_name in self.actions and not self.actions[action_name].mouse_related:
-            self.actions[action_name].secondary_key = key
-            return True
-        return False
-
-    def get_key_for_action(self, action_name: str) -> tuple[str | None, str | None]:
-        """Get primary and secondary keys for an action."""
-        action = self.actions.get(action_name)
-        if action:
-            return action.primary_key, action.secondary_key
-        return None, None
-
-    def is_key_in_use(self, key: str, exclude_action: str = None) -> str | None:
-        """Check if a key is already in use by another action."""
-        for name, action in self.actions.items():
-            if name == exclude_action:
-                continue
-            if action.primary_key == key or action.secondary_key == key:
-                return name
-        return None
-
-    def reset_to_defaults(self):
-        """Reset all hotkeys to default values."""
-        self._initialize_default_hotkeys()
-
-    def save_hotkeys(self):
-        """Save hotkeys to file."""
-        os.makedirs(self.config_dir, exist_ok=True)
-
-        # Convert to serializable format
-        data = {}
-        for name, action in self.actions.items():
-            if not action.mouse_related:  # Don't save mouse-related actions
-                data[name] = {
-                    "primary_key": action.primary_key,
-                    "secondary_key": action.secondary_key,
-                }
-
-        with open(self.hotkeys_file, "w") as f:
-            json.dump(data, f, indent=4)
-
-    def load_hotkeys(self):
-        """Load hotkeys from file."""
-        if not os.path.exists(self.hotkeys_file):
-            return
-
-        try:
-            with open(self.hotkeys_file) as f:
-                data = json.load(f)
-
-            for name, keys in data.items():
-                if name in self.actions and not self.actions[name].mouse_related:
-                    self.actions[name].primary_key = keys.get("primary_key", "")
-                    self.actions[name].secondary_key = keys.get("secondary_key")
-        except (json.JSONDecodeError, KeyError, FileNotFoundError):
-            # If loading fails, keep defaults
-            pass
-
-    def key_sequence_to_string(self, key_sequence: QKeySequence) -> str:
-        """Convert QKeySequence to string representation."""
-        return key_sequence.toString()
-
-    def string_to_key_sequence(self, key_string: str) -> QKeySequence:
-        """Convert string to QKeySequence."""
-        return QKeySequence(key_string)
+"""Hotkey management system."""
+
+import json
+import os
+from dataclasses import dataclass
+
+from PyQt6.QtGui import QKeySequence
+
+
+@dataclass
+class HotkeyAction:
+    """Represents a hotkey action with primary and secondary keys."""
+
+    name: str
+    description: str
+    primary_key: str
+    secondary_key: str | None = None
+    category: str = "General"
+    mouse_related: bool = False  # Cannot be reassigned if True
+
+
+class HotkeyManager:
+    """Manages application hotkeys with persistence."""
+
+    def __init__(self, config_dir: str):
+        self.config_dir = config_dir
+        self.hotkeys_file = os.path.join(config_dir, "hotkeys.json")
+        self.actions: dict[str, HotkeyAction] = {}
+        self._initialize_default_hotkeys()
+        self.load_hotkeys()
+
+    def _initialize_default_hotkeys(self):
+        """Initialize default hotkey mappings."""
+        default_hotkeys = [
+            # Navigation
+            HotkeyAction(
+                "load_next_image", "Load Next Image", "Right", category="Navigation"
+            ),
+            HotkeyAction(
+                "load_previous_image",
+                "Load Previous Image",
+                "Left",
+                category="Navigation",
+            ),
+            HotkeyAction("fit_view", "Fit View", ".", category="Navigation"),
+            # Modes
+            HotkeyAction("sam_mode", "Point Mode (SAM)", "1", category="Modes"),
+            HotkeyAction("polygon_mode", "Polygon Mode", "2", category="Modes"),
+            HotkeyAction("bbox_mode", "Bounding Box Mode", "3", category="Modes"),
+            HotkeyAction("selection_mode", "Selection Mode", "E", category="Modes"),
+            HotkeyAction("pan_mode", "Pan Mode", "Q", category="Modes"),
+            HotkeyAction("edit_mode", "Edit Mode", "R", category="Modes"),
+            # Actions
+            HotkeyAction(
+                "clear_points", "Clear Points/Vertices", "C", category="Actions"
+            ),
+            HotkeyAction(
+                "save_segment", "Save Current Segment", "Space", category="Actions"
+            ),
+            HotkeyAction("save_output", "Save Output", "Return", category="Actions"),
+            HotkeyAction(
+                "save_output_alt", "Save Output (Alt)", "Enter", category="Actions"
+            ),
+            HotkeyAction("undo", "Undo Last Action", "Ctrl+Z", category="Actions"),
+            HotkeyAction(
+                "redo", "Redo Last Action", "Ctrl+Y", "Ctrl+Shift+Z", category="Actions"
+            ),
+            HotkeyAction(
+                "escape", "Cancel/Clear Selection", "Escape", category="Actions"
+            ),
+            # Segments
+            HotkeyAction(
+                "merge_segments", "Merge Selected Segments", "M", category="Segments"
+            ),
+            HotkeyAction(
+                "delete_segments", "Delete Selected Segments", "V", category="Segments"
+            ),
+            HotkeyAction(
+                "delete_segments_alt",
+                "Delete Selected Segments (Alt)",
+                "Backspace",
+                category="Segments",
+            ),
+            HotkeyAction(
+                "select_all", "Select All Segments", "Ctrl+A", category="Segments"
+            ),
+            # View
+            HotkeyAction("zoom_in", "Zoom In", "Ctrl+Plus", category="View"),
+            HotkeyAction("zoom_out", "Zoom Out", "Ctrl+Minus", category="View"),
+            # Movement (WASD)
+            HotkeyAction("pan_up", "Pan Up", "W", category="Movement"),
+            HotkeyAction("pan_down", "Pan Down", "S", category="Movement"),
+            HotkeyAction("pan_left", "Pan Left", "A", category="Movement"),
+            HotkeyAction("pan_right", "Pan Right", "D", category="Movement"),
+            # Mouse-related (cannot be reassigned)
+            HotkeyAction(
+                "left_click",
+                "Add Positive Point / Select",
+                "Left Click",
+                category="Mouse",
+                mouse_related=True,
+            ),
+            HotkeyAction(
+                "right_click",
+                "Add Negative Point",
+                "Right Click",
+                category="Mouse",
+                mouse_related=True,
+            ),
+            HotkeyAction(
+                "mouse_drag",
+                "Drag/Pan",
+                "Mouse Drag",
+                category="Mouse",
+                mouse_related=True,
+            ),
+        ]
+
+        for action in default_hotkeys:
+            self.actions[action.name] = action
+
+    def get_action(self, action_name: str) -> HotkeyAction | None:
+        """Get hotkey action by name."""
+        return self.actions.get(action_name)
+
+    def get_actions_by_category(self) -> dict[str, list[HotkeyAction]]:
+        """Get actions grouped by category."""
+        categories = {}
+        for action in self.actions.values():
+            if action.category not in categories:
+                categories[action.category] = []
+            categories[action.category].append(action)
+        return categories
+
+    def set_primary_key(self, action_name: str, key: str) -> bool:
+        """Set primary key for an action."""
+        if action_name in self.actions and not self.actions[action_name].mouse_related:
+            self.actions[action_name].primary_key = key
+            return True
+        return False
+
+    def set_secondary_key(self, action_name: str, key: str | None) -> bool:
+        """Set secondary key for an action."""
+        if action_name in self.actions and not self.actions[action_name].mouse_related:
+            self.actions[action_name].secondary_key = key
+            return True
+        return False
+
+    def get_key_for_action(self, action_name: str) -> tuple[str | None, str | None]:
+        """Get primary and secondary keys for an action."""
+        action = self.actions.get(action_name)
+        if action:
+            return action.primary_key, action.secondary_key
+        return None, None
+
+    def is_key_in_use(self, key: str, exclude_action: str = None) -> str | None:
+        """Check if a key is already in use by another action."""
+        for name, action in self.actions.items():
+            if name == exclude_action:
+                continue
+            if action.primary_key == key or action.secondary_key == key:
+                return name
+        return None
+
+    def reset_to_defaults(self):
+        """Reset all hotkeys to default values."""
+        self._initialize_default_hotkeys()
+
+    def save_hotkeys(self):
+        """Save hotkeys to file."""
+        os.makedirs(self.config_dir, exist_ok=True)
+
+        # Convert to serializable format
+        data = {}
+        for name, action in self.actions.items():
+            if not action.mouse_related:  # Don't save mouse-related actions
+                data[name] = {
+                    "primary_key": action.primary_key,
+                    "secondary_key": action.secondary_key,
+                }
+
+        with open(self.hotkeys_file, "w") as f:
+            json.dump(data, f, indent=4)
+
+    def load_hotkeys(self):
+        """Load hotkeys from file."""
+        if not os.path.exists(self.hotkeys_file):
+            return
+
+        try:
+            with open(self.hotkeys_file) as f:
+                data = json.load(f)
+
+            for name, keys in data.items():
+                if name in self.actions and not self.actions[name].mouse_related:
+                    self.actions[name].primary_key = keys.get("primary_key", "")
+                    self.actions[name].secondary_key = keys.get("secondary_key")
+        except (json.JSONDecodeError, KeyError, FileNotFoundError):
+            # If loading fails, keep defaults
+            pass
+
+    def key_sequence_to_string(self, key_sequence: QKeySequence) -> str:
+        """Convert QKeySequence to string representation."""
+        return key_sequence.toString()
+
+    def string_to_key_sequence(self, key_string: str) -> QKeySequence:
+        """Convert string to QKeySequence."""
+        return QKeySequence(key_string)

lazylabel/core/segment_manager.py

@@ -24,13 +24,24 @@ class SegmentManager:
         self.active_class_id = None
 
     def add_segment(self, segment_data: dict[str, Any]) -> None:
-        """Add a new segment."""
+        """Add a new segment.
+
+        If the segment is a polygon, convert QPointF objects to simple lists
+        for serialization compatibility.
+        """
         if "class_id" not in segment_data:
             # Use active class if available, otherwise use next class ID
             if self.active_class_id is not None:
                 segment_data["class_id"] = self.active_class_id
             else:
                 segment_data["class_id"] = self.next_class_id
+
+        # Convert QPointF to list for storage if it's a polygon
+        if segment_data.get("type") == "Polygon" and segment_data.get("vertices"):
+            segment_data["vertices"] = [
+                [p.x(), p.y()] for p in segment_data["vertices"]
+            ]
+
         self.segments.append(segment_data)
         self._update_next_class_id()
 
@@ -103,7 +114,9 @@ class SegmentManager:
             new_channel_idx = id_map[class_id]
 
             if seg["type"] == "Polygon":
-                mask = self.rasterize_polygon(seg["vertices"], image_size)
+                # Convert stored list of lists back to QPointF objects for rasterization
+                qpoints = [QPointF(p[0], p[1]) for p in seg["vertices"]]
+                mask = self.rasterize_polygon(qpoints, image_size)
             else:
                 mask = seg.get("mask")
 

lazylabel/ui/control_panel.py

@@ -19,6 +19,7 @@ class ControlPanel(QWidget):
     # Signals
     sam_mode_requested = pyqtSignal()
     polygon_mode_requested = pyqtSignal()
+    bbox_mode_requested = pyqtSignal()  # New signal for bounding box mode
     selection_mode_requested = pyqtSignal()
     clear_points_requested = pyqtSignal()
     fit_view_requested = pyqtSignal()
@@ -117,11 +118,15 @@ class ControlPanel(QWidget):
         self.btn_polygon_mode = QPushButton("Polygon Mode (2)")
         self.btn_polygon_mode.setToolTip("Switch to Polygon Drawing Mode (2)")
 
+        self.btn_bbox_mode = QPushButton("BBox Mode (3)")
+        self.btn_bbox_mode.setToolTip("Switch to Bounding Box Drawing Mode (3)")
+
         self.btn_selection_mode = QPushButton("Selection Mode (E)")
         self.btn_selection_mode.setToolTip("Toggle segment selection (E)")
 
         layout.addWidget(self.btn_sam_mode)
         layout.addWidget(self.btn_polygon_mode)
+        layout.addWidget(self.btn_bbox_mode)
         layout.addWidget(self.btn_selection_mode)
 
     def _add_action_buttons(self, layout):
@@ -149,6 +154,7 @@ class ControlPanel(QWidget):
         """Connect internal signals."""
         self.btn_sam_mode.clicked.connect(self.sam_mode_requested)
         self.btn_polygon_mode.clicked.connect(self.polygon_mode_requested)
+        self.btn_bbox_mode.clicked.connect(self.bbox_mode_requested)
         self.btn_selection_mode.clicked.connect(self.selection_mode_requested)
         self.btn_clear_points.clicked.connect(self.clear_points_requested)
         self.btn_fit_view.clicked.connect(self.fit_view_requested)

lazylabel/ui/main_window.py

@@ -4,7 +4,7 @@ import os
 
 import cv2
 import numpy as np
-from PyQt6.QtCore import QModelIndex, QPointF, Qt, QTimer, pyqtSignal
+from PyQt6.QtCore import QModelIndex, QPointF, QRectF, Qt, QTimer, pyqtSignal
 from PyQt6.QtGui import (
     QBrush,
     QColor,
@@ -22,6 +22,7 @@ from PyQt6.QtWidgets import (
     QGraphicsEllipseItem,
     QGraphicsLineItem,
     QGraphicsPolygonItem,
+    QGraphicsRectItem,
     QMainWindow,
     QSplitter,
     QTableWidgetItem,
@@ -116,6 +117,7 @@ class MainWindow(QMainWindow):
         self.point_items, self.positive_points, self.negative_points = [], [], []
         self.polygon_points, self.polygon_preview_items = [], []
         self.rubber_band_line = None
+        self.rubber_band_rect = None  # New attribute for bounding box
         self.preview_mask_item = None
         self.segments, self.segment_items, self.highlight_items = [], {}, []
         self.edit_handles = []
@@ -245,6 +247,7 @@ class MainWindow(QMainWindow):
         # Control panel connections
         self.control_panel.sam_mode_requested.connect(self.set_sam_mode)
         self.control_panel.polygon_mode_requested.connect(self.set_polygon_mode)
+        self.control_panel.bbox_mode_requested.connect(self.set_bbox_mode)
         self.control_panel.selection_mode_requested.connect(self.toggle_selection_mode)
         self.control_panel.clear_points_requested.connect(self.clear_all_points)
         self.control_panel.fit_view_requested.connect(self.viewer.fitInView)
@@ -302,6 +305,7 @@ class MainWindow(QMainWindow):
             "load_previous_image": self._load_previous_image,
             "sam_mode": self.set_sam_mode,
             "polygon_mode": self.set_polygon_mode,
+            "bbox_mode": self.set_bbox_mode,
             "selection_mode": self.toggle_selection_mode,
             "pan_mode": self.toggle_pan_mode,
             "edit_mode": self.toggle_edit_mode,
@@ -376,6 +380,10 @@ class MainWindow(QMainWindow):
         """Set polygon drawing mode."""
         self._set_mode("polygon")
 
+    def set_bbox_mode(self):
+        """Set bounding box drawing mode."""
+        self._set_mode("bbox")
+
     def toggle_selection_mode(self):
         """Toggle selection mode."""
         self._toggle_mode("selection")
@@ -401,6 +409,7 @@ class MainWindow(QMainWindow):
         cursor_map = {
             "sam_points": Qt.CursorShape.CrossCursor,
             "polygon": Qt.CursorShape.CrossCursor,
+            "bbox": Qt.CursorShape.CrossCursor,
             "selection": Qt.CursorShape.ArrowCursor,
             "edit": Qt.CursorShape.SizeAllCursor,
             "pan": Qt.CursorShape.OpenHandCursor,
@@ -521,6 +530,9 @@ class MainWindow(QMainWindow):
         path = self.file_model.filePath(index)
 
         if os.path.isfile(path) and self.file_manager.is_image_file(path):
+            if path == self.current_image_path:  # Only reset if loading a new image
+                return
+
             self.current_image_path = path
             pixmap = QPixmap(self.current_image_path)
             if not pixmap.isNull():
@@ -613,7 +625,9 @@ class MainWindow(QMainWindow):
                 highlight_brush = QBrush(QColor(255, 255, 0, 180))
 
             if seg["type"] == "Polygon" and seg.get("vertices"):
-                poly_item = QGraphicsPolygonItem(QPolygonF(seg["vertices"]))
+                # Convert stored list of lists back to QPointF objects
+                qpoints = [QPointF(p[0], p[1]) for p in seg["vertices"]]
+                poly_item = QGraphicsPolygonItem(QPolygonF(qpoints))
                 poly_item.setBrush(highlight_brush)
                 poly_item.setPen(QPen(Qt.GlobalColor.transparent))
                 poly_item.setZValue(99)
@@ -805,13 +819,17 @@ class MainWindow(QMainWindow):
         self._clear_edit_handles()
 
         # Display segments from segment manager
+
         for i, segment in enumerate(self.segment_manager.segments):
             self.segment_items[i] = []
             class_id = segment.get("class_id")
             base_color = self._get_color_for_class(class_id)
 
             if segment["type"] == "Polygon" and segment.get("vertices"):
-                poly_item = HoverablePolygonItem(QPolygonF(segment["vertices"]))
+                # Convert stored list of lists back to QPointF objects
+                qpoints = [QPointF(p[0], p[1]) for p in segment["vertices"]]
+
+                poly_item = HoverablePolygonItem(QPolygonF(qpoints))
                 default_brush = QBrush(
                     QColor(base_color.red(), base_color.green(), base_color.blue(), 70)
                 )
@@ -1129,7 +1147,8 @@ class MainWindow(QMainWindow):
                 for i, vertices in final_vertices.items():
                     if i < len(self.segment_manager.segments):
                         self.segment_manager.segments[i]["vertices"] = [
-                            QPointF(v.x(), v.y()) for v in vertices
+                            [v.x(), v.y()]
+                            for v in [QPointF(p[0], p[1]) for p in vertices]
                         ]
                         self._update_polygon_item(i)
                 self._display_edit_handles()
@@ -1302,7 +1321,8 @@ class MainWindow(QMainWindow):
                 selected_indices = self.right_panel.get_selected_segment_indices()
                 self.drag_initial_vertices = {
                     i: [
-                        QPointF(p) for p in self.segment_manager.segments[i]["vertices"]
+                        QPointF(p[0], p[1])
+                        for p in self.segment_manager.segments[i]["vertices"]
                     ]
                     for i in selected_indices
                     if self.segment_manager.segments[i].get("type") == "Polygon"
@@ -1312,9 +1332,6 @@ class MainWindow(QMainWindow):
 
         # Call the original scene handler.
         self._original_mouse_press(event)
-        # Skip further processing unless we're in selection mode.
-        if event.isAccepted() and self.mode != "selection":
-            return
 
         if self.is_dragging_polygon:
             return
@@ -1338,6 +1355,14 @@ class MainWindow(QMainWindow):
         elif self.mode == "polygon":
             if event.button() == Qt.MouseButton.LeftButton:
                 self._handle_polygon_click(pos)
+        elif self.mode == "bbox":
+            if event.button() == Qt.MouseButton.LeftButton:
+                self.drag_start_pos = pos
+                self.rubber_band_rect = QGraphicsRectItem()
+                self.rubber_band_rect.setPen(
+                    QPen(Qt.GlobalColor.red, 2, Qt.PenStyle.DashLine)
+                )
+                self.viewer.scene().addItem(self.rubber_band_rect)
         elif self.mode == "selection" and event.button() == Qt.MouseButton.LeftButton:
             self._handle_segment_selection_click(pos)
 
@@ -1346,8 +1371,9 @@ class MainWindow(QMainWindow):
         if self.mode == "edit" and self.is_dragging_polygon:
             delta = event.scenePos() - self.drag_start_pos
             for i, initial_verts in self.drag_initial_vertices.items():
+                # initial_verts are already QPointF objects
                 self.segment_manager.segments[i]["vertices"] = [
-                    QPointF(v) + delta for v in initial_verts
+                    [(p + delta).x(), (p + delta).y()] for p in initial_verts
                 ]
                 self._update_polygon_item(i)
             self._display_edit_handles()  # Redraw handles at new positions
@@ -1357,6 +1383,13 @@ class MainWindow(QMainWindow):
 
         self._original_mouse_move(event)
 
+        if self.mode == "bbox" and self.rubber_band_rect and self.drag_start_pos:
+            current_pos = event.scenePos()
+            rect = QRectF(self.drag_start_pos, current_pos).normalized()
+            self.rubber_band_rect.setRect(rect)
+            event.accept()
+            return
+
     def _scene_mouse_release(self, event):
         """Handle mouse release events in the scene."""
         if self.mode == "edit" and self.is_dragging_polygon:
@@ -1383,6 +1416,41 @@ class MainWindow(QMainWindow):
 
         if self.mode == "pan":
             self.viewer.set_cursor(Qt.CursorShape.OpenHandCursor)
+        elif self.mode == "bbox" and self.rubber_band_rect:
+            self.viewer.scene().removeItem(self.rubber_band_rect)
+            rect = self.rubber_band_rect.rect()
+            self.rubber_band_rect = None
+            self.drag_start_pos = None
+
+            if rect.width() > 0 and rect.height() > 0:
+                # Convert QRectF to QPolygonF
+                polygon = QPolygonF()
+                polygon.append(rect.topLeft())
+                polygon.append(rect.topRight())
+                polygon.append(rect.bottomRight())
+                polygon.append(rect.bottomLeft())
+
+                new_segment = {
+                    "vertices": list(polygon),
+                    "type": "Polygon",  # Bounding boxes are stored as polygons
+                    "mask": None,
+                }
+
+                self.segment_manager.add_segment(new_segment)
+
+                # Record the action for undo
+                self.action_history.append(
+                    {
+                        "type": "add_segment",
+                        "segment_index": len(self.segment_manager.segments) - 1,
+                    }
+                )
+                # Clear redo history when a new action is performed
+                self.redo_history.clear()
+                self._update_all_lists()
+            event.accept()
+            return
+
         self._original_mouse_release(event)
 
     def _add_point(self, pos, positive):
@@ -1522,9 +1590,9 @@ class MainWindow(QMainWindow):
                     continue
                 h = self.viewer._pixmap_item.pixmap().height()
                 w = self.viewer._pixmap_item.pixmap().width()
-                points_np = np.array(
-                    [[p.x(), p.y()] for p in seg["vertices"]], dtype=np.int32
-                )
+                # Convert stored list of lists back to QPointF objects for rasterization
+                qpoints = [QPointF(p[0], p[1]) for p in seg["vertices"]]
+                points_np = np.array([[p.x(), p.y()] for p in qpoints], dtype=np.int32)
                 # Ensure points are within bounds
                 points_np = np.clip(points_np, 0, [w - 1, h - 1])
                 mask = np.zeros((h, w), dtype=np.uint8)
@@ -1574,7 +1642,8 @@ class MainWindow(QMainWindow):
         for seg_idx in selected_indices:
             seg = self.segment_manager.segments[seg_idx]
             if seg["type"] == "Polygon" and seg.get("vertices"):
-                for v_idx, pt in enumerate(seg["vertices"]):
+                for v_idx, pt_list in enumerate(seg["vertices"]):
+                    pt = QPointF(pt_list[0], pt_list[1])  # Convert list to QPointF
                     handle = EditableVertexItem(
                         self,
                         seg_idx,
@@ -1610,15 +1679,16 @@ class MainWindow(QMainWindow):
                         "type": "move_vertex",
                         "segment_index": segment_index,
                         "vertex_index": vertex_index,
-                        "old_pos": old_pos,
-                        "new_pos": new_pos,
+                        "old_pos": [old_pos[0], old_pos[1]],  # Store as list
+                        "new_pos": [new_pos.x(), new_pos.y()],  # Store as list
                     }
                 )
                 # Clear redo history when a new action is performed
                 self.redo_history.clear()
-            seg["vertices"][vertex_index] = (
-                new_pos  # new_pos is already the correct scene coordinate
-            )
+            seg["vertices"][vertex_index] = [
+                new_pos.x(),
+                new_pos.y(),  # Store as list
+            ]
             self._update_polygon_item(segment_index)
             self._highlight_selected_segments()  # Keep the highlight in sync with the new shape
 
@@ -1627,9 +1697,12 @@ class MainWindow(QMainWindow):
         items = self.segment_items.get(segment_index, [])
         for item in items:
             if isinstance(item, HoverablePolygonItem):
-                item.setPolygon(
-                    QPolygonF(self.segment_manager.segments[segment_index]["vertices"])
-                )
+                # Convert stored list of lists back to QPointF objects
+                qpoints = [
+                    QPointF(p[0], p[1])
+                    for p in self.segment_manager.segments[segment_index]["vertices"]
+                ]
+                item.setPolygon(QPolygonF(qpoints))
                 return
 
     def _handle_class_toggle(self, class_id):

lazylabel/ui/right_panel.py

@@ -72,6 +72,12 @@ class RightPanel(QWidget):
         # Class management section
         self._setup_class_management(v_splitter)
 
+        # Action history section (new)
+        self.action_pane_widget = QWidget()  # Placeholder for ActionPane
+        action_pane_layout = QVBoxLayout(self.action_pane_widget)
+        action_pane_layout.setContentsMargins(0, 0, 0, 0)
+        v_splitter.addWidget(self.action_pane_widget)
+
         main_layout.addWidget(v_splitter)
 
         # Status label
@@ -81,6 +87,18 @@ class RightPanel(QWidget):
 
         self.v_layout.addWidget(self.main_controls_widget)
 
+    def set_action_pane(self, action_pane_widget):
+        """Sets the ActionPane widget into the right panel."""
+        # Clear existing layout in the placeholder widget
+        while self.action_pane_widget.layout().count():
+            item = self.action_pane_widget.layout().takeAt(0)
+            if item.widget():
+                item.widget().setParent(None)
+        self.action_pane_widget.layout().addWidget(action_pane_widget)
+        action_pane_widget.setParent(
+            self.action_pane_widget
+        )  # Ensure correct parentage
+
     def _setup_file_explorer(self, splitter):
         """Setup file explorer section."""
         file_explorer_widget = QWidget()

{lazylabel_gui-1.1.3.dist-info → lazylabel_gui-1.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lazylabel-gui
-Version: 1.1.3
+Version: 1.1.4
 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.1.3.dist-info → lazylabel_gui-1.1.4.dist-info}/RECORD

@@ -1,26 +1,26 @@
 lazylabel/__init__.py,sha256=0yitHZYNNuF4Rqj7cqE0TrfDV8zhzKD3A5W1vOymHK4,199
 lazylabel/main.py,sha256=AQ-SKj8korOa2rKviFaA1kC-c03VPmVN2xU2qk36764,768
 lazylabel/config/__init__.py,sha256=TnDXH0yx0zy97FfjpiVPHleMgMrM5YwWrUbvevSNJjg,263
-lazylabel/config/hotkeys.py,sha256=Aq5pH2ED91A0wayQD58Vy0gjmajlV4-ra7Vd-IgZr38,8114
+lazylabel/config/hotkeys.py,sha256=bbHPpCNokwgH0EX74vGcNdn3RoyVZNVr-is6us-7J3M,7990
 lazylabel/config/paths.py,sha256=ZVKbtaNOxmYO4l6JgsY-8DXaE_jaJfDg2RQJJn3-5nw,1275
 lazylabel/config/settings.py,sha256=Ud27cSadJ7M4l30XN0KrxZ3ixAOPXTUhj-SvvanMjaI,1787
 lazylabel/core/__init__.py,sha256=FmRjop_uIBSJwKMGhaZ-3Iwu34LkoxTuD-hnq5vbTSY,232
 lazylabel/core/file_manager.py,sha256=Blo55jXW-uGVLrreGRmlHUtK2yTbyj3jsTKkfjD0z7k,4796
 lazylabel/core/model_manager.py,sha256=P3IahI0xUk6-F7Y5U4r5RpnUQSelJqX2KBtcmUGNeNY,3368
-lazylabel/core/segment_manager.py,sha256=h7ikOZXpV-JwutiWK9xYGWctTaNHJKMeWau9ANml1tY,5913
+lazylabel/core/segment_manager.py,sha256=1lABdVdaa69_RPKx6ftYKJh7lNWCanodTsh7Utrpn2Q,6477
 lazylabel/models/__init__.py,sha256=fIlk_0DuZfiClcm0XlZdimeHzunQwBmTMI4PcGsaymw,91
 lazylabel/models/sam_model.py,sha256=89v99hpD0ngAAQKiuRyIib0E-5u9zTDJcubtmxxG-PM,7878
 lazylabel/ui/__init__.py,sha256=4qDIh9y6tABPmD8MAMGZn_G7oSRyrcHt2HkjoWgbGH4,268
-lazylabel/ui/control_panel.py,sha256=iyn6v-GvdSabd0Lk7n6S8p_svuTrqsG0jUOZBGhjqAc,8925
+lazylabel/ui/control_panel.py,sha256=UlETN2IZv1l2xiaWPQvdalaK_f9YQf9iiB1Jb_EEgfs,9260
 lazylabel/ui/editable_vertex.py,sha256=xzc5QdFJJXiy035C3HgR4ph-tuJu8245l-Ar7aBvVv8,2399
 lazylabel/ui/hotkey_dialog.py,sha256=ZlZoPvY822ke8YkbCy22o2RUjxtkXSoEOg8eVETIKpQ,15118
 lazylabel/ui/hoverable_pixelmap_item.py,sha256=kJFOp7WXiyHpNf7l73TZjiob85jgP30b5MZvu_z5L3c,728
 lazylabel/ui/hoverable_polygon_item.py,sha256=aclUwd0P8H8xbcep6GwhnfaVs1zSkqeZKAL-xeDyMiU,1222
-lazylabel/ui/main_window.py,sha256=BQh1OsHxZ_ukjcF4HzcJAAzLqNJENBBHZGpB2bYoXbo,75311
+lazylabel/ui/main_window.py,sha256=ta3nzb6MWG-eLexlGKBc3oKtlsF9HpI-q1SvlrA-W2o,78623
 lazylabel/ui/numeric_table_widget_item.py,sha256=dQUlIFu9syCxTGAHVIlmbgkI7aJ3f3wmDPBz1AGK9Bg,283
 lazylabel/ui/photo_viewer.py,sha256=4n2zSpFAnausCoIU-wwWDHDo6vsNp_RGIkhDyhuM2_A,1997
 lazylabel/ui/reorderable_class_table.py,sha256=sxHhQre5O_MXLDFgKnw43QnvXXoqn5xRKMGitgO7muI,2371
-lazylabel/ui/right_panel.py,sha256=F407BhQSNTKi_9IIqdZZgjSMiUmxOIcNO-7UtWWbbdk,12279
+lazylabel/ui/right_panel.py,sha256=-PeXcu7Lr-xhZniBMvWLDPiFb_RAHYAcILyw8fPJs6I,13139
 lazylabel/ui/widgets/__init__.py,sha256=bYjLRTqWdi4hcPfSSXmXuT-0c5Aee7HnnQurv_k5bfY,314
 lazylabel/ui/widgets/adjustments_widget.py,sha256=xM43q1khpvRIHslPfI6bukzjx9J0mPgHUdNKCmp3rtM,3912
 lazylabel/ui/widgets/model_selection_widget.py,sha256=kMPaBMfdfnEVH-Be1d5OxLEuioO0c04FZT1Hr904axM,3497
@@ -29,9 +29,9 @@ lazylabel/ui/widgets/status_bar.py,sha256=wTbMQNEOBfmtNj8EVFZS_lxgaemu-CbRXeZzEQ
 lazylabel/utils/__init__.py,sha256=V6IR5Gim-39HgM2NyTVT-n8gy3mjilCSFW9y0owN5nc,179
 lazylabel/utils/custom_file_system_model.py,sha256=-3EimlybvevH6bvqBE0qdFnLADVtayylmkntxPXK0Bk,4869
 lazylabel/utils/utils.py,sha256=sYSCoXL27OaLgOZaUkCAhgmKZ7YfhR3Cc5F8nDIa3Ig,414
-lazylabel_gui-1.1.3.dist-info/licenses/LICENSE,sha256=kSDEIgrWAPd1u2UFGGpC9X71dhzrlzBFs8hbDlENnGE,1092
-lazylabel_gui-1.1.3.dist-info/METADATA,sha256=i0c3l4ODbKROaIHXpX9y9kttfEbVOU1A3j7NoNONsmo,9506
-lazylabel_gui-1.1.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lazylabel_gui-1.1.3.dist-info/entry_points.txt,sha256=Hd0WwEG9OPTa_ziYjiD0aRh7R6Fupt-wdQ3sspdc1mM,54
-lazylabel_gui-1.1.3.dist-info/top_level.txt,sha256=YN4uIyrpDBq1wiJaBuZLDipIzyZY0jqJOmmXiPIOUkU,10
-lazylabel_gui-1.1.3.dist-info/RECORD,,
+lazylabel_gui-1.1.4.dist-info/licenses/LICENSE,sha256=kSDEIgrWAPd1u2UFGGpC9X71dhzrlzBFs8hbDlENnGE,1092
+lazylabel_gui-1.1.4.dist-info/METADATA,sha256=hYVIAtM7vZNaJ8-0QOnFtNyaK3UpScgswNyJuaiJaFE,9506
+lazylabel_gui-1.1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lazylabel_gui-1.1.4.dist-info/entry_points.txt,sha256=Hd0WwEG9OPTa_ziYjiD0aRh7R6Fupt-wdQ3sspdc1mM,54
+lazylabel_gui-1.1.4.dist-info/top_level.txt,sha256=YN4uIyrpDBq1wiJaBuZLDipIzyZY0jqJOmmXiPIOUkU,10
+lazylabel_gui-1.1.4.dist-info/RECORD,,