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

label_studio_sdk/converter/imports/yolo.py

@@ -0,0 +1,236 @@
+import os
+import json  # better to use "imports ujson as json" for the best performance
+
+import uuid
+import logging
+
+from PIL import Image
+from typing import Optional, Tuple
+from urllib.request import (
+    pathname2url,
+)  # for converting "+","*", etc. in file paths to appropriate urls
+
+from label_studio_sdk.converter.utils import ExpandFullPath
+from label_studio_sdk.converter.imports.label_config import generate_label_config
+
+logger = logging.getLogger("root")
+default_image_root_url = "/data/local-files/?d=images"
+
+
+def convert_yolo_to_ls(
+    input_dir,
+    out_file,
+    to_name="image",
+    from_name="label",
+    out_type="annotations",
+    image_root_url=default_image_root_url,
+    image_ext=".jpg,.jpeg,.png",
+    image_dims: Optional[Tuple[int, int]] = None,
+):
+    """Convert YOLO labeling to Label Studio JSON
+    :param input_dir: directory with YOLO where images, labels, notes.json are located
+    :param out_file: output file with Label Studio JSON tasks
+    :param to_name: object name from Label Studio labeling config
+    :param from_name: control tag name from Label Studio labeling config
+    :param out_type: annotation type - "annotations" or "predictions"
+    :param image_root_url: root URL path where images will be hosted, e.g.: http://example.com/images
+    :param image_ext: image extension/s - single string or comma separated list to search, eg. .jpeg or .jpg, .png and so on.
+    :param image_dims: image dimensions - optional tuple of integers specifying the image width and height of *all* images in the dataset. Defaults to opening the image to determine it's width and height, which is slower. This should only be used in the special case where you dataset has uniform image dimesions.
+    """
+
+    tasks = []
+    logger.info("Reading YOLO notes and categories from %s", input_dir)
+
+    # build categories=>labels dict
+    notes_file = os.path.join(input_dir, "classes.txt")
+    with open(notes_file) as f:
+        lines = [line.strip() for line in f.readlines()]
+    categories = {i: line for i, line in enumerate(lines)}
+    logger.info(f"Found {len(categories)} categories")
+
+    # generate and save labeling config
+    label_config_file = out_file.replace(".json", "") + ".label_config.xml"
+    generate_label_config(
+        categories,
+        {from_name: "RectangleLabels"},
+        to_name,
+        from_name,
+        label_config_file,
+    )
+
+    # define directories
+    labels_dir = os.path.join(input_dir, "labels")
+    images_dir = os.path.join(input_dir, "images")
+    logger.info("Converting labels from %s", labels_dir)
+
+    # build array out of provided comma separated image_extns (str -> array)
+    image_ext = [x.strip() for x in image_ext.split(",")]
+    logger.info(f"image extensions->, {image_ext}")
+
+    # loop through images
+    for f in os.listdir(images_dir):
+        image_file_found_flag = False
+        for ext in image_ext:
+            if f.endswith(ext):
+                image_file = f
+                image_file_base = os.path.splitext(f)[0]
+                image_file_found_flag = True
+                break
+        if not image_file_found_flag:
+            continue
+
+        image_root_url += "" if image_root_url.endswith("/") else "/"
+        task = {
+            "data": {
+                # eg. '../../foo+you.py' -> '../../foo%2Byou.py'
+                "image": image_root_url
+                + str(pathname2url(image_file))
+            }
+        }
+
+        # define coresponding label file and check existence
+        label_file = os.path.join(labels_dir, image_file_base + ".txt")
+
+        if os.path.exists(label_file):
+            task[out_type] = [
+                {
+                    "result": [],
+                    "ground_truth": False,
+                }
+            ]
+
+            # read image sizes
+            if image_dims is None:
+                # default to opening file if we aren't given image dims. slow!
+                with Image.open(os.path.join(images_dir, image_file)) as im:
+                    image_width, image_height = im.size
+            else:
+                image_width, image_height = image_dims
+
+            with open(label_file) as file:
+                # convert all bounding boxes to Label Studio Results
+                lines = file.readlines()
+                for line in lines:
+                    values = line.split()
+                    label_id, x, y, width, height = values[0:5]
+                    score = float(values[5]) if len(values) >= 6 else None
+                    x, y, width, height = (
+                        float(x),
+                        float(y),
+                        float(width),
+                        float(height),
+                    )
+                    item = {
+                        "id": uuid.uuid4().hex[0:10],
+                        "type": "rectanglelabels",
+                        "value": {
+                            "x": (x - width / 2) * 100,
+                            "y": (y - height / 2) * 100,
+                            "width": width * 100,
+                            "height": height * 100,
+                            "rotation": 0,
+                            "rectanglelabels": [categories[int(label_id)]],
+                        },
+                        "to_name": to_name,
+                        "from_name": from_name,
+                        "image_rotation": 0,
+                        "original_width": image_width,
+                        "original_height": image_height,
+                    }
+                    if score:
+                        item["score"] = score
+                    task[out_type][0]["result"].append(item)
+
+        tasks.append(task)
+
+    if len(tasks) > 0:
+        logger.info("Saving Label Studio JSON to %s", out_file)
+        with open(out_file, "w") as out:
+            json.dump(tasks, out)
+
+        help_root_dir = ""
+        if image_root_url == default_image_root_url:
+            help_root_dir = (
+                f"Set environment variables LABEL_STUDIO_LOCAL_FILES_SERVING_ENABLED=true and "
+                f"LABEL_STUDIO_LOCAL_FILES_DOCUMENT_ROOT={input_dir} for Label Studio run,\n"
+                f"add Local Storage with Absolute local path = {input_dir}/images"
+            )
+
+        print(
+            "\n"
+            f"  1. Create a new project in Label Studio\n"
+            f'  2. Use Labeling Config from "{label_config_file}"\n'
+            f"  3. Setup serving for images\n"
+            f"       E.g. you can use Local Storage (or others):\n"
+            f"       https://labelstud.io/guide/storage.html#Local-storage\n"
+            f"       See tutorial here:\nhttps://github.com/HumanSignal/label-studio-converter/tree/master?tab=readme-ov-file#yolo-to-label-studio-converter\n"
+            f"       {help_root_dir}\n"
+            f'  4. Import "{out_file}" to the project\n'
+        )
+    else:
+        logger.error("No labels converted")
+
+
+def add_parser(subparsers):
+    yolo = subparsers.add_parser("yolo")
+
+    yolo.add_argument(
+        "-i",
+        "--input",
+        dest="input",
+        required=True,
+        help="directory with YOLO where images, labels, notes.json are located",
+        action=ExpandFullPath,
+    )
+    yolo.add_argument(
+        "-o",
+        "--output",
+        dest="output",
+        help="output file with Label Studio JSON tasks",
+        default="output.json",
+        action=ExpandFullPath,
+    )
+    yolo.add_argument(
+        "--to-name",
+        dest="to_name",
+        help="object name from Label Studio labeling config",
+        default="image",
+    )
+    yolo.add_argument(
+        "--from-name",
+        dest="from_name",
+        help="control tag name from Label Studio labeling config",
+        default="label",
+    )
+    yolo.add_argument(
+        "--out-type",
+        dest="out_type",
+        help='annotation type - "annotations" or "predictions"',
+        default="annotations",
+    )
+    yolo.add_argument(
+        "--image-root-url",
+        dest="image_root_url",
+        help="root URL path where images will be hosted, e.g.: http://example.com/images",
+        default=default_image_root_url,
+    )
+    yolo.add_argument(
+        "--image-ext",
+        dest="image_ext",
+        help="image extension to search: .jpeg or .jpg, .png",
+        default=".jpg",
+    )
+    yolo.add_argument(
+        "--image-dims",
+        dest="image_dims",
+        type=int,
+        nargs=2,
+        help=(
+            "optional tuple of integers specifying the image width and height of *all* "
+            "images in the dataset. Defaults to opening the image to determine it's width "
+            "and height, which is slower. This should only be used in the special "
+            "case where you dataset has uniform image dimesions. e.g. `--image-dims 600 800` "
+            "if all your images are of dimensions width=600, height=800"
+        ),
+        default=None,
+    )

