labelimgplusplus 2.0.0a0__py3-none-any.whl

libs/utils.py

@@ -0,0 +1,119 @@
+from math import sqrt
+from libs.ustr import ustr
+import hashlib
+import re
+import sys
+
+try:
+    from PyQt5.QtGui import *
+    from PyQt5.QtCore import *
+    from PyQt5.QtWidgets import *
+    QT5 = True
+except ImportError:
+    from PyQt4.QtGui import *
+    from PyQt4.QtCore import *
+    QT5 = False
+
+
+def new_icon(icon):
+    return QIcon(':/' + icon)
+
+
+def new_button(text, icon=None, slot=None):
+    b = QPushButton(text)
+    if icon is not None:
+        b.setIcon(new_icon(icon))
+    if slot is not None:
+        b.clicked.connect(slot)
+    return b
+
+
+def new_action(parent, text, slot=None, shortcut=None, icon=None,
+               tip=None, checkable=False, enabled=True):
+    """Create a new action and assign callbacks, shortcuts, etc."""
+    a = QAction(text, parent)
+    if icon is not None:
+        a.setIcon(new_icon(icon))
+    if shortcut is not None:
+        if isinstance(shortcut, (list, tuple)):
+            a.setShortcuts(shortcut)
+        else:
+            a.setShortcut(shortcut)
+    if tip is not None:
+        a.setToolTip(tip)
+        a.setStatusTip(tip)
+    if slot is not None:
+        a.triggered.connect(slot)
+    if checkable:
+        a.setCheckable(True)
+    a.setEnabled(enabled)
+    return a
+
+
+def add_actions(widget, actions):
+    for action in actions:
+        if action is None:
+            widget.addSeparator()
+        elif isinstance(action, QMenu):
+            widget.addMenu(action)
+        elif isinstance(action, QWidget):
+            widget.addWidget(action)
+        else:
+            widget.addAction(action)
+
+
+def label_validator():
+    return QRegExpValidator(QRegExp(r'^[^ \t].+'), None)
+
+
+class Struct(object):
+
+    def __init__(self, **kwargs):
+        self.__dict__.update(kwargs)
+
+
+def distance(p):
+    return sqrt(p.x() * p.x() + p.y() * p.y())
+
+
+def format_shortcut(text):
+    mod, key = text.split('+', 1)
+    return '<b>%s</b>+<b>%s</b>' % (mod, key)
+
+
+def generate_color_by_text(text):
+    s = ustr(text)
+    hash_code = int(hashlib.sha256(s.encode('utf-8')).hexdigest(), 16)
+    r = int((hash_code / 255) % 255)
+    g = int((hash_code / 65025) % 255)
+    b = int((hash_code / 16581375) % 255)
+    return QColor(r, g, b, 100)
+
+
+def have_qstring():
+    """p3/qt5 get rid of QString wrapper as py3 has native unicode str type"""
+    return not (sys.version_info.major >= 3 or QT_VERSION_STR.startswith('5.'))
+
+
+def util_qt_strlistclass():
+    return QStringList if have_qstring() else list
+
+
+def natural_sort(list, key=lambda s:s):
+    """
+    Sort the list into natural alphanumeric order.
+    """
+    def get_alphanum_key_func(key):
+        convert = lambda text: int(text) if text.isdigit() else text
+        return lambda s: [convert(c) for c in re.split('([0-9]+)', key(s))]
+    sort_key = get_alphanum_key_func(key)
+    list.sort(key=sort_key)
+
+
+# QT4 has a trimmed method, in QT5 this is called strip
+if QT5:
+    def trimmed(text):
+        return text.strip()
+else:
+    def trimmed(text):
+        return text.trimmed()

libs/yolo_io.py

