lazylabel-gui 1.0.5__tar.gz → 1.0.7__tar.gz

{lazylabel_gui-1.0.5 → lazylabel_gui-1.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lazylabel-gui
-Version: 1.0.5
+Version: 1.0.7
 Summary: An image segmentation GUI for generating mask tensors.
 Author-email: "Deniz N. Cakan" <deniz.n.cakan@gmail.com>
 License: MIT License
@@ -48,7 +48,7 @@ Requires-Dist: tqdm>=4.67.1
 Dynamic: license-file
 
 # <img src="https://raw.githubusercontent.com/dnzckn/LazyLabel/main/src/lazylabel/demo_pictures/logo2.png" alt="LazyLabel Logo" style="height:60px; vertical-align:middle;" /> <img src="https://raw.githubusercontent.com/dnzckn/LazyLabel/main/src/lazylabel/demo_pictures/logo_black.png" alt="LazyLabel Cursive" style="height:60px; vertical-align:middle;" />
-LazyLabel is an intuitive, AI-assisted image segmentation tool. It uses Meta's Segment Anything Model (SAM) for quick, precise mask generation, alongside advanced polygon editing for fine-tuned control. Outputs are saved in a clean, one-hot encoded format for easy machine learning integration.
+LazyLabel is an intuitive, AI-assisted image segmentation tool. It uses Meta's Segment Anything Model (SAM) for quick, precise mask generation, alongside advanced polygon editing for fine-tuned control. Outputs are saved in a clean, one-hot encoded `.npz` format for easy machine learning integration and in YOLO `.txt` format.
 
 Inspired by [LabelMe](https://github.com/wkentaro/labelme?tab=readme-ov-file#installation) and [Segment-Anything-UI](https://github.com/branislavhesko/segment-anything-ui/tree/main).
 

{lazylabel_gui-1.0.5 → lazylabel_gui-1.0.7}/README.md

@@ -1,5 +1,5 @@
 # <img src="https://raw.githubusercontent.com/dnzckn/LazyLabel/main/src/lazylabel/demo_pictures/logo2.png" alt="LazyLabel Logo" style="height:60px; vertical-align:middle;" /> <img src="https://raw.githubusercontent.com/dnzckn/LazyLabel/main/src/lazylabel/demo_pictures/logo_black.png" alt="LazyLabel Cursive" style="height:60px; vertical-align:middle;" />
-LazyLabel is an intuitive, AI-assisted image segmentation tool. It uses Meta's Segment Anything Model (SAM) for quick, precise mask generation, alongside advanced polygon editing for fine-tuned control. Outputs are saved in a clean, one-hot encoded format for easy machine learning integration.
+LazyLabel is an intuitive, AI-assisted image segmentation tool. It uses Meta's Segment Anything Model (SAM) for quick, precise mask generation, alongside advanced polygon editing for fine-tuned control. Outputs are saved in a clean, one-hot encoded `.npz` format for easy machine learning integration and in YOLO `.txt` format.
 
 Inspired by [LabelMe](https://github.com/wkentaro/labelme?tab=readme-ov-file#installation) and [Segment-Anything-UI](https://github.com/branislavhesko/segment-anything-ui/tree/main).
 

{lazylabel_gui-1.0.5 → lazylabel_gui-1.0.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lazylabel-gui"
-version = "1.0.5"
+version = "1.0.7"
 authors = [
   { name="Deniz N. Cakan", email="deniz.n.cakan@gmail.com" },
 ]

{lazylabel_gui-1.0.5 → lazylabel_gui-1.0.7}/src/lazylabel/controls.py

@@ -10,6 +10,7 @@ from PyQt6.QtWidgets import (
     QHBoxLayout,
     QComboBox,
     QHeaderView,
+    QCheckBox,
 )
 from PyQt6.QtCore import Qt
 from .reorderable_class_table import ReorderableClassTable
@@ -26,20 +27,56 @@ class ControlPanel(QWidget):
         font.setBold(True)
         self.mode_label.setFont(font)
         layout.addWidget(self.mode_label)
+
+        # Mode Buttons
         self.btn_sam_mode = QPushButton("Point Mode (1)")
+        self.btn_sam_mode.setToolTip("Switch to Point Mode for AI segmentation (1)")
         self.btn_polygon_mode = QPushButton("Polygon Mode (2)")
+        self.btn_polygon_mode.setToolTip("Switch to Polygon Drawing Mode (2)")
         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_selection_mode)
+
         layout.addSpacing(20)
         line1 = QFrame()
         line1.setFrameShape(QFrame.Shape.HLine)
         layout.addWidget(line1)
         layout.addSpacing(10)
+
+        # Action Buttons
+        self.btn_fit_view = QPushButton("Fit View (.)")
+        self.btn_fit_view.setToolTip("Reset image zoom and pan to fit the view (.)")
         self.btn_clear_points = QPushButton("Clear Clicks (C)")
+        self.btn_clear_points.setToolTip("Clear current temporary points/vertices (C)")
+        layout.addWidget(self.btn_fit_view)
         layout.addWidget(self.btn_clear_points)
+
+        layout.addSpacing(10)
+
+        # Settings
+        self.chk_auto_save = QCheckBox("Auto-Save on Navigate")
+        self.chk_auto_save.setToolTip(
+            "Automatically save work when using arrow keys to change images."
+        )
+        self.chk_auto_save.setChecked(True)
+        layout.addWidget(self.chk_auto_save)
+
         layout.addStretch()
+
+        # Notification Label
+        self.notification_label = QLabel("")
+        font = self.notification_label.font()
+        font.setItalic(True)
+        self.notification_label.setFont(font)
+        self.notification_label.setStyleSheet(
+            "color: #ffa500;"
+        )  # Orange color for visibility
+        self.notification_label.setWordWrap(True)
+        layout.addWidget(self.notification_label)
+
+        # Device Label
         self.device_label = QLabel("Device: Unknown")
         layout.addWidget(self.device_label)
         self.setFixedWidth(250)
@@ -53,6 +90,7 @@ class RightPanel(QWidget):
         # File Explorer
         file_explorer_layout = QVBoxLayout()
         self.btn_open_folder = QPushButton("Open Image Folder")
+        self.btn_open_folder.setToolTip("Open a directory of images")
         self.file_tree = QTreeView()
         file_explorer_layout.addWidget(self.btn_open_folder)
         file_explorer_layout.addWidget(self.file_tree)
@@ -68,12 +106,13 @@ class RightPanel(QWidget):
         class_filter_layout = QHBoxLayout()
         class_filter_layout.addWidget(QLabel("Filter Class:"))
         self.class_filter_combo = QComboBox()
+        self.class_filter_combo.setToolTip("Filter segments list by class")
         class_filter_layout.addWidget(self.class_filter_combo)
         segment_layout.addLayout(class_filter_layout)
 
         self.segment_table = QTableWidget()
         self.segment_table.setColumnCount(3)
-        self.segment_table.setHorizontalHeaderLabels(["Index", "Class", "Type"])
+        self.segment_table.setHorizontalHeaderLabels(["Index", "Class ID", "Type"])
         self.segment_table.horizontalHeader().setSectionResizeMode(
             QHeaderView.ResizeMode.Stretch
         )
@@ -85,7 +124,13 @@ class RightPanel(QWidget):
 
         segment_action_layout = QHBoxLayout()
         self.btn_merge_selection = QPushButton("Merge to Class")
+        self.btn_merge_selection.setToolTip(
+            "Merge selected segments into a single class (M)"
+        )
         self.btn_delete_selection = QPushButton("Delete")
+        self.btn_delete_selection.setToolTip(
+            "Delete selected segments (Delete/Backspace)"
+        )
         segment_action_layout.addWidget(self.btn_merge_selection)
         segment_action_layout.addWidget(self.btn_delete_selection)
         segment_layout.addLayout(segment_action_layout)
@@ -95,13 +140,23 @@ class RightPanel(QWidget):
         class_layout = QVBoxLayout()
         class_layout.addWidget(QLabel("Class Order:"))
         self.class_table = ReorderableClassTable()
-        self.class_table.setColumnCount(1)
-        self.class_table.setHorizontalHeaderLabels(["Class ID"])
+        self.class_table.setToolTip(
+            "Set class aliases and drag to reorder channels for saving."
+        )
+        self.class_table.setColumnCount(2)
+        self.class_table.setHorizontalHeaderLabels(["Alias", "Channel Index"])
         self.class_table.horizontalHeader().setSectionResizeMode(
-            QHeaderView.ResizeMode.Stretch
+            0, QHeaderView.ResizeMode.Stretch
         )
+        self.class_table.horizontalHeader().setSectionResizeMode(
+            1, QHeaderView.ResizeMode.ResizeToContents
+        )
+
         class_layout.addWidget(self.class_table)
         self.btn_reassign_classes = QPushButton("Reassign Class IDs")
+        self.btn_reassign_classes.setToolTip(
+            "Re-index class channels based on the current order in this table"
+        )
         class_layout.addWidget(self.btn_reassign_classes)
         layout.addLayout(class_layout, 1)
 

{lazylabel_gui-1.0.5 → lazylabel_gui-1.0.7}/src/lazylabel/custom_file_system_model.py

@@ -12,7 +12,9 @@ class CustomFileSystemModel(QFileSystemModel):
         self.highlighted_path = None
 
     def set_highlighted_path(self, path):
-        self.highlighted_path = path
+        self.highlighted_path = os.path.normpath(path) if path else None
+        # Trigger repaint of the entire view
+        self.layoutChanged.emit()
 
     def columnCount(self, parent: QModelIndex = QModelIndex()) -> int:
         return 2
@@ -39,9 +41,13 @@ class CustomFileSystemModel(QFileSystemModel):
 
         # Handle the temporary highlight for saving
         if role == Qt.ItemDataRole.BackgroundRole:
-            filePath = self.filePath(index)
-            if filePath == self.highlighted_path:
-                return QBrush(QColor("yellow"))
+            filePath = os.path.normpath(self.filePath(index))
+            if (
+                self.highlighted_path
+                and os.path.splitext(filePath)[0]
+                == os.path.splitext(self.highlighted_path)[0]
+            ):
+                return QBrush(QColor(40, 80, 40))  # Dark green highlight
 
         if index.column() == 1:
             if role == Qt.ItemDataRole.CheckStateRole:

{lazylabel_gui-1.0.5 → lazylabel_gui-1.0.7}/src/lazylabel/editable_vertex.py

@@ -1,6 +1,6 @@
 from PyQt6.QtWidgets import QGraphicsEllipseItem, QGraphicsItem
 from PyQt6.QtCore import Qt
-from PyQt6.QtGui import QBrush, QPen
+from PyQt6.QtGui import QBrush, QPen, QColor
 
 
 class EditableVertexItem(QGraphicsEllipseItem):
@@ -11,8 +11,12 @@ class EditableVertexItem(QGraphicsEllipseItem):
         self.vertex_index = vertex_index
 
         self.setZValue(200)
-        self.setBrush(QBrush(Qt.GlobalColor.cyan))
-        self.setPen(QPen(Qt.GlobalColor.white, 1))
+
+        color = QColor(Qt.GlobalColor.cyan)
+        color.setAlpha(180)
+        self.setBrush(QBrush(color))
+
+        self.setPen(QPen(Qt.GlobalColor.transparent))
         self.setFlag(QGraphicsItem.GraphicsItemFlag.ItemIsMovable)
         self.setFlag(QGraphicsItem.GraphicsItemFlag.ItemSendsGeometryChanges)
 

lazylabel_gui-1.0.7/src/lazylabel/hoverable_pixelmap_item.py

@@ -0,0 +1,22 @@
+from PyQt6.QtWidgets import QGraphicsPixmapItem
+
+
+class HoverablePixmapItem(QGraphicsPixmapItem):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setAcceptHoverEvents(True)
+        self.default_pixmap = None
+        self.hover_pixmap = None
+
+    def set_pixmaps(self, default_pixmap, hover_pixmap):
+        self.default_pixmap = default_pixmap
+        self.hover_pixmap = hover_pixmap
+        self.setPixmap(self.default_pixmap)
+
+    def hoverEnterEvent(self, event):
+        self.setPixmap(self.hover_pixmap)
+        super().hoverEnterEvent(event)
+
+    def hoverLeaveEvent(self, event):
+        self.setPixmap(self.default_pixmap)
+        super().hoverLeaveEvent(event)

{lazylabel_gui-1.0.5 → lazylabel_gui-1.0.7}/src/lazylabel/main.py

@@ -16,8 +16,18 @@ from PyQt6.QtWidgets import (
     QGraphicsPolygonItem,
     QTableWidgetSelectionRange,
 )
-from PyQt6.QtGui import QPixmap, QColor, QPen, QBrush, QPolygonF, QIcon
-from PyQt6.QtCore import Qt, QPointF, QTimer
+from PyQt6.QtGui import (
+    QPixmap,
+    QColor,
+    QPen,
+    QBrush,
+    QPolygonF,
+    QIcon,
+    QCursor,
+    QKeySequence,
+    QShortcut,
+)
+from PyQt6.QtCore import Qt, QPointF, QTimer, QModelIndex
 
 from .photo_viewer import PhotoViewer
 from .sam_model import SamModel
@@ -26,6 +36,7 @@ from .controls import ControlPanel, RightPanel
 from .custom_file_system_model import CustomFileSystemModel
 from .editable_vertex import EditableVertexItem
 from .hoverable_polygon_item import HoverablePolygonItem
+from .hoverable_pixelmap_item import HoverablePixmapItem
 from .numeric_table_widget_item import NumericTableWidgetItem
 
 
@@ -46,9 +57,18 @@ class MainWindow(QMainWindow):
         self.mode = "sam_points"
         self.previous_mode = "sam_points"
         self.current_image_path = None
-        self.current_file_index = None
+        self.current_file_index = QModelIndex()
+
         self.next_class_id = 0
 
+        self.class_aliases = {}  # {class_id: "alias_string"}
+
+        self.point_radius = 0.3
+        self.line_thickness = 0.5
+
+        self._original_point_radius = self.point_radius
+        self._original_line_thickness = self.line_thickness
+
         self.point_items, self.positive_points, self.negative_points = [], [], []
         self.polygon_points, self.polygon_preview_items = [], []
         self.rubber_band_line = None
@@ -103,6 +123,7 @@ class MainWindow(QMainWindow):
             self.highlight_selected_segments
         )
         self.right_panel.segment_table.itemChanged.connect(self.handle_class_id_change)
+        self.right_panel.class_table.itemChanged.connect(self.handle_alias_change)
         self.right_panel.btn_reassign_classes.clicked.connect(self.reassign_class_ids)
         self.right_panel.class_filter_combo.currentIndexChanged.connect(
             self.update_segment_table
@@ -114,13 +135,26 @@ class MainWindow(QMainWindow):
             self.toggle_selection_mode
         )
         self.control_panel.btn_clear_points.clicked.connect(self.clear_all_points)
+        self.control_panel.btn_fit_view.clicked.connect(self.viewer.fitInView)
+
+        # **FIX:** Use QShortcut for reliable global hotkeys
+        next_shortcut = QShortcut(QKeySequence(Qt.Key.Key_Right), self)
+        next_shortcut.activated.connect(self.load_next_image)
+        prev_shortcut = QShortcut(QKeySequence(Qt.Key.Key_Left), self)
+        prev_shortcut.activated.connect(self.load_previous_image)
+
+    def show_notification(self, message, duration=3000):
+        self.control_panel.notification_label.setText(message)
+        QTimer.singleShot(
+            duration, lambda: self.control_panel.notification_label.clear()
+        )
 
-    def _get_color_for_class(self, class_id, saturation, value):
+    def _get_color_for_class(self, class_id):
         if class_id is None:
             return QColor.fromHsv(0, 0, 128)
 
         hue = int((class_id * 222.4922359) % 360)
-        color = QColor.fromHsv(hue, saturation, value)
+        color = QColor.fromHsv(hue, 220, 220)
 
         if not color.isValid():
             return QColor(Qt.GlobalColor.white)
@@ -140,6 +174,16 @@ class MainWindow(QMainWindow):
             f"Mode: {mode_name.replace('_', ' ').title()}"
         )
         self.clear_all_points()
+
+        cursor_map = {
+            "sam_points": Qt.CursorShape.CrossCursor,
+            "polygon": Qt.CursorShape.CrossCursor,
+            "selection": Qt.CursorShape.ArrowCursor,
+            "edit": Qt.CursorShape.SizeAllCursor,
+            "pan": Qt.CursorShape.OpenHandCursor,
+        }
+        self.viewer.set_cursor(cursor_map.get(self.mode, Qt.CursorShape.ArrowCursor))
+
         self.viewer.setDragMode(
             self.viewer.DragMode.ScrollHandDrag
             if self.mode == "pan"
@@ -168,14 +212,25 @@ class MainWindow(QMainWindow):
 
     def toggle_edit_mode(self):
         selected_indices = self.get_selected_segment_indices()
+
+        if self.mode == "edit":
+            self.set_mode("selection", is_toggle=True)
+            return
+
+        if not selected_indices:
+            self.show_notification("Select a polygon to edit.")
+            return
+
         can_edit = any(
             self.segments[i].get("type") == "Polygon" for i in selected_indices
         )
-        if self.mode == "edit":
-            self.set_mode("selection", is_toggle=True)
-        elif self.mode == "selection" and can_edit:
-            self.set_mode("edit", is_toggle=True)
-            self.display_all_segments()
+
+        if not can_edit:
+            self.show_notification("Only polygon segments can be edited.")
+            return
+
+        self.set_mode("edit", is_toggle=True)
+        self.display_all_segments()
 
     def open_folder_dialog(self):
         folder_path = QFileDialog.getExistingDirectory(self, "Select Image Folder")
@@ -186,7 +241,7 @@ class MainWindow(QMainWindow):
         self.viewer.setFocus()
 
     def load_selected_image(self, index):
-        if not index.isValid():
+        if not index.isValid() or not self.file_model.isDir(index.parent()):
             return
 
         self.current_file_index = index
@@ -202,10 +257,39 @@ class MainWindow(QMainWindow):
                 self.viewer.set_photo(pixmap)
                 self.sam_model.set_image(self.current_image_path)
                 self.load_existing_mask()
+                self.right_panel.file_tree.setCurrentIndex(index)
                 self.viewer.setFocus()
 
+    def load_next_image(self):
+        if not self.current_file_index.isValid():
+            return
+
+        if self.control_panel.chk_auto_save.isChecked():
+            self.save_output_to_npz()
+
+        row = self.current_file_index.row()
+        parent = self.current_file_index.parent()
+        if row + 1 < self.file_model.rowCount(parent):
+            next_index = self.file_model.index(row + 1, 0, parent)
+            self.load_selected_image(next_index)
+
+    def load_previous_image(self):
+        if not self.current_file_index.isValid():
+            return
+
+        if self.control_panel.chk_auto_save.isChecked():
+            self.save_output_to_npz()
+
+        row = self.current_file_index.row()
+        parent = self.current_file_index.parent()
+        if row > 0:
+            prev_index = self.file_model.index(row - 1, 0, parent)
+            self.load_selected_image(prev_index)
+
     def reset_state(self):
         self.clear_all_points()
+        # Preserve aliases between images in the same session
+        # self.class_aliases.clear()
         self.segments.clear()
         self.next_class_id = 0
         self.update_all_lists()
@@ -223,26 +307,32 @@ class MainWindow(QMainWindow):
         key, mods = event.key(), event.modifiers()
         if event.isAutoRepeat():
             return
+
+        pan_multiplier = 5.0 if (mods & Qt.KeyboardModifier.ShiftModifier) else 2
+
         if key == Qt.Key.Key_W:
+            amount = int(self.viewer.height() * 0.1 * pan_multiplier)
             self.viewer.verticalScrollBar().setValue(
-                self.viewer.verticalScrollBar().value()
-                - int(self.viewer.height() * 0.1)
+                self.viewer.verticalScrollBar().value() - amount
             )
-        elif key == Qt.Key.Key_S and not mods:
+        elif key == Qt.Key.Key_S:
+            amount = int(self.viewer.height() * 0.1 * pan_multiplier)
             self.viewer.verticalScrollBar().setValue(
-                self.viewer.verticalScrollBar().value()
-                + int(self.viewer.height() * 0.1)
+                self.viewer.verticalScrollBar().value() + amount
             )
         elif key == Qt.Key.Key_A and not (mods & Qt.KeyboardModifier.ControlModifier):
+            amount = int(self.viewer.width() * 0.1 * pan_multiplier)
             self.viewer.horizontalScrollBar().setValue(
-                self.viewer.horizontalScrollBar().value()
-                - int(self.viewer.width() * 0.1)
+                self.viewer.horizontalScrollBar().value() - amount
             )
         elif key == Qt.Key.Key_D:
+            amount = int(self.viewer.width() * 0.1 * pan_multiplier)
             self.viewer.horizontalScrollBar().setValue(
-                self.viewer.horizontalScrollBar().value()
-                + int(self.viewer.width() * 0.1)
+                self.viewer.horizontalScrollBar().value() + amount
             )
+        elif key == Qt.Key.Key_Period:
+            self.viewer.fitInView()
+        # Other keybindings
         elif key == Qt.Key.Key_1:
             self.set_sam_mode()
         elif key == Qt.Key.Key_2:
@@ -265,14 +355,42 @@ class MainWindow(QMainWindow):
         elif key == Qt.Key.Key_A and mods == Qt.KeyboardModifier.ControlModifier:
             self.right_panel.segment_table.selectAll()
         elif key == Qt.Key.Key_Space:
-            self.save_current_segment()
+            if self.mode == "polygon" and self.polygon_points:
+                self.finalize_polygon()
+            else:
+                self.save_current_segment()
         elif key == Qt.Key.Key_Return or key == Qt.Key.Key_Enter:
-            self.save_output_to_npz()
+            if self.mode == "polygon" and self.polygon_points:
+                self.finalize_polygon()
+            else:
+                self.save_output_to_npz()
+        elif (
+            key == Qt.Key.Key_Equal or key == Qt.Key.Key_Plus
+        ) and mods == Qt.KeyboardModifier.ControlModifier:
+            self.point_radius = min(20, self.point_radius + self._original_point_radius)
+            self.line_thickness = min(
+                20, self.line_thickness + self._original_line_thickness
+            )
+            self.display_all_segments()
+            self.clear_all_points()
+        elif key == Qt.Key.Key_Minus and mods == Qt.KeyboardModifier.ControlModifier:
+            self.point_radius = max(
+                0.3, self.point_radius - self._original_point_radius
+            )
+            self.line_thickness = max(
+                0.5, self.line_thickness - self._original_line_thickness
+            )
+            self.display_all_segments()
+            self.clear_all_points()
 
     def scene_mouse_press(self, event):
         self._original_mouse_press(event)
         if event.isAccepted():
             return
+
+        if self.mode == "pan":
+            self.viewer.set_cursor(Qt.CursorShape.ClosedHandCursor)
+
         pos = event.scenePos()
         if (
             self.viewer._pixmap_item.pixmap().isNull()
@@ -314,10 +432,15 @@ class MainWindow(QMainWindow):
         elif self.mode == "polygon" and self.polygon_points:
             if self.rubber_band_line is None:
                 self.rubber_band_line = QGraphicsLineItem()
+
+                line_color = QColor(Qt.GlobalColor.white)
+                line_color.setAlpha(150)
+
                 self.rubber_band_line.setPen(
-                    QPen(Qt.GlobalColor.white, 2, Qt.PenStyle.DotLine)
+                    QPen(line_color, self.line_thickness, Qt.PenStyle.DotLine)
                 )
                 self.viewer.scene().addItem(self.rubber_band_line)
+
             self.rubber_band_line.setLine(
                 self.polygon_points[-1].x(),
                 self.polygon_points[-1].y(),
@@ -329,6 +452,9 @@ class MainWindow(QMainWindow):
             self._original_mouse_move(event)
 
     def scene_mouse_release(self, event):
+        if self.mode == "pan":
+            self.viewer.set_cursor(Qt.CursorShape.OpenHandCursor)
+
         if self.mode == "edit" and self.is_dragging_polygon:
             self.is_dragging_polygon = False
             self.drag_initial_vertices.clear()
@@ -337,20 +463,55 @@ class MainWindow(QMainWindow):
     def undo_last_action(self):
         if self.mode == "polygon" and self.polygon_points:
             self.polygon_points.pop()
-            if self.polygon_preview_items:
-                self.viewer.scene().removeItem(self.polygon_preview_items.pop())
+
+            for item in self.polygon_preview_items:
+                if item.scene():
+                    self.viewer.scene().removeItem(item)
+            self.polygon_preview_items.clear()
+
+            for point in self.polygon_points:
+                point_diameter = self.point_radius * 2
+                point_color = QColor(Qt.GlobalColor.blue)
+                point_color.setAlpha(150)
+                dot = QGraphicsEllipseItem(
+                    point.x() - self.point_radius,
+                    point.y() - self.point_radius,
+                    point_diameter,
+                    point_diameter,
+                )
+                dot.setBrush(QBrush(point_color))
+                dot.setPen(QPen(Qt.GlobalColor.transparent))
+                self.viewer.scene().addItem(dot)
+                self.polygon_preview_items.append(dot)
+
             self.draw_polygon_preview()
+
         elif self.mode == "sam_points" and self.point_items:
             item_to_remove = self.point_items.pop()
-            point_pos = item_to_remove.rect().topLeft() + QPointF(4, 4)
+            point_pos = item_to_remove.rect().topLeft() + QPointF(
+                self.point_radius, self.point_radius
+            )
             point_coords = [int(point_pos.x()), int(point_pos.y())]
+
             if point_coords in self.positive_points:
                 self.positive_points.remove(point_coords)
             elif point_coords in self.negative_points:
                 self.negative_points.remove(point_coords)
+
             self.viewer.scene().removeItem(item_to_remove)
             self.update_segmentation()
 
+    def _update_next_class_id(self):
+        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
+
     def finalize_polygon(self):
         if len(self.polygon_points) < 3:
             return
@@ -365,7 +526,7 @@ class MainWindow(QMainWindow):
                 "class_id": self.next_class_id,
             }
         )
-        self.next_class_id += 1
+        self._update_next_class_id()
         self.polygon_points.clear()
         for item in self.polygon_preview_items:
             self.viewer.scene().removeItem(item)
@@ -418,6 +579,7 @@ class MainWindow(QMainWindow):
         for i in selected_indices:
             self.segments[i]["class_id"] = target_class_id
 
+        self._update_next_class_id()
         self.update_all_lists()
         self.right_panel.segment_table.clearSelection()
         self.viewer.setFocus()
@@ -444,7 +606,8 @@ class MainWindow(QMainWindow):
         for i, seg_dict in enumerate(self.segments):
             self.segment_items[i] = []
             class_id = seg_dict.get("class_id")
-            base_color = self._get_color_for_class(class_id, saturation=220, value=220)
+
+            base_color = self._get_color_for_class(class_id)
 
             if seg_dict["type"] == "Polygon":
                 poly_item = HoverablePolygonItem(QPolygonF(seg_dict["vertices"]))
@@ -458,21 +621,47 @@ class MainWindow(QMainWindow):
                 poly_item.setPen(QPen(Qt.GlobalColor.transparent))
                 self.viewer.scene().addItem(poly_item)
                 self.segment_items[i].append(poly_item)
+
+                base_color.setAlpha(150)
                 vertex_color = QBrush(base_color)
+                point_diameter = self.point_radius * 2
                 for v in seg_dict["vertices"]:
-                    dot = QGraphicsEllipseItem(v.x() - 3, v.y() - 3, 6, 6)
+                    dot = QGraphicsEllipseItem(
+                        v.x() - self.point_radius,
+                        v.y() - self.point_radius,
+                        point_diameter,
+                        point_diameter,
+                    )
                     dot.setBrush(vertex_color)
+                    dot.setPen(QPen(Qt.GlobalColor.transparent))
                     self.viewer.scene().addItem(dot)
                     self.segment_items[i].append(dot)
                 if self.mode == "edit" and i in selected_indices:
+                    handle_diameter = self.point_radius * 2
                     for idx, v in enumerate(seg_dict["vertices"]):
-                        vertex_item = EditableVertexItem(self, i, idx, -4, -4, 8, 8)
+                        vertex_item = EditableVertexItem(
+                            self,
+                            i,
+                            idx,
+                            -handle_diameter / 2,
+                            -handle_diameter / 2,
+                            handle_diameter,
+                            handle_diameter,
+                        )
                         vertex_item.setPos(v)
                         self.viewer.scene().addItem(vertex_item)
                         self.segment_items[i].append(vertex_item)
             elif seg_dict.get("mask") is not None:
-                pixmap = mask_to_pixmap(seg_dict["mask"], base_color.getRgb()[:3])
-                pixmap_item = self.viewer.scene().addPixmap(pixmap)
+                default_pixmap = mask_to_pixmap(
+                    seg_dict["mask"], base_color.getRgb()[:3], alpha=70
+                )
+                hover_pixmap = mask_to_pixmap(
+                    seg_dict["mask"], base_color.getRgb()[:3], alpha=170
+                )
+
+                pixmap_item = HoverablePixmapItem()
+                pixmap_item.set_pixmaps(default_pixmap, hover_pixmap)
+                self.viewer.scene().addItem(pixmap_item)
                 pixmap_item.setZValue(i + 1)
                 self.segment_items[i].append(pixmap_item)
         self.highlight_selected_segments()
@@ -508,9 +697,9 @@ class MainWindow(QMainWindow):
                 self.highlight_items.append(highlight_item)
 
     def update_all_lists(self):
+        self.update_class_list()  # Must be before filter combo
         self.update_class_filter_combo()
         self.update_segment_table()
-        self.update_class_list()
         self.display_all_segments()
 
     def update_segment_table(self):
@@ -524,7 +713,7 @@ class MainWindow(QMainWindow):
         filter_class_id = -1
         if not show_all:
             try:
-                filter_class_id = int(filter_text.split(" ")[1])
+                filter_class_id = int(filter_text.split("(ID: ")[1][:-1])
             except (ValueError, IndexError):
                 pass
 
@@ -537,7 +726,7 @@ class MainWindow(QMainWindow):
 
         for row, (original_index, seg) in enumerate(display_segments):
             class_id = seg.get("class_id")
-            color = self._get_color_for_class(class_id, saturation=180, value=200)
+            color = self._get_color_for_class(class_id)
 
             class_id_str = str(class_id) if class_id is not None else "N/A"
             index_item = NumericTableWidgetItem(str(original_index + 1))
@@ -552,7 +741,7 @@ class MainWindow(QMainWindow):
             table.setItem(row, 1, class_item)
             table.setItem(row, 2, type_item)
 
-            for col in range(3):
+            for col in range(table.columnCount()):
                 if table.item(row, col):
                     table.item(row, col).setBackground(QBrush(color))
 
@@ -569,6 +758,18 @@ class MainWindow(QMainWindow):
     def update_class_list(self):
         class_table = self.right_panel.class_table
         class_table.blockSignals(True)
+
+        # Preserve existing aliases during update
+        current_aliases = {}
+        for row in range(class_table.rowCount()):
+            try:
+                alias = class_table.item(row, 0).text()
+                cid = int(class_table.item(row, 1).text())
+                current_aliases[cid] = alias
+            except (AttributeError, ValueError):
+                continue
+        self.class_aliases.update(current_aliases)
+
         class_table.clearContents()
 
         unique_class_ids = sorted(
@@ -583,13 +784,18 @@ class MainWindow(QMainWindow):
         class_table.setRowCount(len(unique_class_ids))
 
         for row, cid in enumerate(unique_class_ids):
-            item = QTableWidgetItem(str(cid))
-            item.setFlags(item.flags() & ~Qt.ItemFlag.ItemIsEditable)
+            alias = self.class_aliases.get(cid, str(cid))
+            alias_item = QTableWidgetItem(alias)
+            id_item = QTableWidgetItem(str(cid))
 
-            color = self._get_color_for_class(cid, saturation=180, value=200)
+            id_item.setFlags(id_item.flags() & ~Qt.ItemFlag.ItemIsEditable)
 
-            item.setBackground(QBrush(color))
-            class_table.setItem(row, 0, item)
+            color = self._get_color_for_class(cid)
+            alias_item.setBackground(QBrush(color))
+            id_item.setBackground(QBrush(color))
+
+            class_table.setItem(row, 0, alias_item)
+            class_table.setItem(row, 1, id_item)
 
         class_table.blockSignals(False)
 
@@ -604,11 +810,18 @@ class MainWindow(QMainWindow):
                 }
             )
         )