label_studio_sdk/converter/main.py

@@ -0,0 +1,202 @@
+import argparse
+import logging
+import os
+
+from label_studio_sdk.converter.converter import (
+    Converter,
+    Format,
+    FormatNotSupportedError,
+)
+from label_studio_sdk.converter.exports.csv import ExportToCSV
+from label_studio_sdk.converter.imports import yolo as import_yolo, coco as import_coco
+from label_studio_sdk.converter.utils import ExpandFullPath
+
+logging.basicConfig(level=logging.INFO)
+
+
+def get_export_args(parser):
+    parser.add_argument(
+        "-i",
+        "--input",
+        dest="input",
+        required=True,
+        help='Directory or JSON file with annotations (e.g. "/<project_path>/annotations")',
+        action=ExpandFullPath,
+    )
+    parser.add_argument(
+        "-c",
+        "--config",
+        dest="config",
+        help='Project config (e.g. "/<project_path>/config.xml")',
+        action=ExpandFullPath,
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        dest="output",
+        help="Output file or directory (will be created if not exists)",
+        default=os.path.join(os.path.dirname(__file__), "output"),
+        action=ExpandFullPath,
+    )
+    parser.add_argument(
+        "-f",
+        "--format",
+        dest="format",
+        metavar="FORMAT",
+        help="Output format: " + ", ".join(f.name for f in Format),
+        type=Format.from_string,
+        choices=list(Format),
+        default=Format.JSON,
+    )
+    parser.add_argument(
+        "--csv-separator",
+        dest="csv_separator",
+        help="Separator used in CSV format",
+        default=",",
+    )
+    parser.add_argument(
+        "--csv-no-header",
+        dest="csv_no_header",
+        help="Whether to omit header in CSV output file",
+        action="store_true",
+    )
+    parser.add_argument(
+        "--image-dir",
+        dest="image_dir",
+        help="In case of image outputs (COCO, VOC, ...), specifies output image directory where downloaded images will "
+        "be stored. (If not specified, local image paths left untouched)",
+    )
+    parser.add_argument(
+        "--project-dir",
+        dest="project_dir",
+        default=None,
+        help="Label Studio project directory path",
+    )
+    parser.add_argument(
+        "--heartex-format",
+        dest="heartex_format",
+        action="store_true",
+        default=True,
+        help="Set this flag if your annotations are in one JSON file instead of multiple JSON files from directory",
+    )
+
+
+def get_all_args():
+    parser = argparse.ArgumentParser()
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+    subparsers.required = False
+
+    # Export
+    parser_export = subparsers.add_parser(
+        "export",
+        help="Converter from Label Studio JSON annotations to external formats",
+    )
+    get_export_args(parser_export)
+
+    # Import
+    parser_import = subparsers.add_parser(
+        "import",
+        help="Converter from external formats to Label Studio JSON annotations",
+    )
+    import_format = parser_import.add_subparsers(dest="import_format")
+    import_yolo.add_parser(import_format)
+    import_coco.add_parser(import_format)
+
+    return parser.parse_args()
+
+
+def export(args):
+    c = Converter(args.config, project_dir=args.project_dir)
+
+    if args.format == Format.JSON:
+        c.convert_to_json(args.input, args.output)
+    elif args.format == Format.CSV:
+        header = not args.csv_no_header
+        sep = args.csv_separator
+        c.convert_to_csv(
+            args.input,
+            args.output,
+            sep=sep,
+            header=header,
+            is_dir=not args.heartex_format,
+        )
+    elif args.format == Format.CSV_OLD:
+        header = not args.csv_no_header
+        sep = args.csv_separator
+        ExportToCSV(args.input).to_file(
+            args.output, sep=sep, header=header, index=False
+        )
+    elif args.format == Format.TSV:
+        header = not args.csv_no_header
+        sep = "\t"
+        c.convert_to_csv(
+            args.input,
+            args.output,
+            sep=sep,
+            header=header,
+            is_dir=not args.heartex_format,
+        )
+    elif args.format == Format.CONLL2003:
+        c.convert_to_conll2003(args.input, args.output, is_dir=not args.heartex_format)
+    elif args.format == Format.COCO:
+        c.convert_to_coco(
+            args.input,
+            args.output,
+            output_image_dir=args.image_dir,
+            is_dir=not args.heartex_format,
+        )
+    elif args.format == Format.VOC:
+        c.convert_to_voc(
+            args.input,
+            args.output,
+            output_image_dir=args.image_dir,
+            is_dir=not args.heartex_format,
+        )
+    elif args.format == Format.YOLO:
+        c.convert_to_yolo(args.input, args.output, is_dir=not args.heartex_format)
+    elif args.format == Format.YOLO_OBB:
+        c.convert_to_yolo(
+            args.input, args.output, is_dir=not args.heartex_format, is_obb=True
+        )
+    else:
+        raise FormatNotSupportedError()
+
+
+def imports(args):
+    if args.import_format == "yolo":
+        import_yolo.convert_yolo_to_ls(
+            input_dir=args.input,
+            out_file=args.output,
+            to_name=args.to_name,
+            from_name=args.from_name,
+            out_type=args.out_type,
+            image_root_url=args.image_root_url,
+            image_ext=args.image_ext,
+        )
+
+    elif args.import_format == "coco":
+        import_coco.convert_coco_to_ls(
+            input_file=args.input,
+            out_file=args.output,
+            to_name=args.to_name,
+            from_name=args.from_name,
+            out_type=args.out_type,
+            image_root_url=args.image_root_url,
+            point_width=args.point_width,
+        )
+    else:
+        raise FormatNotSupportedError()
+
+
+def main():
+    args = get_all_args()
+    if args.command == "export":
+        export(args)
+    elif args.command == "import":
+        imports(args)
+    else:
+        print('Please, use "import" or "export" or "-h" command')
+
+
+if __name__ == "__main__":
+    main()