labelimgplusplus 2.0.0a0__py3-none-any.whl

libs/labelFile.py

@@ -0,0 +1,174 @@
+# Copyright (c) 2016 Tzutalin
+# Create by TzuTaLin <tzu.ta.lin@gmail.com>
+
+try:
+    from PyQt5.QtGui import QImage
+except ImportError:
+    from PyQt4.QtGui import QImage
+
+import os.path
+from enum import Enum
+
+from libs.create_ml_io import CreateMLWriter
+from libs.pascal_voc_io import PascalVocWriter
+from libs.pascal_voc_io import XML_EXT
+from libs.yolo_io import YOLOWriter
+
+
+class LabelFileFormat(Enum):
+    PASCAL_VOC = 1
+    YOLO = 2
+    CREATE_ML = 3
+
+
+class LabelFileError(Exception):
+    pass
+
+
+class LabelFile(object):
+    # It might be changed as window creates. By default, using XML ext
+    # suffix = '.lif'
+    suffix = XML_EXT
+
+    def __init__(self, filename=None):
+        self.shapes = ()
+        self.image_path = None
+        self.image_data = None
+        self.verified = False
+
+    def save_create_ml_format(self, filename, shapes, image_path, image_data, class_list, line_color=None, fill_color=None, database_src=None):
+        img_folder_name = os.path.basename(os.path.dirname(image_path))
+        img_file_name = os.path.basename(image_path)
+
+        image = QImage()
+        image.load(image_path)
+        image_shape = [image.height(), image.width(),
+                       1 if image.isGrayscale() else 3]
+        writer = CreateMLWriter(img_folder_name, img_file_name,
+                                image_shape, shapes, filename, local_img_path=image_path)
+        writer.verified = self.verified
+        writer.write()
+        return
+
+
+    def save_pascal_voc_format(self, filename, shapes, image_path, image_data,
+                               line_color=None, fill_color=None, database_src=None):
+        img_folder_path = os.path.dirname(image_path)
+        img_folder_name = os.path.split(img_folder_path)[-1]
+        img_file_name = os.path.basename(image_path)
+        # imgFileNameWithoutExt = os.path.splitext(img_file_name)[0]
+        # Read from file path because self.imageData might be empty if saving to
+        # Pascal format
+        if isinstance(image_data, QImage):
+            image = image_data
+        else:
+            image = QImage()
+            image.load(image_path)
+        image_shape = [image.height(), image.width(),
+                       1 if image.isGrayscale() else 3]
+        writer = PascalVocWriter(img_folder_name, img_file_name,
+                                 image_shape, local_img_path=image_path)
+        writer.verified = self.verified
+
+        for shape in shapes:
+            points = shape['points']
+            label = shape['label']
+            # Add Chris
+            difficult = int(shape['difficult'])
+            bnd_box = LabelFile.convert_points_to_bnd_box(points)
+            writer.add_bnd_box(bnd_box[0], bnd_box[1], bnd_box[2], bnd_box[3], label, difficult)
+
+        writer.save(target_file=filename)
+        return
+
+    def save_yolo_format(self, filename, shapes, image_path, image_data, class_list,
+                         line_color=None, fill_color=None, database_src=None):
+        img_folder_path = os.path.dirname(image_path)
+        img_folder_name = os.path.split(img_folder_path)[-1]
+        img_file_name = os.path.basename(image_path)
+        # imgFileNameWithoutExt = os.path.splitext(img_file_name)[0]
+        # Read from file path because self.imageData might be empty if saving to
+        # Pascal format
+        if isinstance(image_data, QImage):
+            image = image_data
+        else:
+            image = QImage()
+            image.load(image_path)
+        image_shape = [image.height(), image.width(),
+                       1 if image.isGrayscale() else 3]
+        writer = YOLOWriter(img_folder_name, img_file_name,
+                            image_shape, local_img_path=image_path)
+        writer.verified = self.verified
+
+        for shape in shapes:
+            points = shape['points']
+            label = shape['label']
+            # Add Chris
+            difficult = int(shape['difficult'])
+            bnd_box = LabelFile.convert_points_to_bnd_box(points)
+            writer.add_bnd_box(bnd_box[0], bnd_box[1], bnd_box[2], bnd_box[3], label, difficult)
+
+        writer.save(target_file=filename, class_list=class_list)
+        return
+
+    def toggle_verify(self):
+        self.verified = not self.verified
+
+    ''' ttf is disable
+    def load(self, filename):
+        import json
+        with open(filename, 'rb') as f:
+                data = json.load(f)
+                imagePath = data['imagePath']
+                imageData = b64decode(data['imageData'])
+                lineColor = data['lineColor']
+                fillColor = data['fillColor']
+                shapes = ((s['label'], s['points'], s['line_color'], s['fill_color'])\
+                        for s in data['shapes'])
+                # Only replace data after everything is loaded.
+                self.shapes = shapes
+                self.imagePath = imagePath
+                self.imageData = imageData
+                self.lineColor = lineColor
+                self.fillColor = fillColor
+
+    def save(self, filename, shapes, imagePath, imageData, lineColor=None, fillColor=None):
+        import json
+        with open(filename, 'wb') as f:
+                json.dump(dict(
+                    shapes=shapes,
+                    lineColor=lineColor, fillColor=fillColor,
+                    imagePath=imagePath,
+                    imageData=b64encode(imageData)),
+                    f, ensure_ascii=True, indent=2)
+    '''
+
+    @staticmethod
+    def is_label_file(filename):
+        file_suffix = os.path.splitext(filename)[1].lower()
+        return file_suffix == LabelFile.suffix
+
+    @staticmethod
+    def convert_points_to_bnd_box(points):
+        x_min = float('inf')
+        y_min = float('inf')
+        x_max = float('-inf')
+        y_max = float('-inf')
+        for p in points:
+            x = p[0]
+            y = p[1]
+            x_min = min(x, x_min)
+            y_min = min(y, y_min)
+            x_max = max(x, x_max)
+            y_max = max(y, y_max)
+
+        # Martin Kersner, 2015/11/12
+        # 0-valued coordinates of BB caused an error while
+        # training faster-rcnn object detector.
+        if x_min < 1:
+            x_min = 1
+
+        if y_min < 1:
+            y_min = 1
+
+        return int(x_min), int(y_min), int(x_max), int(y_max)

