labelimgplusplus 2.0.0a0__py3-none-any.whl

libs/settings.py

@@ -0,0 +1,45 @@
+import os
+import pickle
+
+
+class Settings(object):
+    def __init__(self):
+        # Be default, the home will be in the same folder as labelImg
+        home = os.path.expanduser("~")
+        self.data = {}
+        self.path = os.path.join(home, '.labelImgSettings.pkl')
+
+    def __setitem__(self, key, value):
+        self.data[key] = value
+
+    def __getitem__(self, key):
+        return self.data[key]
+
+    def get(self, key, default=None):
+        if key in self.data:
+            return self.data[key]
+        return default
+
+    def save(self):
+        if self.path:
+            with open(self.path, 'wb') as f:
+                pickle.dump(self.data, f, pickle.HIGHEST_PROTOCOL)
+                return True
+        return False
+
+    def load(self):
+        try:
+            if os.path.exists(self.path):
+                with open(self.path, 'rb') as f:
+                    self.data = pickle.load(f)
+                    return True
+        except:
+            print('Loading setting failed')
+        return False
+
+    def reset(self):
+        if os.path.exists(self.path):
+            os.remove(self.path)
+            print('Remove setting pkl file ${0}'.format(self.path))
+        self.data = {}
+        self.path = None

libs/shape.py

