Overhauled Version of Consistency Script, improved README, and Loader

README.md

@@ -11,11 +11,14 @@ language:
 - de
 ---
 
-# Public Ground-Truth Dataset for Handwritten Circuit Diagrams (GTDB-HD)
-This repository contains images of hand-drawn electrical circuit diagrams as well as accompanying bounding box annotation for object detection as well as segmentation ground truth files. This dataset is intended to train (e.g. neural network) models for the purpose of the extraction of electrical graphs from raster graphics.
+
+
+# A Public Ground-Truth Dataset for Handwritten Circuit Diagrams (CGHD)
+This repository contains images of hand-drawn electrical circuit diagrams as well as accompanying bounding box annotation, polygon annotation and segmentation files. These annotations serve as ground truth to train and evaluate several image processing tasks like object detection, instance segmentation and text detection. The purpose of this dataset is to facilitate the automated extraction of electrical graph structures from raster graphics.
+
 
 ## Structure
-The folder structure is made up as follows:
+The folder and file structure is made up as follows:
 
 ```
 gtdh-hd
@@ -25,12 +28,13 @@ gtdh-hd
 │   classes_discontinuous.json  # Classes Morphology Info
 │   classes_ports.json          # Electrical Port Descriptions for Classes
 │   consistency.py              # Dataset Statistics and Consistency Check
-|   loader.py                   # Simple Dataset Loader and Storage Functions
+│   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
+│   └───annotations             # Bounding Box, Rotation and Text Label Annotations
 │   │   │   CX_DY_PZ.xml
 │   │   │   ...
 │   │
@@ -55,13 +59,15 @@ Where:
  - `Y` is the Local Number of the Circuit's Drawings (2 Drawings per Circuit)
  - `Z` is the Local Number of the Drawing's Image (4 Pictures per Drawing)
 
-### Image Files
-Every image is RGB-colored and either stored as `jpg`, `jpeg` or `png` (both uppercase and lowercase suffixes exist).
+### Raw Image Files
+Every raw image is RGB-colored and either stored as `jpg`, `jpeg` or `png` (both uppercase and lowercase suffixes exist). Raw images are always stored in sub-folders named `images`.
 
 ### Bounding Box Annotations
-A complete list of class labels including a suggested mapping table to integer numbers for training and prediction purposes can be found in `classes.json`. The annotations contains **BB**s (Bounding Boxes) of **RoI**s (Regions of Interest) like electrical symbols or texts within the raw images and are stored in the [PASCAL VOC](http://host.robots.ox.ac.uk/pascal/VOC/) format.
+For every raw image in the dataset, there is an annotation file which contains **BB**s (Bounding Boxes) of **RoI**s (Regions of Interest) like electrical symbols or texts within that image. These BB annotations are stored in the [PASCAL VOC](http://host.robots.ox.ac.uk/pascal/VOC/) format. Apart from its location in the image, every BB bears a class label, a complete list of class labels including a suggested mapping table to integer numbers for training and prediction purposes can be found in `classes.json`. As the bb annotations are the most basic and pivotal element of this dataset, they are stored in sub-folders named `annotations`.
+
+Please Note: *For every Raw image in the dataset, there is an accompanying BB annotation file.*
 
-Please note: *For every Raw image in the dataset, there is an accompanying bounding box annotation file.*
+Please Note: *The BB annotation files are also used to store symbol rotation and text label annotations as XML Tags that form an extension of the utilized PASCAL VOC format.*
 
 #### Known Labeled Issues
  - C25_D1_P4 cuts off a text
@@ -71,36 +77,52 @@ Please note: *For every Raw image in the dataset, there is an accompanying bound
  - C33_D1_P4 has a text less
  - C46_D2_P2 cuts of a text
 
-### Instance Segmentation
-For every binary segmentation map, there is an accompanying polygonal annotation file for instance segmentation purposes, which is stored in the [labelme](https://github.com/wkentaro/labelme) format. Note that the contained polygons are quite coarse, intended to be used in conjunction with the binary segmentation maps for connection extraction and to tell individual instances with overlapping BBs apart. 
+### Binary Segmentation Maps
+Binary segmentation images are available for some raw image samples and consequently bear the same resolutions as the respective raw images. The defined goal is to have a segmentation map for at least one of the images of every circuit. Binary segmentation maps are considered to contain black and white pixels only. More precisely, white pixels indicate any kind of background like paper (ruling), surrounding objects or hands and black pixels indicate areas of drawings strokes belonging to the circuit. As binary segmentation images are the only permanent type of segmentation map in this dataset, they are stored in sub-folders named `segmentation`.
 
-### Segmentation Maps
-Binary Segmentation images are available for some samples and bear the same resolution as the respective image files. They are considered to contain only black and white pixels indicating areas of drawings strokes and background respectively.
+### Polygon Annotations
+For every binary segmentation map, there is an accompanying polygonal annotation file for instance segmentation purposes (that's why the polygon annotations are referred to as `instances` and stored in sub-folders of this name), which is stored in the [labelme](https://github.com/wkentaro/labelme) format. Note that the contained polygons are quite coarse, intended to be used in conjunction with the binary segmentation maps for connection extraction and to tell individual instances with overlapping BBs apart.
 
 ### Netlists
 For some images, there are also netlist files available, which are stored in the [ASC](http://ltwiki.org/LTspiceHelp/LTspiceHelp/Spice_Netlist.htm) format.
 
-### Consistency and Statistics
-This repository comes with a stand-alone script to:
 
- - Obtain Statistics on 
+## Processing Scripts
+This repository comes with several python scripts. These have been tested with [Python 3.11](https://docs.python.org/3.11/). Before running them, please make sure all requirements are met (see `requirements.txt`).
+
+### Consistency and Statistics
+The consistency script performs data integrity checks and corrections as well as derives statistics for the dataset. The list of features include:
+
+ - Ensure annotation files are stored uniformly
+   - Same version of annotation file format being used
+   - Same indent, uniform line breaks between tags (important to use `git diff` effectively)
+ - Check Annotation Integrity
+   - Classes referenced the (BB/Polygon) Annotations are contained in the central `classes.json` list
+   - `text` Annotations actually contain a non-empty text label and text labels exist in `text` annotations only
+   - Class Count between Pictures of the same Drawing are identical
+   - Image Dimensions stated in the annotation files match the referenced images
+ - Obtain Statistics
    - Class Distribution
    - BB Sizes
- - Check the BB Consistency
-   - Classes with Regards to the `classes.json`
-   - Counts between Pictures of the same Drawing
- - Ensure a uniform writing style of the Annotation Files (indent)
+   - Image Size Distribustion
+   - Text Character Distribution
 
 The respective script is called without arguments to operate on the **entire** dataset:
 
 ```
