labelimgplusplus 2.0.0a0__py3-none-any.whl

libs/colorDialog.py

@@ -0,0 +1,37 @@
+try:
+    from PyQt5.QtGui import *
+    from PyQt5.QtCore import *
+    from PyQt5.QtWidgets import QColorDialog, QDialogButtonBox
+except ImportError:
+    from PyQt4.QtGui import *
+    from PyQt4.QtCore import *
+
+BB = QDialogButtonBox
+
+
+class ColorDialog(QColorDialog):
+
+    def __init__(self, parent=None):
+        super(ColorDialog, self).__init__(parent)
+        self.setOption(QColorDialog.ShowAlphaChannel)
+        # The Mac native dialog does not support our restore button.
+        self.setOption(QColorDialog.DontUseNativeDialog)
+        # Add a restore defaults button.
+        # The default is set at invocation time, so that it
+        # works across dialogs for different elements.
+        self.default = None
+        self.bb = self.layout().itemAt(1).widget()
+        self.bb.addButton(BB.RestoreDefaults)
+        self.bb.clicked.connect(self.check_restore)
+
+    def getColor(self, value=None, title=None, default=None):
+        self.default = default
+        if title:
+            self.setWindowTitle(title)
+        if value:
+            self.setCurrentColor(value)
+        return self.currentColor() if self.exec_() else None
+
+    def check_restore(self, button):
+        if self.bb.buttonRole(button) & BB.ResetRole and self.default:
+            self.setCurrentColor(self.default)

libs/combobox.py

@@ -0,0 +1,33 @@
+import sys
+try:
+    from PyQt5.QtWidgets import QWidget, QHBoxLayout, QComboBox
+except ImportError:
+    # needed for py3+qt4
+    # Ref:
+    # http://pyqt.sourceforge.net/Docs/PyQt4/incompatible_apis.html
+    # http://stackoverflow.com/questions/21217399/pyqt4-qtcore-qvariant-object-instead-of-a-string
+    if sys.version_info.major >= 3:
+        import sip
+        sip.setapi('QVariant', 2)
+    from PyQt4.QtGui import QWidget, QHBoxLayout, QComboBox
+
+
+class ComboBox(QWidget):
+    def __init__(self, parent=None, items=[]):
+        super(ComboBox, self).__init__(parent)
+
+        layout = QHBoxLayout()
+        self.cb = QComboBox()
+        self.items = items
+        self.cb.addItems(self.items)
+
+        self.cb.currentIndexChanged.connect(parent.combo_selection_changed)
+
+        layout.addWidget(self.cb)
+        self.setLayout(layout)
+
+    def update_items(self, items):
+        self.items = items
+
+        self.cb.clear()
+        self.cb.addItems(self.items)

libs/commands.py

