Updated Utility Files

README.md

@@ -28,6 +28,7 @@ gtdh-hd
 |   loader.py                   # Simple Dataset Loader and Storage Functions
 │   segmentation.py             # Multiclass Segmentation Generation
 │   utils.py                    # Helper Functions
+│   requirements.txt            # Requirements for Scripts
 └───drafter_D
 │   └───annotations             # Bounding Box Annotations
 │   │   │   CX_DY_PZ.xml
@@ -305,3 +306,7 @@ Rotation annotations are currently work in progress. They should be provided for
 ```
 labelme --labels "connector" --config "{shift_auto_shape_color: 1}" --nodata
 ```
+
+## Licence
+The entire content of this repository, including all image files, annotation files as well as has sourcecode,  metadata and documentation has been published under the [Creative Commons Attribution Share Alike Licence 3.0](https://creativecommons.org/licenses/by-sa/3.0/).
+

classes_color.json

@@ -69,5 +69,8 @@
     "antenna":      [112,128,144],
     "crystal":      [230,230,250],
 
+    "magnetic":      [0,230,230],
+    "optical":       [230,0,230],
+
     "unknown":  [240,255,240]
 }

consistency.py

@@ -7,6 +7,7 @@ import re
 
 # Project Imports
 from loader import load_classes, load_properties, read_dataset, write_dataset, file_name
+from utils import bbdist
 
 # Third-Party Imports
 import matplotlib.pyplot as plt
@@ -29,41 +30,42 @@ MAPPING_LOOKUP = {
 }
 
 
-def consistency(db: list, classes: dict, recover: dict = {}) -> tuple:
+def consistency(db: list, classes: dict, recover: dict = {}, skip_texts=False) -> 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"]:
+        for annotation in sample["bboxes"] + sample["polygons"] + sample["points"]:
             total += 1
 
-            if bbox["class"] in classes:
+            if annotation["class"] in classes:
                 ok += 1
 
-            if bbox["class"] in recover:
-                bbox["class"] = recover[bbox["class"]]
+            if annotation["class"] in recover:
+                annotation["class"] = recover[annotation["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']}")
+            if annotation["class"] not in classes and annotation["class"] not in recover:
+                print(f"Can't recover faulty label in {file_name(sample)}: {annotation['class']}")
                 faulty += 1
 
-            if bbox["rotation"] is not None:
+            if annotation["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 not skip_texts:
+                if annotation["class"] == "text" and annotation["text"] is None:
+                    print(f"Missing Text in {file_name(sample)}  ->  {annotation['xmin']}, {annotation['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 annotation["text"] is not None:
+                    if annotation["text"].strip() != annotation["text"]:
+                        print(f"Removing leading of trailing spaces from: {annotation['text']}")
+                        annotation["text"] = annotation["text"].strip()
 
-                if bbox["class"] != "text":
-                    print(f"Text string outside Text BB in {file_name(sample)}: {bbox['class']}: {bbox['text']}")
+                    if annotation["class"] != "text":
+                        print(f"Text string outside Text Annotation in {file_name(sample)} [{annotation['xmin']:4}, {annotation['ymin']:4}]: {annotation['class']}: {annotation['text']}")
 
-                text += 1
+                    text += 1
 
     return total, ok, mapped, faulty, rotation, text
 
@@ -109,12 +111,21 @@ def circuit_annotations(db: list, classes: dict) -> None:
     plt.show()
 
 
+def annotation_distribution(db: list) -> None:
+
+    amount_distribution([sample['bboxes'] for sample in db],
+                        "Image Sample Count by BB Annotation Count",
+                        "BB Annotation Count",
+                        "Image Sample Count",
+                        ticks=False)
+
+
 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])
+    class_counts = [sum([len([annotation for annotation in sample["bboxes"] + sample["polygons"] + sample["points"]
+                              if annotation["class"] == cls])
                          for sample in db]) for cls in classes]
 
     bars = plt.bar(class_nbrs, class_counts)
@@ -154,12 +165,15 @@ def image_count(drafter: int = None, segmentation: bool = False) -> int:
                    (not drafter or f"drafter_{drafter}{os.sep}" in root)])
 
 