+
         current_selection = combo.currentText()
         combo.blockSignals(True)
         combo.clear()
         combo.addItem("All Classes")
-        combo.addItems([f"Class {cid}" for cid in unique_class_ids])
+        combo.addItems(
+            [
+                f"{self.class_aliases.get(cid, cid)} (ID: {cid})"
+                for cid in unique_class_ids
+            ]
+        )
+
         if combo.findText(current_selection) > -1:
             combo.setCurrentText(current_selection)
         else:
@@ -617,22 +830,54 @@ class MainWindow(QMainWindow):
 
     def reassign_class_ids(self):
         class_table = self.right_panel.class_table
-        ordered_ids = [
-            int(class_table.item(row, 0).text())
-            for row in range(class_table.rowCount())
-            if class_table.item(row, 0) is not None
-        ]
+
+        ordered_ids = []
+        for row in range(class_table.rowCount()):
+            id_item = class_table.item(row, 1)
+            if id_item and id_item.text():
+                try:
+                    ordered_ids.append(int(id_item.text()))
+                except ValueError:
+                    continue
+
         id_map = {old_id: new_id for new_id, old_id in enumerate(ordered_ids)}
+
         for seg in self.segments:
             old_id = seg.get("class_id")
             if old_id in id_map:
                 seg["class_id"] = id_map[old_id]
