Added Loading/Statistics/Preprocessing Scripts and Class Info Files

classes.json

@@ -0,0 +1,80 @@
+{
+    "__background__":   0,
+
+    "text":         1,
+    "junction":     2,
+    "crossover":    3,
+    "terminal":     4,
+    "gnd":          5,
+    "vss":          6,
+
+    "voltage.dc":       7,
+    "voltage.ac":       8,
+    "voltage.battery":  9,
+
+    "resistor":             10,
+    "resistor.adjustable":  11,
+    "resistor.photo":       12,
+
+    "capacitor.unpolarized":    13,
+    "capacitor.polarized":      14,
+    "capacitor.adjustable":     15,
+
+    "inductor":         16,
+    "inductor.ferrite": 17,
+    "inductor.coupled": 18,
+    "transformer":      19,
+
+    "diode":                20,
+    "diode.light_emitting": 21,
+    "diode.thyrector":      22,
+    "diode.zener":          23,
+
+    "diac":                 24,
+    "triac":                25,
+    "thyristor":            26,
+    "varistor":             27,
+
+    "transistor.bjt":   28,
+    "transistor.fet":   29,
+    "transistor.photo": 30,
+
+    "operational_amplifier":                    31,
+    "operational_amplifier.schmitt_trigger":    32,
+    "optocoupler":                              33,
+
+    "integrated_circuit":                   34,
+    "integrated_circuit.ne555":             35,
+    "integrated_circuit.voltage_regulator": 36,
+   
+    "xor":  37,
+    "and":  38,
+    "or":   39,
+    "not":  40,
+    "nand": 41,
+    "nor":  42,
+	
+    "probe":         43,
+    "probe.current": 44,
+    "probe.voltage": 45,
+
+    "switch":   46,
+    "relay":    47,
+
+    "socket":   48,
+    "fuse":     49,
+
+    "speaker":      50,
+    "motor":        51,
+    "lamp":         52,
+    "microphone":   53,
+    "antenna":      54,
+    "crystal":      55,
+    
+    "mechanical":   56,
+    "magnetic":     57,
+    "optical":      58,
+    "block":        59,
+
+    "unknown":  60
+}

classes_color.json

@@ -0,0 +1,73 @@
+{
+    "__background__":   [0,0,0],
+
+    "text":         [255,0,0],
+    "junction":     [0,255,0],
+    "crossover":    [0,0,255],
+    "terminal":     [255,255,0],
+    "gnd":          [0,255,255],
+    "vss":          [255,0,255],
+
+    "voltage.dc":       [192,192,192],
+    "voltage.ac":       [128,128,128],
+    "voltage.battery":  [128,0,0],
+
+    "resistor":             [128,128,0],
+    "resistor.adjustable":  [0,128,0],
+    "resistor.photo":       [128,0,128],
+
+    "capacitor.unpolarized":    [0,128,128],
+    "capacitor.polarized":      [0,0,128],
+    "capacitor.adjustable":     [200,200,200],
+
+    "inductor":             [165,42,42],
+    "inductor.ferrite":     [100,100,100],
+    "transformer":          [178,34,34],
+
+    "diode":                [255,127,80],
+    "diode.light_emitting": [240,128,128],
+    "diode.thyrector":      [233,150,122],
+    "diode.zener":          [255,160,122],
+
+    "diac":                 [255,140,0],
+    "triac":                [255,165,0],
+    "thyristor":            [184,134,11],
+    "varistor":             [154,205,50],
+
+    "transistor.bjt":   [124,252,0],
+    "transistor.fet":   [143,188,143],
+    "transistor.photo": [0,255,127],
+
+    "operational_amplifier":                    [46,139,87],
+    "operational_amplifier.schmitt_trigger":    [47,79,79],
+    "optocoupler":                              [176,224,230],
+
+    "integrated_circuit":                   [70,130,180],
+    "integrated_circuit.ne555":             [100,149,237],
+    "integrated_circuit.voltage_regulator": [0,191,255],
+   
+    "xor":  [30,144,255],
+    "and":  [135,206,235],
+    "or":   [25,25,112],
+    "not":  [138,43,226],
+    "nand": [75,0,130],
+    "nor":  [147,112,219],
+
+    "probe.current": [139,0,139],
+    "probe.voltage": [218,112,214],
+
+    "switch":   [219,112,147],
+    "relay":    [250,235,215],
+
+    "socket":   [210,105,30],
+    "fuse":     [244,164,96],
+
+    "speaker":      [188,143,143],
+    "motor":        [255,218,185],
+    "lamp":         [255,240,245],
+    "microphone":   [255,239,213],
+    "antenna":      [112,128,144],
+    "crystal":      [230,230,250],
+
+    "unknown":  [240,255,240]
+}

classes_discontinuous.json

@@ -0,0 +1,19 @@
+[
+ "capacitor.unpolarized",
+  "text",
+  "gnd",
+  "vss",
+  "voltage.battery",
+  "resistor.photo",
+  "capacitor.unpolarized",
+  "capacitor.polarized",
+  "capacitor.adjustable",
+  "inductor.ferrite",
+  "transformer",
+  "diode.light_emitting",
+  "thyristor",
+  "transistor.photo",
+  "switch",
+  "relay",
+  "crystal"
+]

classes_ports.json

@@ -0,0 +1,29 @@
+{
+  "text": [],
+  "voltage.dc": [{"name": "negative", "position": [0.5, 1]}, {"name": "positive", "position": [0.5, 0]}],
+  "voltage.ac": [{"name": "connector", "position": [0.5, 1]}, {"name": "connector", "position": [0.5, 0]}],
+  "voltage.battery": [{"name": "negative", "position": [0.5, 1]}, {"name": "positive", "position": [0.5, 0]}],
+
+  "resistor": [{"name": "connector", "position": [0, 0.5]}, {"name": "connector", "position": [1, 0.5]}],
+
+  "capacitor.unpolarized": [{"name": "connector", "position": [0, 0.5]}, {"name": "connector", "position": [1, 0.5]}],
+  "capacitor.polarized": [{"name": "negative", "position": [1, 0.5]}, {"name": "positive", "position": [0, 0.5]}],
+
+  "inductor": [{"name": "connector", "position": [0, 0.5]}, {"name": "connector", "position": [1, 0.5]}],
+
+  "diode":[{"name": "cathode", "position": [1, 0.5]}, {"name": "anode", "position": [0, 0.5]}],
+  "diode.light_emitting": [{"name": "cathode", "position": [1, 0.5]}, {"name": "anode", "position": [0, 0.5]}],
+  "diode.thyrector": [{"name": "cathode", "position": [1, 0.5]}, {"name": "anode", "position": [0, 0.5]}],
+  "diode.zener":[{"name": "cathode", "position": [1, 0.5]}, {"name": "anode", "position": [0, 0.5]}],
+
+  "transistor.bjt":[{"name": "base", "position": [0, 0.5]}, {"name": "collector", "position": [0.7, 1]}, {"name": "emitter", "position": [0.7, 0]}],
+  "transistor.fet":[{"name": "gate", "position": [0, 0.5]}, {"name": "source", "position": [0.5, 1]}, {"name": "drain", "position": [0.5, 0]}],
+  "transistor.photo":[{"name": "emitter", "position": [0.5, 1]}, {"name": "collector", "position": [0.5, 0]}],
+
+  "xor": [{"name": "output", "position": [1, 0.5]}, {"name": "input", "position": [0, 0.25]}, {"name": "input", "position": [0, 0.75]}],
+  "and": [{"name": "output", "position": [1, 0.5]}, {"name": "input", "position": [0, 0.25]}, {"name": "input", "position": [0, 0.75]}],
+  "or": [{"name": "output", "position": [1, 0.5]}, {"name": "input", "position": [0, 0.25]}, {"name": "input", "position": [0, 0.75]}],
+  "not": [{"name": "output", "position": [1, 0.5]}, {"name": "input", "position": [0, 0.5]}],
+  "nand": [{"name": "output", "position": [1, 0.5]}, {"name": "input", "position": [0, 0.25]}, {"name": "input", "position": [0, 0.75]}],
+  "nor": [{"name": "output", "position": [1, 0.5]}, {"name": "input", "position": [0, 0.25]}, {"name": "input", "position": [0, 0.75]}]
+}

