|
"""consistency.py: Integrity Check, Correction by Mapping for Annotation Class, Metadata Cleaning, Statistics""" |
|
|
|
|
|
import os |
|
import sys |
|
import re |
|
|
|
|
|
from loader import load_classes, load_properties, read_dataset, write_dataset, file_name |
|
from utils import bbdist |
|
|
|
|
|
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__ = "[email protected]" |
|
__status__ = "Prototype" |
|
|
|
|
|
|
|
|
|
|
|
MAPPING_LOOKUP = { |
|
"integrated_cricuit": "integrated_circuit", |
|
"zener": "diode.zener" |
|
} |
|
|
|
|
|
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 annotation in sample["bboxes"] + sample["polygons"] + sample["points"]: |
|
total += 1 |
|
|
|
if annotation["class"] in classes: |
|
ok += 1 |
|
|
|
if annotation["class"] in recover: |
|
annotation["class"] = recover[annotation["class"]] |
|
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']}") |
|
faulty += 1 |
|
|
|
if annotation["rotation"] is not None: |
|
rotation += 1 |
|
|
|
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 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 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 |
|
|
|
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 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([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) |
|
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) -> 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) |
|
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 unique_characters(texts: list) -> list: |
|
"""Returns the Sorted Set of Unique Characters""" |
|
|
|
char_set = set([char for text in texts for char in text]) |
|
return sorted(list(char_set)) |
|
|
|
|
|
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 texts]) |
|
for char in chars] |
|
plt.bar(char_nbrs, char_counts) |
|
plt.xticks(char_nbrs, chars) |
|
plt.title("Character Distribution") |
|
plt.xlabel("Character") |
|
plt.ylabel("Overall Count") |
|
plt.show() |
|
|
|
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 = [] |
|
|
|
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() |
|
|
|
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_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) |
|
consistency_circuit(db_bb, classes) |
|
text_statistics(db_bb) |
|
|
