| """segmentation.py: Toolkit for Generation of Instance Segmentation Material""" |
|
|
| |
| import sys |
| import os |
| from os.path import join, exists |
| import json |
| from math import dist |
|
|
| |
| from loader import read_pascal_voc, read_labelme, write_labelme, load_classes_ports |
| from utils import transform, associated_keypoints, overlap |
|
|
| |
| 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: -(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"]]) |
|
|
| 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(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)], |
| 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'] = [] |
| xml_data['img_path'] = join("..", "segmentation", f"{sample}.{suffix}") |
| xml_data['polygons'] = [{'class': bbox['class'], 'group': None, |
| 'points': [[bbox['xmin'], bbox['ymin']], |
| [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 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, 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)}") |
| 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())}") |
|
|