@@ -0,0 +1,328 @@
+# libs/commands.py
+"""Command pattern implementation for undo/redo functionality.
+
+This module provides undoable command classes for annotation actions.
+"""
+
+from abc import ABC, abstractmethod
+from copy import deepcopy
+
+try:
+    from PyQt5.QtCore import QPointF
+except ImportError:
+    from PyQt4.QtCore import QPointF
+
+
+class Command(ABC):
+    """Base class for all undoable commands."""
+
+    @abstractmethod
+    def execute(self):
+        """Execute the command."""
+        pass
+
+    @abstractmethod
+    def undo(self):
+        """Undo the command."""
+        pass
+
+    @property
+    def description(self):
+        """Return a description of this command."""
+        return "Command"
+
+
+class CreateShapeCommand(Command):
+    """Command for creating a new shape.
+
+    Undo removes the shape from canvas and label list.
+    """
+
+    def __init__(self, main_window, shape):
+        """Initialize with reference to main window and the created shape.
+
+        Args:
+            main_window: The MainWindow instance.
+            shape: The Shape object that was created.
+        """
+        self.main_window = main_window
+        self.shape = shape
+
+    def execute(self):
+        """Add the shape to canvas and label list."""
+        self.main_window.canvas.shapes.append(self.shape)
+        self.main_window.add_label(self.shape)
+        self.main_window.canvas.update()
+
+    def undo(self):
+        """Remove the shape from canvas and label list."""
+        if self.shape in self.main_window.canvas.shapes:
+            self.main_window.canvas.shapes.remove(self.shape)
+        self.main_window.remove_label(self.shape)
+        if self.main_window.canvas.selected_shape == self.shape:
+            self.main_window.canvas.selected_shape = None
+        self.main_window.canvas.update()
+
+    @property
+    def description(self):
+        return f"Create shape '{self.shape.label}'"
+
+
+class DeleteShapeCommand(Command):
+    """Command for deleting a shape.
+
+    Undo restores the shape to canvas and label list.
+    """
+
+    def __init__(self, main_window, shape, index=None):
+        """Initialize with reference to main window and the deleted shape.
+
+        Args:
+            main_window: The MainWindow instance.
+            shape: The Shape object that will be/was deleted.
+            index: Optional index where shape was in the shapes list.
+        """
+        self.main_window = main_window
+        self.shape = shape  # Keep reference to original shape
+        self.index = index
+
+    def execute(self):
+        """Remove the shape from canvas and label list."""
+        if self.shape in self.main_window.canvas.shapes:
+            self.main_window.canvas.shapes.remove(self.shape)
+        self.main_window.remove_label(self.shape)
+        if self.main_window.canvas.selected_shape == self.shape:
+            self.main_window.canvas.selected_shape = None
+        self.main_window.canvas.update()
+
+    def undo(self):
+        """Restore the shape to canvas and label list."""
+        if self.index is not None and self.index <= len(self.main_window.canvas.shapes):
+            self.main_window.canvas.shapes.insert(self.index, self.shape)
+        else:
+            self.main_window.canvas.shapes.append(self.shape)
+        self.main_window.add_label(self.shape)
+        self.main_window.canvas.update()
+
+    @property
+    def description(self):
+        return f"Delete shape '{self.shape.label}'"
+
+
+class MoveShapeCommand(Command):
+    """Command for moving a shape.
+
+    Undo restores the shape to its original position.
+    """
+
+    def __init__(self, main_window, shape, old_points, new_points):
+        """Initialize with shape and its positions.
+
+        Args:
+            main_window: The MainWindow instance.
+            shape: The Shape object being moved.
+            old_points: List of QPointF representing original position.
+            new_points: List of QPointF representing new position.
+        """
+        self.main_window = main_window
+        self.shape = shape
+        # Store copies of points to avoid reference issues
+        self.old_points = [QPointF(p.x(), p.y()) for p in old_points]
+        self.new_points = [QPointF(p.x(), p.y()) for p in new_points]
+
+    def execute(self):
+        """Move shape to new position."""
+        self.shape.points = [QPointF(p.x(), p.y()) for p in self.new_points]
+        self.main_window.canvas.update()
+
+    def undo(self):
+        """Restore shape to original position."""
+        self.shape.points = [QPointF(p.x(), p.y()) for p in self.old_points]
+        self.main_window.canvas.update()
+
+    @property
+    def description(self):
+        return f"Move shape '{self.shape.label}'"
+
+
+class EditLabelCommand(Command):
+    """Command for editing a shape's label.
+
+    Undo restores the old label text.
+    """
+
+    def __init__(self, main_window, shape, old_label, new_label):
+        """Initialize with shape and label values.
+
+        Args:
+            main_window: The MainWindow instance.
+            shape: The Shape object being edited.
+            old_label: The original label text.
+            new_label: The new label text.
+        """
+        self.main_window = main_window
+        self.shape = shape
+        self.old_label = old_label
+        self.new_label = new_label
+
+    def execute(self):
+        """Apply new label."""
+        self.shape.label = self.new_label
+        self._update_list_item()
+        self.main_window.canvas.update()
+
+    def undo(self):
+        """Restore old label."""
+        self.shape.label = self.old_label
+        self._update_list_item()
+        self.main_window.canvas.update()
+
+    def _update_list_item(self):
+        """Update the label list item to reflect current shape label."""
+        if self.shape in self.main_window.shapes_to_items:
+            item = self.main_window.shapes_to_items[self.shape]
+            item.setText(self.shape.label)
+            from libs.hashableQListWidgetItem import generate_color_by_text
+            item.setBackground(generate_color_by_text(self.shape.label))
+
+    @property
+    def description(self):
+        return f"Edit label '{self.old_label}' -> '{self.new_label}'"
+
+
+class UndoStack:
+    """Manages command history for undo/redo operations.
+
+    Maintains two stacks: one for undo operations and one for redo.
+    When a new command is pushed, the redo stack is cleared.
+    """
+
+    def __init__(self, max_size=50):
+        """Initialize the undo stack.
+
+        Args:
+            max_size: Maximum number of commands to store (default 50).
+        """
+        self._undo_stack = []
+        self._redo_stack = []
+        self._max_size = max_size
+        self._callbacks = []
+
+    def push(self, command):
+        """Add a command to the undo stack.
+
+        The command should already be executed before pushing.
+        Clears the redo stack since we're branching history.
+
+        Args:
+            command: The Command object to push.
+        """
+        self._undo_stack.append(command)
+        self._redo_stack.clear()
+
+        # Trim stack if it exceeds max size
+        while len(self._undo_stack) > self._max_size:
+            self._undo_stack.pop(0)
+
+        self._notify_callbacks()
+
+    def undo(self):
+        """Undo the last command.
+
+        Returns:
+            The undone command, or None if stack was empty.
+        """
+        if not self.can_undo():
+            return None
+
+        command = self._undo_stack.pop()
+        command.undo()
+        self._redo_stack.append(command)
+        self._notify_callbacks()
+        return command
+
+    def redo(self):
+        """Redo the last undone command.
+
+        Returns:
+            The redone command, or None if redo stack was empty.
+        """
+        if not self.can_redo():
+            return None
+
+        command = self._redo_stack.pop()
+        command.execute()
+        self._undo_stack.append(command)
+        self._notify_callbacks()
+        return command
+
+    def can_undo(self):
+        """Check if undo is available.
+
+        Returns:
+            True if there are commands to undo.
+        """
+        return len(self._undo_stack) > 0
+
+    def can_redo(self):
+        """Check if redo is available.
+
+        Returns:
+            True if there are commands to redo.
+        """
+        return len(self._redo_stack) > 0
+
+    def clear(self):
+        """Clear both undo and redo stacks.
+
+        Call this when loading a new file.
+        """
+        self._undo_stack.clear()
+        self._redo_stack.clear()
+        self._notify_callbacks()
+
+    def add_callback(self, callback):
+        """Register a callback to be notified when stack changes.
+
+        Args:
+            callback: A callable that takes no arguments.
+        """
+        self._callbacks.append(callback)
+
+    def remove_callback(self, callback):
+        """Remove a previously registered callback.
+
+        Args:
+            callback: The callback to remove.
+        """
+        if callback in self._callbacks:
+            self._callbacks.remove(callback)
+
+    def _notify_callbacks(self):
+        """Notify all registered callbacks of stack change."""
+        for callback in self._callbacks:
+            callback()
+
+    def get_undo_description(self):
+        """Get description of the command that would be undone.
+
+        Returns:
+            Description string or None if stack is empty.
+        """
+        if self.can_undo():
+            return self._undo_stack[-1].description
+        return None
+
+    def get_redo_description(self):
+        """Get description of the command that would be redone.
+
+        Returns:
+            Description string or None if redo stack is empty.
+        """
+        if self.can_redo():
+            return self._redo_stack[-1].description
+        return None
+
+    def __len__(self):
+        """Return number of commands in undo stack."""
+        return len(self._undo_stack)