-        self.next_class_id = len(ordered_ids)
+
+        new_aliases = {
+            id_map[old_id]: self.class_aliases.get(old_id, str(old_id))
+            for old_id in ordered_ids
+            if old_id in self.class_aliases
+        }
+        self.class_aliases = new_aliases
+
+        self._update_next_class_id()
         self.update_all_lists()
         self.viewer.setFocus()
 
+    def handle_alias_change(self, item):
+        if item.column() != 0:  # Alias column
+            return
+
+        class_table = self.right_panel.class_table
+        class_table.blockSignals(True)
+
+        id_item = class_table.item(item.row(), 1)
+        if id_item:
+            try:
+                class_id = int(id_item.text())
+                self.class_aliases[class_id] = item.text()
+            except (ValueError, AttributeError):
+                pass  # Ignore if ID item is not valid
+
+        class_table.blockSignals(False)
+        self.update_class_filter_combo()  # Refresh filter to show new alias
+
     def handle_class_id_change(self, item):
-        if item.column() != 1:
+        if item.column() != 1:  # Class ID column in segment table
             return
         table = self.right_panel.segment_table
         index_item = table.item(item.row(), 0)
@@ -651,8 +896,7 @@ class MainWindow(QMainWindow):
                 raise IndexError("Invalid segment index found in table.")
 
             self.segments[original_index]["class_id"] = new_class_id