@@ -0,0 +1,143 @@
+#!/usr/bin/env python
+# -*- coding: utf8 -*-
+import codecs
+import os
+
+from libs.constants import DEFAULT_ENCODING
+
+TXT_EXT = '.txt'
+ENCODE_METHOD = DEFAULT_ENCODING
+
+class YOLOWriter:
+
+    def __init__(self, folder_name, filename, img_size, 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
+
+    def add_bnd_box(self, x_min, y_min, x_max, y_max, name, difficult):
+        bnd_box = {'xmin': x_min, 'ymin': y_min, 'xmax': x_max, 'ymax': y_max}
+        bnd_box['name'] = name
+        bnd_box['difficult'] = difficult
+        self.box_list.append(bnd_box)
+
+    def bnd_box_to_yolo_line(self, box, class_list=[]):
+        x_min = box['xmin']
+        x_max = box['xmax']
+        y_min = box['ymin']
+        y_max = box['ymax']
+
+        x_center = float((x_min + x_max)) / 2 / self.img_size[1]
+        y_center = float((y_min + y_max)) / 2 / self.img_size[0]
+
+        w = float((x_max - x_min)) / self.img_size[1]
+        h = float((y_max - y_min)) / self.img_size[0]
+
+        # PR387
+        box_name = box['name']
+        if box_name not in class_list:
+            class_list.append(box_name)
+
+        class_index = class_list.index(box_name)
+
+        return class_index, x_center, y_center, w, h
+
+    def save(self, class_list=[], target_file=None):
+
+        out_file = None  # Update yolo .txt
+        out_class_file = None   # Update class list .txt
+
+        if target_file is None:
+            out_file = open(
+            self.filename + TXT_EXT, 'w', encoding=ENCODE_METHOD)
+            classes_file = os.path.join(os.path.dirname(os.path.abspath(self.filename)), "classes.txt")
+            out_class_file = open(classes_file, 'w')
+
+        else:
+            out_file = codecs.open(target_file, 'w', encoding=ENCODE_METHOD)
+            classes_file = os.path.join(os.path.dirname(os.path.abspath(target_file)), "classes.txt")
+            out_class_file = open(classes_file, 'w')
+
+
+        for box in self.box_list:
+            class_index, x_center, y_center, w, h = self.bnd_box_to_yolo_line(box, class_list)
+            # print (classIndex, x_center, y_center, w, h)
+            out_file.write("%d %.6f %.6f %.6f %.6f\n" % (class_index, x_center, y_center, w, h))
+
+        # print (classList)
+        # print (out_class_file)
+        for c in class_list:
+            out_class_file.write(c+'\n')
+
+        out_class_file.close()
+        out_file.close()
+
+
+
+class YoloReader:
+
+    def __init__(self, file_path, image, class_list_path=None):
+        # shapes type:
+        # [labbel, [(x1,y1), (x2,y2), (x3,y3), (x4,y4)], color, color, difficult]
+        self.shapes = []
+        self.file_path = file_path
+
+        if class_list_path is None:
+            dir_path = os.path.dirname(os.path.realpath(self.file_path))
+            self.class_list_path = os.path.join(dir_path, "classes.txt")
+        else:
+            self.class_list_path = class_list_path
+
+        # print (file_path, self.class_list_path)
+
+        classes_file = open(self.class_list_path, 'r')
+        self.classes = classes_file.read().strip('\n').split('\n')
+
+        # print (self.classes)
+
+        img_size = [image.height(), image.width(),
+                    1 if image.isGrayscale() else 3]
+
+        self.img_size = img_size
+
+        self.verified = False
+        # try:
+        self.parse_yolo_format()
+        # except:
+        #     pass
+
+    def get_shapes(self):
+        return self.shapes
+
+    def add_shape(self, label, x_min, y_min, x_max, y_max, difficult):
+
+        points = [(x_min, y_min), (x_max, y_min), (x_max, y_max), (x_min, y_max)]
+        self.shapes.append((label, points, None, None, difficult))
+
+    def yolo_line_to_shape(self, class_index, x_center, y_center, w, h):
+        label = self.classes[int(class_index)]
+
+        x_min = max(float(x_center) - float(w) / 2, 0)
+        x_max = min(float(x_center) + float(w) / 2, 1)
+        y_min = max(float(y_center) - float(h) / 2, 0)
+        y_max = min(float(y_center) + float(h) / 2, 1)
+
+        x_min = round(self.img_size[1] * x_min)
+        x_max = round(self.img_size[1] * x_max)
+        y_min = round(self.img_size[0] * y_min)
+        y_max = round(self.img_size[0] * y_max)
+
+        return label, x_min, y_min, x_max, y_max
+
+    def parse_yolo_format(self):
+        bnd_box_file = open(self.file_path, 'r')
+        for bndBox in bnd_box_file:
+            class_index, x_center, y_center, w, h = bndBox.strip().split(' ')
+            label, x_min, y_min, x_max, y_max = self.yolo_line_to_shape(class_index, x_center, y_center, w, h)
+
+            # Caveat: difficult flag is discarded when saved as yolo format.
+            self.add_shape(label, x_min, y_min, x_max, y_max, False)

libs/zoomWidget.py

@@ -0,0 +1,26 @@
+try:
+    from PyQt5.QtGui import *
+    from PyQt5.QtCore import *
+    from PyQt5.QtWidgets import *
+except ImportError:
+    from PyQt4.QtGui import *
+    from PyQt4.QtCore import *
+
+
+class ZoomWidget(QSpinBox):
+
+    def __init__(self, value=100):
+        super(ZoomWidget, self).__init__()
+        self.setButtonSymbols(QAbstractSpinBox.NoButtons)
+        self.setRange(1, 500)
+        self.setSuffix(' %')
+        self.setValue(value)
+        self.setToolTip(u'Zoom Level')
+        self.setStatusTip(self.toolTip())
+        self.setAlignment(Qt.AlignCenter)
+
+    def minimumSizeHint(self):
+        height = super(ZoomWidget, self).minimumSizeHint().height()
+        fm = QFontMetrics(self.font())
+        width = fm.width(str(self.maximum()))
+        return QSize(width, height)