label-studio-sdk 0.0.32__py3-none-any.whl → 1.0.0__py3-none-any.whl

label_studio_sdk/converter/imports/colors.py

@@ -0,0 +1,198 @@
+COLORS = [
+    (218, 1, 238),
+    (0, 255, 0),
+    (1, 146, 243),
+    (241, 135, 0),
+    (12, 0, 184),
+    (72, 124, 73),
+    (187, 1, 37),
+    (166, 250, 86),
+    (178, 135, 216),
+    (0, 252, 159),
+    (116, 239, 254),
+    (252, 65, 124),
+    (99, 56, 252),
+    (252, 183, 127),
+    (115, 41, 127),
+    (255, 255, 0),
+    (137, 176, 1),
+    (95, 192, 153),
+    (1, 53, 87),
+    (148, 86, 0),
+    (179, 123, 99),
+    (5, 168, 6),
+    (33, 101, 165),
+    (3, 232, 254),
+    (254, 86, 239),
+    (64, 234, 74),
+    (188, 228, 185),
+    (45, 74, 0),
+    (2, 170, 123),
+    (251, 53, 7),
+    (250, 176, 247),
+    (176, 61, 197),
+    (127, 255, 0),
+    (99, 1, 6),
+    (199, 4, 140),
+    (0, 71, 252),
+    (101, 164, 251),
+    (255, 255, 127),
+    (215, 197, 46),
+    (117, 3, 199),
+    (70, 0, 82),
+    (116, 120, 156),
+    (244, 121, 164),
+    (147, 186, 88),
+    (183, 55, 82),
+    (96, 253, 180),
+    (19, 194, 191),
+    (0, 0, 255),
+    (254, 7, 79),
+    (77, 135, 0),
+    (103, 62, 54),
+    (82, 111, 222),
+    (254, 121, 80),
+    (176, 195, 252),
+    (60, 215, 6),
+    (53, 50, 196),
+    (186, 168, 150),
+    (52, 180, 59),
+    (2, 108, 105),
+    (5, 3, 119),
+    (1, 117, 28),
+    (248, 34, 189),
+    (212, 92, 35),
+    (252, 216, 188),
+    (74, 3, 252),
+    (255, 0, 0),
+    (193, 245, 20),
+    (139, 130, 41),
+    (1, 223, 106),
+    (72, 85, 115),
+    (147, 0, 96),
+    (160, 22, 253),
+    (144, 96, 251),
+    (64, 149, 178),
+    (182, 254, 244),
+    (47, 30, 32),
+    (5, 51, 149),
+    (138, 176, 198),
+    (71, 5, 144),
+    (2, 216, 42),
+    (73, 208, 226),
+    (109, 235, 121),
+    (161, 87, 139),
+    (120, 221, 46),
+    (114, 73, 187),
+    (149, 33, 8),
+    (207, 218, 117),
+    (42, 253, 212),
+    (189, 154, 12),
+    (1, 0, 56),
+    (106, 154, 114),
+    (230, 130, 245),
+    (3, 149, 73),
+    (210, 52, 252),
+    (254, 234, 63),
+    (216, 159, 83),
+    (52, 227, 152),
+    (211, 187, 204),
+    (0, 142, 181),
+    (44, 76, 58),
+    (127, 98, 89),
+    (149, 209, 148),
+    (52, 130, 124),
+    (0, 102, 212),
+    (58, 198, 109),
+    (196, 50, 141),
+    (252, 163, 185),
+    (254, 207, 3),
+    (177, 15, 195),
+    (27, 187, 253),
+    (224, 79, 187),
+    (130, 221, 204),
+    (225, 216, 252),
+    (251, 0, 149),
+    (203, 47, 28),
+    (254, 167, 43),
+    (94, 96, 17),
+    (242, 49, 67),
+    (155, 253, 146),
+    (63, 42, 96),
+    (104, 166, 48),
+    (189, 122, 160),
+    (35, 36, 247),
+    (195, 93, 238),
+    (1, 253, 68),
+    (217, 95, 107),
+    (140, 4, 150),
+    (117, 13, 55),
+    (93, 45, 0),
+    (0, 58, 28),
+    (80, 254, 28),
+    (165, 200, 34),
+    (123, 134, 205),
+    (34, 111, 254),
+    (208, 18, 86),
+    (254, 35, 248),
+    (228, 251, 199),
+    (64, 2, 202),
+    (65, 50, 144),
+    (164, 87, 53),
+    (113, 254, 75),
+    (1, 40, 205),
+    (218, 254, 88),
+    (154, 98, 193),
+    (58, 147, 230),
+    (47, 254, 117),
+    (145, 137, 254),
+    (249, 95, 1),
+    (78, 177, 4),
+    (128, 42, 216),
+    (207, 253, 146),
+    (150, 143, 134),
+    (52, 78, 230),
+    (153, 41, 162),
+    (137, 42, 83),
+    (185, 112, 1),
+    (121, 200, 246),
+    (173, 158, 61),
+    (10, 203, 146),
+    (203, 127, 53),
+    (109, 210, 1),
+    (43, 143, 38),
+    (51, 176, 146),
+    (71, 254, 252),
+    (221, 145, 132),
+    (7, 188, 82),
+    (100, 198, 82),
+    (90, 179, 200),
+    (101, 34, 172),
+    (1, 228, 205),
+    (205, 163, 245),
+    (200, 210, 0),
+    (111, 157, 166),
+    (152, 254, 208),
+    (22, 73, 118),
+    (165, 62, 254),
+    (254, 84, 59),
+    (58, 162, 100),
+    (227, 16, 33),
+    (233, 30, 124),
+    (247, 200, 81),
+    (167, 29, 114),
+    (230, 177, 1),
+    (212, 149, 187),
+    (224, 5, 188),
+    (153, 248, 40),
+    (181, 210, 79),
+    (121, 1, 247),
+    (115, 78, 140),
+    (224, 201, 157),
+    (84, 30, 222),
+    (33, 248, 35),
+    (6, 124, 142),
+    (80, 97, 157),
+    (216, 113, 201),
+    (24, 109, 67),
+]