-            if new_class_id >= self.next_class_id:
-                self.next_class_id = new_class_id + 1
+            self._update_next_class_id()
             self.update_all_lists()
         except (ValueError, TypeError, AttributeError, IndexError) as e:
             original_index = index_item.data(Qt.ItemDataRole.UserRole)
@@ -686,22 +930,21 @@ class MainWindow(QMainWindow):
             self.viewer._pixmap_item.pixmap().height(),
             self.viewer._pixmap_item.pixmap().width(),
         )
-        unique_class_ids = sorted(
-            list(
-                {
-                    seg["class_id"]
-                    for seg in self.segments
-                    if seg.get("class_id") is not None
-                }
-            )
-        )
-        if not unique_class_ids:
-            self.right_panel.status_label.setText("Save failed: No classes.")
+
+        class_table = self.right_panel.class_table
+        ordered_ids = [
+            int(class_table.item(row, 1).text())
+            for row in range(class_table.rowCount())
+            if class_table.item(row, 1) is not None
+        ]
+
+        if not ordered_ids:
+            self.right_panel.status_label.setText("Save failed: No classes defined.")
             QTimer.singleShot(3000, lambda: self.right_panel.status_label.clear())
             return
 
-        id_map = {old_id: new_id for new_id, old_id in enumerate(unique_class_ids)}
-        num_final_classes = len(unique_class_ids)
+        id_map = {old_id: new_id for new_id, old_id in enumerate(ordered_ids)}
+        num_final_classes = len(ordered_ids)
         final_mask_tensor = np.zeros((h, w, num_final_classes), dtype=np.uint8)
 
         for seg in self.segments:
@@ -720,11 +963,52 @@ class MainWindow(QMainWindow):
                 )
 
         np.savez_compressed(output_path, mask=final_mask_tensor.astype(np.uint8))
-        self.file_model.setRootPath(self.file_model.rootPath())
+
+        self.file_model.set_highlighted_path(output_path)
+        QTimer.singleShot(1500, lambda: self.file_model.set_highlighted_path(None))
 
         self.right_panel.status_label.setText("Saved!")
+        self.generate_yolo_annotations(npz_file_path=output_path)
         QTimer.singleShot(3000, lambda: self.right_panel.status_label.clear())
 
+    def generate_yolo_annotations(self, npz_file_path):
+        output_path = os.path.splitext(self.current_image_path)[0] + ".txt"
+        npz_data = np.load(npz_file_path)  # Load the saved npz file
+
+        img = npz_data["mask"][:, :, :]
+        num_channels = img.shape[2]  # C
+        h, w = img.shape[:2]  # H, W
+
+        directory_path = os.path.dirname(output_path)
+        os.makedirs(directory_path, exist_ok=True)
+
+        yolo_annotations = []
+
+        for channel in range(num_channels):
+            single_channel_image = img[:, :, channel]
+            contours, _ = cv2.findContours(
+                single_channel_image, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
+            )
+
+            class_id = channel  # Use the channel index as the class ID
+
+            for contour in contours:
+                x, y, width, height = cv2.boundingRect(contour)
+                center_x = x + width / 2
+                center_y = y + height / 2
+
+                normalized_center_x = center_x / w
+                normalized_center_y = center_y / h
+                normalized_width = width / w
+                normalized_height = height / h
+
+                yolo_entry = f"{class_id} {normalized_center_x} {normalized_center_y} {normalized_width} {normalized_height}"
+                yolo_annotations.append(yolo_entry)
+
+        with open(output_path, "w") as file:
+            for annotation in yolo_annotations:
+                file.write(annotation + "\n")
+
     def save_current_segment(self):
         if (
             self.mode != "sam_points"
@@ -742,7 +1026,7 @@ class MainWindow(QMainWindow):
                     "class_id": self.next_class_id,
                 }
             )