libs/constants.py

@@ -0,0 +1,26 @@
+SETTING_FILENAME = 'filename'
+SETTING_RECENT_FILES = 'recentFiles'
+SETTING_WIN_SIZE = 'window/size'
+SETTING_WIN_POSE = 'window/position'
+SETTING_WIN_GEOMETRY = 'window/geometry'
+SETTING_LINE_COLOR = 'line/color'
+SETTING_FILL_COLOR = 'fill/color'
+SETTING_ADVANCE_MODE = 'advanced'
+SETTING_WIN_STATE = 'window/state'
+SETTING_SAVE_DIR = 'savedir'
+SETTING_PAINT_LABEL = 'paintlabel'
+SETTING_LAST_OPEN_DIR = 'lastOpenDir'
+SETTING_AUTO_SAVE = 'autosave'
+SETTING_AUTO_SAVE_ENABLED = 'autoSaveEnabled'  # Timer-based auto-save toggle
+SETTING_AUTO_SAVE_INTERVAL = 'autoSaveInterval'  # Interval in seconds
+SETTING_SINGLE_CLASS = 'singleclass'
+FORMAT_PASCALVOC='PascalVOC'
+FORMAT_YOLO='YOLO'
+FORMAT_CREATEML='CreateML'
+SETTING_DRAW_SQUARE = 'draw/square'
+SETTING_LABEL_FILE_FORMAT= 'labelFileFormat'
+SETTING_FILE_VIEW_MODE = 'fileViewMode'
+SETTING_GALLERY_MODE = 'galleryMode'
+SETTING_ICON_SIZE = 'iconSize'
+SETTING_TOOLBAR_EXPANDED = 'toolbarExpanded'
+DEFAULT_ENCODING = 'utf-8'