consistency.py

@@ -0,0 +1,269 @@
+"""consistency.py: Integrity Check, Correction by Mapping for Annotation Class, Metadata Cleaning, Statistics"""
+
+# System Imports
+import os
+import sys
+import re
+
+# Project Imports
+from loader import load_classes, load_properties, read_dataset, write_dataset, file_name
+
+# Third-Party Imports
+import matplotlib.pyplot as plt
+import numpy as np
+
+__author__ = "Johannes Bayer, Shabi Haider"
+__copyright__ = "Copyright 2021-2023, DFKI"
+__license__ = "CC"
+__version__ = "0.0.2"
+__email__ = "johannes.bayer@dfki.de"
+__status__ = "Prototype"
+
+
+
+
+# Edit this lookup table for relabeling purposes
+MAPPING_LOOKUP = {
+    "integrated_cricuit": "integrated_circuit",
+    "zener": "diode.zener"
+}
+
+
+def consistency(db: list, classes: dict, recover: dict = {}) -> tuple:
+    """Checks Whether Annotation Classes are in provided Classes Dict and Attempts Recovery"""
+
+    total, ok, mapped, faulty, rotation, text = 0, 0, 0, 0, 0, 0
+
+    for sample in db:
+        for bbox in sample["bboxes"] + sample["polygons"] + sample["points"]:
+            total += 1
+
+            if bbox["class"] in classes:
+                ok += 1
+
+            if bbox["class"] in recover:
+                bbox["class"] = recover[bbox["class"]]
+                mapped += 1
+
+            if bbox["class"] not in classes and bbox["class"] not in recover:
+                print(f"Can't recover faulty label in {file_name(sample)}: {bbox['class']}")
+                faulty += 1
+
+            if bbox["rotation"] is not None:
+                rotation += 1
+
+            if bbox["class"] == "text" and bbox["text"] is None:
+                print(f"Missing Text in {file_name(sample)}  ->  {bbox['xmin']}, {bbox['ymin']}")
+
+            if bbox["text"] is not None:
+                if bbox["text"].strip() != bbox["text"]:
+                    print(f"Removing leading of trailing spaces from: {bbox['text']}")
+                    bbox["text"] = bbox["text"].strip()
+
+                if bbox["class"] != "text":
+                    print(f"Text string outside Text BB in {file_name(sample)}: {bbox['class']}: {bbox['text']}")
+
+                text += 1
+
+    return total, ok, mapped, faulty, rotation, text
+
+
+def consistency_circuit(db: list, classes: dict) -> None:
+    """Checks whether the Amount of Annotation per Class is Consistent Among the Samples of a Circuits"""
+
+    print("BBox Inconsistency Report:")
+    sample_cls_bb_count = {(sample["circuit"], sample["drawing"], sample["picture"]):
+                               {cls: len([bbox for bbox in sample["bboxes"] if bbox["class"] == cls])
+                                for cls in classes} for sample in db}
+
+    for circuit in set(sample["circuit"] for sample in db):
+        circuit_samples = [sample for sample in sample_cls_bb_count if sample[0] == circuit]
+        for cls in classes:
+            check = [sample_cls_bb_count[sample][cls] for sample in circuit_samples]
+            if not all(c == check[0] for c in check):
+                print(f"  Circuit {circuit}:  {cls}: {check}")
+
+
+def circuit_annotations(db: list, classes: dict) -> None:
+    """Plots the Annotations per Sample and Class"""
+
+    fig, axes = plt.subplots(nrows=1, ncols=1, figsize=(8, 6))
+    axes.plot([len(sample["bboxes"]) for sample in db], label="all")
+
+    for cls in classes:
+        axes.plot([len([annotation for annotation in sample["bboxes"]
+                        if annotation["class"] == cls]) for sample in db], label=cls)
+
+    plt.minorticks_on()
+    axes.set_xticks(np.arange(0, len(db)+1, step=8))
+    axes.set_xticks(np.arange(0, len(db), step=8)+4, minor=True)
+    axes.grid(axis='x', linestyle='solid')
+    axes.grid(axis='x', linestyle='dotted', alpha=0.7, which="minor")
+
+    plt.title("Class Distribution in Samples")
+    plt.xlabel("Image Sample")
+    plt.ylabel("BB Annotation Count")
+
+    plt.yscale('log')
+    plt.legend(ncol=2, loc='center left', bbox_to_anchor=(1.0, 0.5))
+    plt.show()
+
+
+def class_distribution(db: list, classes: dict) -> None:
+    """Plots the Class Distribution over the Dataset"""
+
+    class_nbrs = np.arange(len(classes))
+    class_counts = [sum([len([bbox for bbox in sample["bboxes"] + sample["polygons"] + sample["points"]
+                              if bbox["class"] == cls])
+                         for sample in db]) for cls in classes]
+
+    bars = plt.bar(class_nbrs, class_counts)
+    plt.xticks(class_nbrs, labels=classes, rotation=90)
+    plt.yscale('log')
+    plt.title("Class Distribution")
+    plt.xlabel("Class")
+    plt.ylabel("BB Annotation Count")
+
+    for rect in bars:
+        height = rect.get_height()
+        plt.annotate('{}'.format(height),
+                     xy=(rect.get_x() + rect.get_width() / 2, height),
+                     xytext=(0, -3), textcoords="offset points", ha='center', va='top', rotation=90)
+
+    plt.show()
+
+
+def class_sizes(db: list, classes: dict) -> None:
+    """"""
+
+    plt.title('BB Sizes')
+    plt.boxplot([[max(bbox["xmax"]-bbox["xmin"], bbox["ymax"]-bbox["ymin"])
+                  for sample in db for bbox in sample["bboxes"] if bbox["class"] == cls]
+                 for cls in classes])
+    class_nbrs = np.arange(len(classes))+1
+    plt.xticks(class_nbrs, labels=classes, rotation=90)
+    plt.show()
+
+
+def image_count(drafter: int = None, segmentation: bool = False) -> int:
+    """Counts the Raw Images or Segmentation Maps in the Dataset"""
+
+    return len([file_name for root, _, files in os.walk(".")
+                for file_name in files
+                if ("segmentation" if segmentation else "annotation") in root and
+                   (not drafter or f"drafter_{drafter}{os.sep}" in root)])
+
+
+def read_check_write(classes: dict, drafter: int = None, segmentation: bool = False):
+    """Reads Annotations, Checks Consistency with Provided Classes
+     Writes Corrected Annotations Back and Returns the Annotations"""
+
+    db = read_dataset(drafter=drafter, segmentation=segmentation)
+    ann_total, ann_ok, ann_mapped, ann_faulty, ann_rot, ann_text = consistency(db, classes)
+    write_dataset(db, segmentation=segmentation)
+
+    print("")
+    print("   Class and File Consistency Report")
+    print(" -------------------------------------")
+    print(f"Annotation Type: {'Polygon' if segmentation else 'Bounding Box'}")
+    print(f"Class Label Count: {len(classes)}")
+    print(f"Raw Image Files:            {image_count(drafter=drafter, segmentation=segmentation)}")
+    print(f"Processed Annotation Files: {len(db)}")
+    print(f"Total Annotation Count: {ann_total}")
+    print(f"Consistent Annotations: {ann_ok}")
+    print(f"Faulty Annotations (no recovery): {ann_faulty}")
+    print(f"Corrected Annotations by Mapping: {ann_mapped}")
+    print(f"Annotations with Rotation: {ann_rot}")
+    print(f"Annotations with Text: {ann_text}")
+
+    return db
+
+
+def text_statistics(db: list, plot_unique_labels: bool = False):
+    """Generates and Plots Statistics on Text Classes"""
+    
+    print("")
+    print("   Text Statistics")
+    print("---------------------")
+
+    text_bbs = len([bbox for sample in db for bbox in sample["bboxes"] if bbox["class"] == "text"])
+    print(f"Text BB Annotations:      {text_bbs}")
+
+    text_labels = [bbox["text"] for sample in db for bbox in sample["bboxes"] if bbox["text"] is not None]
+    print(f"Overall Text Label Count: {len(text_labels)}")
+
+    text_labels_unique = set(text_labels)
+    print(f"Unique Text Label Count:  {len(text_labels_unique)}")
+
+    print(f"Total Character Count:    {sum([len(text_label) for text_label in text_labels])}")
+
+    print("\nSet of all characters occurring in all text labels:")
+    char_set = set([char_set for label in text_labels_unique for char_set in label])
+    chars = sorted(list(char_set))
+    print(chars)
+
+    char_nbrs = np.arange(len(chars))
+    char_counts = [sum([len([None for text_char in text_label if text_char == char])
+                        for text_label in text_labels])
+                   for char in chars]
+    plt.bar(char_nbrs, char_counts)
+    plt.xticks(char_nbrs, chars)
+    plt.title("Character Frequencies")
+    plt.xlabel("Character")
+    plt.ylabel("Overall Count")
+    plt.show()
+    print("\nCharacter Frequencies:")
+    print({char: 1/char_count for char, char_count in zip(chars, char_counts)})
+
+    max_text_len = max([len(text_label) for text_label in text_labels])
+    text_lengths = np.arange(max_text_len)+1
+    text_count_by_length = [len([None for text_label in text_labels if len(text_label) == text_length])
+                            for text_length in text_lengths]
+    plt.bar(text_lengths, text_count_by_length)
+    plt.xticks(text_lengths, rotation=90)
+    plt.title("Text Length Distribution")
+    plt.xlabel("Character Count")
+    plt.ylabel("Annotation Count")
+    plt.show()
+
+    text_instances = text_labels_unique if plot_unique_labels else text_labels
+    text_classes_names = []
+    text_classes_instances = []
+
+    for text_class in load_properties():
+        text_classes_names.append(text_class["name"])
+        text_classes_instances.append([text_instance for text_instance in text_instances
+                                       if re.match(text_class["regex"], text_instance)])
+
+    text_classified = [text for text_class_instances in text_classes_instances for text in text_class_instances]
+    text_classes_names.append("Unclassified")
+    text_classes_instances.append([text_instance for text_instance in text_instances
+                                   if text_instance not in text_classified])
+
+    for text_class_name, text_class_instances in zip(text_classes_names, text_classes_instances):
+        print(f"\n{text_class_name}:")
+        print(sorted(list(set(text_class_instances))))
+
+    plt.bar(text_classes_names, [len(text_class_instances) for text_class_instances in text_classes_instances])
+    plt.title('Count of matching pattern')
+    plt.xlabel('Regex')
+    plt.ylabel('No. of text matched')
+    plt.xticks(rotation=90)
+    plt.tight_layout()
+    plt.show()
+
+
+
+if __name__ == "__main__":
+    drafter_selected = int(sys.argv[1]) if len(sys.argv) == 2 else None
+    classes = load_classes()
+
+    #db_poly = read_check_write(classes, drafter_selected, segmentation=True)
+    db_bb = read_check_write(classes, drafter_selected)
+
+    class_sizes(db_bb, classes)
+    circuit_annotations(db_bb, classes)
+    class_distribution(db_bb, classes)
+    #class_distribution(db_poly, classes)
+    consistency_circuit(db_bb, classes)
+    text_statistics(db_bb)