@@ -0,0 +1,209 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+
+try:
+    from PyQt5.QtGui import *
+    from PyQt5.QtCore import *
+except ImportError:
+    from PyQt4.QtGui import *
+    from PyQt4.QtCore import *
+
+from libs.utils import distance
+import sys
+
+DEFAULT_LINE_COLOR = QColor(0, 255, 0, 128)
+DEFAULT_FILL_COLOR = QColor(255, 0, 0, 128)
+DEFAULT_SELECT_LINE_COLOR = QColor(255, 255, 255)
+DEFAULT_SELECT_FILL_COLOR = QColor(0, 128, 255, 155)
+DEFAULT_VERTEX_FILL_COLOR = QColor(0, 255, 0, 255)
+DEFAULT_HVERTEX_FILL_COLOR = QColor(255, 0, 0)
+
+
+class Shape(object):
+    P_SQUARE, P_ROUND = range(2)
+
+    MOVE_VERTEX, NEAR_VERTEX = range(2)
+
+    # The following class variables influence the drawing
+    # of _all_ shape objects.
+    line_color = DEFAULT_LINE_COLOR
+    fill_color = DEFAULT_FILL_COLOR
+    select_line_color = DEFAULT_SELECT_LINE_COLOR
+    select_fill_color = DEFAULT_SELECT_FILL_COLOR
+    vertex_fill_color = DEFAULT_VERTEX_FILL_COLOR
+    h_vertex_fill_color = DEFAULT_HVERTEX_FILL_COLOR
+    point_type = P_ROUND
+    point_size = 16
+    scale = 1.0
+    label_font_size = 8
+
+    def __init__(self, label=None, line_color=None, difficult=False, paint_label=False):
+        self.label = label
+        self.points = []
+        self.fill = False
+        self.selected = False
+        self.difficult = difficult
+        self.paint_label = paint_label
+
+        self._highlight_index = None
+        self._highlight_mode = self.NEAR_VERTEX
+        self._highlight_settings = {
+            self.NEAR_VERTEX: (4, self.P_ROUND),
+            self.MOVE_VERTEX: (1.5, self.P_SQUARE),
+        }
+
+        self._closed = False
+
+        if line_color is not None:
+            # Override the class line_color attribute
+            # with an object attribute. Currently this
+            # is used for drawing the pending line a different color.
+            self.line_color = line_color
+
+    def close(self):
+        self._closed = True
+
+    def reach_max_points(self):
+        if len(self.points) >= 4:
+            return True
+        return False
+
+    def add_point(self, point):
+        if not self.reach_max_points():
+            self.points.append(point)
+
+    def pop_point(self):
+        if self.points:
+            return self.points.pop()
+        return None
+
+    def is_closed(self):
+        return self._closed
+
+    def set_open(self):
+        self._closed = False
+
+    def paint(self, painter):
+        if self.points:
+            color = self.select_line_color if self.selected else self.line_color
+            pen = QPen(color)
+            # Try using integer sizes for smoother drawing(?)
+            pen.setWidth(max(1, int(round(2.0 / self.scale))))
+            painter.setPen(pen)
+
+            line_path = QPainterPath()
+            vertex_path = QPainterPath()
+
+            line_path.moveTo(self.points[0])
+            # Uncommenting the following line will draw 2 paths
+            # for the 1st vertex, and make it non-filled, which
+            # may be desirable.
+            # self.drawVertex(vertex_path, 0)
+
+            for i, p in enumerate(self.points):
+                line_path.lineTo(p)
+                self.draw_vertex(vertex_path, i)
+            if self.is_closed():
+                line_path.lineTo(self.points[0])
+
+            painter.drawPath(line_path)
+            painter.drawPath(vertex_path)
+            painter.fillPath(vertex_path, self.vertex_fill_color)
+
+            # Draw text at the top-left
+            if self.paint_label:
+                min_x = sys.maxsize
+                min_y = sys.maxsize
+                min_y_label = int(1.25 * self.label_font_size)
+                for point in self.points:
+                    min_x = min(min_x, point.x())
+                    min_y = min(min_y, point.y())
+                if min_x != sys.maxsize and min_y != sys.maxsize:
+                    font = QFont()
+                    font.setPointSize(self.label_font_size)
+                    font.setBold(True)
+                    painter.setFont(font)
+                    if self.label is None:
+                        self.label = ""
+                    if min_y < min_y_label:
+                        min_y += min_y_label
+                    painter.drawText(int(min_x), int(min_y), self.label)
+
+            if self.fill:
+                color = self.select_fill_color if self.selected else self.fill_color
+                painter.fillPath(line_path, color)
+
+    def draw_vertex(self, path, i):
+        d = self.point_size / self.scale
+        shape = self.point_type
+        point = self.points[i]
+        if i == self._highlight_index:
+            size, shape = self._highlight_settings[self._highlight_mode]
+            d *= size
+        if self._highlight_index is not None:
+            self.vertex_fill_color = self.h_vertex_fill_color
+        else:
+            self.vertex_fill_color = Shape.vertex_fill_color
+        if shape == self.P_SQUARE:
+            path.addRect(point.x() - d / 2, point.y() - d / 2, d, d)
+        elif shape == self.P_ROUND:
+            path.addEllipse(point, d / 2.0, d / 2.0)
+        else:
+            assert False, "unsupported vertex shape"
+
+    def nearest_vertex(self, point, epsilon):
+        index = None
+        for i, p in enumerate(self.points):
+            dist = distance(p - point)
+            if dist <= epsilon:
+                index = i
+                epsilon = dist
+        return index
+
+    def contains_point(self, point):
+        return self.make_path().contains(point)
+
+    def make_path(self):
+        path = QPainterPath(self.points[0])
+        for p in self.points[1:]:
+            path.lineTo(p)
+        return path
+
+    def bounding_rect(self):
+        return self.make_path().boundingRect()
+
+    def move_by(self, offset):
+        self.points = [p + offset for p in self.points]
+
+    def move_vertex_by(self, i, offset):
+        self.points[i] = self.points[i] + offset
+
+    def highlight_vertex(self, i, action):
+        self._highlight_index = i
+        self._highlight_mode = action
+
+    def highlight_clear(self):
+        self._highlight_index = None
+
+    def copy(self):
+        shape = Shape("%s" % self.label)
+        shape.points = [p for p in self.points]
+        shape.fill = self.fill
+        shape.selected = self.selected
+        shape._closed = self._closed
+        if self.line_color != Shape.line_color:
+            shape.line_color = self.line_color
+        if self.fill_color != Shape.fill_color:
+            shape.fill_color = self.fill_color
+        shape.difficult = self.difficult
+        return shape
+
+    def __len__(self):
+        return len(self.points)
+
+    def __getitem__(self, key):
+        return self.points[key]
+
+    def __setitem__(self, key, value):
+        self.points[key] = value