-$ python3 consistency.py
+python consistency.py
+```
+
+Note that due to a complete re-write of the annotation data, the script takes several seconds to finish. Therefore, the script can be restricted to an individual drafter, specified as CLI argument (for example drafter 15):
+
+```
+python consistency.py -d 15
 ```
 
-Note that due to a complete re-write of the annotation data, the script takes several seconds to finish. A drafter can be specified as CLI argument to restrict the evaluation (for example drafter 15):
+In order to reduce the computational overhead and CLI prints, most functions are deactivated by default. In order to see the list of available options, run:
 
 ```
-$ python3 consistency.py 15
+python consistency.py -h
 ```
 
 ### Multi-Class (Instance) Segmentation Processing
@@ -166,6 +188,7 @@ db = read_images(drafter=12)   # Returns a list of (Image, Annotation) pairs
 db = read_snippets(drafter=12) # Returns a list of (Image, Annotation) pairs
 ```
 
+
 ## Citation
 If you use this dataset for scientific publications, please consider citing us as follows:
 
@@ -180,8 +203,10 @@ If you use this dataset for scientific publications, please consider citing us a
 }
 ```
 
+
 ## How to Contribute
-If you want to contribute to the dataset as a drafter or in case of any further questions, please send an email to: <johannes.bayer@dfki.de> (corresponding author), <[email protected]>, <[email protected]>
+If you want to contribute to the dataset as a drafter or in case of any further questions, please send an email to: <johannes.bayer@mail.de>
+
 
 ## Guidelines
 These guidelines are used throughout the generation of the dataset. They can be used as an instruction for participants and data providers.
@@ -190,6 +215,8 @@ These guidelines are used throughout the generation of the dataset. They can be
  - 12 Circuits should be drawn, each of them twice (24 drawings in total)
  - Most important: The drawing should be as natural to the drafter as possible
  - Free-Hand sketches are preferred, using rulers and drawing Template stencils should be avoided unless it appears unnatural to the drafter
+ - The sketches should not be traced directly from a template (e.g. from the Original Printed Circuits)
+ - Minor alterations between the two drawings of a circuit (e.g. shifting a wire line) are encouraged within the circuit's layout as long as the circuit's function is preserved (only if the drafter is familiar with schematics)
  - Different types of pens/pencils should be used for different drawings
  - Different kinds of (colored, structured, ruled, lined) paper should be used
  - One symbol set (European/American) should be used throughout one drawing (consistency)
@@ -201,7 +228,7 @@ These guidelines are used throughout the generation of the dataset. They can be
  - Angle should vary
  - Lighting should vary
  - Moderate (e.g. motion) blur is allowed
- - All circuit-related aspects of the drawing must be _human-recognicable_
+ - All circuit-related aspects of the drawing must be _human-recognizable_
  - The drawing should be the main part of the image, but _naturally_ occurring objects from the environment are welcomed
  - The first image should be _clean_, i.e. ideal capturing conditions
  - Kinks and Buckling can be applied to the drawing between individual image capturing
@@ -214,11 +241,11 @@ These guidelines are used throughout the generation of the dataset. They can be
  - General Placement
    - A **RoI** must be **completely** surrounded by its **BB**
    - A **BB** should be as tight as possible to the **RoI**
-   - In case of connecting lines not completely touching the symbol, the BB should extended (only by a small margin) to enclose those gaps (epecially considering junctions)
+   - In case of connecting lines not completely touching the symbol, the BB should be extended (only by a small margin) to enclose those gaps (especially considering junctions)
    - Characters that are part of the **essential symbol definition** should be included in the BB (e.g. the `+` of a polarized capacitor should be included in its BB)
  - **Junction** annotations 
    - Used for actual junction points (Connection of three or more wire segments with a small solid circle)
-   - Used for connection of three or more sraight line wire segements where a physical connection can be inferred by context (i.e. can be distinuished from **crossover**)
+   - Used for connection of three or more straight line wire segments where a physical connection can be inferred by context (i.e. can be distinguished from **crossover**)
    - Used for wire line corners
    - Redundant Junction Points should **not** be annotated (small solid circle in the middle of a straight line segment)
    - Should not be used for corners or junctions that are part of the symbol definition (e.g. Transistors)
@@ -241,7 +268,7 @@ These guidelines are used throughout the generation of the dataset. They can be
      - Only add terminal text annotation if the terminal is not part of the essential symbol definition
    - **Table** cells should be annotated independently
  - **Operation Amplifiers**
-   - Both the triangular US symbols and the european IC-like symbols symbols for OpAmps should be labeled `operational_amplifier`
+   - Both the triangular US symbols and the european IC-like symbols for OpAmps should be labeled `operational_amplifier`
    - The `+` and `-` signs at the OpAmp's input terminals are considered essential and should therefore not be annotated as texts
  - **Complex Components**
    - Both the entire Component and its sub-Components and internal connections should be annotated:
@@ -263,7 +290,7 @@ These guidelines are used throughout the generation of the dataset. They can be
 
 
 #### Rotation Annotations
-The Rotation (integer in degree) should capture the overall rotation of the symbol shape. However, the position of the terminals should also be taked into consideration. Under idealized circumstances (no perspective distorion and accurately drawn symbols according to the symbol library), these two requirements equal each other. For pathological cases however, in which shape and the set of terminals (or even individual terminals) are conflicting, the rotation should compromise between all factors.
+The Rotation (integer in degree) should capture the overall rotation of the symbol shape. However, the position of the terminals should also be taken into consideration. Under idealized circumstances (no perspective distortion and accurately drawn symbols according to the symbol library), these two requirements equal each other. For pathological cases however, in which shape and the set of terminals (or even individual terminals) are conflicting, the rotation should compromise between all factors.
 
 Rotation annotations are currently work in progress. They should be provided for at least the following classes:
 - "voltage.dc"
@@ -273,8 +300,8 @@ Rotation annotations are currently work in progress. They should be provided for
 - "transistor.bjt"
 
 #### Text Annotations
- - The Character Sequence in the Text Label Annotations should describe the actual Characters depicted in the respective Bounding Box as Precisely as Possible
- - Bounding Box Annotations of class `text`
+ - The Character Sequence in the Text Label Annotations should describe the actual Characters depicted in the respective BB as Precisely as Possible
+ - BB Annotations of class `text`
  - Bear an additional `<text>` tag in which their content is given as string
  - The `Omega` and `Mikro` Symbols are escaped respectively
  - Currently Work in Progress
@@ -307,6 +334,6 @@ 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/).
 
+## Licence
+The entire content of this repository, including all image files, annotation files as well as 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

@@ -71,6 +71,7 @@
 
     "magnetic":      [0,230,230],
     "optical":       [230,0,230],
+    "explanatory":   [230,100,100],
 
     "unknown":  [240,255,240]
 }

consistency.py

@@ -2,11 +2,11 @@
 
 # System Imports
 import os
-import sys
 import re
+import argparse
 
 # Project Imports
-from loader import load_classes, load_properties, read_dataset, write_dataset, file_name
+from loader import load_classes, load_properties, read_dataset, write_dataset, read_image, sample_name_tracable
 from utils import bbdist
 
 # Third-Party Imports
@@ -14,10 +14,10 @@ import matplotlib.pyplot as plt
 import numpy as np
 
 __author__ = "Johannes Bayer, Shabi Haider"
-__copyright__ = "Copyright 2021-2023, DFKI"
+__copyright__ = "Copyright 2021-2023, DFKI, 2024-2025, Johannes Bayer"
 __license__ = "CC"
 __version__ = "0.0.2"
-__email__ = "johannes.bayer@dfki.de"
+__email__ = "johannes.bayer@mail.de"
 __status__ = "Prototype"
 
 
@@ -30,10 +30,10 @@ MAPPING_LOOKUP = {
 }
 
 
-def consistency(db: list, classes: dict, recover: dict = {}, skip_texts=False) -> tuple:
+def consistency(db: list, classes: dict, recover: dict = {}, check_texts=True, check_images=True) -> 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
+    total, ok, mapped, faulty, rotation, mirror_h, mirror_v, text = 0, 0, 0, 0, 0, 0, 0, 0
 
     for sample in db:
         for annotation in sample["bboxes"] + sample["polygons"] + sample["points"]:
@@ -47,15 +47,21 @@ def consistency(db: list, classes: dict, recover: dict = {}, skip_texts=False) -
                 mapped += 1
 
             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']}")
+                print(f"Can't recover faulty label in {sample_name_tracable(sample)}: {annotation['class']}")
                 faulty += 1
 
             if annotation["rotation"] is not None:
                 rotation += 1
 
-            if not skip_texts:
+            if annotation["mirror_horizontal"]:
+                mirror_h += 1
+
+            if annotation["mirror_vertical"]:
+                mirror_v += 1
+
+            if check_texts:
                 if annotation["class"] == "text" and annotation["text"] is None:
-                    print(f"Missing Text in {file_name(sample)}  ->  {annotation['xmin']}, {annotation['ymin']}")
+                    print(f"Missing Text in {sample_name_tracable(sample)}  ->  {annotation['xmin']}, {annotation['ymin']}")
 
                 if annotation["text"] is not None:
                     if annotation["text"].strip() != annotation["text"]:
@@ -63,11 +69,23 @@ def consistency(db: list, classes: dict, recover: dict = {}, skip_texts=False) -
                         annotation["text"] = annotation["text"].strip()
 
                     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']}")
+                        print(f"Text string outside Text Annotation in {sample_name_tracable(sample)} [{annotation['xmin']:4}, {annotation['ymin']:4}]: {annotation['class']}: {annotation['text']}")
 
                     text += 1
 
-    return total, ok, mapped, faulty, rotation, text
+        if check_images:
+            try:
+                height, width, _ = read_image(sample).shape
+
+                if (not sample['width'] == width) or (not sample['height'] == height):
+                    sample['width'] = width
+                    sample['height'] = height
+                    print(f"Corrected Image Dimensions in Sample {sample_name_tracable(sample)}")
+
+            except AttributeError:
+                print(f"Missing or Corrupt Image for Sample {sample_name_tracable(sample)}")
+
+    return total, ok, mapped, faulty, rotation, mirror_h, mirror_v, text
 
 
 def consistency_circuit(db: list, classes: dict) -> None:
@@ -86,6 +104,22 @@ def consistency_circuit(db: list, classes: dict) -> None:
                 print(f"  Circuit {circuit}:  {cls}: {check}")
 
 
+
+def consistency_text(db: list) -> None:
+    """Reports all Text Labels that Exist in a Strict Subset of Image Annotations of the same Circuit"""
+    
+    for circuit in set(sample["circuit"] for sample in db):
+        circuit_samples = [sample for sample in db if sample["circuit"] == circuit]
+
+        circuit_samples_texts = [sorted([bbox["text"] for bbox in sample["bboxes"] if bbox["text"]])
+                                 for sample in circuit_samples]
+	
+        print(circuit)
+        for c in circuit_samples_texts:
+            print(c)
+
+
+
 def circuit_annotations(db: list, classes: dict) -> None:
     """Plots the Annotations per Sample and Class"""
 
@@ -144,15 +178,31 @@ def class_distribution(db: list, classes: dict) -> None:
     plt.show()
 
 
+def image_sizes(db: list) -> None:
+    """Statistics of the Raw Image's Widths and Heights"""
+
+    widths = [sample['width'] for sample in db]
+    heights = [sample['height'] for sample in db]
+    print(f"Raw Image Width Range:  [{min(widths)}, {max(widths)}]")
+    print(f"Raw Image Height Range:  [{min(heights)}, {max(heights)}]")
+
+    plt.title('Image Sizes')
+    plt.boxplot([heights, widths], vert=False)
+    plt.yticks([2, 1], labels=["width", "height"])
+    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])
+                 for cls in list(classes)[::-1]], vert=False)
     class_nbrs = np.arange(len(classes))+1
-    plt.xticks(class_nbrs, labels=classes, rotation=90)
+    plt.yticks(class_nbrs, labels=list(classes)[::-1])
+    plt.tight_layout()
     plt.show()
 
 
@@ -161,19 +211,21 @@ def image_count(drafter: int = None, segmentation: bool = False) -> int:
 
     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)])
+                if (f"segmentation{os.sep}" if segmentation else "annotation") in root and
+                   (drafter is None or f"drafter_{drafter}{os.sep}" in root)])
 
 
-def read_check_write(classes: dict, drafter: int = None, segmentation: bool = False) -> list:
+def read_check_write(classes: dict, drafter: int = None, segmentation: bool = False,
+                     check_images: bool = False, check_texts: 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,
-                                                                               MAPPING_LOOKUP,
-                                                                               skip_texts=segmentation)
+    ann_total, ann_ok, ann_mapped, ann_faulty, ann_rot, ann_mirror_h, ann_mirror_v, ann_text = consistency(db,
+                                                                                                           classes,
+                                                                                                           MAPPING_LOOKUP,
+                                                                                                           check_texts=check_texts and not segmentation,
+                                                                                                           check_images=check_images)
     write_dataset(db, segmentation=segmentation)
 
     print("")
@@ -188,7 +240,9 @@ def read_check_write(classes: dict, drafter: int = None, segmentation: bool = Fa
     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 Mirror: {ann_mirror_h+ann_mirror_v} = {ann_mirror_h}(H) + {ann_mirror_v}(V)")
     print(f"Annotations with Text: {ann_text}")
+    print("")
 
     return db
 
@@ -321,16 +375,46 @@ def text_statistics(db: list, plot_unique_labels: bool = False):
 
 
 if __name__ == "__main__":
-    drafter_selected = int(sys.argv[1]) if len(sys.argv) == 2 else None
-    classes = load_classes()
 
-    db_bb = read_check_write(classes, drafter_selected)
-    db_poly = read_check_write(classes, drafter_selected, segmentation=True)
+    # Prepare Argument Parser
+    parser = argparse.ArgumentParser(prog='CGHD Consistency',
+                                     description="Performs Integrity Checks and Statistics on the Dataset.")
+    parser.add_argument("-d", "--drafter", type=int, default=None,
+                        help="Performs the actions on a given drafter only. If none is given, the entire dataset is used.")
+    parser.add_argument('-i', "--image-check", action='store_true',
+                        help="Enables Image Dimension Verification")
+    parser.add_argument('-c', "--text-check", action='store_true',
+                        help="searches for text labels outside text annotations and text annotations without text Label")
+    parser.add_argument('-a', "--annotation-consistency", action='store_true',
+                        help="Enables Annotation Consistency Check (Class Count between Images of the Same Circuit)")
+    parser.add_argument('-t', "--text-consistency", action='store_true',
+                        help="Enables Text Consistency Check (Label Equality between Images of the same Circuit)")
+    parser.add_argument('-s', "--statistics", action='store_true',
+                        help="Performs Extended Statistics")
+    args = parser.parse_args()
+
+    # Load Class Info
+    classes = load_classes()
 
-    class_sizes(db_bb, classes)
-    circuit_annotations(db_bb, classes)
-    annotation_distribution(db_bb)
-    class_distribution(db_bb, classes)
-    class_distribution(db_poly, classes)
-    consistency_circuit(db_bb, classes)
-    text_statistics(db_bb)
+    # Basic Integrity Checks
+    db_bb = read_check_write(classes, args.drafter, segmentation=False,
+                             check_images=args.image_check, check_texts=args.text_check)
+    db_poly = read_check_write(classes, args.drafter, segmentation=True,
+                               check_images=args.image_check, check_texts=args.text_check)
+
+    # Consistency Checks between Images of the Same Circuit
+    if args.annotation_consistency:
+        consistency_circuit(db_bb, classes)
+
+    if args.text_consistency:
+        consistency_text(db_bb)
+
+    # Statistics
+    if args.statistics:
+        image_sizes(db_bb)
+        class_sizes(db_bb, classes)
+        circuit_annotations(db_bb, classes)
+        annotation_distribution(db_bb)
+        class_distribution(db_bb, classes)
+        class_distribution(db_poly, classes)
+        text_statistics(db_bb)

loader.py

@@ -5,10 +5,11 @@ 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
+import numpy as np
+from lxml import etree
 
 __author__ = "Johannes Bayer"
 __copyright__ = "Copyright 2022-2023, DFKI"
@@ -55,6 +56,12 @@ def sample_name(sample: dict) -> str:
     return f"C{sample['circuit']}_D{sample['drawing']}_P{sample['picture']}"
 
 
+def sample_name_tracable(sample: dict) -> str:
+    """Returns the Unambiguous, Human-Readable Sample Name"""
+
+    return f"Drafter{sample['drafter']}/{sample_name(sample)}"
+
+
 def file_name(sample: dict) -> str:
     """return the Raw Image File Name of a Sample"""
 
@@ -81,6 +88,8 @@ def read_pascal_voc(path: str) -> dict:
                         "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,
+                        "mirror_horizontal": len([tag for tag in annotation.findall("bndbox/mirror") if tag.text=="horizontal"])>0,
+                        "mirror_vertical": len([tag for tag in annotation.findall("bndbox/mirror") if tag.text=="vertical"])>0,
                         "text": annotation.find("text").text if annotation.find("text") is not None else None}
                        for annotation in root.findall('object')],
             "polygons": [], "points": []}
@@ -115,6 +124,12 @@ def write_pascal_voc(sample: dict) -> None:
         if bbox["rotation"] is not None:
             etree.SubElement(xml_bbox, "rotation").text = str(bbox["rotation"])
 
+        if bbox["mirror_horizontal"]:
+            etree.SubElement(xml_bbox, "mirror").text = "horizontal"
+
+        if bbox["mirror_vertical"]:
+            etree.SubElement(xml_bbox, "mirror").text = "vertical"
+
         if bbox["text"]:
             etree.SubElement(xml_obj, "text").text = bbox["text"]
 
@@ -143,6 +158,8 @@ def read_labelme(path: str) -> dict:
                                    'ymax': max(point[1] for point in shape['points'])},
                           'points': shape['points'],
                           'rotation': shape.get('rotation', None),
+                          'mirror_horizontal': shape.get('mirror_horizontal', None),
+                          'mirror_vertical': shape.get('mirror_vertical', None),
                           'text': shape.get('text', None),
                           'group': shape.get('group_id', None)}
                          for shape in json_data['shapes']
@@ -168,6 +185,8 @@ def write_labelme(geo_data: dict, path: str = None) -> None:
                                'group_id': polygon.get('group', None),
                                'description': polygon.get('description', None),
                                **({'rotation': polygon['rotation']} if polygon.get('rotation', None) else {}),
+                               **({'mirror_horizontal': polygon['mirror_horizontal']} if polygon.get('mirror_horizontal') else {}),
+                               **({'mirror_vertical': polygon['mirror_vertical']} if polygon.get('mirror_vertical') else {}),
                                **({'text': polygon['text']} if polygon.get('text', None) else {}),
                                'shape_type': 'polygon', 'flags': {}}
                               for polygon in geo_data['polygons']] +
@@ -194,9 +213,9 @@ def read_dataset(drafter: int = None, circuit: int = None, segmentation=False, f
     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
+                   if (folder if folder else (f"instances" if segmentation else f"annotations")) in root and
                       (not circuit or f"C{circuit}_" in file_name) and
-                      (not drafter or f"drafter_{drafter}{os.sep}" in root)],
+                      (drafter is None or f"drafter_{drafter}{os.sep}" in root)],
                   key=lambda sample: sample["circuit"]*100+sample["drawing"]*10+sample["picture"])
 
 
@@ -207,13 +226,18 @@ def write_dataset(db: list, segmentation=False) -> None:
         (write_labelme if segmentation else write_pascal_voc)(sample)
 
 
+def read_image(sample: dict) -> np.ndarray:
+    """Loads the Image Associated with a DB Sample"""
+
+    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)))
+
+
 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)]
+    return [(read_image(sample), sample) for sample in read_dataset(**kwargs)]
 
 
 def read_snippets(**kwargs):
@@ -242,3 +266,4 @@ if __name__ == "__main__":
                 snippet = cv2.rotate(snippet, cv2.ROTATE_90_COUNTERCLOCKWISE)
 
             cv2.imwrite(join("test", f"{bbox['text']}___{sample}_{bbox['ymin']}_{bbox['ymax']}_{bbox['xmin']}_{bbox['xmax']}.png"), snippet)
+