-            self.next_class_id += 1
+            self._update_next_class_id()
             self.clear_all_points()
             self.update_all_lists()
 
@@ -752,6 +1036,7 @@ class MainWindow(QMainWindow):
             return
         for i in sorted(selected_indices, reverse=True):
             del self.segments[i]
+        self._update_next_class_id()
         self.update_all_lists()
         self.viewer.setFocus()
 
@@ -777,16 +1062,27 @@ class MainWindow(QMainWindow):
                                     "class_id": i,
                                 }
                             )
-                    self.next_class_id = num_classes
+                    self._update_next_class_id()
             self.update_all_lists()
 
     def add_point(self, pos, positive):
         point_list = self.positive_points if positive else self.negative_points
         point_list.append([int(pos.x()), int(pos.y())])
-        color = Qt.GlobalColor.green if positive else Qt.GlobalColor.red
-        point_item = QGraphicsEllipseItem(pos.x() - 4, pos.y() - 4, 8, 8)
-        point_item.setBrush(QBrush(color))
-        point_item.setPen(QPen(Qt.GlobalColor.white))
+
+        point_color = (
+            QColor(Qt.GlobalColor.green) if positive else QColor(Qt.GlobalColor.red)
+        )
+        point_color.setAlpha(150)
+
+        point_diameter = self.point_radius * 2
+        point_item = QGraphicsEllipseItem(
+            pos.x() - self.point_radius,
+            pos.y() - self.point_radius,
+            point_diameter,
+            point_diameter,
+        )
+        point_item.setBrush(QBrush(point_color))
+        point_item.setPen(QPen(Qt.GlobalColor.transparent))
         self.viewer.scene().addItem(point_item)
         self.point_items.append(point_item)
 