label_studio_sdk/converter/imports/label_config.py

@@ -0,0 +1,45 @@
+from label_studio_sdk.converter.imports.colors import COLORS
+
+
+LABELS = """
+  <{# TAG_NAME #} name="{# FROM_NAME #}" toName="image">
+{# LABELS #}  </{# TAG_NAME #}>
+"""
+
+LABELING_CONFIG = """<View>
+  <Image name="{# TO_NAME #}" value="$image"/>
+{# BODY #}</View>
+"""
+
+
+def generate_label_config(
+    categories, tags, to_name="image", from_name="label", filename=None
+):
+    labels = ""
+    for key in sorted(categories.keys()):
+        color = COLORS[int(key) % len(COLORS)]
+        label = f'    <Label value="{categories[key]}" background="rgba({color[0]}, {color[1]}, {color[2]}, 1)"/>\n'
+        labels += label
+
+    body = ""
+    for from_name in tags:
+        tag_body = (
+            str(LABELS)
+            .replace("{# TAG_NAME #}", tags[from_name])
+            .replace("{# LABELS #}", labels)
+            .replace("{# TO_NAME #}", to_name)
+            .replace("{# FROM_NAME #}", from_name)
+        )
+        body += f'\n  <Header value="{tags[from_name]}"/>' + tag_body
+
+    config = (
+        str(LABELING_CONFIG)
+        .replace("{# BODY #}", body)
+        .replace("{# TO_NAME #}", to_name)
+    )
+
+    if filename:
+        with open(filename, "w") as f:
+            f.write(config)
+
+    return config

label_studio_sdk/converter/imports/pathtrack.py

