lazylabel-gui 1.1.3__py3-none-any.whl → 1.1.5__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

@@ -1,170 +1,188 @@
-"""Segment management functionality."""
-
-from typing import Any
-
-import cv2
-import numpy as np
-from PyQt6.QtCore import QPointF
-
-
-class SegmentManager:
-    """Manages image segments and classes."""
-
-    def __init__(self):
-        self.segments: list[dict[str, Any]] = []
-        self.class_aliases: dict[int, str] = {}
-        self.next_class_id: int = 0
-        self.active_class_id: int | None = None  # Currently active/toggled class
-
-    def clear(self) -> None:
-        """Clear all segments and reset state."""
-        self.segments.clear()
-        self.class_aliases.clear()
-        self.next_class_id = 0
-        self.active_class_id = 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
-            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
-        self.segments.append(segment_data)
-        self._update_next_class_id()
-
-    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:
-        """Assign selected segments to a class."""
-        if not indices:
-            return
-
-        existing_class_ids = [
-            self.segments[i]["class_id"]
-            for i in indices
-            if i < len(self.segments) and self.segments[i].get("class_id") is not None
-        ]
-
-        if existing_class_ids:
-            target_class_id = min(existing_class_ids)
-        else:
-            target_class_id = self.next_class_id
-
-        for i in indices:
-            if i < len(self.segments):
-                self.segments[i]["class_id"] = target_class_id
-
-        self._update_next_class_id()
-
-    def get_unique_class_ids(self) -> list[int]:
-        """Get sorted list of unique class IDs."""
-        return sorted(
-            {
-                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]
-    ) -> np.ndarray | None:
-        """Convert polygon vertices to binary mask."""
-        if not vertices:
-            return None
-
-        h, w = image_size
-        points_np = np.array([[p.x(), p.y()] for p in vertices], dtype=np.int32)
-        mask = np.zeros((h, w), dtype=np.uint8)
-        cv2.fillPoly(mask, [points_np], 1)
-        return mask.astype(bool)
-
-    def create_final_mask_tensor(
-        self, image_size: tuple[int, int], class_order: list[int]
-    ) -> np.ndarray:
-        """Create final mask tensor for saving."""
-        h, w = image_size
-        id_map = {old_id: new_id for new_id, old_id in enumerate(class_order)}
-        num_final_classes = len(class_order)
-        final_mask_tensor = np.zeros((h, w, num_final_classes), dtype=np.uint8)
-
-        for seg in self.segments:
-            class_id = seg.get("class_id")
-            if class_id not in id_map:
-                continue
-
-            new_channel_idx = id_map[class_id]
-
-            if seg["type"] == "Polygon":
-                mask = self.rasterize_polygon(seg["vertices"], image_size)
-            else:
-                mask = seg.get("mask")
-
-            if mask is not None:
-                final_mask_tensor[:, :, new_channel_idx] = np.logical_or(
-                    final_mask_tensor[:, :, new_channel_idx], mask
-                )
-
-        return final_mask_tensor
-
-    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)}
-
-        for seg in self.segments:
-            old_id = seg.get("class_id")
-            if old_id in id_map:
-                seg["class_id"] = id_map[old_id]
-
-        # Update aliases
-        new_aliases = {
-            id_map[old_id]: self.class_aliases.get(old_id, str(old_id))
-            for old_id in new_order
-            if old_id in self.class_aliases
-        }
-        self.class_aliases = new_aliases
-        self._update_next_class_id()
-
-    def set_class_alias(self, class_id: int, alias: str) -> None:
-        """Set alias for a class."""
-        self.class_aliases[class_id] = alias
-
-    def get_class_alias(self, class_id: int) -> str:
-        """Get alias for a class."""
-        return self.class_aliases.get(class_id, str(class_id))
-
-    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) -> int | None:
-        """Get the active class ID."""
-        return self.active_class_id
-
-    def toggle_active_class(self, class_id: int) -> bool:
-        """Toggle a class as active. Returns True if now active, False if deactivated."""
-        if self.active_class_id == class_id:
-            self.active_class_id = None
-            return False
-        else:
-            self.active_class_id = class_id
-            return True
-
-    def _update_next_class_id(self) -> None:
-        """Update the next available class ID."""
-        all_ids = {
-            seg.get("class_id")
-            for seg in self.segments
-            if seg.get("class_id") is not None
-        }
-        if not all_ids:
-            self.next_class_id = 0
-        else:
-            self.next_class_id = max(all_ids) + 1
+"""Segment management functionality."""
+
+from typing import Any
+
+import cv2
+import numpy as np
+from PyQt6.QtCore import QPointF
+
+
+class SegmentManager:
+    """Manages image segments and classes."""
+
+    def __init__(self):
+        self.segments: list[dict[str, Any]] = []
+        self.class_aliases: dict[int, str] = {}
+        self.next_class_id: int = 0
+        self.active_class_id: int | None = None  # Currently active/toggled class
+
+    def clear(self) -> None:
+        """Clear all segments and reset state."""
+        self.segments.clear()
+        self.class_aliases.clear()
+        self.next_class_id = 0
+        self.active_class_id = None
+
+    def add_segment(self, segment_data: dict[str, Any]) -> None:
+        """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 and contains QPointF objects
+        if (
+            segment_data.get("type") == "Polygon"
+            and segment_data.get("vertices")
+            and segment_data["vertices"]
+            and isinstance(segment_data["vertices"][0], QPointF)
+        ):
+            segment_data["vertices"] = [
+                [p.x(), p.y()] for p in segment_data["vertices"]
+            ]
+
+        self.segments.append(segment_data)
+        self._update_next_class_id()
+
+    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:
+        """Assign selected segments to a class."""
+        if not indices:
+            return
+
+        existing_class_ids = [
+            self.segments[i]["class_id"]
+            for i in indices
+            if i < len(self.segments) and self.segments[i].get("class_id") is not None
+        ]
+
+        if existing_class_ids:
+            target_class_id = min(existing_class_ids)
+        else:
+            target_class_id = self.next_class_id
+
+        for i in indices:
+            if i < len(self.segments):
+                self.segments[i]["class_id"] = target_class_id
+
+        self._update_next_class_id()
+
+    def get_unique_class_ids(self) -> list[int]:
+        """Get sorted list of unique class IDs."""
+        return sorted(
+            {
+                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]
+    ) -> np.ndarray | None:
+        """Convert polygon vertices to binary mask."""
+        if not vertices:
+            return None
+
+        h, w = image_size
+        points_np = np.array([[p.x(), p.y()] for p in vertices], dtype=np.int32)
+        mask = np.zeros((h, w), dtype=np.uint8)
+        cv2.fillPoly(mask, [points_np], 1)
+        return mask.astype(bool)
+
+    def create_final_mask_tensor(
+        self, image_size: tuple[int, int], class_order: list[int]
+    ) -> np.ndarray:
+        """Create final mask tensor for saving."""
+        h, w = image_size
+        id_map = {old_id: new_id for new_id, old_id in enumerate(class_order)}
+        num_final_classes = len(class_order)
+        final_mask_tensor = np.zeros((h, w, num_final_classes), dtype=np.uint8)
+
+        for seg in self.segments:
+            class_id = seg.get("class_id")
+            if class_id not in id_map:
+                continue
+
+            new_channel_idx = id_map[class_id]
+
+            if seg["type"] == "Polygon":
+                # 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")
+
+            if mask is not None:
+                final_mask_tensor[:, :, new_channel_idx] = np.logical_or(
+                    final_mask_tensor[:, :, new_channel_idx], mask
+                )
+
+        return final_mask_tensor
+
+    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)}
+
+        for seg in self.segments:
+            old_id = seg.get("class_id")
+            if old_id in id_map:
+                seg["class_id"] = id_map[old_id]
+
+        # Update aliases
+        new_aliases = {
+            id_map[old_id]: self.class_aliases.get(old_id, str(old_id))
+            for old_id in new_order
+            if old_id in self.class_aliases
+        }
+        self.class_aliases = new_aliases
+        self._update_next_class_id()
+
+    def set_class_alias(self, class_id: int, alias: str) -> None:
+        """Set alias for a class."""
+        self.class_aliases[class_id] = alias
+
+    def get_class_alias(self, class_id: int) -> str:
+        """Get alias for a class."""
+        return self.class_aliases.get(class_id, str(class_id))
+
+    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) -> int | None:
+        """Get the active class ID."""
+        return self.active_class_id
+
+    def toggle_active_class(self, class_id: int) -> bool:
+        """Toggle a class as active. Returns True if now active, False if deactivated."""
+        if self.active_class_id == class_id:
+            self.active_class_id = None
+            return False
+        else:
+            self.active_class_id = class_id
+            return True
+
+    def _update_next_class_id(self) -> None:
+        """Update the next available class ID."""
+        all_ids = {
+            seg.get("class_id")
+            for seg in self.segments
+            if seg.get("class_id") is not None
+        }
+        if not all_ids:
+            self.next_class_id = 0
+        else:
+            self.next_class_id = max(all_ids) + 1

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/editable_vertex.py

@@ -55,8 +55,8 @@ class EditableVertexItem(QGraphicsEllipseItem):
                     "type": "move_vertex",
                     "segment_index": self.segment_index,
                     "vertex_index": self.vertex_index,
-                    "old_pos": self.initial_pos,
-                    "new_pos": self.pos(),
+                    "old_pos": [self.initial_pos.x(), self.initial_pos.y()],
+                    "new_pos": [self.pos().x(), self.pos().y()],
                 }
             )
         self.initial_pos = None

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)
                 )
@@ -894,7 +912,7 @@ class MainWindow(QMainWindow):
             return
 
         new_segment = {
-            "vertices": list(self.polygon_points),
+            "vertices": [[p.x(), p.y()] for p in self.polygon_points],
             "type": "Polygon",
             "mask": None,
         }
@@ -1052,7 +1070,9 @@ class MainWindow(QMainWindow):
         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.segment_manager.segments[i]["vertices"] = [
+                    [p[0], p[1]] for p in vertices
+                ]
                 self._update_polygon_item(i)
             self._display_edit_handles()
             self._highlight_selected_segments()
@@ -1061,13 +1081,27 @@ class MainWindow(QMainWindow):
             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")
+            if (
+                segment_index is not None
+                and vertex_index is not None
+                and old_pos is not None
+            ):
+                if segment_index < len(self.segment_manager.segments):
+                    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")
+                else:
+                    self._show_warning_notification(
+                        "Cannot undo: Segment no longer exists"
+                    )
+                    self.redo_history.pop()  # Remove from redo history if segment is gone
+            else:
+                self._show_warning_notification("Cannot undo: Missing vertex data")
+                self.redo_history.pop()  # Remove from redo history if data is incomplete
 
         # Add more undo logic for other action types here in the future
         else:
@@ -1129,7 +1163,7 @@ 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
+                            [p[0], p[1]] for p in vertices
                         ]
                         self._update_polygon_item(i)
                 self._display_edit_handles()
@@ -1159,10 +1193,10 @@ class MainWindow(QMainWindow):
                     self._show_warning_notification(
                         "Cannot redo: Segment no longer exists"
                     )
-                    self.action_history.pop()
+                    self.action_history.pop()  # Remove from action history if segment is gone
             else:
                 self._show_warning_notification("Cannot redo: Missing vertex data")
-                self.action_history.pop()
+                self.action_history.pop()  # Remove from action history if data is incomplete
         else:
             self._show_warning_notification(
                 f"Redo for action '{action_type}' not implemented."
@@ -1302,7 +1336,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"]
+                        [p.x(), p.y()] if isinstance(p, QPointF) else p
+                        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 +1347,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 +1370,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, self.line_thickness, 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 +1386,13 @@ 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 lists, convert to QPointF for addition with delta
                 self.segment_manager.segments[i]["vertices"] = [
-                    QPointF(v) + delta for v in initial_verts
+                    [
+                        (QPointF(p[0], p[1]) + delta).x(),
+                        (QPointF(p[0], p[1]) + delta).y(),
+                    ]
+                    for p in initial_verts
                 ]
                 self._update_polygon_item(i)
             self._display_edit_handles()  # Redraw handles at new positions
@@ -1357,12 +1402,22 @@ 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:
             # Record the action for undo
             final_vertices = {
-                i: list(self.segment_manager.segments[i]["vertices"])
+                i: [
+                    [p.x(), p.y()] if isinstance(p, QPointF) else p
+                    for p in self.segment_manager.segments[i]["vertices"]
+                ]
                 for i in self.drag_initial_vertices
             }
             self.action_history.append(
@@ -1383,6 +1438,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": [[p.x(), p.y()] for p in 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 +1612,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 +1664,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 +1701,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 +1719,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.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lazylabel-gui
-Version: 1.1.3
+Version: 1.1.5
 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.5.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=M6kHcYeiub3WqL01NElCvKOc2GNmf72LUM1W8XwSaxc,6465
 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/editable_vertex.py,sha256=xzc5QdFJJXiy035C3HgR4ph-tuJu8245l-Ar7aBvVv8,2399
+lazylabel/ui/control_panel.py,sha256=UlETN2IZv1l2xiaWPQvdalaK_f9YQf9iiB1Jb_EEgfs,9260
+lazylabel/ui/editable_vertex.py,sha256=nAFC2UuFfbvMbGBbAiLWA77cS5-Hn3a08xe1_QLz2yk,2449
 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=h0wfVjQRskiTIq6X-Wd7OvM-PfOdKEKdFcwgx0iRIj0,79831
 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.5.dist-info/licenses/LICENSE,sha256=kSDEIgrWAPd1u2UFGGpC9X71dhzrlzBFs8hbDlENnGE,1092
+lazylabel_gui-1.1.5.dist-info/METADATA,sha256=2MNsqA48WN9e7YJMg864WZYGMZixitm3XtMnD2uZin4,9506
+lazylabel_gui-1.1.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lazylabel_gui-1.1.5.dist-info/entry_points.txt,sha256=Hd0WwEG9OPTa_ziYjiD0aRh7R6Fupt-wdQ3sspdc1mM,54
+lazylabel_gui-1.1.5.dist-info/top_level.txt,sha256=YN4uIyrpDBq1wiJaBuZLDipIzyZY0jqJOmmXiPIOUkU,10
+lazylabel_gui-1.1.5.dist-info/RECORD,,