@@ -824,26 +1120,35 @@ class MainWindow(QMainWindow):
                 (pos.x() - self.polygon_points[0].x()) ** 2
                 + (pos.y() - self.polygon_points[0].y()) ** 2
             )
-            < 25
+            < 4  # pixel distance threshold squared
         ):
             if len(self.polygon_points) > 2:
                 self.finalize_polygon()
             return
         self.polygon_points.append(pos)
-        dot = QGraphicsEllipseItem(pos.x() - 2, pos.y() - 2, 4, 4)
-        dot.setBrush(QBrush(Qt.GlobalColor.blue))
-        dot.setPen(QPen(Qt.GlobalColor.cyan))
+        point_diameter = self.point_radius * 2
+
+        point_color = QColor(Qt.GlobalColor.blue)
+        point_color.setAlpha(150)
+
+        dot = QGraphicsEllipseItem(
+            pos.x() - self.point_radius,
+            pos.y() - self.point_radius,
+            point_diameter,
+            point_diameter,
+        )
+        dot.setBrush(QBrush(point_color))
+        dot.setPen(QPen(Qt.GlobalColor.transparent))
         self.viewer.scene().addItem(dot)
         self.polygon_preview_items.append(dot)
         self.draw_polygon_preview()
 
     def draw_polygon_preview(self):
-        if self.rubber_band_line:
-            self.viewer.scene().removeItem(self.rubber_band_line)
-            self.rubber_band_line = None
+        # Clean up old preview lines/polygons
         for item in self.polygon_preview_items:
             if not isinstance(item, QGraphicsEllipseItem):