@@ -0,0 +1,269 @@
+"""PathTrack BBoxes to Label Studio convert
+https://www.trace.ethz.ch/publications/2017/pathtrack/index.html
+"""
+
+import os
+import sys
+import json
+import uuid
+import logging
+
+from types import SimpleNamespace
+
+logger = logging.getLogger()
+logger.setLevel(logging.DEBUG)
+
+handler = logging.StreamHandler(sys.stdout)
+handler.setLevel(logging.DEBUG)
+formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+handler.setFormatter(formatter)
+logger.addHandler(handler)
+
+try:
+    import bs4
+except ImportError:
+    logger.info('To use PathTrack convert do "pip install bs4"')
+
+
+def get_labels():
+    return {i: "Other" for i in range(0, 1000)}
+
+
+def get_info(path):
+    with open(path) as f:
+        b = bs4.BeautifulSoup(f.read())
+        return SimpleNamespace(
+            fps=float(b.root.doc.fps.get_text()),
+            original_width=int(b.root.doc.imw.get_text()),
+            original_height=int(b.root.doc.imh.get_text()),
+            frame_count=int(b.root.doc.num_frames.get_text()),
+        )
+
+
+def new_task(data, result, ground_truth=False, model_version=None, score=None):
+    """
+    :param data: dict
+    :param result: annotation results with regions
+    :param ground_truth: only for annotations
+    :param model_version: if not None, there will be prediction
+    :param score: prediction score, used only if model_version is not None
+    """
+    task = {"data": data}
+
+    # add predictions or annotations
+    if model_version:
+        task["predictions"] = [
+            {"result": result, "model_version": model_version, "score": score}
+        ]
+    else:
+        task["annotations"] = [{"result": result, "ground_truth": ground_truth}]
+
+    return task
+
+
+def new_region(labels, info, from_name, to_name):
+    region = {
+        "id": uuid.uuid4().hex[0:10],
+        "type": "videorectangle",
+        "value": {"sequence": [], "framesCount": info.frame_count},
+        "origin": "manual",
+        "to_name": to_name,
+        "from_name": from_name,
+    }
+
+    if labels is not None:
+        region["value"]["labels"] = labels
+
+    return region
+
+
+def new_keyframe(region, bbox, info):
+    region["value"]["sequence"].append(
+        {
+            "x": bbox.x / info.original_width * 100,
+            "y": bbox.y / info.original_height * 100,
+            "width": bbox.width / info.original_width * 100,
+            "height": bbox.height / info.original_height * 100,
+            "time": bbox.frame / info.fps,
+            "frame": bbox.frame,
+            "enabled": False,
+            "rotation": 0,
+        }
+    )
+    return region
+
+
+def generator(path):
+    with open(path) as f:
+        lines = f.readlines()
+
+    for line in lines:
+        v = line.split()
+        yield SimpleNamespace(
+            frame=int(v[0]),
+            bbox_id=int(v[1]),
+            label_id=int(v[1]),
+            x=int(v[2]),
+            y=int(v[3]),
+            width=int(v[4]),
+            height=int(v[5]),
+        )
+
+
+def create_config(
+    from_name="box", to_name="video", source_value="video", target_fps=None
+):
+    return f"""<View>
+   <Header>Label the video:</Header>
+   <Video name="{to_name}" value="${source_value}" framerate="{target_fps}"/>
+   <VideoRectangle name="{from_name}" toName="{to_name}" />
+   <Labels name="videoLabels" toName="{to_name}" allowEmpty="true">
+     <Label value="Man" background="blue"/>
+     <Label value="Woman" background="red"/>
+     <Label value="Other" background="green"/>
+   </Labels>
+</View>
+    """
+
+
+def convert_shot(
+    input_url,
+    label_file,
+    info_file,
+    from_name="box",
+    to_name="video",
+    source_value="video",
+    target_fps=None,
+    hop_keyframes=0,
+):
+    """Convert bounding boxes from PathTrack to Label Studio video format
+
+    :param input_url: video file
+    :param label_file: text file with annotations line by line
+    :param info_file: info.xml with frame rate and other useful info
+    :param from_name: control tag name from Label Studio labeling config
+    :param to_name: object name from Label Studio labeling config
+    :param source_value: source name for Video tag, e.g. $video
+    :param target_fps: keep video with this fps only
+    :param hop_keyframes: how many keyframes to skip
+    """
+    logger.info("Converting of the shot is starting: %s", input_url)
+    if not os.path.exists(label_file):
+        return None
+
+    info = get_info(info_file)
+    if target_fps is not None and info.fps != target_fps:
+        return None
+
+    label_map = get_labels()
+    regions = {}
+    keyframe_count = 0
+
+    # convert all bounding boxes to Label Studio Results
+    for v in generator(label_file):
+        idx = v.label_id
+        if idx in regions:
+            region = regions[idx]
+        else:
+            labels = [label_map[idx]] if idx in label_map else None
+            region = regions[idx] = new_region(labels, info, from_name, to_name)
+
+        # enable previous lifespan
+        if len(regions[idx]["value"]["sequence"]) > 0:
+            regions[idx]["value"]["sequence"][-1]["enabled"] = True
+
+        regions[idx] = new_keyframe(region, bbox=v, info=info)
+        keyframe_count += 1
+
+    # keep only each <hop> keyframe
+    if hop_keyframes > 1:
+        for r in regions:
+            last = regions[r]["value"]["sequence"][-1]
+            regions[r]["value"]["sequence"] = regions[r]["value"]["sequence"][
+                0:-1:hop_keyframes
+            ]
+            if regions[r]["value"]["sequence"][-1] != last:
+                regions[r]["value"]["sequence"].append(last)
+
+    logger.info(
+        "Shot with %i regions and %i keyframes created", len(regions), keyframe_count
+    )
+    data = {source_value: input_url}
+    return new_task(data, result=list(regions.values()))
+
+
+def convert_dataset(
+    root_dir,
+    root_url,
+    from_name="box",
+    to_name="video",
+    source_value="video",
+    target_fps=None,
+    hop_keyframes=0,
+):
+    """Convert PathTrack dataset to Label Studio video labeling format
+
+    :param root_dir: root dir with video folders, e.g.: 'pathtrack/train' or 'pathtrack/test'
+    :param root_url: where the dataset is served by http/https
+    :param to_name: object name from Label Studio labeling config
+    :param from_name: control tag name from Label Studio labeling config
+    :param source_value: source name for Video tag, e.g. $video
+    :param target_fps: keep video with this fps only
+    :param hop_keyframes: how many keyframes to skip
+    """
+    logger.info("Convert dataset start: %s", root_dir)
+    tasks = []
+
+    if not root_url.endswith("/"):
+        root_url += "/"
+
+    for d in os.listdir(root_dir):
+        shot_dir = os.path.join(root_dir, d)
+        if not os.path.isdir(shot_dir):
+            continue
+
+        input_url = root_url + d + "/video.mp4"
+        label_file = os.path.join(shot_dir, "gt/gt.txt")
+        info_file = os.path.join(shot_dir, "info.xml")
+
+        task = convert_shot(
+            input_url,
+            label_file,
+            info_file,
+            from_name,
+            to_name,
+            source_value,
+            target_fps,
+            hop_keyframes,
+        )
+        if task is None:
+            continue
+
+        tasks.append(task)
+
+    fps_name = int(target_fps)
+    path = os.path.join(root_dir, f"import-{fps_name}.json")
+    logger.info("Saving Label Studio JSON: %s", path)
+    with open(path, "w") as f:
+        json.dump(tasks, f)
+
+    path = os.path.join(root_dir, f"config-{fps_name}.xml")
+    logger.info("Saving Labeling Config: %s", path)
+    config = create_config(from_name, to_name, source_value, target_fps)
+    with open(path, "w") as f:
+        f.write(config)
+
+
+if __name__ == "__main__":
+    # convert_dataset('../../tests', 'https://data.heartex.net/pathtrack/train/')
+    # exit()
+    print(f"Usage: {sys.argv[0]} root_url target_fps\n")
+
+    url = (
+        sys.argv[1]
+        if len(sys.argv) > 1
+        else "https://data.heartex.net/pathtrack/train/"
+    )
+    fps = float(sys.argv[2]) if len(sys.argv) > 2 else None
+    hop = int(sys.argv[3]) if len(sys.argv) > 3 else 0
+    convert_dataset("./", url, target_fps=fps, hop_keyframes=hop)