libs/create_ml_io.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python
+# -*- coding: utf8 -*-
+import json
+from pathlib import Path
+
+from libs.constants import DEFAULT_ENCODING
+import os
+
+JSON_EXT = '.json'
+ENCODE_METHOD = DEFAULT_ENCODING
+
+
+class CreateMLWriter:
+    def __init__(self, folder_name, filename, img_size, shapes, output_file, database_src='Unknown', local_img_path=None):
+        self.folder_name = folder_name
+        self.filename = filename
+        self.database_src = database_src
+        self.img_size = img_size
+        self.box_list = []
+        self.local_img_path = local_img_path
+        self.verified = False
+        self.shapes = shapes
+        self.output_file = output_file
+
+    def write(self):
+        if os.path.isfile(self.output_file):
+            with open(self.output_file, "r") as file:
+                input_data = file.read()
+                output_dict = json.loads(input_data)
+        else:
+            output_dict = []
+
+        output_image_dict = {
+            "image": self.filename,
+            "verified": self.verified,
+            "annotations": []
+        }
+
+        for shape in self.shapes:
+            points = shape["points"]
+
+            x1 = points[0][0]
+            y1 = points[0][1]
+            x2 = points[1][0]
+            y2 = points[2][1]
+
+            height, width, x, y = self.calculate_coordinates(x1, x2, y1, y2)
+
+            shape_dict = {
+                "label": shape["label"],
+                "coordinates": {
+                    "x": x,
+                    "y": y,
+                    "width": width,
+                    "height": height
+                }
+            }
+            output_image_dict["annotations"].append(shape_dict)
+
+        # check if image already in output
+        exists = False
+        for i in range(0, len(output_dict)):
+            if output_dict[i]["image"] == output_image_dict["image"]:
+                exists = True
+                output_dict[i] = output_image_dict
+                break
+
+        if not exists:
+            output_dict.append(output_image_dict)
+
+        Path(self.output_file).write_text(json.dumps(output_dict), ENCODE_METHOD)
+
+    def calculate_coordinates(self, x1, x2, y1, y2):
+        if x1 < x2:
+            x_min = x1
+            x_max = x2
+        else:
+            x_min = x2
+            x_max = x1
+        if y1 < y2:
+            y_min = y1
+            y_max = y2
+        else:
+            y_min = y2
+            y_max = y1
+        width = x_max - x_min
+        if width < 0:
+            width = width * -1
+        height = y_max - y_min
+        # x and y from center of rect
+        x = x_min + width / 2
+        y = y_min + height / 2
+        return height, width, x, y
+
+
+class CreateMLReader:
+    def __init__(self, json_path, file_path):
+        self.json_path = json_path
+        self.shapes = []
+        self.verified = False
+        self.filename = os.path.basename(file_path)
+        try:
+            self.parse_json()
+        except ValueError:
+            print("JSON decoding failed")
+
+    def parse_json(self):
+        with open(self.json_path, "r") as file:
+            input_data = file.read()
+
+        # Returns a list
+        output_list = json.loads(input_data)
+
+        if output_list:
+            self.verified = output_list[0].get("verified", False)
+
+        if len(self.shapes) > 0:
+            self.shapes = []
+        for image in output_list:
+            if image["image"] == self.filename:
+                for shape in image["annotations"]:
+                    self.add_shape(shape["label"], shape["coordinates"])
+
+    def add_shape(self, label, bnd_box):
+        x_min = bnd_box["x"] - (bnd_box["width"] / 2)
+        y_min = bnd_box["y"] - (bnd_box["height"] / 2)
+
+        x_max = bnd_box["x"] + (bnd_box["width"] / 2)
+        y_max = bnd_box["y"] + (bnd_box["height"] / 2)
+
+        points = [(x_min, y_min), (x_max, y_min), (x_max, y_max), (x_min, y_max)]
+        self.shapes.append((label, points, None, None, True))
+
+    def get_shapes(self):
+        return self.shapes

libs/default_label_combobox.py

@@ -0,0 +1,27 @@
+import sys
+try:
+    from PyQt5.QtWidgets import QWidget, QHBoxLayout, QComboBox
+except ImportError:
+    # needed for py3+qt4
+    # Ref:
+    # http://pyqt.sourceforge.net/Docs/PyQt4/incompatible_apis.html
+    # http://stackoverflow.com/questions/21217399/pyqt4-qtcore-qvariant-object-instead-of-a-string
+    if sys.version_info.major >= 3:
+        import sip
+        sip.setapi('QVariant', 2)
+    from PyQt4.QtGui import QWidget, QHBoxLayout, QComboBox
+
+
+class DefaultLabelComboBox(QWidget):
+    def __init__(self, parent=None, items=[]):
+        super(DefaultLabelComboBox, self).__init__(parent)
+
+        layout = QHBoxLayout()
+        self.cb = QComboBox()
+        self.items = items
+        self.cb.addItems(self.items)
+
+        self.cb.currentIndexChanged.connect(parent.default_label_combo_selection_changed)
+
+        layout.addWidget(self.cb)
+        self.setLayout(layout)