libs/stringBundle.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+if items were added in files in the resources/strings folder,
+then execute "pyrcc5 resources.qrc -o resources.py" in the root directory
+and execute "pyrcc5 ../resources.qrc -o resources.py" in the libs directory
+"""
+import re
+import os
+import sys
+import locale
+from libs.ustr import ustr
+
+try:
+    from PyQt5.QtCore import *
+except ImportError:
+    if sys.version_info.major >= 3:
+        import sip
+        sip.setapi('QVariant', 2)
+    from PyQt4.QtCore import *
+
+
+class StringBundle:
+
+    __create_key = object()
+
+    def __init__(self, create_key, locale_str):
+        assert(create_key == StringBundle.__create_key), "StringBundle must be created using StringBundle.getBundle"
+        self.id_to_message = {}
+        paths = self.__create_lookup_fallback_list(locale_str)
+        for path in paths:
+            self.__load_bundle(path)
+
+    @classmethod
+    def get_bundle(cls, locale_str=None):
+        if locale_str is None:
+            try:
+                locale_str = locale.getdefaultlocale()[0] if locale.getdefaultlocale() and len(
+                    locale.getdefaultlocale()) > 0 else os.getenv('LANG')
+            except:
+                print('Invalid locale')
+                locale_str = 'en'
+
+        return StringBundle(cls.__create_key, locale_str)
+
+    def get_string(self, string_id):
+        assert(string_id in self.id_to_message), "Missing string id : " + string_id
+        return self.id_to_message[string_id]
+
+    def __create_lookup_fallback_list(self, locale_str):
+        result_paths = []
+        base_path = ":/strings"
+        result_paths.append(base_path)
+        if locale_str is not None:
+            # Don't follow standard BCP47. Simple fallback
+            tags = re.split('[^a-zA-Z]', locale_str)
+            for tag in tags:
+                last_path = result_paths[-1]
+                result_paths.append(last_path + '-' + tag)
+
+        return result_paths
+
+    def __load_bundle(self, path):
+        PROP_SEPERATOR = '='
+        f = QFile(path)
+        if f.exists():
+            if f.open(QIODevice.ReadOnly | QFile.Text):
+                text = QTextStream(f)
+                text.setCodec("UTF-8")
+
+            while not text.atEnd():
+                line = ustr(text.readLine())
+                key_value = line.split(PROP_SEPERATOR)
+                key = key_value[0].strip()
+                value = PROP_SEPERATOR.join(key_value[1:]).strip().strip('"')
+                self.id_to_message[key] = value
+
+            f.close()

libs/styles.py

@@ -0,0 +1,82 @@
+# libs/styles.py
+"""Modern stylesheet definitions for labelImg++."""
+
+# Toolbar stylesheet with modern flat design
+TOOLBAR_STYLE = """
+QToolBar {
+    background: #f5f5f5;
+    border: none;
+    border-right: 1px solid #ddd;
+    spacing: 2px;
+    padding: 4px;
+}
+
+QToolBar::separator {
+    background: #ddd;
+    width: 1px;
+    height: 20px;
+    margin: 6px 4px;
+}
+
+QToolButton {
+    background: transparent;
+    border: none;
+    border-radius: 4px;
+    padding: 4px;
+    margin: 1px;
+    color: #000000;
+}
+
+QToolButton:hover {
+    background: #e0e0e0;
+}
+
+QToolButton:pressed {
+    background: #d0d0d0;
+}
+
+QToolButton:checked {
+    background: #cce5ff;
+    color: #004085;
+}
+
+QToolButton:disabled {
+    color: #999999;
+}
+"""
+
+# Main window stylesheet
+MAIN_WINDOW_STYLE = """
+QMainWindow {
+    background: #ffffff;
+}
+
+QDockWidget::title {
+    background: #f5f5f5;
+    padding: 6px;
+    border-bottom: 1px solid #ddd;
+}
+
+QListWidget {
+    background: #ffffff;
+    border: 1px solid #ddd;
+}
+
+QListWidget::item:selected {
+    background: #cce5ff;
+    color: #004085;
+}
+"""
+
+# Status bar stylesheet
+STATUS_BAR_STYLE = """
+QStatusBar {
+    background: #f5f5f5;
+    border-top: 1px solid #ddd;
+}
+"""
+
+
+def get_combined_style():
+    """Return combined stylesheet for the application."""
+    return TOOLBAR_STYLE + MAIN_WINDOW_STYLE + STATUS_BAR_STYLE

libs/toolBar.py

@@ -0,0 +1,275 @@
+# libs/toolBar.py
+"""Custom toolbar and button classes for labelImg++."""
+
+try:
+    from PyQt5.QtGui import *
+    from PyQt5.QtCore import *
+    from PyQt5.QtWidgets import *
+except ImportError:
+    from PyQt4.QtGui import *
+    from PyQt4.QtCore import *
+
+
+# Base icon size for toolbar buttons (Feather icons are 24x24)
+BASE_ICON_SIZE = 22
+# Minimum and maximum icon sizes for scaling
+MIN_ICON_SIZE = 16
+MAX_ICON_SIZE = 48
+
+
+def get_dpi_scale_factor():
+    """Get the DPI scale factor for the primary screen.
+
+    Returns:
+        float: Scale factor (1.0 for standard 96 DPI, higher for HiDPI displays)
+    """
+    app = QApplication.instance()
+    if app is None:
+        return 1.0
+
+    # Try to get the primary screen
+    try:
+        screen = app.primaryScreen()
+        if screen:
+            # Get logical DPI (accounts for user scaling settings)
+            logical_dpi = screen.logicalDotsPerInch()
+            # Standard DPI is 96 on most systems
+            return logical_dpi / 96.0
+    except AttributeError:
+        # Qt4 fallback
+        pass
+
+    return 1.0
+
+
+def calculate_icon_size(base_size=BASE_ICON_SIZE):
+    """Calculate appropriate icon size based on DPI.
+
+    Args:
+        base_size: Base icon size at standard DPI
+
+    Returns:
+        int: Scaled icon size clamped to min/max bounds
+    """
+    scale = get_dpi_scale_factor()
+    scaled_size = int(base_size * scale)
+    return max(MIN_ICON_SIZE, min(MAX_ICON_SIZE, scaled_size))
+
+
+class ToolBar(QToolBar):
+    """Custom toolbar with modern styling and DPI-aware icons."""
+
+    # Signal emitted when expanded state changes
+    expandedChanged = pyqtSignal(bool)
+
+    def __init__(self, title):
+        super(ToolBar, self).__init__(title)
+        layout = self.layout()
+        layout.setSpacing(0)
+        layout.setContentsMargins(2, 2, 2, 2)
+        self.setContentsMargins(0, 0, 0, 0)
+        self._icon_size = calculate_icon_size()
+        self.setIconSize(QSize(self._icon_size, self._icon_size))
+        self.setWindowFlags(self.windowFlags() | Qt.FramelessWindowHint)
+
+        # Track tool buttons for icon size updates
+        self._tool_buttons = []
+
+        # Expand/collapse state
+        self._expanded = False
+        self._collapsed_width = 85
+        self._expanded_width = 140
+        self._expand_btn = None
+
+    def addAction(self, action):
+        if isinstance(action, QWidgetAction):
+            return super(ToolBar, self).addAction(action)
+        btn = ToolButton(self._icon_size)
+        btn.setDefaultAction(action)
+        btn.setToolButtonStyle(self.toolButtonStyle())
+        self.addWidget(btn)
+        self._tool_buttons.append(btn)
+        return btn
+
+    def addWidget(self, widget):
+        """Override to track widgets that support icon sizing."""
+        super(ToolBar, self).addWidget(widget)
+        if isinstance(widget, (ToolButton, DropdownToolButton)):
+            if widget not in self._tool_buttons:
+                self._tool_buttons.append(widget)
+
+    def update_icon_size(self, size=None):
+        """Update icon size for toolbar and all buttons.
+
+        Args:
+            size: New icon size, or None to recalculate from DPI
+        """
+        if size is None:
+            size = calculate_icon_size()
+
+        self._icon_size = size
+        self.setIconSize(QSize(size, size))
+
+        # Update all tracked buttons
+        for btn in self._tool_buttons:
+            if hasattr(btn, 'update_icon_size'):
+                btn.update_icon_size(size)
+            else:
+                btn.setIconSize(QSize(size, size))
+
+    def showEvent(self, event):
+        """Recalculate icon size when toolbar becomes visible."""
+        super(ToolBar, self).showEvent(event)
+        # Recalculate in case screen/DPI changed
+        new_size = calculate_icon_size()
+        if new_size != self._icon_size:
+            self.update_icon_size(new_size)
+
+    def add_expand_button(self):
+        """Add expand/collapse toggle button at the bottom of toolbar."""
+        from libs.utils import new_icon
+
+        # Add spacer to push button to bottom
+        spacer = QWidget()
+        spacer.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Expanding)
+        self.addWidget(spacer)
+
+        # Add separator
+        self.addSeparator()
+
+        # Create expand button
+        self._expand_btn = QToolButton()
+        self._expand_btn.setIcon(new_icon('chevron-down'))
+        self._expand_btn.setToolTip("Expand toolbar")
+        self._expand_btn.setIconSize(QSize(16, 16))
+        self._expand_btn.clicked.connect(self.toggle_expanded)
+        self._expand_btn.setStyleSheet("""
+            QToolButton {
+                border: none;
+                background: transparent;
+                padding: 4px;
+            }
+            QToolButton:hover {
+                background: #e0e0e0;
+                border-radius: 4px;
+            }
+        """)
+        self.addWidget(self._expand_btn)
+
+        # Set initial width
+        self.setFixedWidth(self._collapsed_width)
+
+    def toggle_expanded(self):
+        """Toggle between expanded and collapsed state."""
+        from libs.utils import new_icon
+
+        self._expanded = not self._expanded
+
+        if self._expanded:
+            self._expand_btn.setIcon(new_icon('chevron-up'))
+            self._expand_btn.setToolTip("Collapse toolbar")
+            self.setFixedWidth(self._expanded_width)
+        else:
+            self._expand_btn.setIcon(new_icon('chevron-down'))
+            self._expand_btn.setToolTip("Expand toolbar")
+            self.setFixedWidth(self._collapsed_width)
+
+        self.expandedChanged.emit(self._expanded)
+
+    def set_expanded(self, expanded):
+        """Set the expanded state programmatically."""
+        if expanded != self._expanded:
+            self.toggle_expanded()
+
+    def is_expanded(self):
+        """Return current expanded state."""
+        return self._expanded
+
+
+class ToolButton(QToolButton):
+    """Custom toolbar button with DPI-aware sizing."""
+
+    def __init__(self, icon_size=None):
+        super(ToolButton, self).__init__()
+        self._icon_size = icon_size or calculate_icon_size()
+        self.setIconSize(QSize(self._icon_size, self._icon_size))
+        self.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Preferred)
+
+    def update_icon_size(self, size):
+        """Update the icon size."""
+        self._icon_size = size
+        self.setIconSize(QSize(size, size))
+        self.updateGeometry()
+
+    def sizeHint(self):
+        hint = super(ToolButton, self).sizeHint()
+        # Calculate width based on actual text
+        fm = self.fontMetrics()
+        text = self.text()
+        text_width = fm.horizontalAdvance(text) if hasattr(fm, 'horizontalAdvance') else fm.width(text)
+        # Add padding for icon and margins
+        width = max(hint.width(), text_width + 20, 70)
+        height = max(hint.height(), self._icon_size + 30)
+        return QSize(width, height)
+
+    def minimumSizeHint(self):
+        # Use actual text width for minimum
+        fm = self.fontMetrics()
+        text = self.text()
+        text_width = fm.horizontalAdvance(text) if hasattr(fm, 'horizontalAdvance') else fm.width(text)
+        return QSize(max(text_width + 16, 65), self._icon_size + 24)
+
+
+class DropdownToolButton(QToolButton):
+    """Toolbar button with dropdown menu and DPI-aware sizing."""
+
+    def __init__(self, text, icon=None, actions=None, icon_size=None):
+        super(DropdownToolButton, self).__init__()
+        self._icon_size = icon_size or calculate_icon_size()
+        self.setText(text)
+        if icon:
+            self.setIcon(icon)
+        self.setIconSize(QSize(self._icon_size, self._icon_size))
+        self.setPopupMode(QToolButton.InstantPopup)
+        self.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Preferred)
+
+        # Create menu for dropdown actions
+        self.dropdown_menu = QMenu(self)
+        if actions:
+            for action in actions:
+                if action is None:
+                    self.dropdown_menu.addSeparator()
+                else:
+                    self.dropdown_menu.addAction(action)
+        self.setMenu(self.dropdown_menu)
+
+    def add_action(self, action):
+        """Add an action to the dropdown menu."""
+        if action is None:
+            self.dropdown_menu.addSeparator()
+        else:
+            self.dropdown_menu.addAction(action)
+
+    def update_icon_size(self, size):
+        """Update the icon size."""
+        self._icon_size = size
+        self.setIconSize(QSize(size, size))
+        self.updateGeometry()
+
+    def sizeHint(self):
+        hint = super(DropdownToolButton, self).sizeHint()
+        # Calculate width based on actual text
+        fm = self.fontMetrics()
+        text = self.text()
+        text_width = fm.horizontalAdvance(text) if hasattr(fm, 'horizontalAdvance') else fm.width(text)
+        # Add padding for icon, dropdown arrow, and margins
+        width = max(hint.width(), text_width + 30, 70)
+        height = max(hint.height(), self._icon_size + 30)
+        return QSize(width, height)
+
+    def minimumSizeHint(self):
+        # Use actual text width for minimum
+        fm = self.fontMetrics()
+        text = self.text()
+        text_width = fm.horizontalAdvance(text) if hasattr(fm, 'horizontalAdvance') else fm.width(text)
+        return QSize(max(text_width + 24, 65), self._icon_size + 24)

libs/ustr.py

@@ -0,0 +1,17 @@
+import sys
+from libs.constants import DEFAULT_ENCODING
+
+def ustr(x):
+    """py2/py3 unicode helper"""
+
+    if sys.version_info < (3, 0, 0):
+        from PyQt4.QtCore import QString
+        if type(x) == str:
+            return x.decode(DEFAULT_ENCODING)
+        if type(x) == QString:
+            # https://blog.csdn.net/friendan/article/details/51088476
+            # https://blog.csdn.net/xxm524/article/details/74937308
+            return unicode(x.toUtf8(), DEFAULT_ENCODING, 'ignore')
+        return x
+    else:
+        return x