loader.py

@@ -0,0 +1,227 @@
+"""loader.py: Load and Store Functions for the Dataset"""
+
+# System Imports
+import os, sys
+from os.path import join, realpath
+import json
+import xml.etree.ElementTree as ET
+from lxml import etree
+
+# Third Party Imports
+import cv2
+
+__author__ = "Johannes Bayer"
+__copyright__ = "Copyright 2022-2023, DFKI"
+__license__ = "CC"
+__version__ = "0.0.1"
+__email__ = "johannes.bayer@dfki.de"
+__status__ = "Prototype"
+
+
+
+def load_classes() -> dict:
+    """Returns the List of Classes as Encoding Map"""
+
+    with open("classes.json") as classes_file:
+        return json.loads(classes_file.read())
+
+
+def load_classes_ports() -> dict:
+    """Reads Symbol Library from File"""
+
+    with open("classes_ports.json") as json_file:
+        return json.loads(json_file.read())
+
+
+def load_properties() -> dict:
+    """Loads the Properties RegEx File"""
+
+    with open("properties.json") as json_file:
+        return json.loads(json_file.read())
+
+
+def _sample_info_from_path(path: str) -> tuple:
+    """Extracts Sample Metadata from File Path"""
+
+    drafter, _, file_name = os.path.normpath(path).split(os.sep)[-3:]
+    circuit, drawing, picture = file_name.split("_")
+    picture, suffix = picture.split(".")
+    return drafter.split("_")[1], int(circuit[1:]), int(drawing[1:]), int(picture[1:]), suffix
+
+
+def file_name(sample: dict) -> str:
+    """return the Raw Image File Name of a Sample"""
+
+    return f"C{sample['circuit']}_D{sample['drawing']}_P{sample['picture']}.{sample['format']}"
+
+
+def read_pascal_voc(path: str) -> dict:
+    """Reads the Content of a Pascal VOC Annotation File"""
+
+    root = ET.parse(path).getroot()
+    circuit, drawing, picture = root.find("filename").text.split("_")
+    drafter = int(os.path.normpath(path).split(os.sep)[-3].split("_")[1])
+
+    return {"drafter": drafter,
+            "circuit": int(circuit[1:]),
+            "drawing": int(drawing[1:]),
+            "picture": int(picture.split(".")[0][1:]),
+            "format": picture.split(".")[-1],
+            "width": int(root.find("size/width").text),
+            "height": int(int(root.find("size/height").text)),
+            "bboxes": [{"class": annotation.find("name").text,
+                        "xmin": int(annotation.find("bndbox/xmin").text),
+                        "xmax": int(annotation.find("bndbox/xmax").text),
+                        "ymin": int(annotation.find("bndbox/ymin").text),
+                        "ymax": int(annotation.find("bndbox/ymax").text),
+                        "rotation": int(annotation.find("bndbox/rotation").text) if annotation.find("bndbox/rotation") is not None else None,
+                        "text": annotation.find("text").text if annotation.find("text") is not None else None}
+                       for annotation in root.findall('object')],
+            "polygons": [], "points": []}
+
+
+def write_pascal_voc(sample: dict) -> None:
+    """Writes a Sample's Content to an Pascal VOC Annotation File"""
+
+    root = etree.Element("annotation")
+    etree.SubElement(root, "folder").text = "images"
+    etree.SubElement(root, "filename").text = file_name(sample)
+    etree.SubElement(root, "path").text = join(".", f"drafter_{sample['drafter']}", "images", file_name(sample))
+    src = etree.SubElement(root, "source")
+    etree.SubElement(src, "database").text = "CGHD"
+    size = etree.SubElement(root, "size")
+    etree.SubElement(size, "width").text = str(sample["width"])
+    etree.SubElement(size, "height").text = str(sample["height"])
+    etree.SubElement(size, "depth").text = "3"
+    etree.SubElement(root, "segmented").text = "0"
+
+    for bbox in sample["bboxes"]:
+        xml_obj = etree.SubElement(root, "object")
+        etree.SubElement(xml_obj, "name").text = bbox["class"]
+        etree.SubElement(xml_obj, "pose").text = "Unspecified"
+        etree.SubElement(xml_obj, "truncated").text = "0"
+        etree.SubElement(xml_obj, "difficult").text = "0"
+        xml_bbox = etree.SubElement(xml_obj, "bndbox")
+
+        for elem in ["xmin", "ymin", "xmax", "ymax"]:
+            etree.SubElement(xml_bbox, elem).text = str(bbox[elem])
+
+        if bbox["rotation"] is not None:
+            etree.SubElement(xml_bbox, "rotation").text = str(bbox["rotation"])
+
+        if bbox["text"]:
+            etree.SubElement(xml_obj, "text").text = bbox["text"]
+
+    etree.indent(root, space="\t")
+    etree.ElementTree(root).write(join(".", f"drafter_{sample['drafter']}", "annotations",
+                                       f"C{sample['circuit']}_D{sample['drawing']}_P{sample['picture']}.xml"),
+                                  pretty_print=True)
+
+
+def read_labelme(path: str) -> dict:
+    """Reads and Returns Geometric Objects from a LabelME JSON File"""
+
+    with open(path) as json_file:
+        json_data = json.load(json_file)
+
+    drafter, circuit, drawing, picture, _ = _sample_info_from_path(path)
+    suffix = json_data['imagePath'].split(".")[-1]
+
+    return {'img_path': json_data['imagePath'], 'drafter': drafter, 'circuit': circuit,
+            'drawing': drawing, 'picture': picture, 'format': suffix,
+            'height': json_data['imageHeight'], 'width': json_data['imageWidth'], 'bboxes': [],
+            'polygons': [{'class': shape['label'], 'points': shape['points'],
+                          'rotation': shape.get('rotation', None),
+                          'text': shape.get('text', None),
+                          'group': shape.get('group_id', None)}
+                         for shape in json_data['shapes']
+                         if shape['shape_type'] == "polygon"],
+            'points': [{'class': shape['label'], 'points': shape['points'][0],
+                        'group': shape['group_id'] if 'group_id' in shape else None}
+                       for shape in json_data['shapes']
+                       if shape['shape_type'] == "point"]}
+
+
+def write_labelme(geo_data: dict, path: str = None) -> None:
+    """Writes Geometric Objects to a LabelMe JSON File"""
+
+    if not path:
+        path = join(f"drafter_{geo_data['drafter']}", "instances",
+                    f"C{geo_data['circuit']}_D{geo_data['drawing']}_P{geo_data['picture']}.json")
+
+    with open(path, 'w') as json_file:
+        json.dump({'version': '3.16.7', 'flags': {}, 'lineColor': [0, 255, 0, 128], 'fillColor': [255, 0, 0, 128],
+                   'imagePath': geo_data['img_path'], 'imageData': None,
+                   'imageHeight': geo_data['height'], 'imageWidth': geo_data['width'],
+                   'shapes': [{'label': polygon['class'], 'line_color': None, 'fill_color': None,
+                               'points': polygon['points'],
+                               **({'group_id': polygon['group']} if polygon['group'] is not None else {}),
+                               **({'rotation': polygon['rotation']} if polygon.get('rotation', None) else {}),
+                               **({'text': polygon['text']} if polygon.get('text', None) else {}),
+                               'shape_type': 'polygon', 'flags': {}}
+                              for polygon in geo_data['polygons']] +
+                             [{'label': point['class'], 'points': [[point['points'][0], point['points'][1]]],
+                               'group_id': point['group'], 'shape_type': 'point', 'flags': {}}
+                              for point in geo_data['points']]},
+                  json_file, indent=2)
+
+
+def read_dataset(drafter: int = None, circuit: int = None, segmentation=False, folder: str = None) -> list:
+    """Reads all BB Annotation Files from Folder Structure
+    This Method can be invoked from Anywhere, can be restricted to a specified drafter
+    and can be use for both BB and Polygon Annotations. Alternative annotation sub-folder
+    can be specified to read processed ground truth."""
+
+    db_root = os.sep.join(realpath(__file__).split(os.sep)[:-1])
+
+    return sorted([(read_labelme if segmentation else read_pascal_voc)(join(root, file_name))
+                   for root, _, files in os.walk(db_root)
+                   for file_name in files
+                   if (folder if folder else ("instances" if segmentation else "annotations")) in root and
+                      (not circuit or f"C{circuit}_" in file_name) and
+                      (not drafter or f"drafter_{drafter}{os.sep}" in root)],
+                  key=lambda sample: sample["circuit"]*100+sample["drawing"]*10+sample["picture"])
+
+
+def write_dataset(db: list, segmentation=False) -> None:
+    """Writes a Dataset"""
+
+    for sample in db:
+        (write_labelme if segmentation else write_pascal_voc)(sample)
+
+
+def read_images(**kwargs) -> list:
+    """Loads Images and BB Annotations and returns them as as List of Pairs"""
+    
+    db_root = os.sep.join(realpath(__file__).split(os.sep)[:-1])
+
+    return [(cv2.imread(join(db_root, f"drafter_{sample['drafter']}", "images", file_name(sample))), sample)
+            for sample in read_dataset(**kwargs)]
+
+
+def read_snippets(**kwargs):
+    """Loads Image Snippets and BBoxes and returns them as List of Pairs"""
+
+    snippets = []
+
+    for img, annotations in read_images(**kwargs):
+        for bbox in annotations['bboxes']:
+            snippets += [(img[bbox['ymin']:bbox['ymax'], bbox['xmin']:bbox['xmax']], bbox)]
+
+    return snippets
+
+
+if __name__ == "__main__":
+    """Sample Loader Usage, Dumps All Text Snippets of (Selectable or All) Drafter to Test Folder"""
+
+    os.mkdir("test")
+    args = {'drafter': int(sys.argv[1])} if len(sys.argv) == 2 else {}
+
+    for nbr, (snippet, bbox) in enumerate(read_snippets(**args)):
+        if bbox['class'] == "text" and bbox.get("text", ""):
+            if bbox['rotation'] == 90:
+                snippet = cv2.rotate(snippet, cv2.ROTATE_90_CLOCKWISE)
+            if bbox['rotation'] == 270:
+                snippet = cv2.rotate(snippet, cv2.ROTATE_90_COUNTERCLOCKWISE)
+
+            cv2.imwrite(join("test", f"{bbox['text']}.{nbr}.png"), snippet)