-                self.viewer.scene().removeItem(item)
+                if item.scene():
+                    self.viewer.scene().removeItem(item)
         self.polygon_preview_items = [
             item
             for item in self.polygon_preview_items
@@ -858,6 +1163,8 @@ class MainWindow(QMainWindow):
             self.polygon_preview_items.append(preview_poly)
 
         if len(self.polygon_points) > 1:
+            line_color = QColor(Qt.GlobalColor.cyan)
+            line_color.setAlpha(150)
             for i in range(len(self.polygon_points) - 1):
                 line = QGraphicsLineItem(
                     self.polygon_points[i].x(),
@@ -865,7 +1172,7 @@ class MainWindow(QMainWindow):
                     self.polygon_points[i + 1].x(),
                     self.polygon_points[i + 1].y(),
                 )
-                line.setPen(QPen(Qt.GlobalColor.cyan, 2))
+                line.setPen(QPen(line_color, self.line_thickness))
                 self.viewer.scene().addItem(line)
                 self.polygon_preview_items.append(line)
 

{lazylabel_gui-1.0.5 → lazylabel_gui-1.0.7}/src/lazylabel/photo_viewer.py

@@ -1,5 +1,5 @@
 from PyQt6.QtCore import Qt, QRectF
-from PyQt6.QtGui import QPixmap
+from PyQt6.QtGui import QPixmap, QCursor
 from PyQt6.QtWidgets import QGraphicsView, QGraphicsScene, QGraphicsPixmapItem
 
 
@@ -21,8 +21,7 @@ class PhotoViewer(QGraphicsView):
         rect = QRectF(self._pixmap_item.pixmap().rect())
         if not rect.isNull():
             self.setSceneRect(rect)
-            unity = self.transform().mapRect(QRectF(0, 0, 1, 1))
-            self.scale(1 / unity.width(), 1 / unity.height())
+            self.resetTransform()
             viewrect = self.viewport().rect()
             scenerect = self.transform().mapRect(rect)
             factor = min(
@@ -30,6 +29,7 @@ class PhotoViewer(QGraphicsView):
                 viewrect.height() / scenerect.height(),
             )
             self.scale(factor, factor)
+            self.centerOn(self._pixmap_item)
 
     def set_photo(self, pixmap):
         if pixmap and not pixmap.isNull():
@@ -38,6 +38,9 @@ class PhotoViewer(QGraphicsView):
         else:
             self._pixmap_item.setPixmap(QPixmap())
 
+    def set_cursor(self, cursor_shape):
+        self.viewport().setCursor(QCursor(cursor_shape))
+
     def resizeEvent(self, event):
         self.fitInView()
         super().resizeEvent(event)

{lazylabel_gui-1.0.5 → lazylabel_gui-1.0.7}/src/lazylabel/reorderable_class_table.py

@@ -34,11 +34,13 @@ class ReorderableClassTable(QTableWidget):
                 list({index.row() for index in self.selectedIndexes()}), reverse=True
             )
 
-            dragged_items = []
+            dragged_rows_data = []
             for row in selected_rows:
-                # Take the item from the row and keep its data
-                item = self.takeItem(row, 0)
-                dragged_items.insert(0, item)
+                # Take all items from the row
+                row_data = [
+                    self.takeItem(row, col) for col in range(self.columnCount())
+                ]
+                dragged_rows_data.insert(0, row_data)
                 # Then remove the row itself
                 self.removeRow(row)
 
@@ -47,10 +49,11 @@ class ReorderableClassTable(QTableWidget):
                 if row < drop_row:
                     drop_row -= 1
 
-            # Insert items at the new location
-            for item in dragged_items:
+            # Insert rows and their items at the new location
+            for row_data in dragged_rows_data:
                 self.insertRow(drop_row)
-                self.setItem(drop_row, 0, item)
+                for col, item in enumerate(row_data):
+                    self.setItem(drop_row, col, item)
                 self.selectRow(drop_row)
                 drop_row += 1
 

{lazylabel_gui-1.0.5 → lazylabel_gui-1.0.7}/src/lazylabel/utils.py

@@ -2,10 +2,10 @@ import numpy as np
 from PyQt6.QtGui import QImage, QPixmap
 
 
-def mask_to_pixmap(mask, color):
+def mask_to_pixmap(mask, color, alpha=150):
     colored_mask = np.zeros((mask.shape[0], mask.shape[1], 4), dtype=np.uint8)
     colored_mask[mask, :3] = color
-    colored_mask[mask, 3] = 150  # Alpha channel for transparency
+    colored_mask[mask, 3] = alpha  # Alpha channel for transparency
     image = QImage(
         colored_mask.data, mask.shape[1], mask.shape[0], QImage.Format.Format_RGBA8888
     )

{lazylabel_gui-1.0.5 → lazylabel_gui-1.0.7}/src/lazylabel_gui.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lazylabel-gui
-Version: 1.0.5
+Version: 1.0.7
 Summary: An image segmentation GUI for generating mask tensors.
 Author-email: "Deniz N. Cakan" <deniz.n.cakan@gmail.com>
 License: MIT License
@@ -48,7 +48,7 @@ Requires-Dist: tqdm>=4.67.1
 Dynamic: license-file
 
 # <img src="https://raw.githubusercontent.com/dnzckn/LazyLabel/main/src/lazylabel/demo_pictures/logo2.png" alt="LazyLabel Logo" style="height:60px; vertical-align:middle;" /> <img src="https://raw.githubusercontent.com/dnzckn/LazyLabel/main/src/lazylabel/demo_pictures/logo_black.png" alt="LazyLabel Cursive" style="height:60px; vertical-align:middle;" />
-LazyLabel is an intuitive, AI-assisted image segmentation tool. It uses Meta's Segment Anything Model (SAM) for quick, precise mask generation, alongside advanced polygon editing for fine-tuned control. Outputs are saved in a clean, one-hot encoded format for easy machine learning integration.
+LazyLabel is an intuitive, AI-assisted image segmentation tool. It uses Meta's Segment Anything Model (SAM) for quick, precise mask generation, alongside advanced polygon editing for fine-tuned control. Outputs are saved in a clean, one-hot encoded `.npz` format for easy machine learning integration and in YOLO `.txt` format.
 
 Inspired by [LabelMe](https://github.com/wkentaro/labelme?tab=readme-ov-file#installation) and [Segment-Anything-UI](https://github.com/branislavhesko/segment-anything-ui/tree/main).
 

{lazylabel_gui-1.0.5 → lazylabel_gui-1.0.7}/src/lazylabel_gui.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ pyproject.toml
 src/lazylabel/controls.py
 src/lazylabel/custom_file_system_model.py
 src/lazylabel/editable_vertex.py
+src/lazylabel/hoverable_pixelmap_item.py
 src/lazylabel/hoverable_polygon_item.py
 src/lazylabel/main.py
 src/lazylabel/numeric_table_widget_item.py