libs/lightWidget.py

@@ -0,0 +1,33 @@
+try:
+    from PyQt5.QtGui import *
+    from PyQt5.QtCore import *
+    from PyQt5.QtWidgets import *
+except ImportError:
+    from PyQt4.QtGui import *
+    from PyQt4.QtCore import *
+
+
+class LightWidget(QSpinBox):
+
+    def __init__(self, title, value=50):
+        super(LightWidget, self).__init__()
+        self.setButtonSymbols(QAbstractSpinBox.NoButtons)
+        self.setRange(0, 100)
+        self.setSuffix(' %')
+        self.setValue(value)
+        self.setToolTip(title)
+        self.setStatusTip(self.toolTip())
+        self.setAlignment(Qt.AlignCenter)
+
+    def minimumSizeHint(self):
+        height = super(LightWidget, self).minimumSizeHint().height()
+        fm = QFontMetrics(self.font())
+        width = fm.width(str(self.maximum()))
+        return QSize(width, height)
+
+    def color(self):
+        if self.value() == 50:
+            return None
+
+        strength = int(self.value()/100 * 255 + 0.5)
+        return QColor(strength, strength, strength)

libs/pascal_voc_io.py

@@ -0,0 +1,171 @@
+#!/usr/bin/env python
+# -*- coding: utf8 -*-
+import sys
+from xml.etree import ElementTree
+from xml.etree.ElementTree import Element, SubElement
+from lxml import etree
+import codecs
+from libs.constants import DEFAULT_ENCODING
+from libs.ustr import ustr
+
+
+XML_EXT = '.xml'
+ENCODE_METHOD = DEFAULT_ENCODING
+
+class PascalVocWriter:
+
+    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 prettify(self, elem):
+        """
+            Return a pretty-printed XML string for the Element.
+        """
+        rough_string = ElementTree.tostring(elem, 'utf8')
+        root = etree.fromstring(rough_string)
+        return etree.tostring(root, pretty_print=True, encoding=ENCODE_METHOD).replace("  ".encode(), "\t".encode())
+        # minidom does not support UTF-8
+        # reparsed = minidom.parseString(rough_string)
+        # return reparsed.toprettyxml(indent="\t", encoding=ENCODE_METHOD)
+
+    def gen_xml(self):
+        """
+            Return XML root
+        """
+        # Check conditions
+        if self.filename is None or \
+                self.folder_name is None or \
+                self.img_size is None:
+            return None
+
+        top = Element('annotation')
+        if self.verified:
+            top.set('verified', 'yes')
+
+        folder = SubElement(top, 'folder')
+        folder.text = self.folder_name
+
+        filename = SubElement(top, 'filename')
+        filename.text = self.filename
+
+        if self.local_img_path is not None:
+            local_img_path = SubElement(top, 'path')
+            local_img_path.text = self.local_img_path
+
+        source = SubElement(top, 'source')
+        database = SubElement(source, 'database')
+        database.text = self.database_src
+
+        size_part = SubElement(top, 'size')
+        width = SubElement(size_part, 'width')
+        height = SubElement(size_part, 'height')
+        depth = SubElement(size_part, 'depth')
+        width.text = str(self.img_size[1])
+        height.text = str(self.img_size[0])
+        if len(self.img_size) == 3:
+            depth.text = str(self.img_size[2])
+        else:
+            depth.text = '1'
+
+        segmented = SubElement(top, 'segmented')
+        segmented.text = '0'
+        return top
+
+    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 append_objects(self, top):
+        for each_object in self.box_list:
+            object_item = SubElement(top, 'object')
+            name = SubElement(object_item, 'name')
+            name.text = ustr(each_object['name'])
+            pose = SubElement(object_item, 'pose')
+            pose.text = "Unspecified"
+            truncated = SubElement(object_item, 'truncated')
+            if int(float(each_object['ymax'])) == int(float(self.img_size[0])) or (int(float(each_object['ymin'])) == 1):
+                truncated.text = "1"  # max == height or min
+            elif (int(float(each_object['xmax'])) == int(float(self.img_size[1]))) or (int(float(each_object['xmin'])) == 1):
+                truncated.text = "1"  # max == width or min
+            else:
+                truncated.text = "0"
+            difficult = SubElement(object_item, 'difficult')
+            difficult.text = str(bool(each_object['difficult']) & 1)
+            bnd_box = SubElement(object_item, 'bndbox')
+            x_min = SubElement(bnd_box, 'xmin')
+            x_min.text = str(each_object['xmin'])
+            y_min = SubElement(bnd_box, 'ymin')
+            y_min.text = str(each_object['ymin'])
+            x_max = SubElement(bnd_box, 'xmax')
+            x_max.text = str(each_object['xmax'])
+            y_max = SubElement(bnd_box, 'ymax')
+            y_max.text = str(each_object['ymax'])
+
+    def save(self, target_file=None):
+        root = self.gen_xml()
+        self.append_objects(root)
+        out_file = None
+        if target_file is None:
+            out_file = codecs.open(
+                self.filename + XML_EXT, 'w', encoding=ENCODE_METHOD)
+        else:
+            out_file = codecs.open(target_file, 'w', encoding=ENCODE_METHOD)
+
+        prettify_result = self.prettify(root)
+        out_file.write(prettify_result.decode('utf8'))
+        out_file.close()
+
+
+class PascalVocReader:
+
+    def __init__(self, file_path):
+        # shapes type:
+        # [labbel, [(x1,y1), (x2,y2), (x3,y3), (x4,y4)], color, color, difficult]
+        self.shapes = []
+        self.file_path = file_path
+        self.verified = False
+        try:
+            self.parse_xml()
+        except:
+            pass
+
+    def get_shapes(self):
+        return self.shapes
+
+    def add_shape(self, label, bnd_box, difficult):
+        x_min = int(float(bnd_box.find('xmin').text))
+        y_min = int(float(bnd_box.find('ymin').text))
+        x_max = int(float(bnd_box.find('xmax').text))
+        y_max = int(float(bnd_box.find('ymax').text))
+        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 parse_xml(self):
+        assert self.file_path.endswith(XML_EXT), "Unsupported file format"
+        parser = etree.XMLParser(encoding=ENCODE_METHOD)
+        xml_tree = ElementTree.parse(self.file_path, parser=parser).getroot()
+        filename = xml_tree.find('filename').text
+        try:
+            verified = xml_tree.attrib['verified']
+            if verified == 'yes':
+                self.verified = True
+        except KeyError:
+            self.verified = False
+
+        for object_iter in xml_tree.findall('object'):
+            bnd_box = object_iter.find("bndbox")
+            label = object_iter.find('name').text
+            # Add chris
+            difficult = False
+            if object_iter.find('difficult') is not None:
+                difficult = bool(int(object_iter.find('difficult').text))
+            self.add_shape(label, bnd_box, difficult)
+        return True