properties.json

@@ -0,0 +1,126 @@
+[
+  {
+    "name": "Resistor Name",
+    "regex": "^R[0-9]+[Ω]$"
+  },
+  {
+    "name": "Resistance",
+    "regex": "[0-9]*([,.][0-9]+)?(\\s*Ω|\\s*kΩ|\\s*KΩ|ohms|\\s*M|K|R|k|\\s*meg|Ohms|(\\s*ohm|\\s*Ohm|m|M))+?[0-9]*"
+  },
+  {
+    "name": "Capacitor Name",
+    "regex": "^C[0-9]+(F|µF)$"
+  },
+  {
+    "name": "Capacity",
+    "regex":"[0-9]*([,.][0-9]+)?[KunµpPfFm][a-zA-Z]?[0-9]*"
+  },
+  {
+    "name": "Inductivity Name",
+    "regex": "^(nH|µH|mH|mh)$"
+  },
+  {
+    "name": "Inductivity",
+    "regex": "^[0-9]+(?:[,.][0-9]+)?(nH|µH|mH|mh)$"
+  },
+  {
+    "name": "Frequency Name",
+    "regex": "(?:m|MHz|k|K|G|hz|KHz|Hz)$"
+  },
+  {
+    "name": "Frequency",
+    "regex": "[0-9]+(?:[,.][0-9]+)?(?:m|MHz|k|K|G|hz|Hz|HZ)$"
+  },
+  {
+    "name": "Wattage Name",
+    "regex": "^(?:KW|W|Watt|Watts)$"
+  },
+  {
+    "name": "Wattage",
+    "regex": "^[0-9]+(?:[\\/,.][0-9]+)?(?:w|KW|\\s*W|watt|\\s*Watt|Watts|\\s*WATTS)$"
+  },
+  {
+    "name": "Current Name",
+    "regex": "(A|mA|MA|UA)$"
+  },
+  {
+    "name": "Current",
+    "regex": "^[0-9]+(?:[,.][0-9]+)?(A|µA|mA|VA|MA)$"
+  },
+  {
+    "name": "Voltage Name",
+    "regex": "(v|V|VCD|V\\s*AC|AC|DC|VCC|VDD)$"
+  },
+  {
+    "name": "Voltage",
+    "regex": "^[-|+|...|0-9]+(?:[,.][0-9]+)?(?:V|v|\\s*V|\\s*volt|uV|uv|VOLT|Volt|kV|Volts|nV|nv|KV|VDC|V\\s*AC|[\\dVv]*[,\\dA-Z]*[A-Z\\s*]*-[\\s*\\d]*[,\\dA-Z]*)$"
+  },
+  {
+    "name": "AC Name",
+    "regex": "^(?:V|VDC|VAC|ac|AC)$"
+  },
+  {
+    "name": "AC",
+    "regex": "^[0-9]+(?:[,.][0-9]+)?(?:V|AC|VDC|\\s*V\\s*AC)$"
+  },
+  {
+    "name": "DC Name",
+    "regex": "^(?:V|VDC|VAC|DC|Dc)$"
+  },
+  {
+    "name": "DC",
+    "regex": "^[-|+|0-9]+(?:[,.][0-9]+)?(?:V|\\s*VDC|vdc|VAC)$"
+  },
+  {
+    "name": "Component Name",
+    "regex": "[0-9\\(]*[\\s*a-zA-Z]+[\\)]*"
+  },
+  {
+    "name": "Name",
+    "class": "resistor",
+    "regex": "^R[0-9]+$"
+  },
+  {
+    "name": "Name",
+    "regex": "^VR[0-9]+$"
+  },
+  {
+    "name": "Name",
+    "regex": "^C[0-9]+$"
+  },
+  {
+    "name": "Name",
+    "regex": "^Q[0-9]+$"
+  },
+  {
+    "name": "Name",
+    "regex": "^D[0-9]+$"
+  },
+  {
+    "name": "Name",
+    "regex": "^L[0-9]+$"
+  },
+  {
+    "name": "Name",
+    "regex": "^(SW|Sw)[0-9]+$"
+  },
+  {
+    "name": "voltage-type",
+    "regex": "(VCC|VDD)$"
+  },
+  {
+    "name": "Device",
+    "class": "transistor.bjt",
+    "regex": "^[0-9]?[A-Z]+[0-9]+$"
+  },
+  {
+    "name": "Taper",
+    "class": "resistor.adjustable",
+    "regex": "(log|lin)$"
+  },
+  {
+    "name": "Pin",
+    "regex": "^[0-9]{1,2}$"
+  }
+
+]

