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

lazylabel/ui/main_window.py

@@ -1,48 +1,46 @@
 """Main application window."""
 
 import os
-import numpy as np
+
 import cv2
+import numpy as np
+from PyQt6.QtCore import QModelIndex, QPointF, Qt, QTimer, pyqtSignal
+from PyQt6.QtGui import (
+    QBrush,
+    QColor,
+    QIcon,
+    QKeySequence,
+    QPen,
+    QPixmap,
+    QPolygonF,
+    QShortcut,
+)
 from PyQt6.QtWidgets import (
-    QMainWindow,
-    QWidget,
-    QHBoxLayout,
-    QVBoxLayout,
-    QFileDialog,
     QApplication,
+    QDialog,
+    QFileDialog,
     QGraphicsEllipseItem,
     QGraphicsLineItem,
     QGraphicsPolygonItem,
+    QMainWindow,
+    QSplitter,
     QTableWidgetItem,
     QTableWidgetSelectionRange,
-    QHeaderView,
-    QSplitter,
-    QDialog,
-)
-from PyQt6.QtGui import (
-    QIcon,
-    QKeySequence,
-    QShortcut,
-    QPixmap,
-    QColor,
-    QPen,
-    QBrush,
-    QPolygonF,
-    QImage,
+    QVBoxLayout,
+    QWidget,
 )
-from PyQt6.QtCore import Qt, QTimer, QModelIndex, QPointF, pyqtSignal
 
+from ..config import HotkeyManager, Paths, Settings
+from ..core import FileManager, ModelManager, SegmentManager
+from ..utils import CustomFileSystemModel, mask_to_pixmap
 from .control_panel import ControlPanel
-from .right_panel import RightPanel
-from .photo_viewer import PhotoViewer
-from .hoverable_polygon_item import HoverablePolygonItem
-from .hoverable_pixelmap_item import HoverablePixmapItem
 from .editable_vertex import EditableVertexItem
-from .numeric_table_widget_item import NumericTableWidgetItem
-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 .hoverable_pixelmap_item import HoverablePixmapItem
+from .hoverable_polygon_item import HoverablePolygonItem
+from .numeric_table_widget_item import NumericTableWidgetItem
+from .photo_viewer import PhotoViewer
+from .right_panel import RightPanel
 from .widgets import StatusBar
 
 
@@ -126,6 +124,8 @@ class MainWindow(QMainWindow):
             None,
             {},
         )
+        self.action_history = []
+        self.redo_history = []
 
         # Update state flags to prevent recursion
         self._updating_lists = False
@@ -311,6 +311,7 @@ class MainWindow(QMainWindow):
             "delete_segments_alt": self._delete_selected_segments,
             "merge_segments": self._handle_merge_press,
             "undo": self._undo_last_action,
+            "redo": self._redo_last_action,
             "select_all": lambda: self.right_panel.select_all_segments(),
             "save_segment": self._handle_space_press,
             "save_output": self._handle_enter_press,
@@ -346,6 +347,7 @@ class MainWindow(QMainWindow):
         self.control_panel.set_annotation_size(
             int(self.settings.annotation_size_multiplier * 10)
         )
+        self.control_panel.set_join_threshold(self.settings.polygon_join_threshold)
         # Set initial mode based on model availability
         if self.model_manager.is_model_available():
             self.set_sam_mode()
@@ -795,7 +797,7 @@ class MainWindow(QMainWindow):
     def _display_all_segments(self):
         """Display all segments on the viewer."""
         # Clear existing segment items
-        for i, items in self.segment_items.items():
+        for _i, items in self.segment_items.items():
             for item in items:
                 if item.scene():
                     self.viewer.scene().removeItem(item)
@@ -868,13 +870,21 @@ class MainWindow(QMainWindow):
             self.positive_points, self.negative_points
         )
         if mask is not None:
-            self.segment_manager.add_segment(
+            new_segment = {
+                "mask": mask,
+                "type": "SAM",
+                "vertices": None,
+            }
+            self.segment_manager.add_segment(new_segment)
+            # Record the action for undo
+            self.action_history.append(
                 {
-                    "mask": mask,
-                    "type": "SAM",
-                    "vertices": None,
+                    "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.clear_all_points()
             self._update_all_lists()
 
@@ -883,13 +893,22 @@ class MainWindow(QMainWindow):
         if len(self.polygon_points) < 3:
             return
 
-        self.segment_manager.add_segment(
+        new_segment = {
+            "vertices": list(self.polygon_points),
+            "type": "Polygon",
+            "mask": None,
+        }
+        self.segment_manager.add_segment(new_segment)
+        # Record the action for undo
+        self.action_history.append(
             {
-                "vertices": list(self.polygon_points),
-                "type": "Polygon",
-                "mask": None,
+                "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.polygon_points.clear()
         self.clear_all_points()
         self._update_all_lists()
@@ -980,9 +999,176 @@ class MainWindow(QMainWindow):
         self.right_panel.clear_selections()
 
     def _undo_last_action(self):
-        """Undo last action."""
-        # Implementation would go here
-        pass
+        """Undo the last action recorded in the history."""
+        if not self.action_history:
+            self._show_notification("Nothing to undo.")
+            return
+
+        last_action = self.action_history.pop()
+        action_type = last_action.get("type")
+
+        # Save to redo history before undoing
+        self.redo_history.append(last_action)
+
+        if action_type == "add_segment":
+            segment_index = last_action.get("segment_index")
+            if segment_index is not None and 0 <= segment_index < len(
+                self.segment_manager.segments
+            ):
+                # Store the segment data for redo
+                last_action["segment_data"] = self.segment_manager.segments[
+                    segment_index
+                ].copy()
+
+                # Remove the segment that was added
+                self.segment_manager.delete_segments([segment_index])
+                self.right_panel.clear_selections()  # Clear selection to prevent phantom highlights
+                self._update_all_lists()
+                self._show_notification("Undid: Add Segment")
+        elif action_type == "add_point":
+            point_type = last_action.get("point_type")
+            point_item = last_action.get("point_item")
+            point_list = (
+                self.positive_points
+                if point_type == "positive"
+                else self.negative_points
+            )
+            if point_list:
+                point_list.pop()
+                if point_item in self.point_items:
+                    self.point_items.remove(point_item)
+                    self.viewer.scene().removeItem(point_item)
+                self._update_segmentation()
+                self._show_notification("Undid: Add Point")
+        elif action_type == "add_polygon_point":
+            dot_item = last_action.get("dot_item")
+            if self.polygon_points:
+                self.polygon_points.pop()
+                if dot_item in self.polygon_preview_items:
+                    self.polygon_preview_items.remove(dot_item)
+                    self.viewer.scene().removeItem(dot_item)
+                self._draw_polygon_preview()
+            self._show_notification("Undid: Add Polygon Point")
+        elif action_type == "move_polygon":
+            initial_vertices = last_action.get("initial_vertices")
+            for i, vertices in initial_vertices.items():
+                self.segment_manager.segments[i]["vertices"] = vertices
+                self._update_polygon_item(i)
+            self._display_edit_handles()
+            self._highlight_selected_segments()
+            self._show_notification("Undid: Move Polygon")
+        elif action_type == "move_vertex":
+            segment_index = last_action.get("segment_index")
+            vertex_index = last_action.get("vertex_index")
+            old_pos = last_action.get("old_pos")
+            self.segment_manager.segments[segment_index]["vertices"][vertex_index] = (
+                old_pos
+            )
+            self._update_polygon_item(segment_index)
+            self._display_edit_handles()
+            self._highlight_selected_segments()
+            self._show_notification("Undid: Move Vertex")
+
+        # Add more undo logic for other action types here in the future
+        else:
+            self._show_warning_notification(
+                f"Undo for action '{action_type}' not implemented."
+            )
+            # Remove from redo history if we couldn't undo it
+            self.redo_history.pop()
+
+    def _redo_last_action(self):
+        """Redo the last undone action."""
+        if not self.redo_history:
+            self._show_notification("Nothing to redo.")
+            return
+
+        last_action = self.redo_history.pop()
+        action_type = last_action.get("type")
+
+        # Add back to action history for potential future undo
+        self.action_history.append(last_action)
+
+        if action_type == "add_segment":
+            # Restore the segment that was removed
+            if "segment_data" in last_action:
+                segment_data = last_action["segment_data"]
+                self.segment_manager.add_segment(segment_data)
+                self._update_all_lists()
+                self._show_notification("Redid: Add Segment")
+            else:
+                # If we don't have the segment data (shouldn't happen), we can't redo
+                self._show_warning_notification("Cannot redo: Missing segment data")
+                self.action_history.pop()  # Remove from action history
+        elif action_type == "add_point":
+            point_type = last_action.get("point_type")
+            point_coords = last_action.get("point_coords")
+            if point_coords:
+                pos = QPointF(point_coords[0], point_coords[1])
+                self._add_point(pos, positive=(point_type == "positive"))
+                self._update_segmentation()
+                self._show_notification("Redid: Add Point")
+            else:
+                self._show_warning_notification(
+                    "Cannot redo: Missing point coordinates"
+                )
+                self.action_history.pop()
+        elif action_type == "add_polygon_point":
+            point_coords = last_action.get("point_coords")
+            if point_coords:
+                self._handle_polygon_click(point_coords)
+                self._show_notification("Redid: Add Polygon Point")
+            else:
+                self._show_warning_notification(
+                    "Cannot redo: Missing polygon point coordinates"
+                )
+                self.action_history.pop()
+        elif action_type == "move_polygon":
+            final_vertices = last_action.get("final_vertices")
+            if final_vertices:
+                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
+                        ]
+                        self._update_polygon_item(i)
+                self._display_edit_handles()
+                self._highlight_selected_segments()
+                self._show_notification("Redid: Move Polygon")
+            else:
+                self._show_warning_notification("Cannot redo: Missing final vertices")
+                self.action_history.pop()
+        elif action_type == "move_vertex":
+            segment_index = last_action.get("segment_index")
+            vertex_index = last_action.get("vertex_index")
+            new_pos = last_action.get("new_pos")
+            if (
+                segment_index is not None
+                and vertex_index is not None
+                and new_pos is not None
+            ):
+                if segment_index < len(self.segment_manager.segments):
+                    self.segment_manager.segments[segment_index]["vertices"][
+                        vertex_index
+                    ] = new_pos
+                    self._update_polygon_item(segment_index)
+                    self._display_edit_handles()
+                    self._highlight_selected_segments()
+                    self._show_notification("Redid: Move Vertex")
+                else:
+                    self._show_warning_notification(
+                        "Cannot redo: Segment no longer exists"
+                    )
+                    self.action_history.pop()
+            else:
+                self._show_warning_notification("Cannot redo: Missing vertex data")
+                self.action_history.pop()
+        else:
+            self._show_warning_notification(
+                f"Redo for action '{action_type}' not implemented."
+            )
+            # Remove from action history if we couldn't redo it
+            self.action_history.pop()
 
     def clear_all_points(self):
         """Clear all temporary points."""
@@ -1091,6 +1277,8 @@ class MainWindow(QMainWindow):
             self.viewer.scene().removeItem(item)
         self.segment_items.clear()
         self.highlight_items.clear()
+        self.action_history.clear()
+        self.redo_history.clear()
 
     def _scene_mouse_press(self, event):
         """Handle mouse press events in the scene."""
@@ -1113,7 +1301,9 @@ class MainWindow(QMainWindow):
                 self.drag_start_pos = pos
                 selected_indices = self.right_panel.get_selected_segment_indices()
                 self.drag_initial_vertices = {
-                    i: list(self.segment_manager.segments[i]["vertices"])
+                    i: [
+                        QPointF(p) for p in self.segment_manager.segments[i]["vertices"]
+                    ]
                     for i in selected_indices
                     if self.segment_manager.segments[i].get("type") == "Polygon"
                 }
@@ -1148,9 +1338,8 @@ class MainWindow(QMainWindow):
         elif self.mode == "polygon":
             if event.button() == Qt.MouseButton.LeftButton:
                 self._handle_polygon_click(pos)
-        elif self.mode == "selection":
-            if event.button() == Qt.MouseButton.LeftButton:
-                self._handle_segment_selection_click(pos)
+        elif self.mode == "selection" and event.button() == Qt.MouseButton.LeftButton:
+            self._handle_segment_selection_click(pos)
 
     def _scene_mouse_move(self, event):
         """Handle mouse move events in the scene."""
@@ -1171,6 +1360,22 @@ class MainWindow(QMainWindow):
     def _scene_mouse_release(self, event):
         """Handle mouse release events in the scene."""
         if self.mode == "edit" and self.is_dragging_polygon:
+            # Record the action for undo
+            final_vertices = {
+                i: list(self.segment_manager.segments[i]["vertices"])
+                for i in self.drag_initial_vertices
+            }
+            self.action_history.append(
+                {
+                    "type": "move_polygon",
+                    "initial_vertices": {
+                        k: list(v) for k, v in self.drag_initial_vertices.items()
+                    },
+                    "final_vertices": final_vertices,
+                }
+            )
+            # Clear redo history when a new action is performed
+            self.redo_history.clear()
             self.is_dragging_polygon = False
             self.drag_initial_vertices.clear()
             event.accept()
@@ -1202,6 +1407,18 @@ class MainWindow(QMainWindow):
         self.viewer.scene().addItem(point_item)
         self.point_items.append(point_item)
 
+        # Record the action for undo
+        self.action_history.append(
+            {
+                "type": "add_point",
+                "point_type": "positive" if positive else "negative",
+                "point_coords": [int(pos.x()), int(pos.y())],
+                "point_item": point_item,
+            }
+        )
+        # Clear redo history when a new action is performed
+        self.redo_history.clear()
+
     def _update_segmentation(self):
         """Update SAM segmentation preview."""
         if hasattr(self, "preview_mask_item") and self.preview_mask_item:
@@ -1250,6 +1467,17 @@ class MainWindow(QMainWindow):
         # Update polygon preview
         self._draw_polygon_preview()
 
+        # Record the action for undo
+        self.action_history.append(
+            {
+                "type": "add_polygon_point",
+                "point_coords": pos,
+                "dot_item": dot,
+            }
+        )
+        # Clear redo history when a new action is performed
+        self.redo_history.clear()
+
     def _draw_polygon_preview(self):
         """Draw polygon preview lines and fill."""
         # Remove old preview lines and polygons (keep dots)
@@ -1371,13 +1599,26 @@ class MainWindow(QMainWindow):
                     self.viewer.scene().removeItem(h)
             self.edit_handles = []
 
-    def update_vertex_pos(self, segment_index, vertex_index, new_pos):
+    def update_vertex_pos(self, segment_index, vertex_index, new_pos, record_undo=True):
         """Update the position of a vertex in a polygon segment."""
         seg = self.segment_manager.segments[segment_index]
         if seg.get("type") == "Polygon":
-            seg["vertices"][
-                vertex_index
-            ] = new_pos  # new_pos is already the correct scene coordinate
+            old_pos = seg["vertices"][vertex_index]
+            if record_undo:
+                self.action_history.append(
+                    {
+                        "type": "move_vertex",
+                        "segment_index": segment_index,
+                        "vertex_index": vertex_index,
+                        "old_pos": old_pos,
+                        "new_pos": new_pos,
+                    }
+                )
+                # 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
+            )
             self._update_polygon_item(segment_index)
             self._highlight_selected_segments()  # Keep the highlight in sync with the new shape
 

lazylabel/ui/photo_viewer.py

@@ -1,6 +1,6 @@
-from PyQt6.QtCore import Qt, QRectF
-from PyQt6.QtGui import QPixmap, QCursor
-from PyQt6.QtWidgets import QGraphicsView, QGraphicsScene, QGraphicsPixmapItem
+from PyQt6.QtCore import QRectF, Qt
+from PyQt6.QtGui import QCursor, QPixmap
+from PyQt6.QtWidgets import QGraphicsPixmapItem, QGraphicsScene, QGraphicsView
 
 
 class PhotoViewer(QGraphicsView):
@@ -47,8 +47,5 @@ class PhotoViewer(QGraphicsView):
 
     def wheelEvent(self, event):
         if not self._pixmap_item.pixmap().isNull():
-            if event.angleDelta().y() > 0:
-                factor = 1.25
-            else:
-                factor = 0.8
+            factor = 1.25 if event.angleDelta().y() > 0 else 0.8
             self.scale(factor, factor)

lazylabel/ui/reorderable_class_table.py

@@ -1,5 +1,4 @@
-from PyQt6.QtWidgets import QTableWidget, QAbstractItemView
-from PyQt6.QtCore import Qt
+from PyQt6.QtWidgets import QAbstractItemView, QTableWidget
 
 
 class ReorderableClassTable(QTableWidget):
@@ -31,7 +30,7 @@ class ReorderableClassTable(QTableWidget):
                 drop_row = self.rowCount()
 
             selected_rows = sorted(
-                list({index.row() for index in self.selectedIndexes()}), reverse=True
+                {index.row() for index in self.selectedIndexes()}, reverse=True
             )
 
             dragged_rows_data = []

lazylabel/ui/right_panel.py

@@ -1,23 +1,20 @@
 """Right panel with file explorer and segment management."""
 
+from PyQt6.QtCore import Qt, pyqtSignal
 from PyQt6.QtWidgets import (
-    QWidget,
-    QVBoxLayout,
-    QPushButton,
-    QLabel,
+    QComboBox,
     QHBoxLayout,
+    QHeaderView,
+    QLabel,
+    QPushButton,
+    QSplitter,
     QTableWidget,
     QTreeView,
-    QComboBox,
-    QSplitter,
-    QSpacerItem,
-    QHeaderView,
+    QVBoxLayout,
+    QWidget,
 )
-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):
@@ -191,10 +188,12 @@ class RightPanel(QWidget):
 
     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_right_panel"):
-                self.parent()._expand_right_panel()
+        if (
+            self.width() < 50
+            and self.parent()
+            and hasattr(self.parent(), "_expand_right_panel")
+        ):
+            self.parent()._expand_right_panel()
         super().mouseDoubleClickEvent(event)
 
     def _handle_class_alias_change(self, item):
@@ -269,7 +268,7 @@ class RightPanel(QWidget):
     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}))
+        selected_rows = sorted({item.row() for item in selected_items})
         return [
             self.segment_table.item(row, 0).data(Qt.ItemDataRole.UserRole)
             for row in selected_rows

lazylabel/ui/widgets/__init__.py

@@ -1,8 +1,8 @@
 """UI widgets for LazyLabel."""
 
+from .adjustments_widget import AdjustmentsWidget
 from .model_selection_widget import ModelSelectionWidget
 from .settings_widget import SettingsWidget
-from .adjustments_widget import AdjustmentsWidget
 from .status_bar import StatusBar
 
 __all__ = ["ModelSelectionWidget", "SettingsWidget", "AdjustmentsWidget", "StatusBar"]