segmentation.py

"""segmentation.py: Toolkit for Generation of Instance Segmentation Material"""

# System Imports
import sys
import os
from os.path import join, exists
import json
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, overlap

# Third-Party Imports
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'] = []                                                   # Adapt to Segmentation Scenario
    xml_data['img_path'] = join("..", "segmentation", f"{sample}.{suffix}")   # Alter source image
    xml_data['polygons'] = [{'class': bbox['class'], 'group': None,           # Keep Class, Prune Rotation and Texts
                             'points': [[bbox['xmin'], bbox['ymin']],         # Turn Rectangles into Polygons
                                        [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())}")