-def read_check_write(classes: dict, drafter: int = None, segmentation: bool = False):
+def read_check_write(classes: dict, drafter: int = None, segmentation: bool = False) -> list:
     """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)
+    ann_total, ann_ok, ann_mapped, ann_faulty, ann_rot, ann_text = consistency(db,
+                                                                               classes,
+                                                                               MAPPING_LOOKUP,
+                                                                               skip_texts=segmentation)
     write_dataset(db, segmentation=segmentation)
 
     print("")
@@ -179,53 +193,101 @@ def read_check_write(classes: dict, drafter: int = None, segmentation: bool = Fa
     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)}")
+def unique_characters(texts: list) -> list:
+    """Returns the Sorted Set of Unique Characters"""
 
-    text_labels_unique = set(text_labels)
-    print(f"Unique Text Label Count:  {len(text_labels_unique)}")
+    char_set = set([char for text in texts for char in text])
+    return sorted(list(char_set))
 
-    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)
+def character_distribution(texts: list, chars: list):
+    """Plots and Returns the Character Distribution"""
 
     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 text_label in texts])
                    for char in chars]
     plt.bar(char_nbrs, char_counts)
     plt.xticks(char_nbrs, chars)
-    plt.title("Character Frequencies")
+    plt.title("Character Distribution")
     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")
+
+    return char_counts
+
+
+def amount_distribution(list_of_lists: list, title: str, x_label: str, y_label: str, ticks: bool = True) -> None:
+    """Plots a Histogram of the Amount of Things Contained in a List of Lists"""
+
+    max_bin = max([len(lst) for lst in list_of_lists])
+    bin_numbers = np.arange(max_bin)+1
+    text_count_by_length = [len([None for lst in list_of_lists if len(lst) == amount])
+                            for amount in bin_numbers]
+    plt.bar(bin_numbers, text_count_by_length)
+
+    if ticks:
+        plt.xticks(bin_numbers, rotation=90)
+
+    plt.title(title)
+    plt.xlabel(x_label)
+    plt.ylabel(y_label)
+    plt.show()
+
+
+def text_proximity(db: list, cls_name: str, cls_regex: str):
+    """Proximity-Based Regex Validation"""
+
+    cls_stat = {}
+
+    for sample in db:
+        bbs_text = [bbox for bbox in sample["bboxes"] if bbox["class"] == "text"]
+        bbs_symbol = [bbox for bbox in sample["bboxes"] if bbox["class"] not in ["text", "junction", "crossover"]]
+
+        for bb_text in bbs_text:
+            if bb_text["text"]:
+                if re.match(cls_regex, bb_text["text"]):
+                    bb_closest_class = sorted(bbs_symbol, key=lambda bb: bbdist(bb_text, bb))[0]["class"]
+                    cls_stat[bb_closest_class] = cls_stat.get(bb_closest_class, 0) + 1
+
+    cls_stat = sorted(cls_stat.items(), key=lambda cls: -cls[1])
+    print(cls_stat)
+    plt.bar(range(len(cls_stat)), [name for _, name in cls_stat])
+    plt.xticks(range(len(cls_stat)), labels=[name for name, _ in cls_stat], rotation=90)
+    plt.title(f"Neighbor Distribution for {cls_name} Text Annotations")
+    plt.xlabel("Symbol Class")
+    plt.ylabel("Number of Closest Neighbors")
+    plt.tight_layout()
     plt.show()
 
+
+def text_statistics(db: list, plot_unique_labels: bool = False):
+    """Generates and Plots Statistics on Text Classes"""
+
+    text_bbs = [bbox for sample in db for bbox in sample["bboxes"] if bbox["class"] == "text"]
+    text_labels = [bbox["text"] for bbox in text_bbs if type(bbox["text"]) is str and len(text_bbs) > 0]
+    text_labels_unique = set(text_labels)
+    chars_unique = unique_characters(text_labels)
+    char_counts = character_distribution(text_labels, chars_unique)
+    amount_distribution(text_labels, "Text Length Distribution", "Character Count", "Annotation Count")
+
+    print("")
+    print("   Text Statistics")
+    print("---------------------")
+    print(f"Text BB Annotations:      {len(text_bbs)}")
+    print(f"Overall Text Label Count: {len(text_labels)}")
+    print(f"Annotation Completeness:  {100*len(text_labels)/len(text_bbs):.2f}%")
+    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(f"Character Types:          {len(chars_unique)}")
+    print("\n\nSet of all characters occurring in all text labels:")
+    print(chars_unique)
+    print("\n\nSet of Text Labels:")
+    print(text_labels_unique)
+
+    print("\nCharacter Frequencies:")
+    print({char: 1/char_count for char, char_count in zip(chars_unique, char_counts)})
+
     text_instances = text_labels_unique if plot_unique_labels else text_labels
     text_classes_names = []
     text_classes_instances = []
@@ -252,18 +314,23 @@ def text_statistics(db: list, plot_unique_labels: bool = False):
     plt.tight_layout()
     plt.show()
 
+    text_proximity(db, "Capacitor Name", "^C[0-9]+$")
+    text_proximity(db, "Resistor Name", "^R[0-9]+$")
+    text_proximity(db, "Inductor Name", "^L[0-9]+$")
+
 
 
 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)
+    db_poly = read_check_write(classes, drafter_selected, segmentation=True)
 
     class_sizes(db_bb, classes)
     circuit_annotations(db_bb, classes)
+    annotation_distribution(db_bb)
     class_distribution(db_bb, classes)
-    #class_distribution(db_poly, classes)
+    class_distribution(db_poly, classes)
     consistency_circuit(db_bb, classes)
     text_statistics(db_bb)

loader.py

@@ -49,10 +49,16 @@ def _sample_info_from_path(path: str) -> tuple:
     return drafter.split("_")[1], int(circuit[1:]), int(drawing[1:]), int(picture[1:]), suffix
 
 
+def sample_name(sample: dict) -> str:
+    """Returns the Name of a Sample"""
+
+    return f"C{sample['circuit']}_D{sample['drawing']}_P{sample['picture']}"
+
+
 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']}"
+    return f"{sample_name(sample)}.{sample['format']}"
 
 
 def read_pascal_voc(path: str) -> dict:
@@ -127,10 +133,15 @@ def read_labelme(path: str) -> dict:
     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,
+    return {'img_path': json_data['imagePath'].replace("\\", "/"), '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'],
+            'polygons': [{'class': shape['label'],
+                          'bbox': {'xmin': min(point[0] for point in shape['points']),
+                                   'ymin': min(point[1] for point in shape['points']),
+                                   'xmax': max(point[0] for point in shape['points']),
+                                   'ymax': max(point[1] for point in shape['points'])},
+                          'points': shape['points'],
                           'rotation': shape.get('rotation', None),
                           'text': shape.get('text', None),
                           'group': shape.get('group_id', None)}
@@ -150,19 +161,25 @@ def write_labelme(geo_data: dict, path: str = None) -> None:
                     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,
+        json.dump({'version': '5.2.0',
+                   'flags': {},
+                   'shapes': [{'line_color': None, 'fill_color': None,'label': polygon['class'],
                                'points': polygon['points'],
-                               **({'group_id': polygon['group']} if polygon['group'] is not None else {}),
+                               'group_id': polygon.get('group', None),
+                               'description': polygon.get('description', None),
                                **({'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']]},
+                              for point in geo_data['points']],
+                   'imagePath': geo_data['img_path'],
+                   'imageData': None,
+                   'imageHeight': geo_data['height'],
+                   'imageWidth': geo_data['width'],
+                   'lineColor': [0, 255, 0, 128],
+                   'fillColor': [255, 0, 0, 128]},
                   json_file, indent=2)
 
 
@@ -206,7 +223,7 @@ def read_snippets(**kwargs):
 
     for img, annotations in read_images(**kwargs):
         for bbox in annotations['bboxes']:
-            snippets += [(img[bbox['ymin']:bbox['ymax'], bbox['xmin']:bbox['xmax']], bbox)]
+            snippets += [(img[bbox['ymin']:bbox['ymax'], bbox['xmin']:bbox['xmax']], bbox, sample_name(annotations))]
 
     return snippets
 
@@ -217,11 +234,11 @@ if __name__ == "__main__":
     os.mkdir("test")
     args = {'drafter': int(sys.argv[1])} if len(sys.argv) == 2 else {}
 
-    for nbr, (snippet, bbox) in enumerate(read_snippets(**args)):
+    for snippet, bbox, sample in 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)
+            cv2.imwrite(join("test", f"{bbox['text']}___{sample}_{bbox['ymin']}_{bbox['ymax']}_{bbox['xmin']}_{bbox['xmax']}.png"), snippet)

requirements.txt

@@ -0,0 +1,14 @@
+contourpy==1.1.0
+cv==1.0.0
+cycler==0.11.0
+fonttools==4.40.0
+kiwisolver==1.4.4
+lxml==4.9.2
+matplotlib==3.7.1
+numpy==1.25.0
+opencv-python==4.7.0.72
+packaging==23.1
+Pillow==9.5.0
+pyparsing==3.1.0
+python-dateutil==2.8.2
+six==1.16.0

segmentation.py

@@ -9,7 +9,7 @@ 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
+from utils import transform, associated_keypoints, overlap
 
 # Third-Party Imports
 import cv2
@@ -34,9 +34,8 @@ def binary_to_multi_seg_map(drafter: str, sample: str, suffix: str, source_folde
     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']]))):
+    for shape in sorted(geo_data["polygons"], key=lambda shape: -(shape['bbox']['xmax']-shape['bbox']['xmin']) *
+                                                                 (shape['bbox']['ymax']-shape['bbox']['ymin'])):
         cv2.fillPoly(shape_mask,
                      pts=[np.array(shape["points"], dtype=np.int32)],
                      color=color_map[shape["class"]])
@@ -80,10 +79,10 @@ def generate_keypoints(drafter: str, sample: str, suffix: str, source_folder: st
         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])
+            x_min = max(int(shape['bbox']['xmin'])-margin, 0)
+            x_max = min(int(shape['bbox']['xmax'])+margin, bin_seg_map.shape[1])
+            y_min = max(int(shape['bbox']['ymin'])-margin, 0)
+            y_max = min(int(shape['bbox']['ymax'])+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)],
@@ -210,25 +209,6 @@ def refine_polygons(drafter: str, sample: str, suffix: str, source_folder: str,
     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:
@@ -256,7 +236,7 @@ def connector_type_assignment(drafter: str, sample: str, suffix: str, source_fol
             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 overlap(bbox, shape["bbox"]) 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)}")

utils.py

@@ -1,7 +1,7 @@
 """utils.py: Helper Functions to keep this Repo Standalone"""
 
 # System Imports
-from math import sin, cos, radians
+from math import sin, cos, radians, sqrt
 
 __author__ = "Johannes Bayer"
 __copyright__ = "Copyright 2023, DFKI"
@@ -42,6 +42,24 @@ def transform(port, bb):
     return {"name": port['name'], "position": p}
 
 
+def bbdist(bb1, bb2):
+    """Calculates the Distance between two Bounding Box Annotations"""
+
+    return sqrt(((bb1["xmin"]+bb1["xmax"])/2 - (bb2["xmin"]+bb2["xmax"])/2)**2 +
+                ((bb1["ymin"]+bb1["ymax"])/2 - (bb2["ymin"]+bb2["ymax"])/2)**2)
+
+
+def overlap(bbox1, bbox2):
+
+    if bbox1["xmin"] > bbox2["xmax"] or bbox1["xmax"] < bbox2["xmin"]:
+        return False
+
+    if bbox1["ymin"] > bbox2["ymax"] or bbox1["ymax"] < bbox2["ymin"]:
+        return False
+
+    return True
+
+
 def associated_keypoints(instances, shape):
     """Returns the points with same group id as the provided polygon"""
 
@@ -49,9 +67,6 @@ def associated_keypoints(instances, shape):
             if point["group"] == shape["group"] and point["class"] == "connector"]
 
 
-def poly_to_bb():
-    pass
-
 def IoU(bb1, bb2):
     """Intersection over Union"""