segmentation.py

@@ -0,0 +1,348 @@
+"""segmentation.py: Toolkit for Generation of Instance Segmentation Material"""
+
+# System Imports
+import sys
+import os
+from os.path import join, exists
+import json
+from math import dist
+
+# Project Imports
+from loader import read_pascal_voc, read_labelme, write_labelme, load_classes_ports
+from utils import transform, associated_keypoints
+
+# Third-Party Imports
+import cv2
+import numpy as np
+
+__author__ = "Amit Kumar Roy"
+__copyright__ = "Copyright 2022-2023, DFKI"
+__credits__ = ["Amit Kumar Roy", "Johannes Bayer"]
+__license__ = "CC"
+__version__ = "0.0.1"
+__email__ = "johannes.bayer@dfki.de"
+__status__ = "Prototype"
+
+
+
+def binary_to_multi_seg_map(drafter: str, sample: str, suffix: str, source_folder: str, target_folder: str,
+                            color_map: dict) -> None:
+    """Creates a Multi Class Segmentation File from a Binary Segmentation File and an Coarse Instance Polygon File"""
+
+    bin_seg_map = cv2.imread(join(drafter, "segmentation", f"{sample}.{suffix}"))
+    bin_seg_map[np.all(bin_seg_map <= (10, 10, 10), axis=-1)] = (0, 0, 0)
+    shape_mask = np.ones(bin_seg_map.shape, dtype=np.uint8)*255
+    geo_data = read_labelme(join(drafter, source_folder, f"{sample}.json"))
+
+    for shape in sorted(geo_data["polygons"],
+                        key=lambda shape: -(max([p[0] for p in shape['points']])-min([p[0] for p in shape['points']])) *
+                                           (max([p[1] for p in shape['points']])-min([p[1] for p in shape['points']]))):
+        cv2.fillPoly(shape_mask,
+                     pts=[np.array(shape["points"], dtype=np.int32)],
+                     color=color_map[shape["class"]])
+
+    multi_seg_map = cv2.bitwise_and(cv2.bitwise_not(bin_seg_map), shape_mask)
+
+    for point in geo_data['points']:
+        if point['class'] == "connector":
+            x, y = point['points']
+            cv2.line(multi_seg_map, (int(x-20), int(y-20)), (int(x+20), int(y+20)), (255, 255, 255), 2)
+            cv2.line(multi_seg_map, (int(x-20), int(y+20)), (int(x+20), int(y-20)), (255, 255, 255), 2)
+
+    cv2.imwrite(join(drafter, target_folder, f"{sample}.png"), multi_seg_map)
+
+
+def generate_keypoints(drafter: str, sample: str, suffix: str, source_folder: str, target_folder: str,
+                       keep_polygons: bool = True, margin=3) -> None:
+    """Generates Connector Keypoints, optionally discarding existing polygons"""
+
+    bin_seg_map = cv2.imread(join(drafter, "segmentation", f"{sample}.{suffix}"), cv2.IMREAD_GRAYSCALE)
+    _, bin_seg_map = cv2.threshold(bin_seg_map, 127, 255, cv2.THRESH_BINARY_INV)
+    geo_data = read_labelme(join(drafter, source_folder, f"{sample}.json"))
+    detector_params = cv2.SimpleBlobDetector_Params()
+    detector_params.minArea = 3
+    detector_params.minDistBetweenBlobs = 3
+    detector_params.minThreshold = 10
+    detector_params.maxThreshold = 255
+    detector_params.blobColor = 255
+    detector_params.filterByArea = False
+    detector_params.filterByCircularity = False
+    detector_params.filterByConvexity = False
+    detector_params.filterByInertia = False
+    detector = cv2.SimpleBlobDetector_create(detector_params)
+    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (5, 5))
+
+    for nbr, shape in enumerate(geo_data["polygons"]):
+        if shape['class'] == "text":
+            cv2.fillPoly(bin_seg_map, pts=[np.array(shape["points"], dtype=np.int32)], color=[0, 0, 0])
+
+    for nbr, shape in enumerate(geo_data["polygons"]):
+        shape['group'] = nbr
+
+        if shape['class'] != "text" and shape['class'] != "wire":
+            x_min = max(int(min([p[0] for p in shape['points']]))-margin, 0)
+            x_max = min(int(max([p[0] for p in shape['points']]))+margin, bin_seg_map.shape[1])
+            y_min = max(int(min([p[1] for p in shape['points']]))-margin, 0)
+            y_max = min(int(max([p[1] for p in shape['points']]))+margin, bin_seg_map.shape[0])
+            cropout = bin_seg_map[y_min:y_max, x_min:x_max]
+            shape_mask = np.zeros((y_max-y_min, x_max-x_min), dtype=np.uint8)
+            cv2.polylines(shape_mask, pts=[np.array(shape["points"]-np.array([[x_min, y_min]]), dtype=np.int32)],
+                          isClosed=True, color=[255, 255, 255], thickness=2)
+            intersect_map = cv2.bitwise_and(cropout, shape_mask)
+            keypoints = detector.detect(intersect_map)
+            geo_data['points'] += [{'class': "connector", 'points': (keypoint.pt[0]+x_min, keypoint.pt[1]+y_min),
+                                    'group': nbr} for keypoint in keypoints]
+
+    for shape in geo_data["polygons"]:
+        if shape['class'] == "wire":
+            wire_connectors = [point["points"] for point in geo_data['points']
+                               if cv2.pointPolygonTest(np.array(shape["points"]), np.array(point['points']), True) > -4]
+
+            if len(wire_connectors) != 2:
+                print(f"    Anomaly Wire Connector Count: {len(wire_connectors)} -> {shape['points'][0]}")
+
+            geo_data['points'] += [{'class': "connector", 'points': (point[0], point[1]),
+                                    'group': shape['group']} for point in wire_connectors]
+
+    geo_data['polygons'] = geo_data['polygons'] if keep_polygons else []
+    write_labelme(geo_data, join(drafter, target_folder, f"{sample}.json"))
+
+
+def generate_wires(drafter: str, sample: str, suffix: str, source_folder: str, target_folder: str) -> None:
+    """Generates wire polygons"""
+
+    geo_data = read_labelme(join(drafter, source_folder, f"{sample}.json"))
+    bin_seg_map = cv2.imread(join(drafter, "segmentation", f"{sample}.{suffix}"), cv2.IMREAD_GRAYSCALE)
+    _, bin_seg_map = cv2.threshold(bin_seg_map, 127, 255, cv2.THRESH_BINARY_INV)
+
+    for nbr, shape in enumerate(geo_data["polygons"]):
+        cv2.fillPoly(bin_seg_map, pts=[np.array(shape["points"], dtype=np.int32)], color=[0, 0, 0])
+
+    cntrs = cv2.findContours(bin_seg_map, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    contours = cntrs[0] if len(cntrs) == 2 else cntrs[1]
+
+    for contour in contours:
+        if len(contour) > 3:
+            geo_data['polygons'] += [{'class': "wire", 'points': np.squeeze(contour).tolist(), 'group': None}]
+
+    write_labelme(geo_data, join(drafter, target_folder, f"{sample}.json"))
+
+
+def pascalvoc_to_labelme(drafter: str, sample: str, suffix: str, source_folder: str, target_folder: str,
+                         keep_existing_json: bool = True) -> None:
+    """Converts a Bounding Box (Rectangle) Annotation File to an Instance Mask (Polygon) File
+
+    Has no Effect in its default Configuration on a
+    consistently populated Dataset."""
+
+    if keep_existing_json and exists(join(drafter, target_folder, f"{sample}.json")):
+        print("  -> SKIP (already exists)")
+        return None
+
+    xml_data = read_pascal_voc(join(drafter, source_folder, f"{sample}.xml"))
+    xml_data['points'] = []                                                   # Adapt to Segmentation Scenario
+    xml_data['img_path'] = join("..", "segmentation", f"{sample}.{suffix}")   # Alter source image
+    xml_data['polygons'] = [{'class': bbox['class'], 'group': None,           # Keep Class, Prune Rotation and Texts
+                             'points': [[bbox['xmin'], bbox['ymin']],         # Turn Rectangles into Polygons
+                                        [bbox['xmax'], bbox['ymin']],
+                                        [bbox['xmax'], bbox['ymax']],
+                                        [bbox['xmin'], bbox['ymax']]]}
+                            for bbox in xml_data['bboxes']]
+    write_labelme(xml_data, join(drafter, target_folder, f"{sample}.json"))
+
+
+def labelme_raw_image(drafter: str, sample: str, suffix: str, source_folder: str, target_folder: str) -> None:
+    """Resets the Source Images of a LabelME file to the Rwa Image"""
+
+    geo_data = read_labelme(join(drafter, source_folder, f"{sample}.json"))
+    geo_data['img_path'] = join("..", "images", f"{sample}.{suffix}")
+    write_labelme(geo_data, join(drafter, target_folder, f"{sample}.json"))
+
+
+def convex_hull(thresh_img: np.ndarray, polygon: np.ndarray) -> list:
+    """Calculates the Convex Hull of a Binary Image, falling back to Polygon"""
+
+    cntrs = cv2.findContours(thresh_img, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    cntrs = cntrs[0] if len(cntrs) == 2 else cntrs[1]
+    good_contours = [contour for contour in cntrs if cv2.contourArea(contour) > 10]
+
+    if good_contours:
+        contours_combined = np.vstack(good_contours)
+        hull = cv2.convexHull(contours_combined)
+        return np.squeeze(hull).tolist()
+
+    return polygon.tolist()
+
+
+def refine_polygons(drafter: str, sample: str, suffix: str, source_folder: str, target_folder: str,
+                    classes_discontinuous: list) -> None:
+    """Main Function for Polygon Refinement"""
+
+    geo_data = read_labelme(join(drafter, source_folder, f"{sample}.json"))
+    img = cv2.imread(join(drafter, "segmentation", f"{sample}.{suffix}"))
+    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    (_, img) = cv2.threshold(gray, 1, 255, cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)
+    background_mask = np.zeros(img.shape, dtype=np.uint8)
+
+    for shape in geo_data['polygons']:
+        if shape["class"] != "wire":
+            polygon = np.array(shape["points"], dtype=np.int32)
+            mask_single_components = cv2.fillPoly(background_mask, pts=[polygon], color=(255, 255, 255))
+            bitwise_and_result = cv2.bitwise_and(img, mask_single_components)
+            background_mask = np.zeros(img.shape, dtype=np.uint8)
+
+            if shape["class"] in classes_discontinuous:
+                hull_list = convex_hull(bitwise_and_result, polygon)
+                shape['points'] = hull_list
+
+            else:
+                contours, _ = cv2.findContours(bitwise_and_result, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+                if contours:
+                    contour = max(contours, key=len)
+                    contour = np.squeeze(contour)
+                    contour_list = contour.tolist()
+                    shape['points'] = contour_list
+
+                else:
+                    print(f"  !!!  WARNING: Empty Polygon: {shape['group']}  !!!")
+
+    write_labelme(geo_data, join(drafter, target_folder, f"{sample}.json"))
+
+
+def bounding_box(points):
+    xmin = min(point[0] for point in points)
+    ymin = min(point[1] for point in points)
+    xmax = max(point[0] for point in points)
+    ymax = max(point[1] for point in points)
+    return [xmin, ymin, xmax, ymax]
+
+
+def overlap(bbox1, bbox2):
+
+    if bbox1["xmin"] > bbox2[2] or bbox1["xmax"] < bbox2[0]:
+        return False
+
+    if bbox1["ymin"] > bbox2[3] or bbox1["ymax"] < bbox2[1]:
+        return False
+
+    return True
+
+
+def find_closest_points(list1, list2):
+    reordered_list2 = []
+    for x1, y1 in list1:
+        min_distance = float("inf")
+        min_point = None
+        for x2, y2 in list2:
+            distance = math.sqrt((x2 - x1)**2 + (y2 - y1)**2)
+            if distance < min_distance:
+                min_distance = distance
+                min_point = (x2, y2)
+        reordered_list2.append(min_point)
+    return [list(row) for row in reordered_list2]
+
+
+def connector_type_assignment(drafter: str, sample: str, suffix: str, source_folder: str, target_folder: str) -> None:
+    """Connector Point to Port Type Assignment by Geometric Transformation Matching"""
+
+    bboxes = read_pascal_voc(join(drafter, "annotations", f"{sample}.xml"))
+    instances = read_labelme(join(drafter, source_folder, f"{sample}.json"))
+    classes_ports = load_classes_ports()
+    bad_connector_symbols = 0
+
+    for shape in instances["polygons"]:
+        if shape["class"] in classes_ports.keys():
+            connectors = associated_keypoints(instances, shape)
+            cls_ports = classes_ports[shape["class"]]
+            bboxes_match = [bbox for bbox in bboxes['bboxes']
+                            if overlap(bbox, bounding_box(shape["points"])) and bbox['class'] == shape['class']]
+
+            if len(cls_ports) != len(connectors):
+                print(f"    Bad Connector Count: {shape['class']}  {shape['points'][0]} -> {len(cls_ports)} vs. {len(connectors)}")
+                bad_connector_symbols += 1
+
+            if len(bboxes_match) != 1:
+                print(f"    No BB for Polygon: {shape['class']}  {shape['points'][0]}")
+                continue
+
+            if bboxes_match[0]["rotation"] is None:
+                print(f"    Missing Rotation in BB: {shape['class']}  {shape['points'][0]}")
+                bboxes_match[0]["rotation"] = 0
+
+            cls_ports_transformed = [transform(port, bboxes_match[0]) for port in cls_ports]
+
+            for con in connectors:
+                closest = sorted(cls_ports_transformed,
+                                 key=lambda cls_port: dist(cls_port['position'], con['points']))[0]
+                con['class'] = f"connector.{closest['name']}"
+
+            shape['rotation'] = bboxes_match[0]['rotation']
+            shape['text'] = bboxes_match[0]['text']
+
+    write_labelme(instances, join(drafter, target_folder, f"{sample}.json"))
+    return bad_connector_symbols
+
+
+def pipeline(drafter: str, sample: str, suffix: str, source_folder: str, target_folder: str, **kwargs) -> None:
+    """Standard Workflow"""
+
+    generate_wires(drafter, sample, suffix, source_folder, target_folder)
+    generate_keypoints(drafter, sample, suffix, target_folder, target_folder)
+    refine_polygons(drafter, sample, suffix, target_folder, target_folder, kwargs["classes_discontinuous"])
+    labelme_raw_image(drafter, sample, suffix, target_folder, target_folder)
+    return connector_type_assignment(drafter, sample, suffix, target_folder, target_folder)
+
+
+def execute(function: callable, source_folder: str, target_folder: str, drafter: str, info_msg: str, **kwargs):
+    """Walks through the Dataset and applies the specified Function"""
+
+    bad_connector_symbols = 0
+
+    for drafter_dir in [f"drafter_{drafter}"] if drafter else sorted(next(os.walk('.'))[1]):
+        if drafter_dir.startswith("drafter_"):
+
+            if not os.path.isdir(join(drafter_dir, target_folder)):
+                os.mkdir(join(drafter_dir, target_folder))
+
+            for sample_raw in sorted(next(os.walk(join(drafter_dir, "segmentation")))[2]):
+                sample, suffix = sample_raw.split(".")
+                print(f"{info_msg} for: {drafter_dir} -> {sample}")
+                res = function(drafter_dir, sample, suffix, source_folder, target_folder, **kwargs)
+                if res is not None:
+                    bad_connector_symbols += res
+
+    print(f"Overall Symbols with incorrect Connector Count: {bad_connector_symbols}")
+
+
+if __name__ == "__main__":
+
+    with open("classes_discontinuous.json") as f:
+        classes_discontinuous = json.load(f)
+
+    with open('classes_color.json') as f:
+        color_map = json.load(f)
+
+    commands = {"transform": [pascalvoc_to_labelme, "annotations", "instances", "Transforming BBs -> Masks", {}],
+                "wire":      [generate_wires, "instances", "wires", "Generating Wires", {}],
+                "keypoint":  [generate_keypoints, "instances", "keypoints", "Generating Keypoints", {}],
+                "create":    [binary_to_multi_seg_map, "instances", "segmentation_multi_class",
+                              "Generating Multi-Class Segmentation Map", {"color_map": color_map}],
+                "refine":    [refine_polygons, "instances", "instances_refined", "Refining Polygons",
+                              {"classes_discontinuous": classes_discontinuous}],
+                "reset":     [labelme_raw_image, "instances_refined", "instances_refined",
+                              "Resetting Source Image", {}],
+                "assign":    [connector_type_assignment, "instances_refined", "instances_refined",
+                              "Assigning Connector Types", {}],
+                "pipeline":  [pipeline, "instances", "instances_refined", "Processing",
+                              {"classes_discontinuous": classes_discontinuous}]}
+
+    if len(sys.argv) > 1 and sys.argv[1] in commands:
+        fun, source, target, info, paras = commands[sys.argv[1]]
+        drafter = sys.argv[2] if len(sys.argv) > 2 else ""
+        target = sys.argv[3] if len(sys.argv) > 3 else target
+        source = sys.argv[4] if len(sys.argv) > 4 else source
+        execute(fun, source, target, drafter, info, **paras)
+
+    else:
+        print(f"Invalid command. Must be one of: {list(commands.keys())}")

utils.py

@@ -0,0 +1,132 @@
+"""utils.py: Helper Functions to keep this Repo Standalone"""
+
+# System Imports
+from math import sin, cos, radians
+
+__author__ = "Johannes Bayer"
+__copyright__ = "Copyright 2023, DFKI"
+__license__ = "CC"
+__version__ = "0.0.1"
+__email__ = "johannes.bayer@dfki.de"
+__status__ = "Prototype"
+
+
+def shift(p, q):
+    """Shifts a Point by another point"""
+
+    return [p[0]+q[0], p[1]+q[1]]
+
+
+def rotate(p, angle):
+    """Rotates a Point by an Angle"""
+
+    return [p[0] * cos(angle) - p[1] * sin(angle),
+            p[0] * sin(angle) + p[1] * cos(angle)]
+
+
+def scale(p, scale_x, scale_y):
+    """Scales a Point in two Dimensions"""
+
+    return [p[0]*scale_x, p[1]*scale_y]
+
+
+def transform(port, bb):
+    """Transforms a Point from Unit Space (classes ports) to Global Bounding Box (image)"""
+
+    p = shift(port['position'], (-.5, -0.5))  # Normalize: [0.0, 1.0]^2 -> [-0.5, 0-5]^2
+    p = scale(p, 1.0, -1.0)                   # Flip
+    p = rotate(p, -radians(bb['rotation']))
+    p = scale(p, bb["xmax"] - bb["xmin"], bb["ymax"] - bb["ymin"])
+    p = shift(p, [(bb["xmin"]+bb["xmax"])/2, (bb["ymin"]+bb["ymax"])/2])
+
+    return {"name": port['name'], "position": p}
+
+
+def associated_keypoints(instances, shape):
+    """Returns the points with same group id as the provided polygon"""
+
+    return [point for point in instances["points"]
+            if point["group"] == shape["group"] and point["class"] == "connector"]
+
+
+def poly_to_bb():
+    pass
+
+def IoU(bb1, bb2):
+    """Intersection over Union"""
+
+    intersection = 1
+    union = 1
+
+    return intersection/union
+
+
+if __name__ == "__main__":
+
+    import sys
+    from loader import read_pascal_voc, write_pascal_voc
+    import numpy as np
+    import random
+
+    if len(sys.argv) == 3:
+        source = sys.argv[1]
+        target = sys.argv[2]
+
+        ann1, ann2 = [[bbox for bbox in read_pascal_voc(path)['bboxes'] if bbox['class'] == "text"]
+                      for path in [source, target]]
+
+        if not len(ann1) == len(ann2):
+
+            print(f"Warning: Unequal Text Count ({len(ann1)} vs. {len(ann2)}), cropping..")
+            consensus = min(len(ann1), len(ann2))
+            ann1 = ann1[:consensus]
+            ann2 = ann2[:consensus]
+
+        x1 = np.array([(bbox['xmin']+bbox['xmax'])/2 for bbox in ann1])
+        y1 = np.array([(bbox['ymin']+bbox['ymax'])/2 for bbox in ann1])
+        x2 = np.array([(bbox['xmin']+bbox['xmax'])/2 for bbox in ann2])
+        y2 = np.array([(bbox['ymin']+bbox['ymax'])/2 for bbox in ann2])
+        x1 = ((x1-np.min(x1))/(np.max(x1)-np.min(x1))) * (np.max(x2)-np.min(x2)) + np.min(x2)
+        y1 = ((y1-np.min(y1))/(np.max(y1)-np.min(y1))) * (np.max(y2)-np.min(y2)) + np.min(y2)
+        dist = np.sqrt((x1-x2[np.newaxis].T)**2 + (y1-y2[np.newaxis].T)**2)
+        indices_1 = np.arange(len(ann1))
+        indices_2 = np.arange(len(ann2))
+        print(np.sum(np.diagonal(dist)))
+
+        for i in range(10000):
+            if random.random() > 0.5:
+                max_dist_pos = np.argmax(np.diagonal(dist))  # Mitigate Largest Cost
+
+            else:
+                max_dist_pos = random.randint(0, len(ann1)-1)
+
+            if np.min(dist[max_dist_pos, :]) < np.min(dist[:, max_dist_pos]):
+                min_dist_pos = np.argmin(dist[max_dist_pos, :])
+                dist[:, [max_dist_pos, min_dist_pos]] = dist[:, [min_dist_pos, max_dist_pos]]  # Swap Columns
+                indices_1[[max_dist_pos, min_dist_pos]] = indices_1[[min_dist_pos, max_dist_pos]]
+
+            else:
+                min_dist_pos = np.argmin(dist[:, max_dist_pos])
+                dist[[max_dist_pos, min_dist_pos], :] = dist[[min_dist_pos, max_dist_pos], :]  # Swap Rows
+                indices_2[[max_dist_pos, min_dist_pos]] = indices_2[[min_dist_pos, max_dist_pos]]
+
+        print(np.sum(np.diagonal(dist)))
+
+        wb = read_pascal_voc(target)
+
+        for i in range(len(ann1)):
+            ann2[indices_2[i]]['text'] = ann1[indices_1[i]]['text']
+            bbox_match = [bbox for bbox in wb['bboxes']
+                          if bbox['xmin'] == ann2[indices_2[i]]['xmin'] and
+                             bbox['xmax'] == ann2[indices_2[i]]['xmax'] and
+                             bbox['ymin'] == ann2[indices_2[i]]['ymin'] and
+                             bbox['ymax'] == ann2[indices_2[i]]['ymax']]
+
+            if len(bbox_match) == 1:
+                bbox_match[0]['text'] = ann1[indices_1[i]]['text']
+                bbox_match[0]['rotation'] = ann1[indices_1[i]]['rotation']
+
+        write_pascal_voc(wb)
+
+    else:
+        print("Args: source target")