| | """loader.py: Load and Store Functions for the Dataset""" |
| |
|
| | |
| | import os, sys |
| | from os.path import join, realpath |
| | import json |
| | import xml.etree.ElementTree as ET |
| |
|
| | |
| | import cv2 |
| | import numpy as np |
| | from lxml import etree |
| |
|
| | __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 sample_name(sample: dict) -> str: |
| | """Returns the Name of a Sample""" |
| |
|
| | 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""" |
| |
|
| | return f"{sample_name(sample)}.{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, |
| | "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": []} |
| |
|
| |
|
| | 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["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"] |
| |
|
| | 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'].replace("\\", "/"), 'drafter': drafter, 'circuit': circuit, |
| | 'drawing': drawing, 'picture': picture, 'format': suffix, |
| | 'height': json_data['imageHeight'], 'width': json_data['imageWidth'], 'bboxes': [], |
| | '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), |
| | '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'] |
| | 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': '5.2.0', |
| | 'flags': {}, |
| | 'shapes': [{'line_color': None, 'fill_color': None,'label': polygon['class'], |
| | 'points': polygon['points'], |
| | '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']] + |
| | [{'label': point['class'], 'points': [[point['points'][0], point['points'][1]]], |
| | 'group_id': point['group'], 'shape_type': 'point', 'flags': {}} |
| | 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) |
| |
|
| |
|
| | 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 (f"instances" if segmentation else f"annotations")) in root and |
| | (not circuit or f"C{circuit}_" in file_name) and |
| | (drafter is None 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_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""" |
| |
|
| | return [(read_image(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, sample_name(annotations))] |
| |
|
| | 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 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']}___{sample}_{bbox['ymin']}_{bbox['ymax']}_{bbox['xmin']}_{bbox['xmax']}.png"), snippet) |
| |
|
| |
|
