Add files using upload-large-folder tool

testbed/openvinotoolkit__datumaro/datumaro/cli/__init__.py

@@ -0,0 +1,4 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT

testbed/openvinotoolkit__datumaro/datumaro/cli/commands/convert.py

@@ -0,0 +1,137 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+import argparse
+import logging as log
+import os
+import os.path as osp
+
+from datumaro.components.project import Environment
+
+from ..contexts.project import FilterModes
+from ..util import CliException, MultilineFormatter, make_file_name
+from ..util.project import generate_next_file_name
+
+
+def build_parser(parser_ctor=argparse.ArgumentParser):
+    builtin_importers = sorted(Environment().importers.items)
+    builtin_converters = sorted(Environment().converters.items)
+
+    parser = parser_ctor(help="Convert an existing dataset to another format",
+        description="""
+            Converts a dataset from one format to another.
+            You can add your own formats using a project.|n
+            |n
+            Supported input formats: %s|n
+            |n
+            Supported output formats: %s|n
+            |n
+            Examples:|n
+            - Export a dataset as a PASCAL VOC dataset, include images:|n
+            |s|sconvert -i src/path -f voc -- --save-images|n
+            |n
+            - Export a dataset as a COCO dataset to a specific directory:|n
+            |s|sconvert -i src/path -f coco -o path/I/like/
+        """ % (', '.join(builtin_importers), ', '.join(builtin_converters)),
+        formatter_class=MultilineFormatter)
+
+    parser.add_argument('-i', '--input-path', default='.', dest='source',
+        help="Path to look for a dataset")
+    parser.add_argument('-if', '--input-format',
+        help="Input dataset format. Will try to detect, if not specified.")
+    parser.add_argument('-f', '--output-format', required=True,
+        help="Output format")
+    parser.add_argument('-o', '--output-dir', dest='dst_dir',
+        help="Directory to save output (default: a subdir in the current one)")
+    parser.add_argument('--overwrite', action='store_true',
+        help="Overwrite existing files in the save directory")
+    parser.add_argument('-e', '--filter',
+        help="Filter expression for dataset items")
+    parser.add_argument('--filter-mode', default=FilterModes.i.name,
+        type=FilterModes.parse,
+        help="Filter mode (options: %s; default: %s)" % \
+            (', '.join(FilterModes.list_options()) , '%(default)s'))
+    parser.add_argument('extra_args', nargs=argparse.REMAINDER,
+        help="Additional arguments for output format (pass '-- -h' for help)")
+    parser.set_defaults(command=convert_command)
+
+    return parser
+
+def convert_command(args):
+    env = Environment()
+
+    try:
+        converter = env.converters.get(args.output_format)
+    except KeyError:
+        raise CliException("Converter for format '%s' is not found" % \
+            args.output_format)
+    extra_args = converter.from_cmdline(args.extra_args)
+    def converter_proxy(extractor, save_dir):
+        return converter.convert(extractor, save_dir, **extra_args)
+
+    filter_args = FilterModes.make_filter_args(args.filter_mode)
+
+    if not args.input_format:
+        matches = []
+        for format_name in env.importers.items:
+            log.debug("Checking '%s' format...", format_name)
+            importer = env.make_importer(format_name)
+            try:
+                match = importer.detect(args.source)
+                if match:
+                    log.debug("format matched")
+                    matches.append((format_name, importer))
+            except NotImplementedError:
+                log.debug("Format '%s' does not support auto detection.",
+                    format_name)
+
+        if len(matches) == 0:
+            log.error("Failed to detect dataset format. "
+                "Try to specify format with '-if/--input-format' parameter.")
+            return 1
+        elif len(matches) != 1:
+            log.error("Multiple formats match the dataset: %s. "
+                "Try to specify format with '-if/--input-format' parameter.",
+                ', '.join(m[0] for m in matches))
+            return 2
+
+        format_name, importer = matches[0]
+        args.input_format = format_name
+        log.info("Source dataset format detected as '%s'", args.input_format)
+    else:
+        try:
+            importer = env.make_importer(args.input_format)
+            if hasattr(importer, 'from_cmdline'):
+                extra_args = importer.from_cmdline()
+        except KeyError:
+            raise CliException("Importer for format '%s' is not found" % \
+                args.input_format)
+
+    source = osp.abspath(args.source)
+
+    dst_dir = args.dst_dir
+    if dst_dir:
+        if not args.overwrite and osp.isdir(dst_dir) and os.listdir(dst_dir):
+            raise CliException("Directory '%s' already exists "
+                "(pass --overwrite to overwrite)" % dst_dir)
+    else:
+        dst_dir = generate_next_file_name('%s-%s' % \
+            (osp.basename(source), make_file_name(args.output_format)))
+    dst_dir = osp.abspath(dst_dir)
+
+    project = importer(source)
+    dataset = project.make_dataset()
+
+    log.info("Exporting the dataset")
+    dataset.export_project(
+        save_dir=dst_dir,
+        converter=converter_proxy,
+        filter_expr=args.filter,
+        **filter_args)
+
+    log.info("Dataset exported to '%s' as '%s'" % \
+        (dst_dir, args.output_format))
+
+    return 0

testbed/openvinotoolkit__datumaro/datumaro/cli/commands/export.py

@@ -0,0 +1,8 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+# pylint: disable=unused-import
+
+from ..contexts.project import build_export_parser as build_parser

testbed/openvinotoolkit__datumaro/datumaro/cli/commands/remove.py

@@ -0,0 +1,8 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+# pylint: disable=unused-import
+
+from ..contexts.source import build_remove_parser as build_parser

testbed/openvinotoolkit__datumaro/datumaro/cli/contexts/__init__.py

@@ -0,0 +1,6 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+from . import project, source, model, item

testbed/openvinotoolkit__datumaro/datumaro/cli/contexts/item/__init__.py

@@ -0,0 +1,36 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+import argparse
+
+from ...util import add_subparser
+
+
+def build_export_parser(parser_ctor=argparse.ArgumentParser):
+    parser = parser_ctor()
+    return parser
+
+def build_stats_parser(parser_ctor=argparse.ArgumentParser):
+    parser = parser_ctor()
+    return parser
+
+def build_diff_parser(parser_ctor=argparse.ArgumentParser):
+    parser = parser_ctor()
+    return parser
+
+def build_edit_parser(parser_ctor=argparse.ArgumentParser):
+    parser = parser_ctor()
+    return parser
+
+def build_parser(parser_ctor=argparse.ArgumentParser):
+    parser = parser_ctor()
+
+    subparsers = parser.add_subparsers()
+    add_subparser(subparsers, 'export', build_export_parser)
+    add_subparser(subparsers, 'stats', build_stats_parser)
+    add_subparser(subparsers, 'diff', build_diff_parser)
+    add_subparser(subparsers, 'edit', build_edit_parser)
+
+    return parser

testbed/openvinotoolkit__datumaro/datumaro/cli/contexts/project/__init__.py

@@ -0,0 +1,831 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+import argparse
+import json
+import logging as log
+import os
+import os.path as osp
+import shutil
+from enum import Enum
+
+from datumaro.components.cli_plugin import CliPlugin
+from datumaro.components.dataset_filter import DatasetItemEncoder
+from datumaro.components.extractor import AnnotationType
+from datumaro.components.operations import (DistanceComparator,
+    ExactComparator, compute_ann_statistics, compute_image_statistics, mean_std)
+from datumaro.components.project import \
+    PROJECT_DEFAULT_CONFIG as DEFAULT_CONFIG
+from datumaro.components.project import Environment, Project
+
+from ...util import (CliException, MultilineFormatter, add_subparser,
+    make_file_name)
+from ...util.project import generate_next_file_name, load_project
+from .diff import DiffVisualizer
+
+
+def build_create_parser(parser_ctor=argparse.ArgumentParser):
+    parser = parser_ctor(help="Create empty project",
+        description="""
+            Create a new empty project.|n
+            |n
+            Examples:|n
+            - Create a project in the current directory:|n
+            |s|screate -n myproject|n
+            |n
+            - Create a project in other directory:|n
+            |s|screate -o path/I/like/
+        """,
+        formatter_class=MultilineFormatter)
+
+    parser.add_argument('-o', '--output-dir', default='.', dest='dst_dir',
+        help="Save directory for the new project (default: current dir")
+    parser.add_argument('-n', '--name', default=None,
+        help="Name of the new project (default: same as project dir)")
+    parser.add_argument('--overwrite', action='store_true',
+        help="Overwrite existing files in the save directory")
+    parser.set_defaults(command=create_command)
+
+    return parser
+
+def create_command(args):
+    project_dir = osp.abspath(args.dst_dir)
+
+    project_env_dir = osp.join(project_dir, DEFAULT_CONFIG.env_dir)
+    if osp.isdir(project_env_dir) and os.listdir(project_env_dir):
+        if not args.overwrite:
+            raise CliException("Directory '%s' already exists "
+                "(pass --overwrite to overwrite)" % project_env_dir)
+        else:
+            shutil.rmtree(project_env_dir, ignore_errors=True)
+
+    own_dataset_dir = osp.join(project_dir, DEFAULT_CONFIG.dataset_dir)
+    if osp.isdir(own_dataset_dir) and os.listdir(own_dataset_dir):
+        if not args.overwrite:
+            raise CliException("Directory '%s' already exists "
+                "(pass --overwrite to overwrite)" % own_dataset_dir)
+        else:
+            # NOTE: remove the dir to avoid using data from previous project
+            shutil.rmtree(own_dataset_dir)
+
+    project_name = args.name
+    if project_name is None:
+        project_name = osp.basename(project_dir)
+
+    log.info("Creating project at '%s'" % project_dir)
+
+    Project.generate(project_dir, {
+        'project_name': project_name,
+    })
+
+    log.info("Project has been created at '%s'" % project_dir)
+
+    return 0
+
+def build_import_parser(parser_ctor=argparse.ArgumentParser):
+    builtins = sorted(Environment().importers.items)
+
+    parser = parser_ctor(help="Create project from existing dataset",
+        description="""
+            Creates a project from an existing dataset. The source can be:|n
+            - a dataset in a supported format (check 'formats' section below)|n
+            - a Datumaro project|n
+            |n
+            Formats:|n
+            Datasets come in a wide variety of formats. Each dataset
+            format defines its own data structure and rules on how to
+            interpret the data. For example, the following data structure
+            is used in COCO format:|n
+            /dataset/|n
+            - /images/<id>.jpg|n
+            - /annotations/|n
+            |n
+            In Datumaro dataset formats are supported by
+            Extractor-s and Importer-s.
+            An Extractor produces a list of dataset items corresponding
+            to the dataset. An Importer creates a project from the
+            data source location.
+            It is possible to add a custom Extractor and Importer.
+            To do this, you need to put an Extractor and
+            Importer implementation scripts to
+            <project_dir>/.datumaro/extractors
+            and <project_dir>/.datumaro/importers.|n
+            |n
+            List of builtin dataset formats: %s|n
+            |n
+            Examples:|n
+            - Create a project from VOC dataset in the current directory:|n
+            |s|simport -f voc -i path/to/voc|n
+            |n
+            - Create a project from COCO dataset in other directory:|n
+            |s|simport -f coco -i path/to/coco -o path/I/like/
+        """ % ', '.join(builtins),
+        formatter_class=MultilineFormatter)
+
+    parser.add_argument('-o', '--output-dir', default='.', dest='dst_dir',
+        help="Directory to save the new project to (default: current dir)")
+    parser.add_argument('-n', '--name', default=None,
+        help="Name of the new project (default: same as project dir)")
+    parser.add_argument('--copy', action='store_true',
+        help="Copy the dataset instead of saving source links")
+    parser.add_argument('--skip-check', action='store_true',
+        help="Skip source checking")
+    parser.add_argument('--overwrite', action='store_true',
+        help="Overwrite existing files in the save directory")
+    parser.add_argument('-i', '--input-path', required=True, dest='source',
+        help="Path to import project from")
+    parser.add_argument('-f', '--format',
+        help="Source project format. Will try to detect, if not specified.")
+    parser.add_argument('extra_args', nargs=argparse.REMAINDER,
+        help="Additional arguments for importer (pass '-- -h' for help)")
+    parser.set_defaults(command=import_command)
+
+    return parser
+
+def import_command(args):
+    project_dir = osp.abspath(args.dst_dir)
+
+    project_env_dir = osp.join(project_dir, DEFAULT_CONFIG.env_dir)
+    if osp.isdir(project_env_dir) and os.listdir(project_env_dir):
+        if not args.overwrite:
+            raise CliException("Directory '%s' already exists "
+                "(pass --overwrite to overwrite)" % project_env_dir)
+        else:
+            shutil.rmtree(project_env_dir, ignore_errors=True)
+
+    own_dataset_dir = osp.join(project_dir, DEFAULT_CONFIG.dataset_dir)
+    if osp.isdir(own_dataset_dir) and os.listdir(own_dataset_dir):
+        if not args.overwrite:
+            raise CliException("Directory '%s' already exists "
+                "(pass --overwrite to overwrite)" % own_dataset_dir)
+        else:
+            # NOTE: remove the dir to avoid using data from previous project
+            shutil.rmtree(own_dataset_dir)
+
+    project_name = args.name
+    if project_name is None:
+        project_name = osp.basename(project_dir)
+
+    env = Environment()
+    log.info("Importing project from '%s'" % args.source)
+
+    extra_args = {}
+    if not args.format:
+        if args.extra_args:
+            raise CliException("Extra args can not be used without format")
+
+        log.info("Trying to detect dataset format...")
+
+        matches = []
+        for format_name in env.importers.items:
+            log.debug("Checking '%s' format...", format_name)
+            importer = env.make_importer(format_name)
+            try:
+                match = importer.detect(args.source)
+                if match:
+                    log.debug("format matched")
+                    matches.append((format_name, importer))
+            except NotImplementedError:
+                log.debug("Format '%s' does not support auto detection.",
+                    format_name)
+
+        if len(matches) == 0:
+            log.error("Failed to detect dataset format automatically. "
+                "Try to specify format with '-f/--format' parameter.")
+            return 1
+        elif len(matches) != 1:
+            log.error("Multiple formats match the dataset: %s. "
+                "Try to specify format with '-f/--format' parameter.",
+                ', '.join(m[0] for m in matches))
+            return 2
+
+        format_name, importer = matches[0]
+        args.format = format_name
+    else:
+        try:
+            importer = env.make_importer(args.format)
+            if hasattr(importer, 'from_cmdline'):
+                extra_args = importer.from_cmdline(args.extra_args)
+        except KeyError:
+            raise CliException("Importer for format '%s' is not found" % \
+                args.format)
+
+    log.info("Importing project as '%s'" % args.format)
+
+    source = osp.abspath(args.source)
+    project = importer(source, **extra_args)
+    project.config.project_name = project_name
+    project.config.project_dir = project_dir
+
+    if not args.skip_check or args.copy:
+        log.info("Checking the dataset...")
+        dataset = project.make_dataset()
+    if args.copy:
+        log.info("Cloning data...")
+        dataset.save(merge=True, save_images=True)
+    else:
+        project.save()
+
+    log.info("Project has been created at '%s'" % project_dir)
+
+    return 0
+
+
+class FilterModes(Enum):
+    # primary
+    items = 1
+    annotations = 2
+    items_annotations = 3
+
+    # shortcuts
+    i = 1
+    a = 2
+    i_a = 3
+    a_i = 3
+    annotations_items = 3
+
+    @staticmethod
+    def parse(s):
+        s = s.lower()
+        s = s.replace('+', '_')
+        return FilterModes[s]
+
+    @classmethod
+    def make_filter_args(cls, mode):
+        if mode == cls.items:
+            return {}
+        elif mode == cls.annotations:
+            return {
+                'filter_annotations': True
+            }
+        elif mode == cls.items_annotations:
+            return {
+                'filter_annotations': True,
+                'remove_empty': True,
+            }
+        else:
+            raise NotImplementedError()
+
+    @classmethod
+    def list_options(cls):
+        return [m.name.replace('_', '+') for m in cls]
+
+def build_export_parser(parser_ctor=argparse.ArgumentParser):
+    builtins = sorted(Environment().converters.items)
+
+    parser = parser_ctor(help="Export project",
+        description="""
+            Exports the project dataset in some format. Optionally, a filter
+            can be passed, check 'filter' command description for more info.
+            Each dataset format has its own options, which
+            are passed after '--' separator (see examples), pass '-- -h'
+            for more info. If not stated otherwise, by default
+            only annotations are exported, to include images pass
+            '--save-images' parameter.|n
+            |n
+            Formats:|n
+            In Datumaro dataset formats are supported by Converter-s.
+            A Converter produces a dataset of a specific format
+            from dataset items. It is possible to add a custom Converter.
+            To do this, you need to put a Converter
+            definition script to <project_dir>/.datumaro/converters.|n
+            |n
+            List of builtin dataset formats: %s|n
+            |n
+            Examples:|n
+            - Export project as a VOC-like dataset, include images:|n
+            |s|sexport -f voc -- --save-images|n
+            |n
+            - Export project as a COCO-like dataset in other directory:|n
+            |s|sexport -f coco -o path/I/like/
+        """ % ', '.join(builtins),
+        formatter_class=MultilineFormatter)
+
+    parser.add_argument('-e', '--filter', default=None,
+        help="Filter expression for dataset items")
+    parser.add_argument('--filter-mode', default=FilterModes.i.name,
+        type=FilterModes.parse,
+        help="Filter mode (options: %s; default: %s)" % \
+            (', '.join(FilterModes.list_options()) , '%(default)s'))
+    parser.add_argument('-o', '--output-dir', dest='dst_dir', default=None,
+        help="Directory to save output (default: a subdir in the current one)")
+    parser.add_argument('--overwrite', action='store_true',
+        help="Overwrite existing files in the save directory")
+    parser.add_argument('-p', '--project', dest='project_dir', default='.',
+        help="Directory of the project to operate on (default: current dir)")
+    parser.add_argument('-f', '--format', required=True,
+        help="Output format")
+    parser.add_argument('extra_args', nargs=argparse.REMAINDER, default=None,
+        help="Additional arguments for converter (pass '-- -h' for help)")
+    parser.set_defaults(command=export_command)
+
+    return parser
+
+def export_command(args):
+    project = load_project(args.project_dir)
+
+    dst_dir = args.dst_dir
+    if dst_dir:
+        if not args.overwrite and osp.isdir(dst_dir) and os.listdir(dst_dir):
+            raise CliException("Directory '%s' already exists "
+                "(pass --overwrite to overwrite)" % dst_dir)
+    else:
+        dst_dir = generate_next_file_name('%s-%s' % \
+            (project.config.project_name, make_file_name(args.format)))
+    dst_dir = osp.abspath(dst_dir)
+
+    try:
+        converter = project.env.converters.get(args.format)
+    except KeyError:
+        raise CliException("Converter for format '%s' is not found" % \
+            args.format)
+
+    extra_args = converter.from_cmdline(args.extra_args)
+    def converter_proxy(extractor, save_dir):
+        return converter.convert(extractor, save_dir, **extra_args)
+
+    filter_args = FilterModes.make_filter_args(args.filter_mode)
+
+    log.info("Loading the project...")
+    dataset = project.make_dataset()
+
+    log.info("Exporting the project...")
+    dataset.export_project(
+        save_dir=dst_dir,
+        converter=converter_proxy,
+        filter_expr=args.filter,
+        **filter_args)
+    log.info("Project exported to '%s' as '%s'" % \
+        (dst_dir, args.format))
+
+    return 0
+
+def build_filter_parser(parser_ctor=argparse.ArgumentParser):
+    parser = parser_ctor(help="Extract subproject",
+        description="""
+            Extracts a subproject that contains only items matching filter.
+            A filter is an XPath expression, which is applied to XML
+            representation of a dataset item. Check '--dry-run' parameter
+            to see XML representations of the dataset items.|n
+            |n
+            To filter annotations use the mode ('-m') parameter.|n
+            Supported modes:|n
+            - 'i', 'items'|n
+            - 'a', 'annotations'|n
+            - 'i+a', 'a+i', 'items+annotations', 'annotations+items'|n
+            When filtering annotations, use the 'items+annotations'
+            mode to point that annotation-less dataset items should be
+            removed. To select an annotation, write an XPath that
+            returns 'annotation' elements (see examples).|n
+            |n
+            Examples:|n
+            - Filter images with width < height:|n
+            |s|sextract -e '/item[image/width < image/height]'|n
+            |n
+            - Filter images with large-area bboxes:|n
+            |s|sextract -e '/item[annotation/type="bbox" and
+                annotation/area>2000]'|n
+            |n
+            - Filter out all irrelevant annotations from items:|n
+            |s|sextract -m a -e '/item/annotation[label = "person"]'|n
+            |n
+            - Filter out all irrelevant annotations from items:|n
+            |s|sextract -m a -e '/item/annotation[label="cat" and
+            area > 99.5]'|n
+            |n
+            - Filter occluded annotations and items, if no annotations left:|n
+            |s|sextract -m i+a -e '/item/annotation[occluded="True"]'
+        """,
+        formatter_class=MultilineFormatter)
+
+    parser.add_argument('-e', '--filter', default=None,
+        help="XML XPath filter expression for dataset items")
+    parser.add_argument('-m', '--mode', default=FilterModes.i.name,
+        type=FilterModes.parse,
+        help="Filter mode (options: %s; default: %s)" % \
+            (', '.join(FilterModes.list_options()) , '%(default)s'))
+    parser.add_argument('--dry-run', action='store_true',
+        help="Print XML representations to be filtered and exit")
+    parser.add_argument('-o', '--output-dir', dest='dst_dir', default=None,
+        help="Output directory (default: update current project)")
+    parser.add_argument('--overwrite', action='store_true',
+        help="Overwrite existing files in the save directory")
+    parser.add_argument('-p', '--project', dest='project_dir', default='.',
+        help="Directory of the project to operate on (default: current dir)")
+    parser.set_defaults(command=filter_command)
+
+    return parser
+
+def filter_command(args):
+    project = load_project(args.project_dir)
+
+    if not args.dry_run:
+        dst_dir = args.dst_dir
+        if dst_dir:
+            if not args.overwrite and osp.isdir(dst_dir) and os.listdir(dst_dir):
+                raise CliException("Directory '%s' already exists "
+                    "(pass --overwrite to overwrite)" % dst_dir)
+        else:
+            dst_dir = generate_next_file_name('%s-filter' % \
+                project.config.project_name)
+        dst_dir = osp.abspath(dst_dir)
+
+    dataset = project.make_dataset()
+
+    filter_args = FilterModes.make_filter_args(args.mode)
+
+    if args.dry_run:
+        dataset = dataset.filter(expr=args.filter, **filter_args)
+        for item in dataset:
+            encoded_item = DatasetItemEncoder.encode(item, dataset.categories())
+            xml_item = DatasetItemEncoder.to_string(encoded_item)
+            print(xml_item)
+        return 0
+
+    if not args.filter:
+        raise CliException("Expected a filter expression ('-e' argument)")
+
+    dataset.filter_project(save_dir=dst_dir,
+        filter_expr=args.filter, **filter_args)
+
+    log.info("Subproject has been extracted to '%s'" % dst_dir)
+
+    return 0
+
+def build_merge_parser(parser_ctor=argparse.ArgumentParser):
+    parser = parser_ctor(help="Merge two projects",
+        description="""
+            Updates items of the current project with items
+            from other project.|n
+            |n
+            Examples:|n
+            - Update a project with items from other project:|n
+            |s|smerge -p path/to/first/project path/to/other/project
+        """,
+        formatter_class=MultilineFormatter)
+
+    parser.add_argument('other_project_dir',
+        help="Path to a project")
+    parser.add_argument('-o', '--output-dir', dest='dst_dir', default=None,
+        help="Output directory (default: current project's dir)")
+    parser.add_argument('--overwrite', action='store_true',
+        help="Overwrite existing files in the save directory")
+    parser.add_argument('-p', '--project', dest='project_dir', default='.',
+        help="Directory of the project to operate on (default: current dir)")
+    parser.set_defaults(command=merge_command)
+
+    return parser
+
+def merge_command(args):
+    first_project = load_project(args.project_dir)
+    second_project = load_project(args.other_project_dir)
+
+    dst_dir = args.dst_dir
+    if dst_dir:
+        if not args.overwrite and osp.isdir(dst_dir) and os.listdir(dst_dir):
+            raise CliException("Directory '%s' already exists "
+                "(pass --overwrite to overwrite)" % dst_dir)
+
+    first_dataset = first_project.make_dataset()
+    second_dataset = second_project.make_dataset()
+
+    first_dataset.update(second_dataset)
+    first_dataset.save(save_dir=dst_dir)
+
+    if dst_dir is None:
+        dst_dir = first_project.config.project_dir
+    dst_dir = osp.abspath(dst_dir)
+    log.info("Merge results have been saved to '%s'" % dst_dir)
+
+    return 0
+
+def build_diff_parser(parser_ctor=argparse.ArgumentParser):
+    parser = parser_ctor(help="Compare projects",
+        description="""
+        Compares two projects, match annotations by distance.|n
+        |n
+        Examples:|n
+        - Compare two projects, match boxes if IoU > 0.7,|n
+        |s|s|s|sprint results to Tensorboard:
+        |s|sdiff path/to/other/project -o diff/ -v tensorboard --iou-thresh 0.7
+        """,
+        formatter_class=MultilineFormatter)
+
+    parser.add_argument('other_project_dir',
+        help="Directory of the second project to be compared")
+    parser.add_argument('-o', '--output-dir', dest='dst_dir', default=None,
+        help="Directory to save comparison results (default: do not save)")
+    parser.add_argument('-v', '--visualizer',
+        default=DiffVisualizer.DEFAULT_FORMAT,
+        choices=[f.name for f in DiffVisualizer.Format],
+        help="Output format (default: %(default)s)")
+    parser.add_argument('--iou-thresh', default=0.5, type=float,
+        help="IoU match threshold for detections (default: %(default)s)")
+    parser.add_argument('--conf-thresh', default=0.5, type=float,
+        help="Confidence threshold for detections (default: %(default)s)")
+    parser.add_argument('--overwrite', action='store_true',
+        help="Overwrite existing files in the save directory")
+    parser.add_argument('-p', '--project', dest='project_dir', default='.',
+        help="Directory of the first project to be compared (default: current dir)")
+    parser.set_defaults(command=diff_command)
+
+    return parser
+
+def diff_command(args):
+    first_project = load_project(args.project_dir)
+    second_project = load_project(args.other_project_dir)
+
+    comparator = DistanceComparator(iou_threshold=args.iou_thresh)
+
+    dst_dir = args.dst_dir
+    if dst_dir:
+        if not args.overwrite and osp.isdir(dst_dir) and os.listdir(dst_dir):
+            raise CliException("Directory '%s' already exists "
+                "(pass --overwrite to overwrite)" % dst_dir)
+    else:
+        dst_dir = generate_next_file_name('%s-%s-diff' % (
+            first_project.config.project_name,
+            second_project.config.project_name)
+        )
+    dst_dir = osp.abspath(dst_dir)
+    log.info("Saving diff to '%s'" % dst_dir)
+
+    dst_dir_existed = osp.exists(dst_dir)
+    try:
+        visualizer = DiffVisualizer(save_dir=dst_dir, comparator=comparator,
+            output_format=args.visualizer)
+        visualizer.save_dataset_diff(
+            first_project.make_dataset(),
+            second_project.make_dataset())
+    except BaseException:
+        if not dst_dir_existed and osp.isdir(dst_dir):
+            shutil.rmtree(dst_dir, ignore_errors=True)
+        raise
+
+    return 0
+
+_ediff_default_if = ['id', 'group'] # avoid https://bugs.python.org/issue16399
+
+def build_ediff_parser(parser_ctor=argparse.ArgumentParser):
+    parser = parser_ctor(help="Compare projects for equality",
+        description="""
+        Compares two projects for equality.|n
+        |n
+        Examples:|n
+        - Compare two projects, exclude annotation group |n
+        |s|s|sand the 'is_crowd' attribute from comparison:|n
+        |s|sediff other/project/ -if group -ia is_crowd
+        """,
+        formatter_class=MultilineFormatter)
+
+    parser.add_argument('other_project_dir',
+        help="Directory of the second project to be compared")
+    parser.add_argument('-iia', '--ignore-item-attr', action='append',
+        help="Ignore item attribute (repeatable)")
+    parser.add_argument('-ia', '--ignore-attr', action='append',
+        help="Ignore annotation attribute (repeatable)")
+    parser.add_argument('-if', '--ignore-field', action='append',
+        help="Ignore annotation field (repeatable, default: %s)" % \
+            _ediff_default_if)
+    parser.add_argument('--match-images', action='store_true',
+        help='Match dataset items by images instead of ids')
+    parser.add_argument('--all', action='store_true',
+        help="Include matches in the output")
+    parser.add_argument('-p', '--project', dest='project_dir', default='.',
+        help="Directory of the first project to be compared (default: current dir)")
+    parser.set_defaults(command=ediff_command)
+
+    return parser
+
+def ediff_command(args):
+    first_project = load_project(args.project_dir)
+    second_project = load_project(args.other_project_dir)
+
+    if args.ignore_field:
+        args.ignore_field = _ediff_default_if
+    comparator = ExactComparator(
+        match_images=args.match_images,
+        ignored_fields=args.ignore_field,
+        ignored_attrs=args.ignore_attr,
+        ignored_item_attrs=args.ignore_item_attr)
+    matches, mismatches, a_extra, b_extra, errors = \
+        comparator.compare_datasets(
+            first_project.make_dataset(), second_project.make_dataset())
+    output = {
+        "mismatches": mismatches,
+        "a_extra_items": sorted(a_extra),
+        "b_extra_items": sorted(b_extra),
+        "errors": errors,
+    }
+    if args.all:
+        output["matches"] = matches
+
+    output_file = generate_next_file_name('diff', ext='.json')
+    with open(output_file, 'w') as f:
+        json.dump(output, f, indent=4, sort_keys=True)
+
+    print("Found:")
+    print("The first project has %s unmatched items" % len(a_extra))
+    print("The second project has %s unmatched items" % len(b_extra))
+    print("%s item conflicts" % len(errors))
+    print("%s matching annotations" % len(matches))
+    print("%s mismatching annotations" % len(mismatches))
+
+    log.info("Output has been saved to '%s'" % output_file)
+
+    return 0
+
+def build_transform_parser(parser_ctor=argparse.ArgumentParser):
+    builtins = sorted(Environment().transforms.items)
+
+    parser = parser_ctor(help="Transform project",
+        description="""
+            Applies some operation to dataset items in the project
+            and produces a new project.|n
+            |n
+            Builtin transforms: %s|n
+            |n
+            Examples:|n
+            - Convert instance polygons to masks:|n
+            |s|stransform -t polygons_to_masks
+        """ % ', '.join(builtins),
+        formatter_class=MultilineFormatter)
+
+    parser.add_argument('-t', '--transform', required=True,
+        help="Transform to apply to the project")
+    parser.add_argument('-o', '--output-dir', dest='dst_dir', default=None,
+        help="Directory to save output (default: current dir)")
+    parser.add_argument('--overwrite', action='store_true',
+        help="Overwrite existing files in the save directory")
+    parser.add_argument('-p', '--project', dest='project_dir', default='.',
+        help="Directory of the project to operate on (default: current dir)")
+    parser.add_argument('extra_args', nargs=argparse.REMAINDER, default=None,
+        help="Additional arguments for transformation (pass '-- -h' for help)")
+    parser.set_defaults(command=transform_command)
+
+    return parser
+
+def transform_command(args):
+    project = load_project(args.project_dir)
+
+    dst_dir = args.dst_dir
+    if dst_dir:
+        if not args.overwrite and osp.isdir(dst_dir) and os.listdir(dst_dir):
+            raise CliException("Directory '%s' already exists "
+                "(pass --overwrite to overwrite)" % dst_dir)
+    else:
+        dst_dir = generate_next_file_name('%s-%s' % \
+            (project.config.project_name, make_file_name(args.transform)))
+    dst_dir = osp.abspath(dst_dir)
+
+    try:
+        transform = project.env.transforms.get(args.transform)
+    except KeyError:
+        raise CliException("Transform '%s' is not found" % args.transform)
+
+    extra_args = {}
+    if hasattr(transform, 'from_cmdline'):
+        extra_args = transform.from_cmdline(args.extra_args)
+
+    log.info("Loading the project...")
+    dataset = project.make_dataset()
+
+    log.info("Transforming the project...")
+    dataset.transform_project(
+        method=transform,
+        save_dir=dst_dir,
+        **extra_args
+    )
+
+    log.info("Transform results have been saved to '%s'" % dst_dir)
+
+    return 0
+
+def build_stats_parser(parser_ctor=argparse.ArgumentParser):
+    parser = parser_ctor(help="Get project statistics",
+        description="""
+            Outputs various project statistics like image mean and std,
+            annotations count etc.
+        """,
+        formatter_class=MultilineFormatter)
+
+    parser.add_argument('-p', '--project', dest='project_dir', default='.',
+        help="Directory of the project to operate on (default: current dir)")
+    parser.set_defaults(command=stats_command)
+
+    return parser
+
+def stats_command(args):
+    project = load_project(args.project_dir)
+
+    dataset = project.make_dataset()
+    stats = {}
+    stats.update(compute_image_statistics(dataset))
+    stats.update(compute_ann_statistics(dataset))
+
+    dst_file = generate_next_file_name('statistics', ext='.json')
+    log.info("Writing project statistics to '%s'" % dst_file)
+    with open(dst_file, 'w') as f:
+        json.dump(stats, f, indent=4, sort_keys=True)
+
+def build_info_parser(parser_ctor=argparse.ArgumentParser):
+    parser = parser_ctor(help="Get project info",
+        description="""
+            Outputs project info.
+        """,
+        formatter_class=MultilineFormatter)
+
+    parser.add_argument('--all', action='store_true',
+        help="Print all information")
+    parser.add_argument('-p', '--project', dest='project_dir', default='.',
+        help="Directory of the project to operate on (default: current dir)")
+    parser.set_defaults(command=info_command)
+
+    return parser
+
+def info_command(args):
+    project = load_project(args.project_dir)
+    config = project.config
+    env = project.env
+    dataset = project.make_dataset()
+
+    print("Project:")
+    print("  name:", config.project_name)
+    print("  location:", config.project_dir)
+    print("Plugins:")
+    print("  importers:", ', '.join(env.importers.items))
+    print("  extractors:", ', '.join(env.extractors.items))
+    print("  converters:", ', '.join(env.converters.items))
+    print("  launchers:", ', '.join(env.launchers.items))
+
+    print("Sources:")
+    for source_name, source in config.sources.items():
+        print("  source '%s':" % source_name)
+        print("    format:", source.format)
+        print("    url:", source.url)
+        print("    location:", project.local_source_dir(source_name))
+
+    def print_extractor_info(extractor, indent=''):
+        print("%slength:" % indent, len(extractor))
+
+        categories = extractor.categories()
+        print("%scategories:" % indent, ', '.join(c.name for c in categories))
+
+        for cat_type, cat in categories.items():
+            print("%s  %s:" % (indent, cat_type.name))
+            if cat_type == AnnotationType.label:
+                print("%s    count:" % indent, len(cat.items))
+
+                count_threshold = 10
+                if args.all:
+                    count_threshold = len(cat.items)
+                labels = ', '.join(c.name for c in cat.items[:count_threshold])
+                if count_threshold < len(cat.items):
+                    labels += " (and %s more)" % (
+                        len(cat.items) - count_threshold)
+                print("%s    labels:" % indent, labels)
+
+    print("Dataset:")
+    print_extractor_info(dataset, indent="  ")
+
+    subsets = dataset.subsets()
+    print("  subsets:", ', '.join(subsets))
+    for subset_name in subsets:
+        subset = dataset.get_subset(subset_name)
+        print("    subset '%s':" % subset_name)
+        print_extractor_info(subset, indent="      ")
+
+    print("Models:")
+    for model_name, model in config.models.items():
+        print("  model '%s':" % model_name)
+        print("    type:", model.launcher)
+
+    return 0
+
+
+def build_parser(parser_ctor=argparse.ArgumentParser):
+    parser = parser_ctor(
+        description="""
+            Manipulate projects.|n
+            |n
+            By default, the project to be operated on is searched for
+            in the current directory. An additional '-p' argument can be
+            passed to specify project location.
+        """,
+        formatter_class=MultilineFormatter)
+
+    subparsers = parser.add_subparsers()
+    add_subparser(subparsers, 'create', build_create_parser)
+    add_subparser(subparsers, 'import', build_import_parser)
+    add_subparser(subparsers, 'export', build_export_parser)
+    add_subparser(subparsers, 'filter', build_filter_parser)
+    add_subparser(subparsers, 'merge', build_merge_parser)
+    add_subparser(subparsers, 'diff', build_diff_parser)
+    add_subparser(subparsers, 'ediff', build_ediff_parser)
+    add_subparser(subparsers, 'transform', build_transform_parser)
+    add_subparser(subparsers, 'info', build_info_parser)
+    add_subparser(subparsers, 'stats', build_stats_parser)
+
+    return parser

testbed/openvinotoolkit__datumaro/datumaro/cli/contexts/source/__init__.py

@@ -0,0 +1,273 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+import argparse
+import logging as log
+import os
+import os.path as osp
+import shutil
+
+from datumaro.components.project import Environment
+from ...util import add_subparser, CliException, MultilineFormatter
+from ...util.project import load_project
+
+
+def build_add_parser(parser_ctor=argparse.ArgumentParser):
+    builtins = sorted(Environment().extractors.items)
+
+    base_parser = argparse.ArgumentParser(add_help=False)
+    base_parser.add_argument('-n', '--name', default=None,
+        help="Name of the new source")
+    base_parser.add_argument('-f', '--format', required=True,
+        help="Source dataset format")
+    base_parser.add_argument('--skip-check', action='store_true',
+        help="Skip source checking")
+    base_parser.add_argument('-p', '--project', dest='project_dir', default='.',
+        help="Directory of the project to operate on (default: current dir)")
+
+    parser = parser_ctor(help="Add data source to project",
+        description="""
+            Adds a data source to a project. The source can be:|n
+            - a dataset in a supported format (check 'formats' section below)|n
+            - a Datumaro project|n
+            |n
+            The source can be either a local directory or a remote
+            git repository. Each source type has its own parameters, which can
+            be checked by:|n
+            '%s'.|n
+            |n
+            Formats:|n
+            Datasets come in a wide variety of formats. Each dataset
+            format defines its own data structure and rules on how to
+            interpret the data. For example, the following data structure
+            is used in COCO format:|n
+            /dataset/|n
+            - /images/<id>.jpg|n
+            - /annotations/|n
+            |n
+            In Datumaro dataset formats are supported by Extractor-s.
+            An Extractor produces a list of dataset items corresponding
+            to the dataset. It is possible to add a custom Extractor.
+            To do this, you need to put an Extractor
+            definition script to <project_dir>/.datumaro/extractors.|n
+            |n
+            List of builtin source formats: %s|n
+            |n
+            Examples:|n
+            - Add a local directory with VOC-like dataset:|n
+            |s|sadd path path/to/voc -f voc_detection|n
+            - Add a local file with CVAT annotations, call it 'mysource'|n
+            |s|s|s|sto the project somewhere else:|n
+            |s|sadd path path/to/cvat.xml -f cvat -n mysource -p somewhere/else/
+        """ % ('%(prog)s SOURCE_TYPE --help', ', '.join(builtins)),
+        formatter_class=MultilineFormatter,
+        add_help=False)
+    parser.set_defaults(command=add_command)
+
+    sp = parser.add_subparsers(dest='source_type', metavar='SOURCE_TYPE',
+        help="The type of the data source "
+            "(call '%s SOURCE_TYPE --help' for more info)" % parser.prog)
+
+    dir_parser = sp.add_parser('path', help="Add local path as source",
+        parents=[base_parser])
+    dir_parser.add_argument('url',
+        help="Path to the source")
+    dir_parser.add_argument('--copy', action='store_true',
+        help="Copy the dataset instead of saving source links")
+
+    repo_parser = sp.add_parser('git', help="Add git repository as source",
+        parents=[base_parser])
+    repo_parser.add_argument('url',
+        help="URL of the source git repository")
+    repo_parser.add_argument('-b', '--branch', default='master',
+        help="Branch of the source repository (default: %(default)s)")
+    repo_parser.add_argument('--checkout', action='store_true',
+        help="Do branch checkout")
+
+    # NOTE: add common parameters to the parent help output
+    # the other way could be to use parse_known_args()
+    display_parser = argparse.ArgumentParser(
+        parents=[base_parser, parser],
+        prog=parser.prog, usage="%(prog)s [-h] SOURCE_TYPE ...",
+        description=parser.description, formatter_class=MultilineFormatter)
+    class HelpAction(argparse._HelpAction):
+        def __call__(self, parser, namespace, values, option_string=None):
+            display_parser.print_help()
+            parser.exit()
+
+    parser.add_argument('-h', '--help', action=HelpAction,
+        help='show this help message and exit')
+
+    # TODO: needed distinction on how to add an extractor or a remote source
+
+    return parser
+
+def add_command(args):
+    project = load_project(args.project_dir)
+
+    if args.source_type == 'git':
+        name = args.name
+        if name is None:
+            name = osp.splitext(osp.basename(args.url))[0]
+
+        if project.env.git.has_submodule(name):
+            raise CliException("Git submodule '%s' already exists" % name)
+
+        try:
+            project.get_source(name)
+            raise CliException("Source '%s' already exists" % name)
+        except KeyError:
+            pass
+
+        rel_local_dir = project.local_source_dir(name)
+        local_dir = osp.join(project.config.project_dir, rel_local_dir)
+        url = args.url
+        project.env.git.create_submodule(name, local_dir,
+            url=url, branch=args.branch, no_checkout=not args.checkout)
+    elif args.source_type == 'path':
+        url = osp.abspath(args.url)
+        if not osp.exists(url):
+            raise CliException("Source path '%s' does not exist" % url)
+
+        name = args.name
+        if name is None:
+            name = osp.splitext(osp.basename(url))[0]
+
+        if project.env.git.has_submodule(name):
+            raise CliException("Git submodule '%s' already exists" % name)
+
+        try:
+            project.get_source(name)
+            raise CliException("Source '%s' already exists" % name)
+        except KeyError:
+            pass
+
+        rel_local_dir = project.local_source_dir(name)
+        local_dir = osp.join(project.config.project_dir, rel_local_dir)
+
+        if args.copy:
+            log.info("Copying from '%s' to '%s'" % (url, local_dir))
+            if osp.isdir(url):
+                # copytree requires destination dir not to exist
+                shutil.copytree(url, local_dir)
+                url = rel_local_dir
+            elif osp.isfile(url):
+                os.makedirs(local_dir)
+                shutil.copy2(url, local_dir)
+                url = osp.join(rel_local_dir, osp.basename(url))
+            else:
+                raise Exception("Expected file or directory")
+        else:
+            os.makedirs(local_dir)
+
+    project.add_source(name, { 'url': url, 'format': args.format })
+
+    if not args.skip_check:
+        log.info("Checking the source...")
+        try:
+            project.make_source_project(name).make_dataset()
+        except Exception:
+            shutil.rmtree(local_dir, ignore_errors=True)
+            raise
+
+    project.save()
+
+    log.info("Source '%s' has been added to the project, location: '%s'" \
+        % (name, rel_local_dir))
+
+    return 0
+
+def build_remove_parser(parser_ctor=argparse.ArgumentParser):
+    parser = parser_ctor(help="Remove source from project",
+        description="Remove a source from a project.")
+
+    parser.add_argument('-n', '--name', required=True,
+        help="Name of the source to be removed")
+    parser.add_argument('--force', action='store_true',
+        help="Ignore possible errors during removal")
+    parser.add_argument('--keep-data', action='store_true',
+        help="Do not remove source data")
+    parser.add_argument('-p', '--project', dest='project_dir', default='.',
+        help="Directory of the project to operate on (default: current dir)")
+    parser.set_defaults(command=remove_command)
+
+    return parser
+
+def remove_command(args):
+    project = load_project(args.project_dir)
+
+    name = args.name
+    if not name:
+        raise CliException("Expected source name")
+    try:
+        project.get_source(name)
+    except KeyError:
+        if not args.force:
+            raise CliException("Source '%s' does not exist" % name)
+
+    if project.env.git.has_submodule(name):
+        if args.force:
+            log.warning("Forcefully removing the '%s' source..." % name)
+
+        project.env.git.remove_submodule(name, force=args.force)
+
+    source_dir = osp.join(project.config.project_dir,
+        project.local_source_dir(name))
+    project.remove_source(name)
+    project.save()
+
+    if not args.keep_data:
+        shutil.rmtree(source_dir, ignore_errors=True)
+
+    log.info("Source '%s' has been removed from the project" % name)
+
+    return 0
+
+def build_info_parser(parser_ctor=argparse.ArgumentParser):
+    parser = parser_ctor()
+
+    parser.add_argument('-n', '--name',
+        help="Source name")
+    parser.add_argument('-v', '--verbose', action='store_true',
+        help="Show details")
+    parser.add_argument('-p', '--project', dest='project_dir', default='.',
+        help="Directory of the project to operate on (default: current dir)")
+    parser.set_defaults(command=info_command)
+
+    return parser
+
+def info_command(args):
+    project = load_project(args.project_dir)
+
+    if args.name:
+        source = project.get_source(args.name)
+        print(source)
+    else:
+        for name, conf in project.config.sources.items():
+            print(name)
+            if args.verbose:
+                print(dict(conf))
+
+def build_parser(parser_ctor=argparse.ArgumentParser):
+    parser = parser_ctor(description="""
+            Manipulate data sources inside of a project.|n
+            |n
+            A data source is a source of data for a project.
+            The project combines multiple data sources into one dataset.
+            The role of a data source is to provide dataset items - images
+            and/or annotations.|n
+            |n
+            By default, the project to be operated on is searched for
+            in the current directory. An additional '-p' argument can be
+            passed to specify project location.
+        """,
+        formatter_class=MultilineFormatter)
+
+    subparsers = parser.add_subparsers()
+    add_subparser(subparsers, 'add', build_add_parser)
+    add_subparser(subparsers, 'remove', build_remove_parser)
+    add_subparser(subparsers, 'info', build_info_parser)
+
+    return parser

testbed/openvinotoolkit__datumaro/datumaro/cli/util/__init__.py

@@ -0,0 +1,74 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+import argparse
+import textwrap
+
+
+class CliException(Exception): pass
+
+def add_subparser(subparsers, name, builder):
+    return builder(lambda **kwargs: subparsers.add_parser(name, **kwargs))
+
+class MultilineFormatter(argparse.HelpFormatter):
+    """
+    Keeps line breaks introduced with '|n' separator
+    and spaces introduced with '|s'.
+    """
+
+    def __init__(self, keep_natural=False, **kwargs):
+        super().__init__(**kwargs)
+        self._keep_natural = keep_natural
+
+    def _fill_text(self, text, width, indent):
+        text = self._whitespace_matcher.sub(' ', text).strip()
+        text = text.replace('|s', ' ')
+
+        paragraphs = text.split('|n ')
+        if self._keep_natural:
+            paragraphs = sum((p.split('\n ') for p in paragraphs), [])
+
+        multiline_text = ''
+        for paragraph in paragraphs:
+            formatted_paragraph = textwrap.fill(paragraph, width,
+                initial_indent=indent, subsequent_indent=indent) + '\n'
+            multiline_text += formatted_paragraph
+        return multiline_text
+
+def required_count(nmin=0, nmax=0):
+    assert 0 <= nmin and 0 <= nmax and nmin or nmax
+
+    class RequiredCount(argparse.Action):
+        def __call__(self, parser, args, values, option_string=None):
+            k = len(values)
+            if not ((nmin and (nmin <= k) or not nmin) and \
+                    (nmax and (k <= nmax) or not nmax)):
+                msg = "Argument '%s' requires" % self.dest
+                if nmin and nmax:
+                    msg += " from %s to %s arguments" % (nmin, nmax)
+                elif nmin:
+                    msg += " at least %s arguments" % nmin
+                else:
+                    msg += " no more %s arguments" % nmax
+                raise argparse.ArgumentTypeError(msg)
+            setattr(args, self.dest, values)
+    return RequiredCount
+
+def at_least(n):
+    return required_count(n, 0)
+
+def make_file_name(s):
+    # adapted from
+    # https://docs.djangoproject.com/en/2.1/_modules/django/utils/text/#slugify
+    """
+    Normalizes string, converts to lowercase, removes non-alpha characters,
+    and converts spaces to hyphens.
+    """
+    import unicodedata, re
+    s = unicodedata.normalize('NFKD', s).encode('ascii', 'ignore')
+    s = s.decode()
+    s = re.sub(r'[^\w\s-]', '', s).strip().lower()
+    s = re.sub(r'[-\s]+', '-', s)
+    return s

testbed/openvinotoolkit__datumaro/datumaro/cli/util/project.py

@@ -0,0 +1,39 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+import os
+import re
+
+from datumaro.components.project import Project
+from datumaro.util import cast
+
+
+def load_project(project_dir):
+    return Project.load(project_dir)
+
+def generate_next_file_name(basename, basedir='.', sep='.', ext=''):
+    """
+    If basedir does not contain basename, returns basename,
+    otherwise generates a name by appending sep to the basename
+    and the number, next to the last used number in the basedir for
+    files with basename prefix. Optionally, appends ext.
+    """
+
+    return generate_next_name(os.listdir(basedir), basename, sep, ext)
+
+def generate_next_name(names, basename, sep='.', suffix='', default=None):
+    pattern = re.compile(r'%s(?:%s(\d+))?%s' % \
+        tuple(map(re.escape, [basename, sep, suffix])))
+    matches = [match for match in (pattern.match(n) for n in names) if match]
+
+    max_idx = max([cast(match[1], int, 0) for match in matches], default=None)
+    if max_idx is None:
+        if default is not None:
+            idx = sep + str(default)
+        else:
+            idx = ''
+    else:
+        idx = sep + str(max_idx + 1)
+    return basename + idx + suffix

testbed/openvinotoolkit__datumaro/datumaro/components/__init__.py

@@ -0,0 +1,5 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+

testbed/openvinotoolkit__datumaro/datumaro/components/algorithms/__init__.py

@@ -0,0 +1,5 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+

testbed/openvinotoolkit__datumaro/datumaro/components/cli_plugin.py

@@ -0,0 +1,44 @@
+
+# Copyright (C) 2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+import argparse
+
+from datumaro.cli.util import MultilineFormatter
+from datumaro.util import to_snake_case
+
+
+class CliPlugin:
+    @staticmethod
+    def _get_name(cls):
+        return getattr(cls, 'NAME',
+            remove_plugin_type(to_snake_case(cls.__name__)))
+
+    @staticmethod
+    def _get_doc(cls):
+        return getattr(cls, '__doc__', "")
+
+    @classmethod
+    def build_cmdline_parser(cls, **kwargs):
+        args = {
+            'prog': cls._get_name(cls),
+            'description': cls._get_doc(cls),
+            'formatter_class': MultilineFormatter,
+        }
+        args.update(kwargs)
+
+        return argparse.ArgumentParser(**args)
+
+    @classmethod
+    def from_cmdline(cls, args=None):
+        if args and args[0] == '--':
+            args = args[1:]
+        parser = cls.build_cmdline_parser()
+        args = parser.parse_args(args)
+        return vars(args)
+
+def remove_plugin_type(s):
+    for t in {'transform', 'extractor', 'converter', 'launcher', 'importer'}:
+        s = s.replace('_' + t, '')
+    return s

testbed/openvinotoolkit__datumaro/datumaro/components/config_model.py

@@ -0,0 +1,63 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+from datumaro.components.config import Config, \
+    DefaultConfig as _DefaultConfig, \
+    SchemaBuilder as _SchemaBuilder
+
+
+SOURCE_SCHEMA = _SchemaBuilder() \
+    .add('url', str) \
+    .add('format', str) \
+    .add('options', dict) \
+    .build()
+
+class Source(Config):
+    def __init__(self, config=None):
+        super().__init__(config, schema=SOURCE_SCHEMA)
+
+
+MODEL_SCHEMA = _SchemaBuilder() \
+    .add('launcher', str) \
+    .add('options', dict) \
+    .build()
+
+class Model(Config):
+    def __init__(self, config=None):
+        super().__init__(config, schema=MODEL_SCHEMA)
+
+
+PROJECT_SCHEMA = _SchemaBuilder() \
+    .add('project_name', str) \
+    .add('format_version', int) \
+    \
+    .add('subsets', list) \
+    .add('sources', lambda: _DefaultConfig(
+        lambda v=None: Source(v))) \
+    .add('models', lambda: _DefaultConfig(
+        lambda v=None: Model(v))) \
+    \
+    .add('models_dir', str, internal=True) \
+    .add('plugins_dir', str, internal=True) \
+    .add('sources_dir', str, internal=True) \
+    .add('dataset_dir', str, internal=True) \
+    .add('project_filename', str, internal=True) \
+    .add('project_dir', str, internal=True) \
+    .add('env_dir', str, internal=True) \
+    .build()
+
+PROJECT_DEFAULT_CONFIG = Config({
+    'project_name': 'undefined',
+    'format_version': 1,
+
+    'sources_dir': 'sources',
+    'dataset_dir': 'dataset',
+    'models_dir': 'models',
+    'plugins_dir': 'plugins',
+
+    'project_filename': 'config.yaml',
+    'project_dir': '',
+    'env_dir': '.datumaro',
+}, mutable=False, schema=PROJECT_SCHEMA)

testbed/openvinotoolkit__datumaro/datumaro/components/converter.py

@@ -0,0 +1,76 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+import logging as log
+import os
+import os.path as osp
+import shutil
+
+from datumaro.components.cli_plugin import CliPlugin
+from datumaro.util.image import save_image, ByteImage
+
+
+class Converter(CliPlugin):
+    DEFAULT_IMAGE_EXT = None
+
+    @classmethod
+    def build_cmdline_parser(cls, **kwargs):
+        parser = super().build_cmdline_parser(**kwargs)
+        parser.add_argument('--save-images', action='store_true',
+            help="Save images (default: %(default)s)")
+        parser.add_argument('--image-ext', default=None,
+            help="Image extension (default: keep or use format default%s)" % \
+                (' ' + cls.DEFAULT_IMAGE_EXT if cls.DEFAULT_IMAGE_EXT else ''))
+
+        return parser
+
+    @classmethod
+    def convert(cls, extractor, save_dir, **options):
+        converter = cls(extractor, save_dir, **options)
+        return converter.apply()
+
+    def apply(self):
+        raise NotImplementedError("Should be implemented in a subclass")
+
+    def __init__(self, extractor, save_dir, save_images=False,
+            image_ext=None, default_image_ext=None):
+        default_image_ext = default_image_ext or self.DEFAULT_IMAGE_EXT
+        assert default_image_ext
+        self._default_image_ext = default_image_ext
+
+        self._save_images = save_images
+        self._image_ext = image_ext
+
+        self._extractor = extractor
+        self._save_dir = save_dir
+
+    def _find_image_ext(self, item):
+        src_ext = None
+        if item.has_image:
+            src_ext = item.image.ext
+
+        return self._image_ext or src_ext or self._default_image_ext
+
+    def _make_image_filename(self, item):
+        return item.id + self._find_image_ext(item)
+
+    def _save_image(self, item, path=None):
+        if not item.image.has_data:
+            log.warning("Item '%s' has no image", item.id)
+            return
+
+        path = path or self._make_image_filename(item)
+
+        src_ext = item.image.ext.lower()
+        dst_ext = osp.splitext(osp.basename(path))[1].lower()
+
+        os.makedirs(osp.dirname(path), exist_ok=True)
+        if src_ext == dst_ext and osp.isfile(item.image.path):
+            shutil.copyfile(item.image.path, path)
+        elif src_ext == dst_ext and isinstance(item.image, ByteImage):
+            with open(path, 'wb') as f:
+                f.write(item.image.get_bytes())
+        else:
+            save_image(path, item.image.data)

testbed/openvinotoolkit__datumaro/datumaro/components/dataset.py

@@ -0,0 +1,186 @@
+# Copyright (C) 2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+from collections import OrderedDict, defaultdict
+from typing import Iterable, Union, Dict, List
+
+from datumaro.components.extractor import (Extractor, LabelCategories,
+    AnnotationType, DatasetItem, DEFAULT_SUBSET_NAME)
+from datumaro.components.dataset_filter import \
+    XPathDatasetFilter, XPathAnnotationsFilter
+
+
+class Dataset(Extractor):
+    class Subset(Extractor):
+        def __init__(self, parent):
+            self.parent = parent
+            self.items = OrderedDict()
+
+        def __iter__(self):
+            yield from self.items.values()
+
+        def __len__(self):
+            return len(self.items)
+
+        def categories(self):
+            return self.parent.categories()
+
+    @classmethod
+    def from_iterable(cls, iterable: Iterable[DatasetItem],
+            categories: Union[Dict, List[str]] = None):
+        if isinstance(categories, list):
+            categories = { AnnotationType.label:
+                LabelCategories.from_iterable(categories)
+            }
+
+        if not categories:
+            categories = {}
+
+        class _extractor(Extractor):
+            def __iter__(self):
+                return iter(iterable)
+
+            def categories(self):
+                return categories
+
+        return cls.from_extractors(_extractor())
+
+    @classmethod
+    def from_extractors(cls, *sources):
+        categories = cls._merge_categories(s.categories() for s in sources)
+        dataset = Dataset(categories=categories)
+
+        # merge items
+        subsets = defaultdict(lambda: cls.Subset(dataset))
+        for source in sources:
+            for item in source:
+                existing_item = subsets[item.subset].items.get(item.id)
+                if existing_item is not None:
+                    path = existing_item.path
+                    if item.path != path:
+                        path = None
+                    item = cls._merge_items(existing_item, item, path=path)
+
+                subsets[item.subset].items[item.id] = item
+
+        dataset._subsets = dict(subsets)
+        return dataset
+
+    def __init__(self, categories=None):
+        super().__init__()
+
+        self._subsets = {}
+
+        if not categories:
+            categories = {}
+        self._categories = categories
+
+    def __iter__(self):
+        for subset in self._subsets.values():
+            for item in subset:
+                yield item
+
+    def __len__(self):
+        if self._length is None:
+            self._length = sum(len(s) for s in self._subsets.values())
+        return self._length
+
+    def get_subset(self, name):
+        return self._subsets[name]
+
+    def subsets(self):
+        return self._subsets
+
+    def categories(self):
+        return self._categories
+
+    def get(self, item_id, subset=None, path=None):
+        if path:
+            raise KeyError("Requested dataset item path is not found")
+        item_id = str(item_id)
+        subset = subset or DEFAULT_SUBSET_NAME
+        subset = self._subsets[subset]
+        return subset.items[item_id]
+
+    def put(self, item, item_id=None, subset=None, path=None):
+        if path:
+            raise KeyError("Requested dataset item path is not found")
+
+        if item_id is None:
+            item_id = item.id
+        if subset is None:
+            subset = item.subset
+
+        item = item.wrap(id=item_id, subset=subset, path=None)
+        if subset not in self._subsets:
+            self._subsets[subset] = self.Subset(self)
+        self._subsets[subset].items[item_id] = item
+        self._length = None
+
+        return item
+
+    def filter(self, expr, filter_annotations=False, remove_empty=False):
+        if filter_annotations:
+            return self.transform(XPathAnnotationsFilter, expr, remove_empty)
+        else:
+            return self.transform(XPathDatasetFilter, expr)
+
+    def update(self, items):
+        for item in items:
+            self.put(item)
+        return self
+
+    def define_categories(self, categories):
+        assert not self._categories
+        self._categories = categories
+
+    @staticmethod
+    def _lazy_image(item):
+        # NOTE: avoid https://docs.python.org/3/faq/programming.html#why-do-lambdas-defined-in-a-loop-with-different-values-all-return-the-same-result
+        return lambda: item.image
+
+    @classmethod
+    def _merge_items(cls, existing_item, current_item, path=None):
+        return existing_item.wrap(path=path,
+            image=cls._merge_images(existing_item, current_item),
+            annotations=cls._merge_anno(
+                existing_item.annotations, current_item.annotations))
+
+    @staticmethod
+    def _merge_images(existing_item, current_item):
+        image = None
+        if existing_item.has_image and current_item.has_image:
+            if existing_item.image.has_data:
+                image = existing_item.image
+            else:
+                image = current_item.image
+
+            if existing_item.image.path != current_item.image.path:
+                if not existing_item.image.path:
+                    image._path = current_item.image.path
+
+            if all([existing_item.image._size, current_item.image._size]):
+                assert existing_item.image._size == current_item.image._size, "Image info differs for item '%s'" % existing_item.id
+            elif existing_item.image._size:
+                image._size = existing_item.image._size
+            else:
+                image._size = current_item.image._size
+        elif existing_item.has_image:
+            image = existing_item.image
+        else:
+            image = current_item.image
+
+        return image
+
+    @staticmethod
+    def _merge_anno(a, b):
+        # TODO: implement properly with merging and annotations remapping
+        from .operations import merge_annotations_equal
+        return merge_annotations_equal(a, b)
+
+    @staticmethod
+    def _merge_categories(sources):
+        # TODO: implement properly with merging and annotations remapping
+        from .operations import merge_categories
+        return merge_categories(sources)

testbed/openvinotoolkit__datumaro/datumaro/components/dataset_filter.py

@@ -0,0 +1,261 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+import logging as log
+from lxml import etree as ET # lxml has proper XPath implementation
+from datumaro.components.extractor import (Transform,
+    Annotation, AnnotationType,
+    Label, Mask, Points, Polygon, PolyLine, Bbox, Caption,
+)
+
+
+class DatasetItemEncoder:
+    @classmethod
+    def encode(cls, item, categories=None):
+        item_elem = ET.Element('item')
+        ET.SubElement(item_elem, 'id').text = str(item.id)
+        ET.SubElement(item_elem, 'subset').text = str(item.subset)
+        ET.SubElement(item_elem, 'path').text = str('/'.join(item.path))
+
+        image = item.image
+        if image is not None:
+            item_elem.append(cls.encode_image(image))
+
+        for ann in item.annotations:
+            item_elem.append(cls.encode_annotation(ann, categories))
+
+        return item_elem
+
+    @classmethod
+    def encode_image(cls, image):
+        image_elem = ET.Element('image')
+
+        size = image.size
+        if size is not None:
+            h, w = size
+        else:
+            h = 'unknown'
+            w = h
+        ET.SubElement(image_elem, 'width').text = str(w)
+        ET.SubElement(image_elem, 'height').text = str(h)
+
+        ET.SubElement(image_elem, 'has_data').text = '%d' % int(image.has_data)
+        ET.SubElement(image_elem, 'path').text = image.path
+
+        return image_elem
+
+    @classmethod
+    def encode_annotation_base(cls, annotation):
+        assert isinstance(annotation, Annotation)
+        ann_elem = ET.Element('annotation')
+        ET.SubElement(ann_elem, 'id').text = str(annotation.id)
+        ET.SubElement(ann_elem, 'type').text = str(annotation.type.name)
+
+        for k, v in annotation.attributes.items():
+            ET.SubElement(ann_elem, k.replace(' ', '-')).text = str(v)
+
+        ET.SubElement(ann_elem, 'group').text = str(annotation.group)
+
+        return ann_elem
+
+    @staticmethod
+    def _get_label(label_id, categories):
+        label = ''
+        if label_id is None:
+            return ''
+        if categories is not None:
+            label_cat = categories.get(AnnotationType.label)
+            if label_cat is not None:
+                label = label_cat.items[label_id].name
+        return label
+
+    @classmethod
+    def encode_label_object(cls, obj, categories):
+        ann_elem = cls.encode_annotation_base(obj)
+
+        ET.SubElement(ann_elem, 'label').text = \
+            str(cls._get_label(obj.label, categories))
+        ET.SubElement(ann_elem, 'label_id').text = str(obj.label)
+
+        return ann_elem
+
+    @classmethod
+    def encode_mask_object(cls, obj, categories):
+        ann_elem = cls.encode_annotation_base(obj)
+
+        ET.SubElement(ann_elem, 'label').text = \
+            str(cls._get_label(obj.label, categories))
+        ET.SubElement(ann_elem, 'label_id').text = str(obj.label)
+
+        return ann_elem
+
+    @classmethod
+    def encode_bbox_object(cls, obj, categories):
+        ann_elem = cls.encode_annotation_base(obj)
+
+        ET.SubElement(ann_elem, 'label').text = \
+            str(cls._get_label(obj.label, categories))
+        ET.SubElement(ann_elem, 'label_id').text = str(obj.label)
+        ET.SubElement(ann_elem, 'x').text = str(obj.x)
+        ET.SubElement(ann_elem, 'y').text = str(obj.y)
+        ET.SubElement(ann_elem, 'w').text = str(obj.w)
+        ET.SubElement(ann_elem, 'h').text = str(obj.h)
+        ET.SubElement(ann_elem, 'area').text = str(obj.get_area())
+
+        return ann_elem
+
+    @classmethod
+    def encode_points_object(cls, obj, categories):
+        ann_elem = cls.encode_annotation_base(obj)
+
+        ET.SubElement(ann_elem, 'label').text = \
+            str(cls._get_label(obj.label, categories))
+        ET.SubElement(ann_elem, 'label_id').text = str(obj.label)
+
+        x, y, w, h = obj.get_bbox()
+        area = w * h
+        bbox_elem = ET.SubElement(ann_elem, 'bbox')
+        ET.SubElement(bbox_elem, 'x').text = str(x)
+        ET.SubElement(bbox_elem, 'y').text = str(y)
+        ET.SubElement(bbox_elem, 'w').text = str(w)
+        ET.SubElement(bbox_elem, 'h').text = str(h)
+        ET.SubElement(bbox_elem, 'area').text = str(area)
+
+        points = obj.points
+        for i in range(0, len(points), 2):
+            point_elem = ET.SubElement(ann_elem, 'point')
+            ET.SubElement(point_elem, 'x').text = str(points[i])
+            ET.SubElement(point_elem, 'y').text = str(points[i + 1])
+            ET.SubElement(point_elem, 'visible').text = \
+                str(obj.visibility[i // 2].name)
+
+        return ann_elem
+
+    @classmethod
+    def encode_polygon_object(cls, obj, categories):
+        ann_elem = cls.encode_annotation_base(obj)
+
+        ET.SubElement(ann_elem, 'label').text = \
+            str(cls._get_label(obj.label, categories))
+        ET.SubElement(ann_elem, 'label_id').text = str(obj.label)
+
+        x, y, w, h = obj.get_bbox()
+        area = w * h
+        bbox_elem = ET.SubElement(ann_elem, 'bbox')
+        ET.SubElement(bbox_elem, 'x').text = str(x)
+        ET.SubElement(bbox_elem, 'y').text = str(y)
+        ET.SubElement(bbox_elem, 'w').text = str(w)
+        ET.SubElement(bbox_elem, 'h').text = str(h)
+        ET.SubElement(bbox_elem, 'area').text = str(area)
+
+        points = obj.points
+        for i in range(0, len(points), 2):
+            point_elem = ET.SubElement(ann_elem, 'point')
+            ET.SubElement(point_elem, 'x').text = str(points[i])
+            ET.SubElement(point_elem, 'y').text = str(points[i + 1])
+
+        return ann_elem
+
+    @classmethod
+    def encode_polyline_object(cls, obj, categories):
+        ann_elem = cls.encode_annotation_base(obj)
+
+        ET.SubElement(ann_elem, 'label').text = \
+            str(cls._get_label(obj.label, categories))
+        ET.SubElement(ann_elem, 'label_id').text = str(obj.label)
+
+        x, y, w, h = obj.get_bbox()
+        area = w * h
+        bbox_elem = ET.SubElement(ann_elem, 'bbox')
+        ET.SubElement(bbox_elem, 'x').text = str(x)
+        ET.SubElement(bbox_elem, 'y').text = str(y)
+        ET.SubElement(bbox_elem, 'w').text = str(w)
+        ET.SubElement(bbox_elem, 'h').text = str(h)
+        ET.SubElement(bbox_elem, 'area').text = str(area)
+
+        points = obj.points
+        for i in range(0, len(points), 2):
+            point_elem = ET.SubElement(ann_elem, 'point')
+            ET.SubElement(point_elem, 'x').text = str(points[i])
+            ET.SubElement(point_elem, 'y').text = str(points[i + 1])
+
+        return ann_elem
+
+    @classmethod
+    def encode_caption_object(cls, obj):
+        ann_elem = cls.encode_annotation_base(obj)
+
+        ET.SubElement(ann_elem, 'caption').text = str(obj.caption)
+
+        return ann_elem
+
+    @classmethod
+    def encode_annotation(cls, o, categories=None):
+        if isinstance(o, Label):
+            return cls.encode_label_object(o, categories)
+        if isinstance(o, Mask):
+            return cls.encode_mask_object(o, categories)
+        if isinstance(o, Bbox):
+            return cls.encode_bbox_object(o, categories)
+        if isinstance(o, Points):
+            return cls.encode_points_object(o, categories)
+        if isinstance(o, PolyLine):
+            return cls.encode_polyline_object(o, categories)
+        if isinstance(o, Polygon):
+            return cls.encode_polygon_object(o, categories)
+        if isinstance(o, Caption):
+            return cls.encode_caption_object(o)
+        raise NotImplementedError("Unexpected annotation object passed: %s" % o)
+
+    @staticmethod
+    def to_string(encoded_item):
+        return ET.tostring(encoded_item, encoding='unicode', pretty_print=True)
+
+def XPathDatasetFilter(extractor, xpath=None):
+    if xpath is None:
+        return extractor
+    try:
+        xpath = ET.XPath(xpath)
+    except Exception:
+        log.error("Failed to create XPath from expression '%s'", xpath)
+        raise
+    f = lambda item: bool(xpath(
+        DatasetItemEncoder.encode(item, extractor.categories())))
+    return extractor.select(f)
+
+class XPathAnnotationsFilter(Transform):
+    def __init__(self, extractor, xpath=None, remove_empty=False):
+        super().__init__(extractor)
+
+        if xpath is not None:
+            try:
+                xpath = ET.XPath(xpath)
+            except Exception:
+                log.error("Failed to create XPath from expression '%s'", xpath)
+                raise
+        self._filter = xpath
+
+        self._remove_empty = remove_empty
+
+    def __iter__(self):
+        for item in self._extractor:
+            item = self.transform_item(item)
+            if item is not None:
+                yield item
+
+    def transform_item(self, item):
+        if self._filter is None:
+            return item
+
+        encoded = DatasetItemEncoder.encode(item, self._extractor.categories())
+        filtered = self._filter(encoded)
+        filtered = [elem for elem in filtered if elem.tag == 'annotation']
+
+        encoded = encoded.findall('annotation')
+        annotations = [item.annotations[encoded.index(e)] for e in filtered]
+
+        if self._remove_empty and len(annotations) == 0:
+            return None
+        return self.wrap_item(item, annotations=annotations)

testbed/openvinotoolkit__datumaro/datumaro/components/extractor.py

@@ -0,0 +1,657 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+from enum import Enum
+from glob import glob
+from typing import List, Dict
+import numpy as np
+import os.path as osp
+
+import attr
+from attr import attrs, attrib
+
+from datumaro.util.image import Image
+from datumaro.util.attrs_util import not_empty, default_if_none
+
+
+AnnotationType = Enum('AnnotationType',
+    [
+        'label',
+        'mask',
+        'points',
+        'polygon',
+        'polyline',
+        'bbox',
+        'caption',
+    ])
+
+_COORDINATE_ROUNDING_DIGITS = 2
+
+@attrs(kw_only=True)
+class Annotation:
+    id = attrib(default=0, validator=default_if_none(int))
+    attributes = attrib(factory=dict, validator=default_if_none(dict))
+    group = attrib(default=0, validator=default_if_none(int))
+
+    def __attrs_post_init__(self):
+        assert isinstance(self.type, AnnotationType)
+
+    @property
+    def type(self) -> AnnotationType:
+        return self._type # must be set in subclasses
+
+    def wrap(self, **kwargs):
+        return attr.evolve(self, **kwargs)
+
+@attrs(kw_only=True)
+class Categories:
+    attributes = attrib(factory=set, validator=default_if_none(set), eq=False)
+
+@attrs
+class LabelCategories(Categories):
+    @attrs(repr_ns='LabelCategories')
+    class Category:
+        name = attrib(converter=str, validator=not_empty)
+        parent = attrib(default='', validator=default_if_none(str))
+        attributes = attrib(factory=set, validator=default_if_none(set))
+
+    items = attrib(factory=list, validator=default_if_none(list))
+    _indices = attrib(factory=dict, init=False, eq=False)
+
+    @classmethod
+    def from_iterable(cls, iterable):
+        """Generation of LabelCategories from iterable object
+
+        Args:
+            iterable ([type]): This iterable object can be:
+            1)simple str - will generate one Category with str as name
+            2)list of str - will interpreted as list of Category names
+            3)list of positional argumetns - will generate Categories
+            with this arguments
+
+
+        Returns:
+            LabelCategories: LabelCategories object
+        """
+        temp_categories = cls()
+
+        if isinstance(iterable, str):
+            iterable = [[iterable]]
+
+        for category in iterable:
+            if isinstance(category, str):
+                category = [category]
+            temp_categories.add(*category)
+
+        return temp_categories
+
+    def __attrs_post_init__(self):
+        self._reindex()
+
+    def _reindex(self):
+        indices = {}
+        for index, item in enumerate(self.items):
+            assert item.name not in self._indices
+            indices[item.name] = index
+        self._indices = indices
+
+    def add(self, name: str, parent: str = None, attributes: dict = None):
+        assert name not in self._indices, name
+
+        index = len(self.items)
+        self.items.append(self.Category(name, parent, attributes))
+        self._indices[name] = index
+        return index
+
+    def find(self, name: str):
+        index = self._indices.get(name)
+        if index is not None:
+            return index, self.items[index]
+        return index, None
+
+    def __getitem__(self, idx):
+        return self.items[idx]
+
+    def __len__(self):
+        return len(self.items)
+
+    def __iter__(self):
+        return iter(self.items)
+
+@attrs
+class Label(Annotation):
+    _type = AnnotationType.label
+    label = attrib(converter=int)
+
+@attrs(eq=False)
+class MaskCategories(Categories):
+    colormap = attrib(factory=dict, validator=default_if_none(dict))
+    _inverse_colormap = attrib(default=None,
+        validator=attr.validators.optional(dict))
+
+    @property
+    def inverse_colormap(self):
+        from datumaro.util.mask_tools import invert_colormap
+        if self._inverse_colormap is None:
+            if self.colormap is not None:
+                self._inverse_colormap = invert_colormap(self.colormap)
+        return self._inverse_colormap
+
+    def __eq__(self, other):
+        if not super().__eq__(other):
+            return False
+        if not isinstance(other, __class__):
+            return False
+        for label_id, my_color in self.colormap.items():
+            other_color = other.colormap.get(label_id)
+            if not np.array_equal(my_color, other_color):
+                return False
+        return True
+
+@attrs(eq=False)
+class Mask(Annotation):
+    _type = AnnotationType.mask
+    _image = attrib()
+    label = attrib(converter=attr.converters.optional(int),
+        default=None, kw_only=True)
+    z_order = attrib(default=0, validator=default_if_none(int), kw_only=True)
+
+    @property
+    def image(self):
+        if callable(self._image):
+            return self._image()
+        return self._image
+
+    def as_class_mask(self, label_id=None):
+        if label_id is None:
+            label_id = self.label
+        return self.image * label_id
+
+    def as_instance_mask(self, instance_id):
+        return self.image * instance_id
+
+    def get_area(self):
+        return np.count_nonzero(self.image)
+
+    def get_bbox(self):
+        from datumaro.util.mask_tools import find_mask_bbox
+        return find_mask_bbox(self.image)
+
+    def paint(self, colormap):
+        from datumaro.util.mask_tools import paint_mask
+        return paint_mask(self.as_class_mask(), colormap)
+
+    def __eq__(self, other):
+        if not super().__eq__(other):
+            return False
+        if not isinstance(other, __class__):
+            return False
+        return \
+            (self.label == other.label) and \
+            (self.z_order == other.z_order) and \
+            (np.array_equal(self.image, other.image))
+
+@attrs(eq=False)
+class RleMask(Mask):
+    rle = attrib()
+    _image = attrib(default=attr.Factory(
+        lambda self: self._lazy_decode(self.rle),
+        takes_self=True), init=False)
+
+    @staticmethod
+    def _lazy_decode(rle):
+        from pycocotools import mask as mask_utils
+        return lambda: mask_utils.decode(rle).astype(np.bool)
+
+    def get_area(self):
+        from pycocotools import mask as mask_utils
+        return mask_utils.area(self.rle)
+
+    def get_bbox(self):
+        from pycocotools import mask as mask_utils
+        return mask_utils.toBbox(self.rle)
+
+    def __eq__(self, other):
+        if not isinstance(other, __class__):
+            return super().__eq__(other)
+        return self.rle == other.rle
+
+class CompiledMask:
+    @staticmethod
+    def from_instance_masks(instance_masks,
+            instance_ids=None, instance_labels=None):
+        from datumaro.util.mask_tools import merge_masks
+
+        if instance_ids is not None:
+            assert len(instance_ids) == len(instance_masks)
+        else:
+            instance_ids = [None] * len(instance_masks)
+
+        if instance_labels is not None:
+            assert len(instance_labels) == len(instance_masks)
+        else:
+            instance_labels = [None] * len(instance_masks)
+
+        instance_masks = sorted(
+            zip(instance_masks, instance_ids, instance_labels),
+            key=lambda m: m[0].z_order)
+
+        instance_mask = [m.as_instance_mask(id if id is not None else 1 + idx)
+            for idx, (m, id, _) in enumerate(instance_masks)]
+        instance_mask = merge_masks(instance_mask)
+
+        cls_mask = [m.as_class_mask(c) for m, _, c in instance_masks]
+        cls_mask = merge_masks(cls_mask)
+        return __class__(class_mask=cls_mask, instance_mask=instance_mask)
+
+    def __init__(self, class_mask=None, instance_mask=None):
+        self._class_mask = class_mask
+        self._instance_mask = instance_mask
+
+    @staticmethod
+    def _get_image(image):
+        if callable(image):
+            return image()
+        return image
+
+    @property
+    def class_mask(self):
+        return self._get_image(self._class_mask)
+
+    @property
+    def instance_mask(self):
+        return self._get_image(self._instance_mask)
+
+    @property
+    def instance_count(self):
+        return int(self.instance_mask.max())
+
+    def get_instance_labels(self):
+        class_shift = 16
+        m = (self.class_mask.astype(np.uint32) << class_shift) \
+            + self.instance_mask.astype(np.uint32)
+        keys = np.unique(m)
+        instance_labels = {k & ((1 << class_shift) - 1): k >> class_shift
+            for k in keys if k & ((1 << class_shift) - 1) != 0
+        }
+        return instance_labels
+
+    def extract(self, instance_id):
+        return self.instance_mask == instance_id
+
+    def lazy_extract(self, instance_id):
+        return lambda: self.extract(instance_id)
+
+@attrs
+class _Shape(Annotation):
+    points = attrib(converter=lambda x:
+        [round(p, _COORDINATE_ROUNDING_DIGITS) for p in x])
+    label = attrib(converter=attr.converters.optional(int),
+        default=None, kw_only=True)
+    z_order = attrib(default=0, validator=default_if_none(int), kw_only=True)
+
+    def get_area(self):
+        raise NotImplementedError()
+
+    def get_bbox(self):
+        points = self.points
+        if not points:
+            return None
+
+        xs = [p for p in points[0::2]]
+        ys = [p for p in points[1::2]]
+        x0 = min(xs)
+        x1 = max(xs)
+        y0 = min(ys)
+        y1 = max(ys)
+        return [x0, y0, x1 - x0, y1 - y0]
+
+@attrs
+class PolyLine(_Shape):
+    _type = AnnotationType.polyline
+
+    def as_polygon(self):
+        return self.points[:]
+
+    def get_area(self):
+        return 0
+
+@attrs
+class Polygon(_Shape):
+    _type = AnnotationType.polygon
+
+    def __attrs_post_init__(self):
+        super().__attrs_post_init__()
+        # keep the message on a single line to produce informative output
+        assert len(self.points) % 2 == 0 and 3 <= len(self.points) // 2, "Wrong polygon points: %s" % self.points
+
+    def get_area(self):
+        import pycocotools.mask as mask_utils
+
+        x, y, w, h = self.get_bbox()
+        rle = mask_utils.frPyObjects([self.points], y + h, x + w)
+        area = mask_utils.area(rle)[0]
+        return area
+
+@attrs
+class Bbox(_Shape):
+    _type = AnnotationType.bbox
+
+    # will be overridden by attrs, then will be overridden again by us
+    # attrs' method will be renamed to __attrs_init__
+    def __init__(self, x, y, w, h, *args, **kwargs):
+        kwargs.pop('points', None) # comes from wrap()
+        self.__attrs_init__([x, y, x + w, y + h], *args, **kwargs)
+    __actual_init__ = __init__ # save pointer
+
+    @property
+    def x(self):
+        return self.points[0]
+
+    @property
+    def y(self):
+        return self.points[1]
+
+    @property
+    def w(self):
+        return self.points[2] - self.points[0]
+
+    @property
+    def h(self):
+        return self.points[3] - self.points[1]
+
+    def get_area(self):
+        return self.w * self.h
+
+    def get_bbox(self):
+        return [self.x, self.y, self.w, self.h]
+
+    def as_polygon(self):
+        x, y, w, h = self.get_bbox()
+        return [
+            x, y,
+            x + w, y,
+            x + w, y + h,
+            x, y + h
+        ]
+
+    def iou(self, other):
+        from datumaro.util.annotation_util import bbox_iou
+        return bbox_iou(self.get_bbox(), other.get_bbox())
+
+    def wrap(item, **kwargs):
+        d = {'x': item.x, 'y': item.y, 'w': item.w, 'h': item.h}
+        d.update(kwargs)
+        return attr.evolve(item, **d)
+
+assert not hasattr(Bbox, '__attrs_init__') # hopefully, it will be supported
+setattr(Bbox, '__attrs_init__', Bbox.__init__)
+setattr(Bbox, '__init__', Bbox.__actual_init__)
+
+@attrs
+class PointsCategories(Categories):
+    @attrs(repr_ns="PointsCategories")
+    class Category:
+        labels = attrib(factory=list, validator=default_if_none(list))
+        joints = attrib(factory=set, validator=default_if_none(set))
+
+    items = attrib(factory=dict, validator=default_if_none(dict))
+
+    @classmethod
+    def from_iterable(cls, iterable):
+        """Generation of PointsCategories from iterable object
+
+        Args:
+            iterable ([type]): This iterable object can be:
+            1) list of positional argumetns - will generate Categories
+                with these arguments
+
+        Returns:
+            PointsCategories: PointsCategories object
+        """
+        temp_categories = cls()
+
+        for category in iterable:
+            temp_categories.add(*category)
+        return temp_categories
+
+    def add(self, label_id, labels=None, joints=None):
+        if joints is None:
+            joints = []
+        joints = set(map(tuple, joints))
+        self.items[label_id] = self.Category(labels, joints)
+
+@attrs
+class Points(_Shape):
+    Visibility = Enum('Visibility', [
+        ('absent', 0),
+        ('hidden', 1),
+        ('visible', 2),
+    ])
+    _type = AnnotationType.points
+
+    visibility = attrib(type=list, default=None)
+    @visibility.validator
+    def _visibility_validator(self, attribute, visibility):
+        if visibility is None:
+            visibility = [self.Visibility.visible] * (len(self.points) // 2)
+        else:
+            for i, v in enumerate(visibility):
+                if not isinstance(v, self.Visibility):
+                    visibility[i] = self.Visibility(v)
+        assert len(visibility) == len(self.points) // 2
+        self.visibility = visibility
+
+    def __attrs_post_init__(self):
+        super().__attrs_post_init__()
+        assert len(self.points) % 2 == 0, self.points
+
+    def get_area(self):
+        return 0
+
+    def get_bbox(self):
+        xs = [p for p, v in zip(self.points[0::2], self.visibility)
+            if v != __class__.Visibility.absent]
+        ys = [p for p, v in zip(self.points[1::2], self.visibility)
+            if v != __class__.Visibility.absent]
+        x0 = min(xs, default=0)
+        x1 = max(xs, default=0)
+        y0 = min(ys, default=0)
+        y1 = max(ys, default=0)
+        return [x0, y0, x1 - x0, y1 - y0]
+
+@attrs
+class Caption(Annotation):
+    _type = AnnotationType.caption
+    caption = attrib(converter=str)
+
+
+DEFAULT_SUBSET_NAME = 'default'
+
+@attrs
+class DatasetItem:
+    id = attrib(converter=lambda x: str(x).replace('\\', '/'),
+        type=str, validator=not_empty)
+    annotations = attrib(factory=list, validator=default_if_none(list))
+    subset = attrib(converter=lambda v: v or DEFAULT_SUBSET_NAME, default=None)
+    path = attrib(factory=list, validator=default_if_none(list))
+
+    image = attrib(type=Image, default=None)
+    @image.validator
+    def _image_validator(self, attribute, image):
+        if callable(image) or isinstance(image, np.ndarray):
+            image = Image(data=image)
+        elif isinstance(image, str):
+            image = Image(path=image)
+        assert image is None or isinstance(image, Image)
+        self.image = image
+
+    attributes = attrib(factory=dict, validator=default_if_none(dict))
+
+    @property
+    def has_image(self):
+        return self.image is not None
+
+    def wrap(item, **kwargs):
+        return attr.evolve(item, **kwargs)
+
+class IExtractor:
+    def __iter__(self):
+        raise NotImplementedError()
+
+    def __len__(self):
+        raise NotImplementedError()
+
+    def subsets(self):
+        raise NotImplementedError()
+
+    def get_subset(self, name):
+        raise NotImplementedError()
+
+    def categories(self):
+        raise NotImplementedError()
+
+    def select(self, pred):
+        raise NotImplementedError()
+
+class Extractor(IExtractor):
+    def __init__(self, length=None, subsets=None):
+        self._length = length
+        self._subsets = subsets
+
+    def _init_cache(self):
+        subsets = set()
+        length = -1
+        for length, item in enumerate(self):
+            subsets.add(item.subset)
+        length += 1
+
+        if self._length is None:
+            self._length = length
+        if self._subsets is None:
+            self._subsets = subsets
+
+    def __len__(self):
+        if self._length is None:
+            self._init_cache()
+        return self._length
+
+    def subsets(self) -> Dict[str, IExtractor]:
+        if self._subsets is None:
+            self._init_cache()
+        return {name or DEFAULT_SUBSET_NAME: self.get_subset(name)
+            for name in self._subsets}
+
+    def get_subset(self, name):
+        if self._subsets is None:
+            self._init_cache()
+        if name in self._subsets:
+            return self.select(lambda item: item.subset == name)
+        else:
+            raise Exception("Unknown subset '%s', available subsets: %s" % \
+                (name, set(self._subsets)))
+
+    def transform(self, method, *args, **kwargs):
+        return method(self, *args, **kwargs)
+
+    def select(self, pred):
+        class _DatasetFilter(Extractor):
+            def __init__(self, _):
+                super().__init__()
+            def __iter__(_):
+                return filter(pred, iter(self))
+            def categories(_):
+                return self.categories()
+
+        return self.transform(_DatasetFilter)
+
+    def categories(self):
+        return {}
+
+class SourceExtractor(Extractor):
+    def __init__(self, length=None, subset=None):
+        self._subset = subset or DEFAULT_SUBSET_NAME
+        super().__init__(length=length, subsets=[self._subset])
+
+        self._categories = {}
+        self._items = []
+
+    def categories(self):
+        return self._categories
+
+    def __iter__(self):
+        yield from self._items
+
+    def __len__(self):
+        return len(self._items)
+
+class Importer:
+    @classmethod
+    def detect(cls, path):
+        return len(cls.find_sources(path)) != 0
+
+    @classmethod
+    def find_sources(cls, path) -> List[Dict]:
+        raise NotImplementedError()
+
+    def __call__(self, path, **extra_params):
+        from datumaro.components.project import Project # cyclic import
+        project = Project()
+
+        sources = self.find_sources(osp.normpath(path))
+        if len(sources) == 0:
+            raise Exception("Failed to find dataset at '%s'" % path)
+
+        for desc in sources:
+            params = dict(extra_params)
+            params.update(desc.get('options', {}))
+            desc['options'] = params
+
+            source_name = osp.splitext(osp.basename(desc['url']))[0]
+            project.add_source(source_name, desc)
+
+        return project
+
+    @classmethod
+    def _find_sources_recursive(cls, path, ext, extractor_name, filename='*'):
+        if path.endswith(ext) and osp.isfile(path):
+            sources = [{'url': path, 'format': extractor_name}]
+        else:
+            sources = [{'url': p, 'format': extractor_name} for p in
+                glob(osp.join(path, '**', filename + ext), recursive=True)]
+        return sources
+
+class Transform(Extractor):
+    @staticmethod
+    def wrap_item(item, **kwargs):
+        return item.wrap(**kwargs)
+
+    def __init__(self, extractor):
+        super().__init__()
+
+        self._extractor = extractor
+
+    def __iter__(self):
+        for item in self._extractor:
+            yield self.transform_item(item)
+
+    def categories(self):
+        return self._extractor.categories()
+
+    def subsets(self):
+        if self._subsets is None:
+            self._subsets = set(self._extractor.subsets())
+        return super().subsets()
+
+    def __len__(self):
+        assert self._length in {None, 'parent'} or isinstance(self._length, int)
+        if self._length is None and \
+                    self.__iter__.__func__ == Transform.__iter__ \
+                or self._length == 'parent':
+            self._length = len(self._extractor)
+        return super().__len__()
+
+    def transform_item(self, item: DatasetItem) -> DatasetItem:
+        raise NotImplementedError()

testbed/openvinotoolkit__datumaro/datumaro/components/launcher.py

@@ -0,0 +1,67 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+import numpy as np
+
+from datumaro.components.extractor import (Transform, LabelCategories,
+    AnnotationType)
+from datumaro.util import take_by
+
+
+# pylint: disable=no-self-use
+class Launcher:
+    def __init__(self, model_dir=None):
+        pass
+
+    def launch(self, inputs):
+        raise NotImplementedError()
+
+    def categories(self):
+        return None
+# pylint: enable=no-self-use
+
+class ModelTransform(Transform):
+    def __init__(self, extractor, launcher, batch_size=1):
+        super().__init__(extractor)
+        self._launcher = launcher
+        self._batch_size = batch_size
+
+    def __iter__(self):
+        for batch in take_by(self._extractor, self._batch_size):
+            inputs = np.array([item.image.data for item in batch])
+            inference = self._launcher.launch(inputs)
+
+            for item, annotations in zip(batch, inference):
+                self._check_annotations(annotations)
+                yield self.wrap_item(item, annotations=annotations)
+
+    def get_subset(self, name):
+        subset = self._extractor.get_subset(name)
+        return __class__(subset, self._launcher, self._batch_size)
+
+    def categories(self):
+        launcher_override = self._launcher.categories()
+        if launcher_override is not None:
+            return launcher_override
+        return self._extractor.categories()
+
+    def transform_item(self, item):
+        inputs = np.expand_dims(item.image, axis=0)
+        annotations = self._launcher.launch(inputs)[0]
+        return self.wrap_item(item, annotations=annotations)
+
+    def _check_annotations(self, annotations):
+        labels_count = len(self.categories().get(
+            AnnotationType.label, LabelCategories()).items)
+
+        for ann in annotations:
+            label = getattr(ann, 'label')
+            if label is None:
+                continue
+
+            if label not in range(labels_count):
+                raise Exception("Annotation has unexpected label id %s, "
+                    "while there is only %s defined labels." % \
+                    (label, labels_count))

testbed/openvinotoolkit__datumaro/datumaro/components/operations.py

@@ -0,0 +1,1503 @@
+
+# Copyright (C) 2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+from collections import OrderedDict
+from copy import deepcopy
+import hashlib
+import logging as log
+
+import attr
+import cv2
+import numpy as np
+from attr import attrib, attrs
+from unittest import TestCase
+
+from datumaro.components.cli_plugin import CliPlugin
+from datumaro.components.extractor import (AnnotationType, Bbox, Label,
+    LabelCategories, PointsCategories, MaskCategories)
+from datumaro.components.project import Dataset
+from datumaro.util import find, filter_dict
+from datumaro.util.attrs_util import ensure_cls, default_if_none
+from datumaro.util.annotation_util import (segment_iou, bbox_iou,
+    mean_bbox, OKS, find_instances, max_bbox, smooth_line)
+
+def get_ann_type(anns, t):
+    return [a for a in anns if a.type == t]
+
+def match_annotations_equal(a, b):
+    matches = []
+    a_unmatched = a[:]
+    b_unmatched = b[:]
+    for a_ann in a:
+        for b_ann in b_unmatched:
+            if a_ann != b_ann:
+                continue
+
+            matches.append((a_ann, b_ann))
+            a_unmatched.remove(a_ann)
+            b_unmatched.remove(b_ann)
+            break
+
+    return matches, a_unmatched, b_unmatched
+
+def merge_annotations_equal(a, b):
+    matches, a_unmatched, b_unmatched = match_annotations_equal(a, b)
+    return [ann_a for (ann_a, _) in matches] + a_unmatched + b_unmatched
+
+def merge_categories(sources):
+    categories = {}
+    for source in sources:
+        for cat_type, source_cat in source.items():
+            existing_cat = categories.setdefault(cat_type, source_cat)
+            if existing_cat != source_cat:
+                raise NotImplementedError(
+                    "Merging of datasets with different categories is "
+                    "only allowed in 'merge' command.")
+    return categories
+
+class MergingStrategy(CliPlugin):
+    @classmethod
+    def merge(cls, sources, **options):
+        instance = cls(**options)
+        return instance(sources)
+
+    def __init__(self, **options):
+        super().__init__(**options)
+        self.__dict__['_sources'] = None
+
+    def __call__(self, sources):
+        raise NotImplementedError()
+
+
+@attrs
+class DatasetError:
+    item_id = attrib()
+
+@attrs
+class QualityError(DatasetError):
+    pass
+
+@attrs
+class TooCloseError(QualityError):
+    a = attrib()
+    b = attrib()
+    distance = attrib()
+
+    def __str__(self):
+        return "Item %s: annotations are too close: %s, %s, distance = %s" % \
+            (self.item_id, self.a, self.b, self.distance)
+
+@attrs
+class WrongGroupError(QualityError):
+    found = attrib(converter=set)
+    expected = attrib(converter=set)
+    group = attrib(converter=list)
+
+    def __str__(self):
+        return "Item %s: annotation group has wrong labels: " \
+            "found %s, expected %s, group %s" % \
+            (self.item_id, self.found, self.expected, self.group)
+
+@attrs
+class MergeError(DatasetError):
+    sources = attrib(converter=set)
+
+@attrs
+class NoMatchingAnnError(MergeError):
+    ann = attrib()
+
+    def __str__(self):
+        return "Item %s: can't find matching annotation " \
+            "in sources %s, annotation is %s" % \
+            (self.item_id, self.sources, self.ann)
+
+@attrs
+class NoMatchingItemError(MergeError):
+    def __str__(self):
+        return "Item %s: can't find matching item in sources %s" % \
+            (self.item_id, self.sources)
+
+@attrs
+class FailedLabelVotingError(MergeError):
+    votes = attrib()
+    ann = attrib(default=None)
+
+    def __str__(self):
+        return "Item %s: label voting failed%s, votes %s, sources %s" % \
+            (self.item_id, 'for ann %s' % self.ann if self.ann else '',
+            self.votes, self.sources)
+
+@attrs
+class FailedAttrVotingError(MergeError):
+    attr = attrib()
+    votes = attrib()
+    ann = attrib()
+
+    def __str__(self):
+        return "Item %s: attribute voting failed " \
+            "for ann %s, votes %s, sources %s" % \
+            (self.item_id, self.ann, self.votes, self.sources)
+
+@attrs
+class IntersectMerge(MergingStrategy):
+    @attrs(repr_ns='IntersectMerge', kw_only=True)
+    class Conf:
+        pairwise_dist = attrib(converter=float, default=0.5)
+        sigma = attrib(converter=list, factory=list)
+
+        output_conf_thresh = attrib(converter=float, default=0)
+        quorum = attrib(converter=int, default=0)
+        ignored_attributes = attrib(converter=set, factory=set)
+
+        def _groups_conveter(value):
+            result = []
+            for group in value:
+                rg = set()
+                for label in group:
+                    optional = label.endswith('?')
+                    name = label if not optional else label[:-1]
+                    rg.add((name, optional))
+                result.append(rg)
+            return result
+        groups = attrib(converter=_groups_conveter, factory=list)
+        close_distance = attrib(converter=float, default=0.75)
+    conf = attrib(converter=ensure_cls(Conf), factory=Conf)
+
+    # Error trackers:
+    errors = attrib(factory=list, init=False)
+    def add_item_error(self, error, *args, **kwargs):
+        self.errors.append(error(self._item_id, *args, **kwargs))
+
+    # Indexes:
+    _dataset_map = attrib(init=False) # id(dataset) -> (dataset, index)
+    _item_map = attrib(init=False) # id(item) -> (item, id(dataset))
+    _ann_map = attrib(init=False) # id(ann) -> (ann, id(item))
+    _item_id = attrib(init=False)
+    _item = attrib(init=False)
+
+    # Misc.
+    _categories = attrib(init=False) # merged categories
+
+    def __call__(self, datasets):
+        self._categories = self._merge_categories(
+            [d.categories() for d in datasets])
+        merged = Dataset(categories=self._categories)
+
+        self._check_groups_definition()
+
+        item_matches, item_map = self.match_items(datasets)
+        self._item_map = item_map
+        self._dataset_map = { id(d): (d, i) for i, d in enumerate(datasets) }
+
+        for item_id, items in item_matches.items():
+            self._item_id = item_id
+
+            if len(items) < len(datasets):
+                missing_sources = set(id(s) for s in datasets) - set(items)
+                missing_sources = [self._dataset_map[s][1]
+                    for s in missing_sources]
+                self.add_item_error(NoMatchingItemError, missing_sources)
+            merged.put(self.merge_items(items))
+
+        return merged
+
+    def get_ann_source(self, ann_id):
+        return self._item_map[self._ann_map[ann_id][1]][1]
+
+    def merge_items(self, items):
+        self._item = next(iter(items.values()))
+
+        self._ann_map = {}
+        sources = []
+        for item in items.values():
+            self._ann_map.update({ id(a): (a, id(item))
+                for a in item.annotations })
+            sources.append(item.annotations)
+        log.debug("Merging item %s: source annotations %s" % \
+            (self._item_id, list(map(len, sources))))
+
+        annotations = self.merge_annotations(sources)
+
+        annotations = [a for a in annotations
+            if self.conf.output_conf_thresh <= a.attributes.get('score', 1)]
+
+        return self._item.wrap(annotations=annotations)
+
+    def merge_annotations(self, sources):
+        self._make_mergers(sources)
+
+        clusters = self._match_annotations(sources)
+
+        joined_clusters = sum(clusters.values(), [])
+        group_map = self._find_cluster_groups(joined_clusters)
+
+        annotations = []
+        for t, clusters in clusters.items():
+            for cluster in clusters:
+                self._check_cluster_sources(cluster)
+
+            merged_clusters = self._merge_clusters(t, clusters)
+
+            for merged_ann, cluster in zip(merged_clusters, clusters):
+                attributes = self._find_cluster_attrs(cluster, merged_ann)
+                attributes = { k: v for k, v in attributes.items()
+                    if k not in self.conf.ignored_attributes }
+                attributes.update(merged_ann.attributes)
+                merged_ann.attributes = attributes
+
+                new_group_id = find(enumerate(group_map),
+                    lambda e: id(cluster) in e[1][0])
+                if new_group_id is None:
+                    new_group_id = 0
+                else:
+                    new_group_id = new_group_id[0] + 1
+                merged_ann.group = new_group_id
+
+            if self.conf.close_distance:
+                self._check_annotation_distance(t, merged_clusters)
+
+            annotations += merged_clusters
+
+        if self.conf.groups:
+            self._check_groups(annotations)
+
+        return annotations
+
+    @staticmethod
+    def match_items(datasets):
+        item_ids = set((item.id, item.subset) for d in datasets for item in d)
+
+        item_map = {} # id(item) -> (item, id(dataset))
+
+        matches = OrderedDict()
+        for (item_id, item_subset) in sorted(item_ids, key=lambda e: e[0]):
+            items = {}
+            for d in datasets:
+                try:
+                    item = d.get(item_id, subset=item_subset)
+                    items[id(d)] = item
+                    item_map[id(item)] = (item, id(d))
+                except KeyError:
+                    pass
+            matches[(item_id, item_subset)] = items
+
+        return matches, item_map
+
+    def _merge_label_categories(self, sources):
+        same = True
+        common = None
+        for src_categories in sources:
+            src_cat = src_categories.get(AnnotationType.label)
+            if common is None:
+                common = src_cat
+            elif common != src_cat:
+                same = False
+                break
+
+        if same:
+            return common
+
+        dst_cat = LabelCategories()
+        for src_id, src_categories in enumerate(sources):
+            src_cat = src_categories.get(AnnotationType.label)
+            if src_cat is None:
+                continue
+
+            for src_label in src_cat.items:
+                dst_label = dst_cat.find(src_label.name)[1]
+                if dst_label is not None:
+                    if dst_label != src_label:
+                        if src_label.parent and dst_label.parent and \
+                                src_label.parent != dst_label.parent:
+                            raise ValueError("Can't merge label category "
+                                "%s (from #%s): "
+                                "parent label conflict: %s vs. %s" % \
+                                (src_label.name, src_id,
+                                 src_label.parent, dst_label.parent)
+                            )
+                        dst_label.parent = dst_label.parent or src_label.parent
+                        dst_label.attributes |= src_label.attributes
+                    else:
+                        pass
+                else:
+                    dst_cat.add(src_label.name,
+                        src_label.parent, src_label.attributes)
+
+        return dst_cat
+
+    def _merge_point_categories(self, sources, label_cat):
+        dst_point_cat = PointsCategories()
+
+        for src_id, src_categories in enumerate(sources):
+            src_label_cat = src_categories.get(AnnotationType.label)
+            src_point_cat = src_categories.get(AnnotationType.points)
+            if src_label_cat is None or src_point_cat is None:
+                continue
+
+            for src_label_id, src_cat in src_point_cat.items.items():
+                src_label = src_label_cat.items[src_label_id].name
+                dst_label_id = label_cat.find(src_label)[0]
+                dst_cat = dst_point_cat.items.get(dst_label_id)
+                if dst_cat is not None:
+                    if dst_cat != src_cat:
+                        raise ValueError("Can't merge point category for label "
+                            "%s (from #%s): %s vs. %s" % \
+                            (src_label, src_id, src_cat, dst_cat)
+                        )
+                    else:
+                        pass
+                else:
+                    dst_point_cat.add(dst_label_id,
+                        src_cat.labels, src_cat.joints)
+
+        if len(dst_point_cat.items) == 0:
+            return None
+
+        return dst_point_cat
+
+    def _merge_mask_categories(self, sources, label_cat):
+        dst_mask_cat = MaskCategories()
+
+        for src_id, src_categories in enumerate(sources):
+            src_label_cat = src_categories.get(AnnotationType.label)
+            src_mask_cat = src_categories.get(AnnotationType.mask)
+            if src_label_cat is None or src_mask_cat is None:
+                continue
+
+            for src_label_id, src_cat in src_mask_cat.colormap.items():
+                src_label = src_label_cat.items[src_label_id].name
+                dst_label_id = label_cat.find(src_label)[0]
+                dst_cat = dst_mask_cat.colormap.get(dst_label_id)
+                if dst_cat is not None:
+                    if dst_cat != src_cat:
+                        raise ValueError("Can't merge mask category for label "
+                            "%s (from #%s): %s vs. %s" % \
+                            (src_label, src_id, src_cat, dst_cat)
+                        )
+                    else:
+                        pass
+                else:
+                    dst_mask_cat.colormap[dst_label_id] = src_cat
+
+        if len(dst_mask_cat.colormap) == 0:
+            return None
+
+        return dst_mask_cat
+
+    def _merge_categories(self, sources):
+        dst_categories = {}
+
+        label_cat = self._merge_label_categories(sources)
+        if label_cat is None:
+            return dst_categories
+
+        dst_categories[AnnotationType.label] = label_cat
+
+        points_cat = self._merge_point_categories(sources, label_cat)
+        if points_cat is not None:
+            dst_categories[AnnotationType.points] = points_cat
+
+        mask_cat = self._merge_mask_categories(sources, label_cat)
+        if mask_cat is not None:
+            dst_categories[AnnotationType.mask] = mask_cat
+
+        return dst_categories
+
+    def _match_annotations(self, sources):
+        all_by_type = {}
+        for s in sources:
+            src_by_type = {}
+            for a in s:
+                src_by_type.setdefault(a.type, []).append(a)
+            for k, v in src_by_type.items():
+                all_by_type.setdefault(k, []).append(v)
+
+        clusters = {}
+        for k, v in all_by_type.items():
+            clusters.setdefault(k, []).extend(self._match_ann_type(k, v))
+
+        return clusters
+
+    def _make_mergers(self, sources):
+        def _make(c, **kwargs):
+            kwargs.update(attr.asdict(self.conf))
+            fields = attr.fields_dict(c)
+            return c(**{ k: v for k, v in kwargs.items() if k in fields },
+                context=self)
+
+        def _for_type(t, **kwargs):
+            if t is AnnotationType.label:
+                return _make(LabelMerger, **kwargs)
+            elif t is AnnotationType.bbox:
+                return _make(BboxMerger, **kwargs)
+            elif t is AnnotationType.mask:
+                return _make(MaskMerger, **kwargs)
+            elif t is AnnotationType.polygon:
+                return _make(PolygonMerger, **kwargs)
+            elif t is AnnotationType.polyline:
+                return _make(LineMerger, **kwargs)
+            elif t is AnnotationType.points:
+                return _make(PointsMerger, **kwargs)
+            elif t is AnnotationType.caption:
+                return _make(CaptionsMerger, **kwargs)
+            else:
+                raise NotImplementedError("Type %s is not supported" % t)
+
+        instance_map = {}
+        for s in sources:
+            s_instances = find_instances(s)
+            for inst in s_instances:
+                inst_bbox = max_bbox([a for a in inst if a.type in
+                    {AnnotationType.polygon,
+                     AnnotationType.mask, AnnotationType.bbox}
+                ])
+                for ann in inst:
+                    instance_map[id(ann)] = [inst, inst_bbox]
+
+        self._mergers = { t: _for_type(t, instance_map=instance_map)
+            for t in AnnotationType }
+
+    def _match_ann_type(self, t, sources):
+        return self._mergers[t].match_annotations(sources)
+
+    def _merge_clusters(self, t, clusters):
+        return self._mergers[t].merge_clusters(clusters)
+
+    @staticmethod
+    def _find_cluster_groups(clusters):
+        cluster_groups = []
+        visited = set()
+        for a_idx, cluster_a in enumerate(clusters):
+            if a_idx in visited:
+                continue
+            visited.add(a_idx)
+
+            cluster_group = { id(cluster_a) }
+
+            # find segment groups in the cluster group
+            a_groups = set(ann.group for ann in cluster_a)
+            for cluster_b in clusters[a_idx+1 :]:
+                b_groups = set(ann.group for ann in cluster_b)
+                if a_groups & b_groups:
+                    a_groups |= b_groups
+
+            # now we know all the segment groups in this cluster group
+            # so we can find adjacent clusters
+            for b_idx, cluster_b in enumerate(clusters[a_idx+1 :]):
+                b_idx = a_idx + 1 + b_idx
+                b_groups = set(ann.group for ann in cluster_b)
+                if a_groups & b_groups:
+                    cluster_group.add( id(cluster_b) )
+                    visited.add(b_idx)
+
+            if a_groups == {0}:
+                continue # skip annotations without a group
+            cluster_groups.append( (cluster_group, a_groups) )
+        return cluster_groups
+
+    def _find_cluster_attrs(self, cluster, ann):
+        quorum = self.conf.quorum or 0
+
+        # TODO: when attribute types are implemented, add linear
+        # interpolation for contiguous values
+
+        attr_votes = {} # name -> { value: score , ... }
+        for s in cluster:
+            for name, value in s.attributes.items():
+                votes = attr_votes.get(name, {})
+                votes[value] = 1 + votes.get(value, 0)
+                attr_votes[name] = votes
+
+        attributes = {}
+        for name, votes in attr_votes.items():
+            winner, count = max(votes.items(), key=lambda e: e[1])
+            if count < quorum:
+                if sum(votes.values()) < quorum:
+                    # blame provokers
+                    missing_sources = set(
+                        self.get_ann_source(id(a)) for a in cluster
+                        if s.attributes.get(name) == winner)
+                else:
+                    # blame outliers
+                    missing_sources = set(
+                        self.get_ann_source(id(a)) for a in cluster
+                        if s.attributes.get(name) != winner)
+                missing_sources = [self._dataset_map[s][1]
+                    for s in missing_sources]
+                self.add_item_error(FailedAttrVotingError,
+                    missing_sources, name, votes, ann)
+                continue
+            attributes[name] = winner
+
+        return attributes
+
+    def _check_cluster_sources(self, cluster):
+        if len(cluster) == len(self._dataset_map):
+            return
+
+        def _has_item(s):
+            try:
+                item =self._dataset_map[s][0].get(*self._item_id)
+                if len(item.annotations) == 0:
+                    return False
+                return True
+            except KeyError:
+                return False
+
+        missing_sources = set(self._dataset_map) - \
+            set(self.get_ann_source(id(a)) for a in cluster)
+        missing_sources = [self._dataset_map[s][1] for s in missing_sources
+            if _has_item(s)]
+        if missing_sources:
+            self.add_item_error(NoMatchingAnnError, missing_sources, cluster[0])
+
+    def _check_annotation_distance(self, t, annotations):
+        for a_idx, a_ann in enumerate(annotations):
+            for b_ann in annotations[a_idx+1:]:
+                d = self._mergers[t].distance(a_ann, b_ann)
+                if self.conf.close_distance < d:
+                    self.add_item_error(TooCloseError, a_ann, b_ann, d)
+
+    def _check_groups(self, annotations):
+        check_groups = []
+        for check_group_raw in self.conf.groups:
+            check_group = set(l[0] for l in check_group_raw)
+            optional = set(l[0] for l in check_group_raw if l[1])
+            check_groups.append((check_group, optional))
+
+        def _check_group(group_labels, group):
+            for check_group, optional in check_groups:
+                common = check_group & group_labels
+                real_miss = check_group - common - optional
+                extra = group_labels - check_group
+                if common and (extra or real_miss):
+                    self.add_item_error(WrongGroupError, group_labels,
+                        check_group, group)
+                    break
+
+        groups = find_instances(annotations)
+        for group in groups:
+            group_labels = set()
+            for ann in group:
+                if not hasattr(ann, 'label'):
+                    continue
+                label = self._get_label_name(ann.label)
+
+                if ann.group:
+                    group_labels.add(label)
+                else:
+                    _check_group({label}, [ann])
+
+            if not group_labels:
+                continue
+            _check_group(group_labels, group)
+
+    def _get_label_name(self, label_id):
+        if label_id is None:
+            return None
+        return self._categories[AnnotationType.label].items[label_id].name
+
+    def _get_label_id(self, label):
+        return self._categories[AnnotationType.label].find(label)[0]
+
+    def _get_src_label_name(self, ann, label_id):
+        if label_id is None:
+            return None
+        item_id = self._ann_map[id(ann)][1]
+        dataset_id = self._item_map[item_id][1]
+        return self._dataset_map[dataset_id][0] \
+            .categories()[AnnotationType.label].items[label_id].name
+
+    def _get_any_label_name(self, ann, label_id):
+        if label_id is None:
+            return None
+        try:
+            return self._get_src_label_name(ann, label_id)
+        except KeyError:
+            return self._get_label_name(label_id)
+
+    def _check_groups_definition(self):
+        for group in self.conf.groups:
+            for label, _ in group:
+                _, entry = self._categories[AnnotationType.label].find(label)
+                if entry is None:
+                    raise ValueError("Datasets do not contain "
+                        "label '%s', available labels %s" % \
+                        (label, [i.name for i in
+                            self._categories[AnnotationType.label].items])
+                    )
+
+@attrs(kw_only=True)
+class AnnotationMatcher:
+    _context = attrib(type=IntersectMerge, default=None)
+
+    def match_annotations(self, sources):
+        raise NotImplementedError()
+
+@attrs
+class LabelMatcher(AnnotationMatcher):
+    def distance(self, a, b):
+        a_label = self._context._get_any_label_name(a, a.label)
+        b_label = self._context._get_any_label_name(b, b.label)
+        return a_label == b_label
+
+    def match_annotations(self, sources):
+        return [sum(sources, [])]
+
+@attrs(kw_only=True)
+class _ShapeMatcher(AnnotationMatcher):
+    pairwise_dist = attrib(converter=float, default=0.9)
+    cluster_dist = attrib(converter=float, default=-1.0)
+
+    def match_annotations(self, sources):
+        distance = self.distance
+        label_matcher = self.label_matcher
+        pairwise_dist = self.pairwise_dist
+        cluster_dist = self.cluster_dist
+
+        if cluster_dist < 0: cluster_dist = pairwise_dist
+
+        id_segm = { id(a): (a, id(s)) for s in sources for a in s }
+
+        def _is_close_enough(cluster, extra_id):
+            # check if whole cluster IoU will not be broken
+            # when this segment is added
+            b = id_segm[extra_id][0]
+            for a_id in cluster:
+                a = id_segm[a_id][0]
+                if distance(a, b) < cluster_dist:
+                    return False
+            return True
+
+        def _has_same_source(cluster, extra_id):
+            b = id_segm[extra_id][1]
+            for a_id in cluster:
+                a = id_segm[a_id][1]
+                if a == b:
+                    return True
+            return False
+
+        # match segments in sources, pairwise
+        adjacent = { i: [] for i in id_segm } # id(sgm) -> [id(adj_sgm1), ...]
+        for a_idx, src_a in enumerate(sources):
+            for src_b in sources[a_idx+1 :]:
+                matches, _, _, _ = match_segments(src_a, src_b,
+                    dist_thresh=pairwise_dist,
+                    distance=distance, label_matcher=label_matcher)
+                for a, b in matches:
+                    adjacent[id(a)].append(id(b))
+
+        # join all segments into matching clusters
+        clusters = []
+        visited = set()
+        for cluster_idx in adjacent:
+            if cluster_idx in visited:
+                continue
+
+            cluster = set()
+            to_visit = { cluster_idx }
+            while to_visit:
+                c = to_visit.pop()
+                cluster.add(c)
+                visited.add(c)
+
+                for i in adjacent[c]:
+                    if i in visited:
+                        continue
+                    if 0 < cluster_dist and not _is_close_enough(cluster, i):
+                        continue
+                    if _has_same_source(cluster, i):
+                        continue
+
+                    to_visit.add(i)
+
+            clusters.append([id_segm[i][0] for i in cluster])
+
+        return clusters
+
+    @staticmethod
+    def distance(a, b):
+        return segment_iou(a, b)
+
+    def label_matcher(self, a, b):
+        a_label = self._context._get_any_label_name(a, a.label)
+        b_label = self._context._get_any_label_name(b, b.label)
+        return a_label == b_label
+
+@attrs
+class BboxMatcher(_ShapeMatcher):
+    pass
+
+@attrs
+class PolygonMatcher(_ShapeMatcher):
+    pass
+
+@attrs
+class MaskMatcher(_ShapeMatcher):
+    pass
+
+@attrs(kw_only=True)
+class PointsMatcher(_ShapeMatcher):
+    sigma = attrib(type=list, default=None)
+    instance_map = attrib(converter=dict)
+
+    def distance(self, a, b):
+        a_bbox = self.instance_map[id(a)][1]
+        b_bbox = self.instance_map[id(b)][1]
+        if bbox_iou(a_bbox, b_bbox) <= 0:
+            return 0
+        bbox = mean_bbox([a_bbox, b_bbox])
+        return OKS(a, b, sigma=self.sigma, bbox=bbox)
+
+@attrs
+class LineMatcher(_ShapeMatcher):
+    @staticmethod
+    def distance(a, b):
+        a_bbox = a.get_bbox()
+        b_bbox = b.get_bbox()
+        bbox = max_bbox([a_bbox, b_bbox])
+        area = bbox[2] * bbox[3]
+        if not area:
+            return 1
+
+        # compute inter-line area, normalize by common bbox
+        point_count = max(max(len(a.points) // 2, len(b.points) // 2), 5)
+        a, sa = smooth_line(a.points, point_count)
+        b, sb = smooth_line(b.points, point_count)
+        dists = np.linalg.norm(a - b, axis=1)
+        dists = (dists[:-1] + dists[1:]) * 0.5
+        s = np.sum(dists) * 0.5 * (sa + sb) / area
+        return abs(1 - s)
+
+@attrs
+class CaptionsMatcher(AnnotationMatcher):
+    def match_annotations(self, sources):
+        raise NotImplementedError()
+
+
+@attrs(kw_only=True)
+class AnnotationMerger:
+    def merge_clusters(self, clusters):
+        raise NotImplementedError()
+
+@attrs(kw_only=True)
+class LabelMerger(AnnotationMerger, LabelMatcher):
+    quorum = attrib(converter=int, default=0)
+
+    def merge_clusters(self, clusters):
+        assert len(clusters) <= 1
+        if len(clusters) == 0:
+            return []
+
+        votes = {} # label -> score
+        for ann in clusters[0]:
+            label = self._context._get_src_label_name(ann, ann.label)
+            votes[label] = 1 + votes.get(label, 0)
+
+        merged = []
+        for label, count in votes.items():
+            if count < self.quorum:
+                sources = set(self.get_ann_source(id(a)) for a in clusters[0]
+                    if label not in [self._context._get_src_label_name(l, l.label)
+                        for l in a])
+                sources = [self._context._dataset_map[s][1] for s in sources]
+                self._context.add_item_error(FailedLabelVotingError,
+                    sources, votes)
+                continue
+
+            merged.append(Label(self._context._get_label_id(label), attributes={
+                'score': count / len(self._context._dataset_map)
+            }))
+
+        return merged
+
+@attrs(kw_only=True)
+class _ShapeMerger(AnnotationMerger, _ShapeMatcher):
+    quorum = attrib(converter=int, default=0)
+
+    def merge_clusters(self, clusters):
+        merged = []
+        for cluster in clusters:
+            label, label_score = self.find_cluster_label(cluster)
+            shape, shape_score = self.merge_cluster_shape(cluster)
+
+            shape.z_order = max(cluster, key=lambda a: a.z_order).z_order
+            shape.label = label
+            shape.attributes['score'] = label_score * shape_score \
+                if label is not None else shape_score
+
+            merged.append(shape)
+
+        return merged
+
+    def find_cluster_label(self, cluster):
+        votes = {}
+        for s in cluster:
+            label = self._context._get_src_label_name(s, s.label)
+            state = votes.setdefault(label, [0, 0])
+            state[0] += s.attributes.get('score', 1.0)
+            state[1] += 1
+
+        label, (score, count) = max(votes.items(), key=lambda e: e[1][0])
+        if count < self.quorum:
+            self._context.add_item_error(FailedLabelVotingError, votes)
+            label = None
+        score = score / len(self._context._dataset_map)
+        label = self._context._get_label_id(label)
+        return label, score
+
+    @staticmethod
+    def _merge_cluster_shape_mean_box_nearest(cluster):
+        mbbox = Bbox(*mean_bbox(cluster))
+        dist = (segment_iou(mbbox, s) for s in cluster)
+        nearest_pos, _ = max(enumerate(dist), key=lambda e: e[1])
+        return cluster[nearest_pos]
+
+    def merge_cluster_shape(self, cluster):
+        shape = self._merge_cluster_shape_mean_box_nearest(cluster)
+        shape_score = sum(max(0, self.distance(shape, s))
+            for s in cluster) / len(cluster)
+        return shape, shape_score
+
+@attrs
+class BboxMerger(_ShapeMerger, BboxMatcher):
+    pass
+
+@attrs
+class PolygonMerger(_ShapeMerger, PolygonMatcher):
+    pass
+
+@attrs
+class MaskMerger(_ShapeMerger, MaskMatcher):
+    pass
+
+@attrs
+class PointsMerger(_ShapeMerger, PointsMatcher):
+    pass
+
+@attrs
+class LineMerger(_ShapeMerger, LineMatcher):
+    pass
+
+@attrs
+class CaptionsMerger(AnnotationMerger, CaptionsMatcher):
+    pass
+
+def match_segments(a_segms, b_segms, distance=segment_iou, dist_thresh=1.0,
+        label_matcher=lambda a, b: a.label == b.label):
+    assert callable(distance), distance
+    assert callable(label_matcher), label_matcher
+
+    a_segms.sort(key=lambda ann: 1 - ann.attributes.get('score', 1))
+    b_segms.sort(key=lambda ann: 1 - ann.attributes.get('score', 1))
+
+    # a_matches: indices of b_segms matched to a bboxes
+    # b_matches: indices of a_segms matched to b bboxes
+    a_matches = -np.ones(len(a_segms), dtype=int)
+    b_matches = -np.ones(len(b_segms), dtype=int)
+
+    distances = np.array([[distance(a, b) for b in b_segms] for a in a_segms])
+
+    # matches: boxes we succeeded to match completely
+    # mispred: boxes we succeeded to match, having label mismatch
+    matches = []
+    mispred = []
+
+    for a_idx, a_segm in enumerate(a_segms):
+        if len(b_segms) == 0:
+            break
+        matched_b = -1
+        max_dist = -1
+        b_indices = np.argsort([not label_matcher(a_segm, b_segm)
+            for b_segm in b_segms],
+            kind='stable') # prioritize those with same label, keep score order
+        for b_idx in b_indices:
+            if 0 <= b_matches[b_idx]: # assign a_segm with max conf
+                continue
+            d = distances[a_idx, b_idx]
+            if d < dist_thresh or d <= max_dist:
+                continue
+            max_dist = d
+            matched_b = b_idx
+
+        if matched_b < 0:
+            continue
+        a_matches[a_idx] = matched_b
+        b_matches[matched_b] = a_idx
+
+        b_segm = b_segms[matched_b]
+
+        if label_matcher(a_segm, b_segm):
+            matches.append( (a_segm, b_segm) )
+        else:
+            mispred.append( (a_segm, b_segm) )
+
+    # *_umatched: boxes of (*) we failed to match
+    a_unmatched = [a_segms[i] for i, m in enumerate(a_matches) if m < 0]
+    b_unmatched = [b_segms[i] for i, m in enumerate(b_matches) if m < 0]
+
+    return matches, mispred, a_unmatched, b_unmatched
+
+def mean_std(dataset):
+    """
+    Computes unbiased mean and std. dev. for dataset images, channel-wise.
+    """
+    # Use an online algorithm to:
+    # - handle different image sizes
+    # - avoid cancellation problem
+    if len(dataset) == 0:
+        return [0, 0, 0], [0, 0, 0]
+
+    stats = np.empty((len(dataset), 2, 3), dtype=np.double)
+    counts = np.empty(len(dataset), dtype=np.uint32)
+
+    mean = lambda i, s: s[i][0]
+    var = lambda i, s: s[i][1]
+
+    for i, item in enumerate(dataset):
+        counts[i] = np.prod(item.image.size)
+
+        image = item.image.data
+        if len(image.shape) == 2:
+            image = image[:, :, np.newaxis]
+        else:
+            image = image[:, :, :3]
+        # opencv is much faster than numpy here
+        cv2.meanStdDev(image.astype(np.double) / 255,
+            mean=mean(i, stats), stddev=var(i, stats))
+
+    # make variance unbiased
+    np.multiply(np.square(stats[:, 1]),
+        (counts / (counts - 1))[:, np.newaxis],
+        out=stats[:, 1])
+
+    _, mean, var = StatsCounter().compute_stats(stats, counts, mean, var)
+    return mean * 255, np.sqrt(var) * 255
+
+class StatsCounter:
+    # Implements online parallel computation of sample variance
+    # https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Parallel_algorithm
+
+    # Needed do avoid catastrophic cancellation in floating point computations
+    @staticmethod
+    def pairwise_stats(count_a, mean_a, var_a, count_b, mean_b, var_b):
+        delta = mean_b - mean_a
+        m_a = var_a * (count_a - 1)
+        m_b = var_b * (count_b - 1)
+        M2 = m_a + m_b + delta ** 2 * count_a * count_b / (count_a + count_b)
+        return (
+            count_a + count_b,
+            mean_a * 0.5 + mean_b * 0.5,
+            M2 / (count_a + count_b - 1)
+        )
+
+    # stats = float array of shape N, 2 * d, d = dimensions of values
+    # count = integer array of shape N
+    # mean_accessor = function(idx, stats) to retrieve element mean
+    # variance_accessor = function(idx, stats) to retrieve element variance
+    # Recursively computes total count, mean and variance, does O(log(N)) calls
+    @staticmethod
+    def compute_stats(stats, counts, mean_accessor, variance_accessor):
+        m = mean_accessor
+        v = variance_accessor
+        n = len(stats)
+        if n == 1:
+            return counts[0], m(0, stats), v(0, stats)
+        if n == 2:
+            return __class__.pairwise_stats(
+                counts[0], m(0, stats), v(0, stats),
+                counts[1], m(1, stats), v(1, stats)
+                )
+        h = n // 2
+        return __class__.pairwise_stats(
+            *__class__.compute_stats(stats[:h], counts[:h], m, v),
+            *__class__.compute_stats(stats[h:], counts[h:], m, v)
+            )
+
+def compute_image_statistics(dataset):
+    stats = {
+        'dataset': {},
+        'subsets': {}
+    }
+
+    def _extractor_stats(extractor):
+        available = True
+        for item in extractor:
+            if not (item.has_image and item.image.has_data):
+                available = False
+                log.warn("Item %s has no image. Image stats won't be computed",
+                    item.id)
+                break
+
+        stats = {
+            'images count': len(extractor),
+        }
+
+        if available:
+            mean, std = mean_std(extractor)
+            stats.update({
+                'image mean': [float(n) for n in mean[::-1]],
+                'image std': [float(n) for n in std[::-1]],
+            })
+        else:
+            stats.update({
+                'image mean': 'n/a',
+                'image std': 'n/a',
+            })
+        return stats
+
+    stats['dataset'].update(_extractor_stats(dataset))
+
+    subsets = dataset.subsets() or [None]
+    if subsets and 0 < len([s for s in subsets if s]):
+        for subset_name in subsets:
+            stats['subsets'][subset_name] = _extractor_stats(
+                dataset.get_subset(subset_name))
+
+    return stats
+
+def compute_ann_statistics(dataset):
+    labels = dataset.categories().get(AnnotationType.label)
+    def get_label(ann):
+        return labels.items[ann.label].name if ann.label is not None else None
+
+    stats = {
+        'images count': len(dataset),
+        'annotations count': 0,
+        'unannotated images count': 0,
+        'unannotated images': [],
+        'annotations by type': { t.name: {
+            'count': 0,
+        } for t in AnnotationType },
+        'annotations': {},
+    }
+    by_type = stats['annotations by type']
+
+    attr_template = {
+        'count': 0,
+        'values count': 0,
+        'values present': set(),
+        'distribution': {}, # value -> (count, total%)
+    }
+    label_stat = {
+        'count': 0,
+        'distribution': { l.name: [0, 0] for l in labels.items
+        }, # label -> (count, total%)
+
+        'attributes': {},
+    }
+    stats['annotations']['labels'] = label_stat
+    segm_stat = {
+        'avg. area': 0,
+        'area distribution': [], # a histogram with 10 bins
+        # (min, min+10%), ..., (min+90%, max) -> (count, total%)
+
+        'pixel distribution': { l.name: [0, 0] for l in labels.items
+        }, # label -> (count, total%)
+    }
+    stats['annotations']['segments'] = segm_stat
+    segm_areas = []
+    pixel_dist = segm_stat['pixel distribution']
+    total_pixels = 0
+
+    for item in dataset:
+        if len(item.annotations) == 0:
+            stats['unannotated images'].append(item.id)
+            continue
+
+        for ann in item.annotations:
+            by_type[ann.type.name]['count'] += 1
+
+            if not hasattr(ann, 'label') or ann.label is None:
+                continue
+
+            if ann.type in {AnnotationType.mask,
+                    AnnotationType.polygon, AnnotationType.bbox}:
+                area = ann.get_area()
+                segm_areas.append(area)
+                pixel_dist[get_label(ann)][0] += int(area)
+
+            label_stat['count'] += 1
+            label_stat['distribution'][get_label(ann)][0] += 1
+
+            for name, value in ann.attributes.items():
+                if name.lower() in { 'occluded', 'visibility', 'score',
+                        'id', 'track_id' }:
+                    continue
+                attrs_stat = label_stat['attributes'].setdefault(name,
+                    deepcopy(attr_template))
+                attrs_stat['count'] += 1
+                attrs_stat['values present'].add(str(value))
+                attrs_stat['distribution'] \
+                    .setdefault(str(value), [0, 0])[0] += 1
+
+    stats['annotations count'] = sum(t['count'] for t in
+        stats['annotations by type'].values())
+    stats['unannotated images count'] = len(stats['unannotated images'])
+
+    for label_info in label_stat['distribution'].values():
+        label_info[1] = label_info[0] / (label_stat['count'] or 1)
+
+    for label_attr in label_stat['attributes'].values():
+        label_attr['values count'] = len(label_attr['values present'])
+        label_attr['values present'] = sorted(label_attr['values present'])
+        for attr_info in label_attr['distribution'].values():
+            attr_info[1] = attr_info[0] / (label_attr['count'] or 1)
+
+    # numpy.sum might be faster, but could overflow with large datasets.
+    # Python's int can transparently mutate to be of indefinite precision (long)
+    total_pixels = sum(int(a) for a in segm_areas)
+
+    segm_stat['avg. area'] = total_pixels / (len(segm_areas) or 1.0)
+
+    for label_info in segm_stat['pixel distribution'].values():
+        label_info[1] = label_info[0] / (total_pixels or 1)
+
+    if len(segm_areas) != 0:
+        hist, bins = np.histogram(segm_areas)
+        segm_stat['area distribution'] = [{
+            'min': float(bin_min), 'max': float(bin_max),
+            'count': int(c), 'percent': int(c) / len(segm_areas)
+        } for c, (bin_min, bin_max) in zip(hist, zip(bins[:-1], bins[1:]))]
+
+    return stats
+
+@attrs
+class DistanceComparator:
+    iou_threshold = attrib(converter=float, default=0.5)
+
+    @staticmethod
+    def match_datasets(a, b):
+        a_items = set((item.id, item.subset) for item in a)
+        b_items = set((item.id, item.subset) for item in b)
+
+        matches = a_items & b_items
+        a_unmatched = a_items - b_items
+        b_unmatched = b_items - a_items
+        return matches, a_unmatched, b_unmatched
+
+    @staticmethod
+    def match_classes(a, b):
+        a_label_cat = a.categories().get(AnnotationType.label, LabelCategories())
+        b_label_cat = b.categories().get(AnnotationType.label, LabelCategories())
+
+        a_labels = set(c.name for c in a_label_cat)
+        b_labels = set(c.name for c in b_label_cat)
+
+        matches = a_labels & b_labels
+        a_unmatched = a_labels - b_labels
+        b_unmatched = b_labels - a_labels
+        return matches, a_unmatched, b_unmatched
+
+    def match_annotations(self, item_a, item_b):
+        return { t: self._match_ann_type(t, item_a, item_b) }
+
+    def _match_ann_type(self, t, *args):
+        # pylint: disable=no-value-for-parameter
+        if t == AnnotationType.label:
+            return self.match_labels(*args)
+        elif t == AnnotationType.bbox:
+            return self.match_boxes(*args)
+        elif t == AnnotationType.polygon:
+            return self.match_polygons(*args)
+        elif t == AnnotationType.mask:
+            return self.match_masks(*args)
+        elif t == AnnotationType.points:
+            return self.match_points(*args)
+        elif t == AnnotationType.polyline:
+            return self.match_lines(*args)
+        # pylint: enable=no-value-for-parameter
+        else:
+            raise NotImplementedError("Unexpected annotation type %s" % t)
+
+    @staticmethod
+    def _get_ann_type(t, item):
+        return get_ann_type(item.annotations, t)
+
+    def match_labels(self, item_a, item_b):
+        a_labels = set(a.label for a in
+            self._get_ann_type(AnnotationType.label, item_a))
+        b_labels = set(a.label for a in
+            self._get_ann_type(AnnotationType.label, item_b))
+
+        matches = a_labels & b_labels
+        a_unmatched = a_labels - b_labels
+        b_unmatched = b_labels - a_labels
+        return matches, a_unmatched, b_unmatched
+
+    def _match_segments(self, t, item_a, item_b):
+        a_boxes = self._get_ann_type(t, item_a)
+        b_boxes = self._get_ann_type(t, item_b)
+        return match_segments(a_boxes, b_boxes, dist_thresh=self.iou_threshold)
+
+    def match_polygons(self, item_a, item_b):
+        return self._match_segments(AnnotationType.polygon, item_a, item_b)
+
+    def match_masks(self, item_a, item_b):
+        return self._match_segments(AnnotationType.mask, item_a, item_b)
+
+    def match_boxes(self, item_a, item_b):
+        return self._match_segments(AnnotationType.bbox, item_a, item_b)
+
+    def match_points(self, item_a, item_b):
+        a_points = self._get_ann_type(AnnotationType.points, item_a)
+        b_points = self._get_ann_type(AnnotationType.points, item_b)
+
+        instance_map = {}
+        for s in [item_a.annotations, item_b.annotations]:
+            s_instances = find_instances(s)
+            for inst in s_instances:
+                inst_bbox = max_bbox(inst)
+                for ann in inst:
+                    instance_map[id(ann)] = [inst, inst_bbox]
+        matcher = PointsMatcher(instance_map=instance_map)
+
+        return match_segments(a_points, b_points,
+            dist_thresh=self.iou_threshold, distance=matcher.distance)
+
+    def match_lines(self, item_a, item_b):
+        a_lines = self._get_ann_type(AnnotationType.polyline, item_a)
+        b_lines = self._get_ann_type(AnnotationType.polyline, item_b)
+
+        matcher = LineMatcher()
+
+        return match_segments(a_lines, b_lines,
+            dist_thresh=self.iou_threshold, distance=matcher.distance)
+
+def match_items_by_id(a, b):
+    a_items = set((item.id, item.subset) for item in a)
+    b_items = set((item.id, item.subset) for item in b)
+
+    matches = a_items & b_items
+    matches = [([m], [m]) for m in matches]
+    a_unmatched = a_items - b_items
+    b_unmatched = b_items - a_items
+    return matches, a_unmatched, b_unmatched
+
+def match_items_by_image_hash(a, b):
+    def _hash(item):
+        if not item.image.has_data:
+            log.warning("Image (%s, %s) has no image "
+                "data, counted as unmatched", item.id, item.subset)
+            return None
+        return hashlib.md5(item.image.data.tobytes()).hexdigest()
+
+    def _build_hashmap(source):
+        d = {}
+        for item in source:
+            h = _hash(item)
+            if h is None:
+                h = str(id(item)) # anything unique
+            d.setdefault(h, []).append((item.id, item.subset))
+        return d
+
+    a_hash = _build_hashmap(a)
+    b_hash = _build_hashmap(b)
+
+    a_items = set(a_hash)
+    b_items = set(b_hash)
+
+    matches = a_items & b_items
+    a_unmatched = a_items - b_items
+    b_unmatched = b_items - a_items
+
+    matches = [(a_hash[h], b_hash[h]) for h in matches]
+    a_unmatched = set(i for h in a_unmatched for i in a_hash[h])
+    b_unmatched = set(i for h in b_unmatched for i in b_hash[h])
+
+    return matches, a_unmatched, b_unmatched
+
+@attrs
+class ExactComparator:
+    match_images = attrib(kw_only=True, type=bool, default=False)
+    ignored_fields = attrib(kw_only=True,
+        factory=set, validator=default_if_none(set))
+    ignored_attrs = attrib(kw_only=True,
+        factory=set, validator=default_if_none(set))
+    ignored_item_attrs = attrib(kw_only=True,
+        factory=set, validator=default_if_none(set))
+
+    _test = attrib(init=False, type=TestCase)
+    errors = attrib(init=False, type=list)
+
+    def __attrs_post_init__(self):
+        self._test = TestCase()
+        self._test.maxDiff = None
+
+
+    def _match_items(self, a, b):
+        if self.match_images:
+            return match_items_by_image_hash(a, b)
+        else:
+            return match_items_by_id(a, b)
+
+    def _compare_categories(self, a, b):
+        test = self._test
+        errors = self.errors
+
+        try:
+            test.assertEqual(
+                sorted(a, key=lambda t: t.value),
+                sorted(b, key=lambda t: t.value)
+            )
+        except AssertionError as e:
+            errors.append({'type': 'categories', 'message': str(e)})
+
+        if AnnotationType.label in a:
+            try:
+                test.assertEqual(
+                    a[AnnotationType.label].items,
+                    b[AnnotationType.label].items,
+                )
+            except AssertionError as e:
+                errors.append({'type': 'labels', 'message': str(e)})
+        if AnnotationType.mask in a:
+            try:
+                test.assertEqual(
+                    a[AnnotationType.mask].colormap,
+                    b[AnnotationType.mask].colormap,
+                )
+            except AssertionError as e:
+                errors.append({'type': 'colormap', 'message': str(e)})
+        if AnnotationType.points in a:
+            try:
+                test.assertEqual(
+                    a[AnnotationType.points].items,
+                    b[AnnotationType.points].items,
+                )
+            except AssertionError as e:
+                errors.append({'type': 'points', 'message': str(e)})
+
+    def _compare_annotations(self, a, b):
+        ignored_fields = self.ignored_fields
+        ignored_attrs = self.ignored_attrs
+
+        a_fields = { k: None for k in vars(a) if k in ignored_fields }
+        b_fields = { k: None for k in vars(b) if k in ignored_fields }
+        if 'attributes' not in ignored_fields:
+            a_fields['attributes'] = filter_dict(a.attributes, ignored_attrs)
+            b_fields['attributes'] = filter_dict(b.attributes, ignored_attrs)
+
+        result = a.wrap(**a_fields) == b.wrap(**b_fields)
+
+        return result
+
+    def _compare_items(self, item_a, item_b):
+        test = self._test
+
+        a_id = (item_a.id, item_a.subset)
+        b_id = (item_b.id, item_b.subset)
+
+        matched = []
+        unmatched = []
+        errors = []
+
+        try:
+            test.assertEqual(
+                filter_dict(item_a.attributes, self.ignored_item_attrs),
+                filter_dict(item_b.attributes, self.ignored_item_attrs)
+            )
+        except AssertionError as e:
+            errors.append({'type': 'item_attr',
+                'a_item': a_id, 'b_item': b_id, 'message': str(e)})
+
+        b_annotations = item_b.annotations[:]
+        for ann_a in item_a.annotations:
+            ann_b_candidates = [x for x in item_b.annotations
+                if x.type == ann_a.type]
+
+            ann_b = find(enumerate(self._compare_annotations(ann_a, x)
+                for x in ann_b_candidates), lambda x: x[1])
+            if ann_b is None:
+                unmatched.append({
+                    'item': a_id, 'source': 'a', 'ann': str(ann_a),
+                })
+                continue
+            else:
+                ann_b = ann_b_candidates[ann_b[0]]
+
+            b_annotations.remove(ann_b) # avoid repeats
+            matched.append({'a_item': a_id, 'b_item': b_id,
+                'a': str(ann_a), 'b': str(ann_b)})
+
+        for ann_b in b_annotations:
+            unmatched.append({'item': b_id, 'source': 'b', 'ann': str(ann_b)})
+
+        return matched, unmatched, errors
+
+    def compare_datasets(self, a, b):
+        self.errors = []
+        errors = self.errors
+
+        self._compare_categories(a.categories(), b.categories())
+
+        matched = []
+        unmatched = []
+
+        matches, a_unmatched, b_unmatched = self._match_items(a, b)
+
+        if a.categories().get(AnnotationType.label) != \
+           b.categories().get(AnnotationType.label):
+            return matched, unmatched, a_unmatched, b_unmatched, errors
+
+        _dist = lambda s: len(s[1]) + len(s[2])
+        for a_ids, b_ids in matches:
+            # build distance matrix
+            match_status = {} # (a_id, b_id): [matched, unmatched, errors]
+            a_matches = { a_id: None for a_id in a_ids }
+            b_matches = { b_id: None for b_id in b_ids }
+
+            for a_id in a_ids:
+                item_a = a.get(*a_id)
+                candidates = {}
+
+                for b_id in b_ids:
+                    item_b = b.get(*b_id)
+
+                    i_m, i_um, i_err = self._compare_items(item_a, item_b)
+                    candidates[b_id] = [i_m, i_um, i_err]
+
+                    if len(i_um) == 0:
+                        a_matches[a_id] = b_id
+                        b_matches[b_id] = a_id
+                        matched.extend(i_m)
+                        errors.extend(i_err)
+                        break
+
+                match_status[a_id] = candidates
+
+            # assign
+            for a_id in a_ids:
+                if len(b_ids) == 0:
+                    break
+
+                # find the closest, ignore already assigned
+                matched_b = a_matches[a_id]
+                if matched_b is not None:
+                    continue
+                min_dist = -1
+                for b_id in b_ids:
+                    if b_matches[b_id] is not None:
+                        continue
+                    d = _dist(match_status[a_id][b_id])
+                    if d < min_dist and 0 <= min_dist:
+                        continue
+                    min_dist = d
+                    matched_b = b_id
+
+                if matched_b is None:
+                    continue
+                a_matches[a_id] = matched_b
+                b_matches[matched_b] = a_id
+
+                m = match_status[a_id][matched_b]
+                matched.extend(m[0])
+                unmatched.extend(m[1])
+                errors.extend(m[2])
+
+            a_unmatched |= set(a_id for a_id, m in a_matches.items() if not m)
+            b_unmatched |= set(b_id for b_id, m in b_matches.items() if not m)
+
+        return matched, unmatched, a_unmatched, b_unmatched, errors

testbed/openvinotoolkit__datumaro/datumaro/plugins/accuracy_checker_plugin/__init__.py

@@ -0,0 +1,4 @@
+# Copyright (C) 2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+

testbed/openvinotoolkit__datumaro/datumaro/plugins/accuracy_checker_plugin/details/ac.py

@@ -0,0 +1,116 @@
+
+# Copyright (C) 2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+from datumaro.util.tf_util import import_tf
+import_tf() # prevent TF loading and potential interpeter crash
+
+from itertools import groupby
+
+from accuracy_checker.adapters import create_adapter
+from accuracy_checker.data_readers import DataRepresentation
+from accuracy_checker.launcher import InputFeeder, create_launcher
+from accuracy_checker.postprocessor import PostprocessingExecutor
+from accuracy_checker.preprocessor import PreprocessingExecutor
+from accuracy_checker.utils import extract_image_representations
+
+from datumaro.components.extractor import AnnotationType, LabelCategories
+
+from .representation import import_predictions
+
+
+class _FakeDataset:
+    def __init__(self, metadata=None):
+        self.metadata = metadata or {}
+
+class GenericAcLauncher:
+    @staticmethod
+    def from_config(config):
+        launcher_config = config['launcher']
+        launcher = create_launcher(launcher_config)
+
+        dataset = _FakeDataset()
+        adapter_config = config.get('adapter') or launcher_config.get('adapter')
+        label_config = adapter_config.get('labels') \
+            if isinstance(adapter_config, dict) else None
+        if label_config:
+            assert isinstance(label_config, (list, dict))
+            if isinstance(label_config, list):
+                label_config = dict(enumerate(label_config))
+
+            dataset.metadata = {'label_map': {
+                int(key): label for key, label in label_config.items()
+            }}
+        adapter = create_adapter(adapter_config, launcher, dataset)
+
+        preproc_config = config.get('preprocessing')
+        preproc = None
+        if preproc_config:
+            preproc = PreprocessingExecutor(preproc_config,
+                dataset_meta=dataset.metadata,
+                input_shapes=launcher.inputs_info_for_meta()
+            )
+
+        postproc_config = config.get('postprocessing')
+        postproc = None
+        if postproc_config:
+            postproc = PostprocessingExecutor(postproc_config,
+                dataset_meta=dataset.metadata,
+            )
+
+        return __class__(launcher,
+            adapter=adapter, preproc=preproc, postproc=postproc)
+
+    def __init__(self, launcher, adapter=None,
+            preproc=None, postproc=None, input_feeder=None):
+        self._launcher = launcher
+        self._input_feeder = input_feeder or InputFeeder(
+            launcher.config.get('inputs', []), launcher.inputs,
+            launcher.fit_to_input, launcher.default_layout
+        )
+        self._adapter = adapter
+        self._preproc = preproc
+        self._postproc = postproc
+
+        self._categories = self._init_categories()
+
+    def launch_raw(self, inputs):
+        ids = range(len(inputs))
+        inputs = [DataRepresentation(inp, identifier=id)
+            for id, inp in zip(ids, inputs)]
+        _, batch_meta = extract_image_representations(inputs)
+
+        if self._preproc:
+            inputs = self._preproc.process(inputs)
+
+        inputs = self._input_feeder.fill_inputs(inputs)
+        outputs = self._launcher.predict(inputs, batch_meta)
+
+        if self._adapter:
+            outputs = self._adapter.process(outputs, ids, batch_meta)
+
+        if self._postproc:
+            outputs = self._postproc.process(outputs)
+
+        return outputs
+
+    def launch(self, inputs):
+        outputs = self.launch_raw(inputs)
+        return [import_predictions(g) for _, g in
+            groupby(outputs, key=lambda o: o.identifier)]
+
+    def categories(self):
+        return self._categories
+
+    def _init_categories(self):
+        if self._adapter is None or self._adapter.label_map is None:
+            return None
+
+        label_map = sorted(self._adapter.label_map.items(), key=lambda e: e[0])
+
+        label_cat = LabelCategories()
+        for _, label in label_map:
+            label_cat.add(label)
+
+        return { AnnotationType.label: label_cat }

testbed/openvinotoolkit__datumaro/datumaro/plugins/accuracy_checker_plugin/details/representation.py

@@ -0,0 +1,62 @@
+
+# Copyright (C) 2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+from datumaro.util.tf_util import import_tf
+import_tf() # prevent TF loading and potential interpeter crash
+
+import accuracy_checker.representation as ac
+
+import datumaro.components.extractor as dm
+from datumaro.util.annotation_util import softmax
+
+def import_predictions(predictions):
+    # Convert Accuracy checker predictions to Datumaro annotations
+
+    anns = []
+
+    for pred in predictions:
+        anns.extend(import_prediction(pred))
+
+    return anns
+
+def import_prediction(pred):
+    if isinstance(pred, ac.ClassificationPrediction):
+        scores = softmax(pred.scores)
+        return (dm.Label(label_id, attributes={'score': float(score)})
+            for label_id, score in enumerate(scores))
+    elif isinstance(pred, ac.ArgMaxClassificationPrediction):
+        return (dm.Label(int(pred.label)), )
+    elif isinstance(pred, ac.CharacterRecognitionPrediction):
+        return (dm.Label(int(pred.label)), )
+    elif isinstance(pred, (ac.DetectionPrediction, ac.ActionDetectionPrediction)):
+        return (dm.Bbox(x0, y0, x1 - x0, y1 - y0, int(label_id),
+                attributes={'score': float(score)})
+            for label, score, x0, y0, x1, y1 in zip(pred.labels, pred.scores,
+                pred.x_mins, pred.y_mins, pred.x_maxs, pred.y_maxs)
+        )
+    elif isinstance(pred, ac.DepthEstimationPrediction):
+        return (dm.Mask(pred.depth_map), ) # 2d floating point mask
+    # elif isinstance(pred, ac.HitRatioPrediction):
+    #     -
+    elif isinstance(pred, ac.ImageInpaintingPrediction):
+        return (dm.Mask(pred.value), ) # an image
+    # elif isinstance(pred, ac.MultiLabelRecognitionPrediction):
+    #     -
+    # elif isinstance(pred, ac.MachineTranslationPrediction):
+    #     -
+    # elif isinstance(pred, ac.QuestionAnsweringPrediction):
+    #     -
+    # elif isinstance(pred, ac.PoseEstimation3dPrediction):
+    #     -
+    # elif isinstance(pred, ac.PoseEstimationPrediction):
+    #     -
+    # elif isinstance(pred, ac.RegressionPrediction):
+    #     -
+    else:
+        raise NotImplementedError("Can't convert %s" % type(pred))
+
+
+
+

testbed/openvinotoolkit__datumaro/datumaro/plugins/coco_format/converter.py

@@ -0,0 +1,597 @@
+
+# Copyright (C) 2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+import json
+import logging as log
+import os
+import os.path as osp
+from enum import Enum
+from itertools import groupby
+
+import pycocotools.mask as mask_utils
+
+import datumaro.util.annotation_util as anno_tools
+import datumaro.util.mask_tools as mask_tools
+from datumaro.components.converter import Converter
+from datumaro.components.extractor import (_COORDINATE_ROUNDING_DIGITS,
+    DEFAULT_SUBSET_NAME, AnnotationType, Points)
+from datumaro.util import cast, find, str_to_bool
+
+from .format import CocoPath, CocoTask
+
+SegmentationMode = Enum('SegmentationMode', ['guess', 'polygons', 'mask'])
+
+class _TaskConverter:
+    def __init__(self, context):
+        self._min_ann_id = 1
+        self._context = context
+
+        data = {
+            'licenses': [],
+            'info': {},
+            'categories': [],
+            'images': [],
+            'annotations': []
+            }
+
+        data['licenses'].append({
+            'name': '',
+            'id': 0,
+            'url': ''
+        })
+
+        data['info'] = {
+            'contributor': '',
+            'date_created': '',
+            'description': '',
+            'url': '',
+            'version': '',
+            'year': ''
+        }
+        self._data = data
+
+    def is_empty(self):
+        return len(self._data['annotations']) == 0
+
+    def _get_image_id(self, item):
+        return self._context._get_image_id(item)
+
+    def save_image_info(self, item, filename):
+        if item.has_image:
+            h, w = item.image.size
+        else:
+            h = 0
+            w = 0
+
+        self._data['images'].append({
+            'id': self._get_image_id(item),
+            'width': int(w),
+            'height': int(h),
+            'file_name': cast(filename, str, ''),
+            'license': 0,
+            'flickr_url': '',
+            'coco_url': '',
+            'date_captured': 0,
+        })
+
+    def save_categories(self, dataset):
+        raise NotImplementedError()
+
+    def save_annotations(self, item):
+        raise NotImplementedError()
+
+    def write(self, path):
+        next_id = self._min_ann_id
+        for ann in self.annotations:
+            if not ann['id']:
+                ann['id'] = next_id
+                next_id += 1
+
+        with open(path, 'w') as outfile:
+            json.dump(self._data, outfile)
+
+    @property
+    def annotations(self):
+        return self._data['annotations']
+
+    @property
+    def categories(self):
+        return self._data['categories']
+
+    def _get_ann_id(self, annotation):
+        ann_id = 0 if self._context._reindex else annotation.id
+        if ann_id:
+            self._min_ann_id = max(ann_id, self._min_ann_id)
+        return ann_id
+
+    @staticmethod
+    def _convert_attributes(ann):
+        return { k: v for k, v in ann.attributes.items()
+            if k not in {'is_crowd', 'score'}
+        }
+
+class _ImageInfoConverter(_TaskConverter):
+    def is_empty(self):
+        return len(self._data['images']) == 0
+
+    def save_categories(self, dataset):
+        pass
+
+    def save_annotations(self, item):
+        pass
+
+class _CaptionsConverter(_TaskConverter):
+    def save_categories(self, dataset):
+        pass
+
+    def save_annotations(self, item):
+        for ann_idx, ann in enumerate(item.annotations):
+            if ann.type != AnnotationType.caption:
+                continue
+
+            elem = {
+                'id': self._get_ann_id(ann),
+                'image_id': self._get_image_id(item),
+                'category_id': 0, # NOTE: workaround for a bug in cocoapi
+                'caption': ann.caption,
+            }
+            if 'score' in ann.attributes:
+                try:
+                    elem['score'] = float(ann.attributes['score'])
+                except Exception as e:
+                    log.warning("Item '%s', ann #%s: failed to convert "
+                        "attribute 'score': %e" % (item.id, ann_idx, e))
+            if self._context._allow_attributes:
+                elem['attributes'] = self._convert_attributes(ann)
+
+            self.annotations.append(elem)
+
+class _InstancesConverter(_TaskConverter):
+    def save_categories(self, dataset):
+        label_categories = dataset.categories().get(AnnotationType.label)
+        if label_categories is None:
+            return
+
+        for idx, cat in enumerate(label_categories.items):
+            self.categories.append({
+                'id': 1 + idx,
+                'name': cast(cat.name, str, ''),
+                'supercategory': cast(cat.parent, str, ''),
+            })
+
+    @classmethod
+    def crop_segments(cls, instances, img_width, img_height):
+        instances = sorted(instances, key=lambda x: x[0].z_order)
+
+        segment_map = []
+        segments = []
+        for inst_idx, (_, polygons, mask, _) in enumerate(instances):
+            if polygons:
+                segment_map.extend(inst_idx for p in polygons)
+                segments.extend(polygons)
+            elif mask is not None:
+                segment_map.append(inst_idx)
+                segments.append(mask)
+
+        segments = mask_tools.crop_covered_segments(
+            segments, img_width, img_height)
+
+        for inst_idx, inst in enumerate(instances):
+            new_segments = [s for si_id, s in zip(segment_map, segments)
+                if si_id == inst_idx]
+
+            if not new_segments:
+                inst[1] = []
+                inst[2] = None
+                continue
+
+            if inst[1]:
+                inst[1] = sum(new_segments, [])
+            else:
+                mask = mask_tools.merge_masks(new_segments)
+                inst[2] = mask_tools.mask_to_rle(mask)
+
+        return instances
+
+    def find_instance_parts(self, group, img_width, img_height):
+        boxes = [a for a in group if a.type == AnnotationType.bbox]
+        polygons = [a for a in group if a.type == AnnotationType.polygon]
+        masks = [a for a in group if a.type == AnnotationType.mask]
+
+        anns = boxes + polygons + masks
+        leader = anno_tools.find_group_leader(anns)
+        bbox = anno_tools.max_bbox(anns)
+        mask = None
+        polygons = [p.points for p in polygons]
+
+        if self._context._segmentation_mode == SegmentationMode.guess:
+            use_masks = True == leader.attributes.get('is_crowd',
+                find(masks, lambda x: x.label == leader.label) is not None)
+        elif self._context._segmentation_mode == SegmentationMode.polygons:
+            use_masks = False
+        elif self._context._segmentation_mode == SegmentationMode.mask:
+            use_masks = True
+        else:
+            raise NotImplementedError("Unexpected segmentation mode '%s'" % \
+                self._context._segmentation_mode)
+
+        if use_masks:
+            if polygons:
+                mask = mask_tools.rles_to_mask(polygons, img_width, img_height)
+
+            if masks:
+                if mask is not None:
+                    masks += [mask]
+                mask = mask_tools.merge_masks([m.image for m in masks])
+
+            if mask is not None:
+                mask = mask_tools.mask_to_rle(mask)
+            polygons = []
+        else:
+            if masks:
+                mask = mask_tools.merge_masks([m.image for m in masks])
+                polygons += mask_tools.mask_to_polygons(mask)
+            mask = None
+
+        return [leader, polygons, mask, bbox]
+
+    @staticmethod
+    def find_instance_anns(annotations):
+        return [a for a in annotations
+            if a.type in { AnnotationType.bbox,
+                AnnotationType.polygon, AnnotationType.mask }
+        ]
+
+    @classmethod
+    def find_instances(cls, annotations):
+        return anno_tools.find_instances(cls.find_instance_anns(annotations))
+
+    def save_annotations(self, item):
+        instances = self.find_instances(item.annotations)
+        if not instances:
+            return
+
+        if not item.has_image:
+            log.warn("Item '%s': skipping writing instances "
+                "since no image info available" % item.id)
+            return
+        h, w = item.image.size
+        instances = [self.find_instance_parts(i, w, h) for i in instances]
+
+        if self._context._crop_covered:
+            instances = self.crop_segments(instances, w, h)
+
+        for instance in instances:
+            elem = self.convert_instance(instance, item)
+            if elem:
+                self.annotations.append(elem)
+
+    def convert_instance(self, instance, item):
+        ann, polygons, mask, bbox = instance
+
+        is_crowd = mask is not None
+        if is_crowd:
+            segmentation = {
+                'counts': list(int(c) for c in mask['counts']),
+                'size': list(int(c) for c in mask['size'])
+            }
+        else:
+            segmentation = [list(map(float, p)) for p in polygons]
+
+        area = 0
+        if segmentation:
+            if item.has_image:
+                h, w = item.image.size
+            else:
+                # NOTE: here we can guess the image size as
+                # it is only needed for the area computation
+                w = bbox[0] + bbox[2]
+                h = bbox[1] + bbox[3]
+
+            rles = mask_utils.frPyObjects(segmentation, h, w)
+            if is_crowd:
+                rles = [rles]
+            else:
+                rles = mask_utils.merge(rles)
+            area = mask_utils.area(rles)
+        else:
+            _, _, w, h = bbox
+            segmentation = []
+            area = w * h
+
+        elem = {
+            'id': self._get_ann_id(ann),
+            'image_id': self._get_image_id(item),
+            'category_id': cast(ann.label, int, -1) + 1,
+            'segmentation': segmentation,
+            'area': float(area),
+            'bbox': [round(float(n), _COORDINATE_ROUNDING_DIGITS) for n in bbox],
+            'iscrowd': int(is_crowd),
+        }
+        if 'score' in ann.attributes:
+            try:
+                elem['score'] = float(ann.attributes['score'])
+            except Exception as e:
+                log.warning("Item '%s': failed to convert attribute "
+                    "'score': %e" % (item.id, e))
+        if self._context._allow_attributes:
+                elem['attributes'] = self._convert_attributes(ann)
+
+        return elem
+
+class _KeypointsConverter(_InstancesConverter):
+    def save_categories(self, dataset):
+        label_categories = dataset.categories().get(AnnotationType.label)
+        if label_categories is None:
+            return
+        point_categories = dataset.categories().get(AnnotationType.points)
+
+        for idx, label_cat in enumerate(label_categories.items):
+            cat = {
+                'id': 1 + idx,
+                'name': cast(label_cat.name, str, ''),
+                'supercategory': cast(label_cat.parent, str, ''),
+                'keypoints': [],
+                'skeleton': [],
+            }
+
+            if point_categories is not None:
+                kp_cat = point_categories.items.get(idx)
+                if kp_cat is not None:
+                    cat.update({
+                        'keypoints': [str(l) for l in kp_cat.labels],
+                        'skeleton': [list(map(int, j)) for j in kp_cat.joints],
+                    })
+            self.categories.append(cat)
+
+    def save_annotations(self, item):
+        point_annotations = [a for a in item.annotations
+            if a.type == AnnotationType.points]
+        if not point_annotations:
+            return
+
+        # Create annotations for solitary keypoints annotations
+        for points in self.find_solitary_points(item.annotations):
+            instance = [points, [], None, points.get_bbox()]
+            elem = super().convert_instance(instance, item)
+            elem.update(self.convert_points_object(points))
+            self.annotations.append(elem)
+
+        # Create annotations for complete instance + keypoints annotations
+        super().save_annotations(item)
+
+    @classmethod
+    def find_solitary_points(cls, annotations):
+        annotations = sorted(annotations, key=lambda a: a.group)
+        solitary_points = []
+
+        for g_id, group in groupby(annotations, lambda a: a.group):
+            if not g_id or g_id and not cls.find_instance_anns(group):
+                group = [a for a in group if a.type == AnnotationType.points]
+                solitary_points.extend(group)
+
+        return solitary_points
+
+    @staticmethod
+    def convert_points_object(ann):
+        keypoints = []
+        points = ann.points
+        visibility = ann.visibility
+        for index in range(0, len(points), 2):
+            kp = points[index : index + 2]
+            state = visibility[index // 2].value
+            keypoints.extend([*kp, state])
+
+        num_annotated = len([v for v in visibility \
+            if v != Points.Visibility.absent])
+
+        return {
+            'keypoints': keypoints,
+            'num_keypoints': num_annotated,
+        }
+
+    def convert_instance(self, instance, item):
+        points_ann = find(item.annotations, lambda x: \
+            x.type == AnnotationType.points and \
+            instance[0].group and x.group == instance[0].group)
+        if not points_ann:
+            return None
+
+        elem = super().convert_instance(instance, item)
+        elem.update(self.convert_points_object(points_ann))
+
+        return elem
+
+class _LabelsConverter(_TaskConverter):
+    def save_categories(self, dataset):
+        label_categories = dataset.categories().get(AnnotationType.label)
+        if label_categories is None:
+            return
+
+        for idx, cat in enumerate(label_categories.items):
+            self.categories.append({
+                'id': 1 + idx,
+                'name': cast(cat.name, str, ''),
+                'supercategory': cast(cat.parent, str, ''),
+            })
+
+    def save_annotations(self, item):
+        for ann in item.annotations:
+            if ann.type != AnnotationType.label:
+                continue
+
+            elem = {
+                'id': self._get_ann_id(ann),
+                'image_id': self._get_image_id(item),
+                'category_id': int(ann.label) + 1,
+            }
+            if 'score' in ann.attributes:
+                try:
+                    elem['score'] = float(ann.attributes['score'])
+                except Exception as e:
+                    log.warning("Item '%s': failed to convert attribute "
+                        "'score': %e" % (item.id, e))
+            if self._context._allow_attributes:
+                elem['attributes'] = self._convert_attributes(ann)
+
+            self.annotations.append(elem)
+
+class CocoConverter(Converter):
+    @staticmethod
+    def _split_tasks_string(s):
+        return [CocoTask[i.strip()] for i in s.split(',')]
+
+    @classmethod
+    def build_cmdline_parser(cls, **kwargs):
+        parser = super().build_cmdline_parser(**kwargs)
+        parser.add_argument('--segmentation-mode',
+            choices=[m.name for m in SegmentationMode],
+            default=SegmentationMode.guess.name,
+            help="""
+                Save mode for instance segmentation:|n
+                - '{sm.guess.name}': guess the mode for each instance,|n
+                |s|suse 'is_crowd' attribute as hint|n
+                - '{sm.polygons.name}': save polygons,|n
+                |s|smerge and convert masks, prefer polygons|n
+                - '{sm.mask.name}': save masks,|n
+                |s|smerge and convert polygons, prefer masks|n
+                Default: %(default)s.
+                """.format(sm=SegmentationMode))
+        parser.add_argument('--crop-covered', action='store_true',
+            help="Crop covered segments so that background objects' "
+                "segmentation was more accurate (default: %(default)s)")
+        parser.add_argument('--allow-attributes',
+            type=str_to_bool, default=True,
+            help="Allow export of attributes (default: %(default)s)")
+        parser.add_argument('--reindex', action='store_true',
+            help="Assign new indices to images and annotations "
+                "(default: %(default)s)")
+        parser.add_argument('--tasks', type=cls._split_tasks_string,
+            help="COCO task filter, comma-separated list of {%s} "
+                "(default: all)" % ', '.join(t.name for t in CocoTask))
+        return parser
+
+    DEFAULT_IMAGE_EXT = CocoPath.IMAGE_EXT
+
+    _TASK_CONVERTER = {
+        CocoTask.image_info: _ImageInfoConverter,
+        CocoTask.instances: _InstancesConverter,
+        CocoTask.person_keypoints: _KeypointsConverter,
+        CocoTask.captions: _CaptionsConverter,
+        CocoTask.labels: _LabelsConverter,
+    }
+
+    def __init__(self, extractor, save_dir,
+            tasks=None, segmentation_mode=None, crop_covered=False,
+            allow_attributes=True, reindex=False, **kwargs):
+        super().__init__(extractor, save_dir, **kwargs)
+
+        assert tasks is None or isinstance(tasks, (CocoTask, list, str))
+        if isinstance(tasks, CocoTask):
+            tasks = [tasks]
+        elif isinstance(tasks, str):
+            tasks = [CocoTask[tasks]]
+        elif tasks:
+            for i, t in enumerate(tasks):
+                if isinstance(t, str):
+                    tasks[i] = CocoTask[t]
+                else:
+                    assert t in CocoTask, t
+        self._tasks = tasks
+
+        assert segmentation_mode is None or \
+            isinstance(segmentation_mode, str) or \
+            segmentation_mode in SegmentationMode
+        if segmentation_mode is None:
+            segmentation_mode = SegmentationMode.guess
+        if isinstance(segmentation_mode, str):
+            segmentation_mode = SegmentationMode[segmentation_mode]
+        self._segmentation_mode = segmentation_mode
+
+        self._crop_covered = crop_covered
+        self._allow_attributes = allow_attributes
+        self._reindex = reindex
+
+        self._image_ids = {}
+
+    def _make_dirs(self):
+        self._images_dir = osp.join(self._save_dir, CocoPath.IMAGES_DIR)
+        os.makedirs(self._images_dir, exist_ok=True)
+
+        self._ann_dir = osp.join(self._save_dir, CocoPath.ANNOTATIONS_DIR)
+        os.makedirs(self._ann_dir, exist_ok=True)
+
+    def _make_task_converter(self, task):
+        if task not in self._TASK_CONVERTER:
+            raise NotImplementedError()
+        return self._TASK_CONVERTER[task](self)
+
+    def _make_task_converters(self):
+        return { task: self._make_task_converter(task)
+            for task in (self._tasks or self._TASK_CONVERTER) }
+
+    def _get_image_id(self, item):
+        image_id = self._image_ids.get(item.id)
+        if image_id is None:
+            if not self._reindex:
+                image_id = cast(item.attributes.get('id'), int,
+                    len(self._image_ids) + 1)
+            else:
+                image_id = len(self._image_ids) + 1
+            self._image_ids[item.id] = image_id
+        return image_id
+
+    def _save_image(self, item, path=None):
+        super()._save_image(item,
+            osp.join(self._images_dir, self._make_image_filename(item)))
+
+    def apply(self):
+        self._make_dirs()
+
+        for subset_name, subset in self._extractor.subsets().items():
+            task_converters = self._make_task_converters()
+            for task_conv in task_converters.values():
+                task_conv.save_categories(subset)
+            for item in subset:
+                if self._save_images:
+                    if item.has_image:
+                        self._save_image(item)
+                    else:
+                        log.debug("Item '%s' has no image info", item.id)
+                for task_conv in task_converters.values():
+                    task_conv.save_image_info(item,
+                        self._make_image_filename(item))
+                    task_conv.save_annotations(item)
+
+            for task, task_conv in task_converters.items():
+                if task_conv.is_empty() and not self._tasks:
+                    continue
+                task_conv.write(osp.join(self._ann_dir,
+                    '%s_%s.json' % (task.name, subset_name)))
+
+class CocoInstancesConverter(CocoConverter):
+    def __init__(self, *args, **kwargs):
+        kwargs['tasks'] = CocoTask.instances
+        super().__init__(*args, **kwargs)
+
+class CocoImageInfoConverter(CocoConverter):
+    def __init__(self, *args, **kwargs):
+        kwargs['tasks'] = CocoTask.image_info
+        super().__init__(*args, **kwargs)
+
+class CocoPersonKeypointsConverter(CocoConverter):
+    def __init__(self, *args, **kwargs):
+        kwargs['tasks'] = CocoTask.person_keypoints
+        super().__init__(*args, **kwargs)
+
+class CocoCaptionsConverter(CocoConverter):
+    def __init__(self, *args, **kwargs):
+        kwargs['tasks'] = CocoTask.captions
+        super().__init__(*args, **kwargs)
+
+class CocoLabelsConverter(CocoConverter):
+    def __init__(self, *args, **kwargs):
+        kwargs['tasks'] = CocoTask.labels
+        super().__init__(*args, **kwargs)

testbed/openvinotoolkit__datumaro/datumaro/plugins/coco_format/extractor.py

@@ -0,0 +1,251 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+from collections import OrderedDict
+import logging as log
+import os.path as osp
+
+from pycocotools.coco import COCO
+import pycocotools.mask as mask_utils
+
+from datumaro.components.extractor import (SourceExtractor,
+    DEFAULT_SUBSET_NAME, DatasetItem,
+    AnnotationType, Label, RleMask, Points, Polygon, Bbox, Caption,
+    LabelCategories, PointsCategories
+)
+from datumaro.util.image import Image
+
+from .format import CocoTask, CocoPath
+
+
+class _CocoExtractor(SourceExtractor):
+    def __init__(self, path, task, merge_instance_polygons=False):
+        assert osp.isfile(path), path
+
+        subset = osp.splitext(osp.basename(path))[0].rsplit('_', maxsplit=1)
+        subset = subset[1] if len(subset) == 2 else None
+        super().__init__(subset=subset)
+
+        rootpath = ''
+        if path.endswith(osp.join(CocoPath.ANNOTATIONS_DIR, osp.basename(path))):
+            rootpath = path.rsplit(CocoPath.ANNOTATIONS_DIR, maxsplit=1)[0]
+        images_dir = ''
+        if rootpath and osp.isdir(osp.join(rootpath, CocoPath.IMAGES_DIR)):
+            images_dir = osp.join(rootpath, CocoPath.IMAGES_DIR)
+            if osp.isdir(osp.join(images_dir, subset or DEFAULT_SUBSET_NAME)):
+                images_dir = osp.join(images_dir, subset or DEFAULT_SUBSET_NAME)
+        self._images_dir = images_dir
+        self._task = task
+
+        self._merge_instance_polygons = merge_instance_polygons
+
+        loader = self._make_subset_loader(path)
+        self._load_categories(loader)
+        self._items = list(self._load_items(loader).values())
+
+    @staticmethod
+    def _make_subset_loader(path):
+        # COCO API has an 'unclosed file' warning
+        coco_api = COCO()
+        with open(path, 'r') as f:
+            import json
+            dataset = json.load(f)
+
+        coco_api.dataset = dataset
+        coco_api.createIndex()
+        return coco_api
+
+    def _load_categories(self, loader):
+        self._categories = {}
+
+        if self._task in [CocoTask.instances, CocoTask.labels,
+                CocoTask.person_keypoints,
+                # TODO: Task.stuff, CocoTask.panoptic
+                ]:
+            label_categories, label_map = self._load_label_categories(loader)
+            self._categories[AnnotationType.label] = label_categories
+            self._label_map = label_map
+
+        if self._task == CocoTask.person_keypoints:
+            person_kp_categories = self._load_person_kp_categories(loader)
+            self._categories[AnnotationType.points] = person_kp_categories
+
+    # pylint: disable=no-self-use
+    def _load_label_categories(self, loader):
+        catIds = loader.getCatIds()
+        cats = loader.loadCats(catIds)
+
+        categories = LabelCategories()
+        label_map = {}
+        for idx, cat in enumerate(cats):
+            label_map[cat['id']] = idx
+            categories.add(name=cat['name'], parent=cat.get('supercategory'))
+
+        return categories, label_map
+    # pylint: enable=no-self-use
+
+    def _load_person_kp_categories(self, loader):
+        catIds = loader.getCatIds()
+        cats = loader.loadCats(catIds)
+
+        categories = PointsCategories()
+        for cat in cats:
+            label_id = self._label_map[cat['id']]
+            categories.add(label_id=label_id,
+                labels=cat['keypoints'], joints=cat['skeleton']
+            )
+
+        return categories
+
+    def _load_items(self, loader):
+        items = OrderedDict()
+
+        for img_id in loader.getImgIds():
+            image_info = loader.loadImgs(img_id)[0]
+            image_path = osp.join(self._images_dir, image_info['file_name'])
+            image_size = (image_info.get('height'), image_info.get('width'))
+            if all(image_size):
+                image_size = (int(image_size[0]), int(image_size[1]))
+            else:
+                image_size = None
+            image = Image(path=image_path, size=image_size)
+
+            anns = loader.getAnnIds(imgIds=img_id)
+            anns = loader.loadAnns(anns)
+            anns = sum((self._load_annotations(a, image_info) for a in anns), [])
+
+            items[img_id] = DatasetItem(
+                id=osp.splitext(image_info['file_name'])[0],
+                subset=self._subset, image=image, annotations=anns,
+                attributes={'id': img_id})
+
+        return items
+
+    def _get_label_id(self, ann):
+        cat_id = ann.get('category_id')
+        if cat_id in [0, None]:
+            return None
+        return self._label_map[cat_id]
+
+    def _load_annotations(self, ann, image_info=None):
+        parsed_annotations = []
+
+        ann_id = ann.get('id')
+
+        attributes = {}
+        if 'attributes' in ann:
+            try:
+                attributes.update(ann['attributes'])
+            except Exception as e:
+                log.debug("item #%s: failed to read annotation attributes: %s",
+                    image_info['id'], e)
+        if 'score' in ann:
+            attributes['score'] = ann['score']
+
+        group = ann_id # make sure all tasks' annotations are merged
+
+        if self._task in [CocoTask.instances, CocoTask.person_keypoints]:
+            x, y, w, h = ann['bbox']
+            label_id = self._get_label_id(ann)
+
+            is_crowd = bool(ann['iscrowd'])
+            attributes['is_crowd'] = is_crowd
+
+            if self._task is CocoTask.person_keypoints:
+                keypoints = ann['keypoints']
+                points = [p for i, p in enumerate(keypoints) if i % 3 != 2]
+                visibility = keypoints[2::3]
+                parsed_annotations.append(
+                    Points(points, visibility, label=label_id,
+                        id=ann_id, attributes=attributes, group=group)
+                )
+
+            segmentation = ann.get('segmentation')
+            if segmentation and segmentation != [[]]:
+                rle = None
+
+                if isinstance(segmentation, list):
+                    if not self._merge_instance_polygons:
+                        # polygon - a single object can consist of multiple parts
+                        for polygon_points in segmentation:
+                            parsed_annotations.append(Polygon(
+                                points=polygon_points, label=label_id,
+                                id=ann_id, attributes=attributes, group=group
+                            ))
+                    else:
+                        # merge all parts into a single mask RLE
+                        img_h = image_info['height']
+                        img_w = image_info['width']
+                        rles = mask_utils.frPyObjects(segmentation, img_h, img_w)
+                        rle = mask_utils.merge(rles)
+                elif isinstance(segmentation['counts'], list):
+                    # uncompressed RLE
+                    img_h = image_info['height']
+                    img_w = image_info['width']
+                    mask_h, mask_w = segmentation['size']
+                    if img_h == mask_h and img_w == mask_w:
+                        rle = mask_utils.frPyObjects(
+                            [segmentation], mask_h, mask_w)[0]
+                    else:
+                        log.warning("item #%s: mask #%s "
+                            "does not match image size: %s vs. %s. "
+                            "Skipping this annotation.",
+                            image_info['id'], ann_id,
+                            (mask_h, mask_w), (img_h, img_w)
+                        )
+                else:
+                    # compressed RLE
+                    rle = segmentation
+
+                if rle is not None:
+                    parsed_annotations.append(RleMask(rle=rle, label=label_id,
+                        id=ann_id, attributes=attributes, group=group
+                    ))
+            else:
+                parsed_annotations.append(
+                    Bbox(x, y, w, h, label=label_id,
+                        id=ann_id, attributes=attributes, group=group)
+                )
+        elif self._task is CocoTask.labels:
+            label_id = self._get_label_id(ann)
+            parsed_annotations.append(
+                Label(label=label_id,
+                    id=ann_id, attributes=attributes, group=group)
+            )
+        elif self._task is CocoTask.captions:
+            caption = ann['caption']
+            parsed_annotations.append(
+                Caption(caption,
+                    id=ann_id, attributes=attributes, group=group)
+            )
+        else:
+            raise NotImplementedError()
+
+        return parsed_annotations
+
+class CocoImageInfoExtractor(_CocoExtractor):
+    def __init__(self, path, **kwargs):
+        kwargs['task'] = CocoTask.image_info
+        super().__init__(path, **kwargs)
+
+class CocoCaptionsExtractor(_CocoExtractor):
+    def __init__(self, path, **kwargs):
+        kwargs['task'] = CocoTask.captions
+        super().__init__(path, **kwargs)
+
+class CocoInstancesExtractor(_CocoExtractor):
+    def __init__(self, path, **kwargs):
+        kwargs['task'] = CocoTask.instances
+        super().__init__(path, **kwargs)
+
+class CocoPersonKeypointsExtractor(_CocoExtractor):
+    def __init__(self, path, **kwargs):
+        kwargs['task'] = CocoTask.person_keypoints
+        super().__init__(path, **kwargs)
+
+class CocoLabelsExtractor(_CocoExtractor):
+    def __init__(self, path, **kwargs):
+        kwargs['task'] = CocoTask.labels
+        super().__init__(path, **kwargs)

testbed/openvinotoolkit__datumaro/datumaro/plugins/coco_format/format.py

@@ -0,0 +1,23 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+from enum import Enum
+
+
+CocoTask = Enum('CocoTask', [
+    'instances',
+    'person_keypoints',
+    'captions',
+    'labels', # extension, does not exist in the original COCO format
+    'image_info',
+    # 'panoptic',
+    # 'stuff',
+])
+
+class CocoPath:
+    IMAGES_DIR = 'images'
+    ANNOTATIONS_DIR = 'annotations'
+
+    IMAGE_EXT = '.jpg'

testbed/openvinotoolkit__datumaro/datumaro/plugins/coco_format/importer.py

@@ -0,0 +1,95 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+from collections import defaultdict
+from glob import glob
+import logging as log
+import os.path as osp
+
+from datumaro.components.extractor import Importer
+from datumaro.util.log_utils import logging_disabled
+
+from .format import CocoTask
+
+
+class CocoImporter(Importer):
+    _COCO_EXTRACTORS = {
+        CocoTask.instances: 'coco_instances',
+        CocoTask.person_keypoints: 'coco_person_keypoints',
+        CocoTask.captions: 'coco_captions',
+        CocoTask.labels: 'coco_labels',
+        CocoTask.image_info: 'coco_image_info',
+    }
+
+    @classmethod
+    def detect(cls, path):
+        with logging_disabled(log.WARN):
+            return len(cls.find_sources(path)) != 0
+
+    def __call__(self, path, **extra_params):
+        from datumaro.components.project import Project # cyclic import
+        project = Project()
+
+        subsets = self.find_sources(path)
+
+        if len(subsets) == 0:
+            raise Exception("Failed to find 'coco' dataset at '%s'" % path)
+
+        # TODO: should be removed when proper label merging is implemented
+        conflicting_types = {CocoTask.instances,
+            CocoTask.person_keypoints, CocoTask.labels}
+        ann_types = set(t for s in subsets.values() for t in s) \
+            & conflicting_types
+        if 1 <= len(ann_types):
+            selected_ann_type = sorted(ann_types, key=lambda x: x.name)[0]
+        if 1 < len(ann_types):
+            log.warning("Not implemented: "
+                "Found potentially conflicting source types with labels: %s. "
+                "Only one type will be used: %s" \
+                % (", ".join(t.name for t in ann_types), selected_ann_type.name))
+
+        for ann_files in subsets.values():
+            for ann_type, ann_file in ann_files.items():
+                if ann_type in conflicting_types:
+                    if ann_type is not selected_ann_type:
+                        log.warning("Not implemented: "
+                            "conflicting source '%s' is skipped." % ann_file)
+                        continue
+                log.info("Found a dataset at '%s'" % ann_file)
+
+                source_name = osp.splitext(osp.basename(ann_file))[0]
+                project.add_source(source_name, {
+                    'url': ann_file,
+                    'format': self._COCO_EXTRACTORS[ann_type],
+                    'options': dict(extra_params),
+                })
+
+        return project
+
+    @staticmethod
+    def find_sources(path):
+        if path.endswith('.json') and osp.isfile(path):
+            subset_paths = [path]
+        else:
+            subset_paths = glob(osp.join(path, '**', '*_*.json'),
+                recursive=True)
+
+        subsets = defaultdict(dict)
+        for subset_path in subset_paths:
+            name_parts = osp.splitext(osp.basename(subset_path))[0] \
+                .rsplit('_', maxsplit=1)
+
+            ann_type = name_parts[0]
+            try:
+                ann_type = CocoTask[ann_type]
+            except KeyError:
+                log.warn("Skipping '%s': unknown subset "
+                    "type '%s', the only known are: %s" % \
+                    (subset_path, ann_type,
+                        ', '.join([e.name for e in CocoTask])))
+                continue
+            subset_name = name_parts[1]
+            subsets[subset_name][ann_type] = subset_path
+        return dict(subsets)

testbed/openvinotoolkit__datumaro/datumaro/plugins/cvat_format/converter.py

@@ -0,0 +1,332 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+import logging as log
+import os
+import os.path as osp
+from collections import OrderedDict
+from xml.sax.saxutils import XMLGenerator
+
+from datumaro.components.converter import Converter
+from datumaro.components.extractor import DEFAULT_SUBSET_NAME, AnnotationType
+from datumaro.util import cast, pairs
+
+from .format import CvatPath
+
+
+class XmlAnnotationWriter:
+    VERSION = '1.1'
+
+    def __init__(self, f):
+        self.xmlgen = XMLGenerator(f, 'utf-8')
+        self._level = 0
+
+    def _indent(self, newline = True):
+        if newline:
+            self.xmlgen.ignorableWhitespace('\n')
+        self.xmlgen.ignorableWhitespace('  ' * self._level)
+
+    def _add_version(self):
+        self._indent()
+        self.xmlgen.startElement('version', {})
+        self.xmlgen.characters(self.VERSION)
+        self.xmlgen.endElement('version')
+
+    def open_root(self):
+        self.xmlgen.startDocument()
+        self.xmlgen.startElement('annotations', {})
+        self._level += 1
+        self._add_version()
+
+    def _add_meta(self, meta):
+        self._level += 1
+        for k, v in meta.items():
+            if isinstance(v, OrderedDict):
+                self._indent()
+                self.xmlgen.startElement(k, {})
+                self._add_meta(v)
+                self._indent()
+                self.xmlgen.endElement(k)
+            elif isinstance(v, list):
+                self._indent()
+                self.xmlgen.startElement(k, {})
+                for tup in v:
+                    self._add_meta(OrderedDict([tup]))
+                self._indent()
+                self.xmlgen.endElement(k)
+            else:
+                self._indent()
+                self.xmlgen.startElement(k, {})
+                self.xmlgen.characters(v)
+                self.xmlgen.endElement(k)
+        self._level -= 1
+
+    def write_meta(self, meta):
+        self._indent()
+        self.xmlgen.startElement('meta', {})
+        self._add_meta(meta)
+        self._indent()
+        self.xmlgen.endElement('meta')
+
+    def open_track(self, track):
+        self._indent()
+        self.xmlgen.startElement('track', track)
+        self._level += 1
+
+    def open_image(self, image):
+        self._indent()
+        self.xmlgen.startElement('image', image)
+        self._level += 1
+
+    def open_box(self, box):
+        self._indent()
+        self.xmlgen.startElement('box', box)
+        self._level += 1
+
+    def open_polygon(self, polygon):
+        self._indent()
+        self.xmlgen.startElement('polygon', polygon)
+        self._level += 1
+
+    def open_polyline(self, polyline):
+        self._indent()
+        self.xmlgen.startElement('polyline', polyline)
+        self._level += 1
+
+    def open_points(self, points):
+        self._indent()
+        self.xmlgen.startElement('points', points)
+        self._level += 1
+
+    def open_tag(self, tag):
+        self._indent()
+        self.xmlgen.startElement("tag", tag)
+        self._level += 1
+
+    def add_attribute(self, attribute):
+        self._indent()
+        self.xmlgen.startElement('attribute', {'name': attribute['name']})
+        self.xmlgen.characters(attribute['value'])
+        self.xmlgen.endElement('attribute')
+
+    def _close_element(self, element):
+        self._level -= 1
+        self._indent()
+        self.xmlgen.endElement(element)
+
+    def close_box(self):
+        self._close_element('box')
+
+    def close_polygon(self):
+        self._close_element('polygon')
+
+    def close_polyline(self):
+        self._close_element('polyline')
+
+    def close_points(self):
+        self._close_element('points')
+
+    def close_tag(self):
+        self._close_element('tag')
+
+    def close_image(self):
+        self._close_element('image')
+
+    def close_track(self):
+        self._close_element('track')
+
+    def close_root(self):
+        self._close_element('annotations')
+        self.xmlgen.endDocument()
+
+class _SubsetWriter:
+    def __init__(self, file, name, extractor, context):
+        self._writer = XmlAnnotationWriter(file)
+        self._name = name
+        self._extractor = extractor
+        self._context = context
+
+    def write(self):
+        self._writer.open_root()
+        self._write_meta()
+
+        for index, item in enumerate(self._extractor):
+            self._write_item(item, index)
+
+        self._writer.close_root()
+
+    def _write_item(self, item, index):
+        if not self._context._reindex:
+            index = cast(item.attributes.get('frame'), int, index)
+        image_info = OrderedDict([ ("id", str(index)), ])
+        filename = item.id + CvatPath.IMAGE_EXT
+        image_info["name"] = filename
+        if item.has_image:
+            size = item.image.size
+            if size:
+                h, w = size
+                image_info["width"] = str(w)
+                image_info["height"] = str(h)
+
+            if self._context._save_images:
+                self._context._save_image(item,
+                    osp.join(self._context._images_dir, filename))
+        else:
+            log.debug("Item '%s' has no image info", item.id)
+        self._writer.open_image(image_info)
+
+        for ann in item.annotations:
+            if ann.type in {AnnotationType.points, AnnotationType.polyline,
+                    AnnotationType.polygon, AnnotationType.bbox}:
+                self._write_shape(ann)
+            elif ann.type == AnnotationType.label:
+                self._write_tag(ann)
+            else:
+                continue
+
+        self._writer.close_image()
+
+    def _write_meta(self):
+        label_cat = self._extractor.categories()[AnnotationType.label]
+        meta = OrderedDict([
+            ("task", OrderedDict([
+                ("id", ""),
+                ("name", self._name),
+                ("size", str(len(self._extractor))),
+                ("mode", "annotation"),
+                ("overlap", ""),
+                ("start_frame", "0"),
+                ("stop_frame", str(len(self._extractor))),
+                ("frame_filter", ""),
+                ("z_order", "True"),
+
+                ("labels", [
+                    ("label", OrderedDict([
+                        ("name", label.name),
+                        ("attributes", [
+                            ("attribute", OrderedDict([
+                                ("name", attr),
+                                ("mutable", "True"),
+                                ("input_type", "text"),
+                                ("default_value", ""),
+                                ("values", ""),
+                            ])) for attr in label.attributes
+                        ])
+                    ])) for label in label_cat.items
+                ]),
+            ])),
+        ])
+        self._writer.write_meta(meta)
+
+    def _get_label(self, label_id):
+        label_cat = self._extractor.categories()[AnnotationType.label]
+        return label_cat.items[label_id]
+
+    def _write_shape(self, shape):
+        if shape.label is None:
+            return
+
+        shape_data = OrderedDict([
+            ("label", self._get_label(shape.label).name),
+            ("occluded", str(int(shape.attributes.get('occluded', False)))),
+        ])
+
+        if shape.type == AnnotationType.bbox:
+            shape_data.update(OrderedDict([
+                ("xtl", "{:.2f}".format(shape.points[0])),
+                ("ytl", "{:.2f}".format(shape.points[1])),
+                ("xbr", "{:.2f}".format(shape.points[2])),
+                ("ybr", "{:.2f}".format(shape.points[3]))
+            ]))
+        else:
+            shape_data.update(OrderedDict([
+                ("points", ';'.join((
+                    ','.join((
+                        "{:.2f}".format(x),
+                        "{:.2f}".format(y)
+                    )) for x, y in pairs(shape.points))
+                )),
+            ]))
+
+        shape_data['z_order'] = str(int(shape.z_order))
+        if shape.group:
+            shape_data['group_id'] = str(shape.group)
+
+        if shape.type == AnnotationType.bbox:
+            self._writer.open_box(shape_data)
+        elif shape.type == AnnotationType.polygon:
+            self._writer.open_polygon(shape_data)
+        elif shape.type == AnnotationType.polyline:
+            self._writer.open_polyline(shape_data)
+        elif shape.type == AnnotationType.points:
+            self._writer.open_points(shape_data)
+        else:
+            raise NotImplementedError("unknown shape type")
+
+        for attr_name, attr_value in shape.attributes.items():
+            if isinstance(attr_value, bool):
+                attr_value = 'true' if attr_value else 'false'
+            if attr_name in self._get_label(shape.label).attributes:
+                self._writer.add_attribute(OrderedDict([
+                    ("name", str(attr_name)),
+                    ("value", str(attr_value)),
+                ]))
+
+        if shape.type == AnnotationType.bbox:
+            self._writer.close_box()
+        elif shape.type == AnnotationType.polygon:
+            self._writer.close_polygon()
+        elif shape.type == AnnotationType.polyline:
+            self._writer.close_polyline()
+        elif shape.type == AnnotationType.points:
+            self._writer.close_points()
+        else:
+            raise NotImplementedError("unknown shape type")
+
+    def _write_tag(self, label):
+        if label.label is None:
+            return
+
+        tag_data = OrderedDict([
+            ('label', self._get_label(label.label).name),
+        ])
+        if label.group:
+            tag_data['group_id'] = str(label.group)
+        self._writer.open_tag(tag_data)
+
+        for attr_name, attr_value in label.attributes.items():
+            if isinstance(attr_value, bool):
+                attr_value = 'true' if attr_value else 'false'
+            if attr_name in self._get_label(label.label).attributes:
+                self._writer.add_attribute(OrderedDict([
+                    ("name", str(attr_name)),
+                    ("value", str(attr_value)),
+                ]))
+
+        self._writer.close_tag()
+
+class CvatConverter(Converter):
+    DEFAULT_IMAGE_EXT = CvatPath.IMAGE_EXT
+
+    @classmethod
+    def build_cmdline_parser(cls, **kwargs):
+        parser = super().build_cmdline_parser(**kwargs)
+        parser.add_argument('--reindex', action='store_true',
+            help="Assign new indices to frames (default: %(default)s)")
+        return parser
+
+    def __init__(self, extractor, save_dir, reindex=False, **kwargs):
+        super().__init__(extractor, save_dir, **kwargs)
+
+        self._reindex = reindex
+
+    def apply(self):
+        self._images_dir = osp.join(self._save_dir, CvatPath.IMAGES_DIR)
+        os.makedirs(self._images_dir, exist_ok=True)
+
+        for subset_name, subset in self._extractor.subsets().items():
+            with open(osp.join(self._save_dir, '%s.xml' % subset_name), 'w') as f:
+                writer = _SubsetWriter(f, subset_name, subset, self)
+                writer.write()

testbed/openvinotoolkit__datumaro/datumaro/plugins/cvat_format/extractor.py

@@ -0,0 +1,311 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+from collections import OrderedDict
+import os.path as osp
+from defusedxml import ElementTree
+
+from datumaro.components.extractor import (SourceExtractor, DatasetItem,
+    AnnotationType, Points, Polygon, PolyLine, Bbox, Label,
+    LabelCategories, Importer
+)
+from datumaro.util.image import Image
+
+from .format import CvatPath
+
+
+class CvatExtractor(SourceExtractor):
+    _SUPPORTED_SHAPES = ('box', 'polygon', 'polyline', 'points')
+
+    def __init__(self, path):
+        assert osp.isfile(path), path
+        rootpath = osp.dirname(path)
+        images_dir = ''
+        if osp.isdir(osp.join(rootpath, CvatPath.IMAGES_DIR)):
+            images_dir = osp.join(rootpath, CvatPath.IMAGES_DIR)
+        self._images_dir = images_dir
+        self._path = path
+
+        super().__init__(subset=osp.splitext(osp.basename(path))[0])
+
+        items, categories = self._parse(path)
+        self._items = list(self._load_items(items).values())
+        self._categories = categories
+
+    @classmethod
+    def _parse(cls, path):
+        context = ElementTree.iterparse(path, events=("start", "end"))
+        context = iter(context)
+
+        categories, frame_size = cls._parse_meta(context)
+
+        items = OrderedDict()
+
+        track = None
+        shape = None
+        tag = None
+        attributes = None
+        image = None
+        for ev, el in context:
+            if ev == 'start':
+                if el.tag == 'track':
+                    track = {
+                        'id': el.attrib['id'],
+                        'label': el.attrib.get('label'),
+                        'group': int(el.attrib.get('group_id', 0)),
+                        'height': frame_size[0],
+                        'width': frame_size[1],
+                    }
+                elif el.tag == 'image':
+                    image = {
+                        'name': el.attrib.get('name'),
+                        'frame': el.attrib['id'],
+                        'width': el.attrib.get('width'),
+                        'height': el.attrib.get('height'),
+                    }
+                elif el.tag in cls._SUPPORTED_SHAPES and (track or image):
+                    attributes = {}
+                    shape = {
+                        'type': None,
+                        'attributes': attributes,
+                    }
+                    if track:
+                        shape.update(track)
+                        shape['track_id'] = int(track['id'])
+                    if image:
+                        shape.update(image)
+                elif el.tag == 'tag' and image:
+                    attributes = {}
+                    tag = {
+                        'frame': image['frame'],
+                        'attributes': attributes,
+                        'group': int(el.attrib.get('group_id', 0)),
+                        'label': el.attrib['label'],
+                    }
+            elif ev == 'end':
+                if el.tag == 'attribute' and attributes is not None:
+                    attr_value = el.text or ''
+                    if el.text in ['true', 'false']:
+                        attr_value = attr_value == 'true'
+                    else:
+                        try:
+                            attr_value = float(attr_value)
+                        except ValueError:
+                            pass
+                    attributes[el.attrib['name']] = attr_value
+                elif el.tag in cls._SUPPORTED_SHAPES:
+                    if track is not None:
+                        shape['frame'] = el.attrib['frame']
+                        shape['outside'] = (el.attrib.get('outside') == '1')
+                        shape['keyframe'] = (el.attrib.get('keyframe') == '1')
+                    if image is not None:
+                        shape['label'] = el.attrib.get('label')
+                        shape['group'] = int(el.attrib.get('group_id', 0))
+
+                    shape['type'] = el.tag
+                    shape['occluded'] = (el.attrib.get('occluded') == '1')
+                    shape['z_order'] = int(el.attrib.get('z_order', 0))
+
+                    if el.tag == 'box':
+                        shape['points'] = list(map(float, [
+                            el.attrib['xtl'], el.attrib['ytl'],
+                            el.attrib['xbr'], el.attrib['ybr'],
+                        ]))
+                    else:
+                        shape['points'] = []
+                        for pair in el.attrib['points'].split(';'):
+                            shape['points'].extend(map(float, pair.split(',')))
+
+                    frame_desc = items.get(shape['frame'], {'annotations': []})
+                    frame_desc['annotations'].append(
+                        cls._parse_shape_ann(shape, categories))
+                    items[shape['frame']] = frame_desc
+                    shape = None
+
+                elif el.tag == 'tag':
+                    frame_desc = items.get(tag['frame'], {'annotations': []})
+                    frame_desc['annotations'].append(
+                        cls._parse_tag_ann(tag, categories))
+                    items[tag['frame']] = frame_desc
+                    tag = None
+                elif el.tag == 'track':
+                    track = None
+                elif el.tag == 'image':
+                    frame_desc = items.get(image['frame'], {'annotations': []})
+                    frame_desc.update({
+                        'name': image.get('name'),
+                        'height': image.get('height'),
+                        'width': image.get('width'),
+                    })
+                    items[image['frame']] = frame_desc
+                    image = None
+                el.clear()
+
+        return items, categories
+
+    @staticmethod
+    def _parse_meta(context):
+        ev, el = next(context)
+        if not (ev == 'start' and el.tag == 'annotations'):
+            raise Exception("Unexpected token ")
+
+        categories = {}
+
+        frame_size = None
+        mode = None
+        labels = OrderedDict()
+        label = None
+
+        # Recursive descent parser
+        el = None
+        states = ['annotations']
+        def accepted(expected_state, tag, next_state=None):
+            state = states[-1]
+            if state == expected_state and el is not None and el.tag == tag:
+                if not next_state:
+                    next_state = tag
+                states.append(next_state)
+                return True
+            return False
+        def consumed(expected_state, tag):
+            state = states[-1]
+            if state == expected_state and el is not None and el.tag == tag:
+                states.pop()
+                return True
+            return False
+
+        for ev, el in context:
+            if ev == 'start':
+                if accepted('annotations', 'meta'): pass
+                elif accepted('meta', 'task'): pass
+                elif accepted('task', 'mode'): pass
+                elif accepted('task', 'original_size'):
+                    frame_size = [None, None]
+                elif accepted('original_size', 'height', next_state='frame_height'): pass
+                elif accepted('original_size', 'width', next_state='frame_width'): pass
+                elif accepted('task', 'labels'): pass
+                elif accepted('labels', 'label'):
+                    label = { 'name': None, 'attributes': set() }
+                elif accepted('label', 'name', next_state='label_name'): pass
+                elif accepted('label', 'attributes'): pass
+                elif accepted('attributes', 'attribute'): pass
+                elif accepted('attribute', 'name', next_state='attr_name'): pass
+                elif accepted('annotations', 'image') or \
+                     accepted('annotations', 'track') or \
+                     accepted('annotations', 'tag'):
+                    break
+                else:
+                    pass
+            elif ev == 'end':
+                if consumed('meta', 'meta'):
+                    break
+                elif consumed('task', 'task'): pass
+                elif consumed('mode', 'mode'):
+                    mode = el.text
+                elif consumed('original_size', 'original_size'): pass
+                elif consumed('frame_height', 'height'):
+                    frame_size[0] = int(el.text)
+                elif consumed('frame_width', 'width'):
+                    frame_size[1] = int(el.text)
+                elif consumed('label_name', 'name'):
+                    label['name'] = el.text
+                elif consumed('attr_name', 'name'):
+                    label['attributes'].add(el.text)
+                elif consumed('attribute', 'attribute'): pass
+                elif consumed('attributes', 'attributes'): pass
+                elif consumed('label', 'label'):
+                    labels[label['name']] = label['attributes']
+                    label = None
+                elif consumed('labels', 'labels'): pass
+                else:
+                    pass
+
+        assert len(states) == 1 and states[0] == 'annotations', \
+            "Expected 'meta' section in the annotation file, path: %s" % states
+
+        common_attrs = ['occluded']
+        if mode == 'interpolation':
+            common_attrs.append('keyframe')
+            common_attrs.append('outside')
+            common_attrs.append('track_id')
+
+        label_cat = LabelCategories(attributes=common_attrs)
+        for label, attrs in labels.items():
+            label_cat.add(label, attributes=attrs)
+
+        categories[AnnotationType.label] = label_cat
+
+        return categories, frame_size
+
+    @classmethod
+    def _parse_shape_ann(cls, ann, categories):
+        ann_id = ann.get('id', 0)
+        ann_type = ann['type']
+
+        attributes = ann.get('attributes') or {}
+        if 'occluded' in categories[AnnotationType.label].attributes:
+            attributes['occluded'] = ann.get('occluded', False)
+        if 'outside' in ann:
+            attributes['outside'] = ann['outside']
+        if 'keyframe' in ann:
+            attributes['keyframe'] = ann['keyframe']
+        if 'track_id' in ann:
+            attributes['track_id'] = ann['track_id']
+
+        group = ann.get('group')
+
+        label = ann.get('label')
+        label_id = categories[AnnotationType.label].find(label)[0]
+
+        z_order = ann.get('z_order', 0)
+        points = ann.get('points', [])
+
+        if ann_type == 'polyline':
+            return PolyLine(points, label=label_id, z_order=z_order,
+                id=ann_id, attributes=attributes, group=group)
+
+        elif ann_type == 'polygon':
+            return Polygon(points, label=label_id, z_order=z_order,
+                id=ann_id, attributes=attributes, group=group)
+
+        elif ann_type == 'points':
+            return Points(points, label=label_id, z_order=z_order,
+                id=ann_id, attributes=attributes, group=group)
+
+        elif ann_type == 'box':
+            x, y = points[0], points[1]
+            w, h = points[2] - x, points[3] - y
+            return Bbox(x, y, w, h, label=label_id, z_order=z_order,
+                id=ann_id, attributes=attributes, group=group)
+
+        else:
+            raise NotImplementedError("Unknown annotation type '%s'" % ann_type)
+
+    @classmethod
+    def _parse_tag_ann(cls, ann, categories):
+        label = ann.get('label')
+        label_id = categories[AnnotationType.label].find(label)[0]
+        group = ann.get('group')
+        attributes = ann.get('attributes')
+        return Label(label_id, attributes=attributes, group=group)
+
+    def _load_items(self, parsed):
+        for frame_id, item_desc in parsed.items():
+            name = item_desc.get('name', 'frame_%06d.png' % int(frame_id))
+            image = osp.join(self._images_dir, name)
+            image_size = (item_desc.get('height'), item_desc.get('width'))
+            if all(image_size):
+                image = Image(path=image, size=tuple(map(int, image_size)))
+
+            parsed[frame_id] = DatasetItem(id=osp.splitext(name)[0],
+                subset=self._subset, image=image,
+                annotations=item_desc.get('annotations'),
+                attributes={'frame': int(frame_id)})
+        return parsed
+
+class CvatImporter(Importer):
+    @classmethod
+    def find_sources(cls, path):
+        return cls._find_sources_recursive(path, '.xml', 'cvat')

testbed/openvinotoolkit__datumaro/datumaro/plugins/datumaro_format/extractor.py

@@ -0,0 +1,152 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+import json
+import os.path as osp
+
+from datumaro.components.extractor import (SourceExtractor, DatasetItem,
+    AnnotationType, Label, RleMask, Points, Polygon, PolyLine, Bbox, Caption,
+    LabelCategories, MaskCategories, PointsCategories, Importer
+)
+from datumaro.util.image import Image
+
+from .format import DatumaroPath
+
+
+class DatumaroExtractor(SourceExtractor):
+    def __init__(self, path):
+        assert osp.isfile(path), path
+        rootpath = ''
+        if path.endswith(osp.join(DatumaroPath.ANNOTATIONS_DIR, osp.basename(path))):
+            rootpath = path.rsplit(DatumaroPath.ANNOTATIONS_DIR, maxsplit=1)[0]
+        images_dir = ''
+        if rootpath and osp.isdir(osp.join(rootpath, DatumaroPath.IMAGES_DIR)):
+            images_dir = osp.join(rootpath, DatumaroPath.IMAGES_DIR)
+        self._images_dir = images_dir
+
+        super().__init__(subset=osp.splitext(osp.basename(path))[0])
+
+        with open(path, 'r') as f:
+            parsed_anns = json.load(f)
+        self._categories = self._load_categories(parsed_anns)
+        self._items = self._load_items(parsed_anns)
+
+    @staticmethod
+    def _load_categories(parsed):
+        categories = {}
+
+        parsed_label_cat = parsed['categories'].get(AnnotationType.label.name)
+        if parsed_label_cat:
+            label_categories = LabelCategories()
+            for item in parsed_label_cat['labels']:
+                label_categories.add(item['name'], parent=item['parent'])
+
+            categories[AnnotationType.label] = label_categories
+
+        parsed_mask_cat = parsed['categories'].get(AnnotationType.mask.name)
+        if parsed_mask_cat:
+            colormap = {}
+            for item in parsed_mask_cat['colormap']:
+                colormap[int(item['label_id'])] = \
+                    (item['r'], item['g'], item['b'])
+
+            mask_categories = MaskCategories(colormap=colormap)
+            categories[AnnotationType.mask] = mask_categories
+
+        parsed_points_cat = parsed['categories'].get(AnnotationType.points.name)
+        if parsed_points_cat:
+            point_categories = PointsCategories()
+            for item in parsed_points_cat['items']:
+                point_categories.add(int(item['label_id']),
+                    item['labels'], joints=item['joints'])
+
+            categories[AnnotationType.points] = point_categories
+
+        return categories
+
+    def _load_items(self, parsed):
+        items = []
+        for item_desc in parsed['items']:
+            item_id = item_desc['id']
+
+            image = None
+            image_info = item_desc.get('image')
+            if image_info:
+                image_path = image_info.get('path') or \
+                    item_id + DatumaroPath.IMAGE_EXT
+                image_path = osp.join(self._images_dir, image_path)
+                image = Image(path=image_path, size=image_info.get('size'))
+
+            annotations = self._load_annotations(item_desc)
+
+            item = DatasetItem(id=item_id, subset=self._subset,
+                annotations=annotations, image=image,
+                attributes=item_desc.get('attr'))
+
+            items.append(item)
+
+        return items
+
+    @staticmethod
+    def _load_annotations(item):
+        parsed = item['annotations']
+        loaded = []
+
+        for ann in parsed:
+            ann_id = ann.get('id')
+            ann_type = AnnotationType[ann['type']]
+            attributes = ann.get('attributes')
+            group = ann.get('group')
+
+            label_id = ann.get('label_id')
+            z_order = ann.get('z_order')
+            points = ann.get('points')
+
+            if ann_type == AnnotationType.label:
+                loaded.append(Label(label=label_id,
+                    id=ann_id, attributes=attributes, group=group))
+
+            elif ann_type == AnnotationType.mask:
+                rle = ann['rle']
+                rle['counts'] = rle['counts'].encode('ascii')
+                loaded.append(RleMask(rle=rle, label=label_id,
+                    id=ann_id, attributes=attributes, group=group,
+                    z_order=z_order))
+
+            elif ann_type == AnnotationType.polyline:
+                loaded.append(PolyLine(points, label=label_id,
+                    id=ann_id, attributes=attributes, group=group,
+                    z_order=z_order))
+
+            elif ann_type == AnnotationType.polygon:
+                loaded.append(Polygon(points, label=label_id,
+                    id=ann_id, attributes=attributes, group=group,
+                    z_order=z_order))
+
+            elif ann_type == AnnotationType.bbox:
+                x, y, w, h = ann['bbox']
+                loaded.append(Bbox(x, y, w, h, label=label_id,
+                    id=ann_id, attributes=attributes, group=group,
+                    z_order=z_order))
+
+            elif ann_type == AnnotationType.points:
+                loaded.append(Points(points, label=label_id,
+                    id=ann_id, attributes=attributes, group=group,
+                    z_order=z_order))
+
+            elif ann_type == AnnotationType.caption:
+                caption = ann.get('caption')
+                loaded.append(Caption(caption,
+                    id=ann_id, attributes=attributes, group=group))
+
+            else:
+                raise NotImplementedError()
+
+        return loaded
+
+class DatumaroImporter(Importer):
+    @classmethod
+    def find_sources(cls, path):
+        return cls._find_sources_recursive(path, '.json', 'datumaro')

testbed/openvinotoolkit__datumaro/datumaro/plugins/tf_detection_api_format/format.py

@@ -0,0 +1,13 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+class DetectionApiPath:
+    IMAGES_DIR = 'images'
+    ANNOTATIONS_DIR = 'annotations'
+
+    DEFAULT_IMAGE_EXT = '.jpg'
+    IMAGE_EXT_FORMAT = {'.jpg': 'jpeg', '.jpeg': 'jpeg', '.png': 'png'}
+
+    LABELMAP_FILE = 'label_map.pbtxt'

testbed/openvinotoolkit__datumaro/datumaro/plugins/voc_format/extractor.py

@@ -0,0 +1,296 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+from collections import defaultdict
+import logging as log
+import numpy as np
+import os.path as osp
+from defusedxml import ElementTree
+
+from datumaro.components.extractor import (SourceExtractor, DatasetItem,
+    AnnotationType, Label, Mask, Bbox, CompiledMask
+)
+from datumaro.util import dir_items
+from datumaro.util.image import Image
+from datumaro.util.mask_tools import lazy_mask, invert_colormap
+
+from .format import (
+    VocTask, VocPath, VocInstColormap, parse_label_map, make_voc_categories
+)
+
+
+_inverse_inst_colormap = invert_colormap(VocInstColormap)
+
+class _VocExtractor(SourceExtractor):
+    def __init__(self, path):
+        assert osp.isfile(path), path
+        self._path = path
+        self._dataset_dir = osp.dirname(osp.dirname(osp.dirname(path)))
+
+        super().__init__(subset=osp.splitext(osp.basename(path))[0])
+
+        self._categories = self._load_categories(self._dataset_dir)
+
+        label_color = lambda label_idx: \
+            self._categories[AnnotationType.mask].colormap.get(label_idx, None)
+        log.debug("Loaded labels: %s" % ', '.join(
+            "'%s' %s" % (l.name, ('(%s, %s, %s)' % c) if c else '')
+            for i, l, c in ((i, l, label_color(i)) for i, l in enumerate(
+                self._categories[AnnotationType.label].items
+            ))
+        ))
+        self._items = self._load_subset_list(path)
+
+    def _get_label_id(self, label):
+        label_id, _ = self._categories[AnnotationType.label].find(label)
+        assert label_id is not None, label
+        return label_id
+
+    @staticmethod
+    def _load_categories(dataset_path):
+        label_map = None
+        label_map_path = osp.join(dataset_path, VocPath.LABELMAP_FILE)
+        if osp.isfile(label_map_path):
+            label_map = parse_label_map(label_map_path)
+        return make_voc_categories(label_map)
+
+    @staticmethod
+    def _load_subset_list(subset_path):
+        with open(subset_path) as f:
+            return [line.split()[0] for line in f]
+
+class VocClassificationExtractor(_VocExtractor):
+    def __iter__(self):
+        raw_anns = self._load_annotations()
+        for item_id in self._items:
+            log.debug("Reading item '%s'" % item_id)
+            image = osp.join(self._dataset_dir, VocPath.IMAGES_DIR,
+                item_id + VocPath.IMAGE_EXT)
+            anns = self._parse_annotations(raw_anns, item_id)
+            yield DatasetItem(id=item_id, subset=self._subset,
+                image=image, annotations=anns)
+
+    def _load_annotations(self):
+        annotations = defaultdict(list)
+        task_dir = osp.dirname(self._path)
+        anno_files = [s for s in dir_items(task_dir, '.txt')
+            if s.endswith('_' + osp.basename(self._path))]
+        for ann_filename in anno_files:
+            with open(osp.join(task_dir, ann_filename)) as f:
+                label = ann_filename[:ann_filename.rfind('_')]
+                label_id = self._get_label_id(label)
+                for line in f:
+                    item, present = line.split()
+                    if present == '1':
+                        annotations[item].append(label_id)
+
+        return dict(annotations)
+
+    @staticmethod
+    def _parse_annotations(raw_anns, item_id):
+        return [Label(label_id) for label_id in raw_anns.get(item_id, [])]
+
+class _VocXmlExtractor(_VocExtractor):
+    def __init__(self, path, task):
+        super().__init__(path)
+        self._task = task
+
+    def __iter__(self):
+        anno_dir = osp.join(self._dataset_dir, VocPath.ANNOTATIONS_DIR)
+
+        for item_id in self._items:
+            log.debug("Reading item '%s'" % item_id)
+            image = item_id + VocPath.IMAGE_EXT
+            height, width = 0, 0
+
+            anns = []
+            ann_file = osp.join(anno_dir, item_id + '.xml')
+            if osp.isfile(ann_file):
+                root_elem = ElementTree.parse(ann_file)
+                height = root_elem.find('size/height')
+                if height is not None:
+                    height = int(height.text)
+                width = root_elem.find('size/width')
+                if width is not None:
+                    width = int(width.text)
+                filename_elem = root_elem.find('filename')
+                if filename_elem is not None:
+                    image = filename_elem.text
+                anns = self._parse_annotations(root_elem)
+
+            image = osp.join(self._dataset_dir, VocPath.IMAGES_DIR, image)
+            if height and width:
+                image = Image(path=image, size=(height, width))
+
+            yield DatasetItem(id=item_id, subset=self._subset,
+                image=image, annotations=anns)
+
+    def _parse_annotations(self, root_elem):
+        item_annotations = []
+
+        for obj_id, object_elem in enumerate(root_elem.findall('object')):
+            obj_id += 1
+            attributes = {}
+            group = obj_id
+
+            obj_label_id = None
+            label_elem = object_elem.find('name')
+            if label_elem is not None:
+                obj_label_id = self._get_label_id(label_elem.text)
+
+            obj_bbox = self._parse_bbox(object_elem)
+
+            if obj_label_id is None or obj_bbox is None:
+                continue
+
+            difficult_elem = object_elem.find('difficult')
+            attributes['difficult'] = difficult_elem is not None and \
+                difficult_elem.text == '1'
+
+            truncated_elem = object_elem.find('truncated')
+            attributes['truncated'] = truncated_elem is not None and \
+                truncated_elem.text == '1'
+
+            occluded_elem = object_elem.find('occluded')
+            attributes['occluded'] = occluded_elem is not None and \
+                occluded_elem.text == '1'
+
+            pose_elem = object_elem.find('pose')
+            if pose_elem is not None:
+                attributes['pose'] = pose_elem.text
+
+            point_elem = object_elem.find('point')
+            if point_elem is not None:
+                point_x = point_elem.find('x')
+                point_y = point_elem.find('y')
+                point = [float(point_x.text), float(point_y.text)]
+                attributes['point'] = point
+
+            actions_elem = object_elem.find('actions')
+            actions = {a: False
+                for a in self._categories[AnnotationType.label] \
+                    .items[obj_label_id].attributes}
+            if actions_elem is not None:
+                for action_elem in actions_elem:
+                    actions[action_elem.tag] = (action_elem.text == '1')
+            for action, present in actions.items():
+                attributes[action] = present
+
+            has_parts = False
+            for part_elem in object_elem.findall('part'):
+                part = part_elem.find('name').text
+                part_label_id = self._get_label_id(part)
+                part_bbox = self._parse_bbox(part_elem)
+
+                if self._task is not VocTask.person_layout:
+                    break
+                if part_bbox is None:
+                    continue
+                has_parts = True
+                item_annotations.append(Bbox(*part_bbox, label=part_label_id,
+                    group=group))
+
+            attributes_elem = object_elem.find('attributes')
+            if attributes_elem is not None:
+                for attr_elem in attributes_elem.iter('attribute'):
+                    attributes[attr_elem.find('name').text] = \
+                        attr_elem.find('value').text
+
+            if self._task is VocTask.person_layout and not has_parts:
+                continue
+            if self._task is VocTask.action_classification and not actions:
+                continue
+
+            item_annotations.append(Bbox(*obj_bbox, label=obj_label_id,
+                attributes=attributes, id=obj_id, group=group))
+
+        return item_annotations
+
+    @staticmethod
+    def _parse_bbox(object_elem):
+        bbox_elem = object_elem.find('bndbox')
+        xmin = float(bbox_elem.find('xmin').text)
+        xmax = float(bbox_elem.find('xmax').text)
+        ymin = float(bbox_elem.find('ymin').text)
+        ymax = float(bbox_elem.find('ymax').text)
+        return [xmin, ymin, xmax - xmin, ymax - ymin]
+
+class VocDetectionExtractor(_VocXmlExtractor):
+    def __init__(self, path):
+        super().__init__(path, task=VocTask.detection)
+
+class VocLayoutExtractor(_VocXmlExtractor):
+    def __init__(self, path):
+        super().__init__(path, task=VocTask.person_layout)
+
+class VocActionExtractor(_VocXmlExtractor):
+    def __init__(self, path):
+        super().__init__(path, task=VocTask.action_classification)
+
+class VocSegmentationExtractor(_VocExtractor):
+    def __iter__(self):
+        for item_id in self._items:
+            log.debug("Reading item '%s'" % item_id)
+            image = osp.join(self._dataset_dir, VocPath.IMAGES_DIR,
+                item_id + VocPath.IMAGE_EXT)
+            anns = self._load_annotations(item_id)
+            yield DatasetItem(id=item_id, subset=self._subset,
+                image=image, annotations=anns)
+
+    @staticmethod
+    def _lazy_extract_mask(mask, c):
+        return lambda: mask == c
+
+    def _load_annotations(self, item_id):
+        item_annotations = []
+
+        class_mask = None
+        segm_path = osp.join(self._dataset_dir, VocPath.SEGMENTATION_DIR,
+            item_id + VocPath.SEGM_EXT)
+        if osp.isfile(segm_path):
+            inverse_cls_colormap = \
+                self._categories[AnnotationType.mask].inverse_colormap
+            class_mask = lazy_mask(segm_path, inverse_cls_colormap)
+
+        instances_mask = None
+        inst_path = osp.join(self._dataset_dir, VocPath.INSTANCES_DIR,
+            item_id + VocPath.SEGM_EXT)
+        if osp.isfile(inst_path):
+            instances_mask = lazy_mask(inst_path, _inverse_inst_colormap)
+
+        if instances_mask is not None:
+            compiled_mask = CompiledMask(class_mask, instances_mask)
+
+            if class_mask is not None:
+                label_cat = self._categories[AnnotationType.label]
+                instance_labels = compiled_mask.get_instance_labels()
+            else:
+                instance_labels = {i: None
+                    for i in range(compiled_mask.instance_count)}
+
+            for instance_id, label_id in instance_labels.items():
+                image = compiled_mask.lazy_extract(instance_id)
+
+                attributes = {}
+                if label_id is not None:
+                    actions = {a: False
+                        for a in label_cat.items[label_id].attributes
+                    }
+                    attributes.update(actions)
+
+                item_annotations.append(Mask(
+                    image=image, label=label_id,
+                    attributes=attributes, group=instance_id
+                ))
+        elif class_mask is not None:
+            log.warn("item '%s': has only class segmentation, "
+                "instance masks will not be available" % item_id)
+            class_mask = class_mask()
+            classes = np.unique(class_mask)
+            for label_id in classes:
+                image = self._lazy_extract_mask(class_mask, label_id)
+                item_annotations.append(Mask(image=image, label=label_id))
+
+        return item_annotations

testbed/openvinotoolkit__datumaro/datumaro/plugins/yolo_format/converter.py

@@ -0,0 +1,105 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+import logging as log
+import os
+import os.path as osp
+from collections import OrderedDict
+
+from datumaro.components.converter import Converter
+from datumaro.components.extractor import AnnotationType, DEFAULT_SUBSET_NAME
+
+from .format import YoloPath
+
+
+def _make_yolo_bbox(img_size, box):
+    # https://github.com/pjreddie/darknet/blob/master/scripts/voc_label.py
+    # <x> <y> <width> <height> - values relative to width and height of image
+    # <x> <y> - are center of rectangle
+    x = (box[0] + box[2]) / 2 / img_size[0]
+    y = (box[1] + box[3]) / 2 / img_size[1]
+    w = (box[2] - box[0]) / img_size[0]
+    h = (box[3] - box[1]) / img_size[1]
+    return x, y, w, h
+
+class YoloConverter(Converter):
+    # https://github.com/AlexeyAB/darknet#how-to-train-to-detect-your-custom-objects
+    DEFAULT_IMAGE_EXT = '.jpg'
+
+    def apply(self):
+        extractor = self._extractor
+        save_dir = self._save_dir
+
+        os.makedirs(save_dir, exist_ok=True)
+
+        label_categories = extractor.categories()[AnnotationType.label]
+        label_ids = {label.name: idx
+            for idx, label in enumerate(label_categories.items)}
+        with open(osp.join(save_dir, 'obj.names'), 'w') as f:
+            f.writelines('%s\n' % l[0]
+                for l in sorted(label_ids.items(), key=lambda x: x[1]))
+
+        subset_lists = OrderedDict()
+
+        for subset_name, subset in self._extractor.subsets().items():
+            if not subset_name or subset_name == DEFAULT_SUBSET_NAME:
+                subset_name = YoloPath.DEFAULT_SUBSET_NAME
+            elif subset_name not in YoloPath.SUBSET_NAMES:
+                log.warn("Skipping subset export '%s'. "
+                    "If specified, the only valid names are %s" % \
+                    (subset_name, ', '.join(
+                        "'%s'" % s for s in YoloPath.SUBSET_NAMES)))
+                continue
+
+            subset_dir = osp.join(save_dir, 'obj_%s_data' % subset_name)
+            os.makedirs(subset_dir, exist_ok=True)
+
+            image_paths = OrderedDict()
+
+            for item in subset:
+                if not item.has_image:
+                    raise Exception("Failed to export item '%s': "
+                        "item has no image info" % item.id)
+                height, width = item.image.size
+
+                image_name = self._make_image_filename(item)
+                if self._save_images:
+                    if item.has_image and item.image.has_data:
+                        self._save_image(item, osp.join(subset_dir, image_name))
+                    else:
+                        log.warning("Item '%s' has no image" % item.id)
+                image_paths[item.id] = osp.join('data',
+                    osp.basename(subset_dir), image_name)
+
+                yolo_annotation = ''
+                for bbox in item.annotations:
+                    if bbox.type is not AnnotationType.bbox:
+                        continue
+                    if bbox.label is None:
+                        continue
+
+                    yolo_bb = _make_yolo_bbox((width, height), bbox.points)
+                    yolo_bb = ' '.join('%.6f' % p for p in yolo_bb)
+                    yolo_annotation += '%s %s\n' % (bbox.label, yolo_bb)
+
+                annotation_path = osp.join(subset_dir, '%s.txt' % item.id)
+                os.makedirs(osp.dirname(annotation_path), exist_ok=True)
+                with open(annotation_path, 'w') as f:
+                    f.write(yolo_annotation)
+
+            subset_list_name = '%s.txt' % subset_name
+            subset_lists[subset_name] = subset_list_name
+            with open(osp.join(save_dir, subset_list_name), 'w') as f:
+                f.writelines('%s\n' % s for s in image_paths.values())
+
+        with open(osp.join(save_dir, 'obj.data'), 'w') as f:
+            f.write('classes = %s\n' % len(label_ids))
+
+            for subset_name, subset_list_name in subset_lists.items():
+                f.write('%s = %s\n' % (subset_name,
+                    osp.join('data', subset_list_name)))
+
+            f.write('names = %s\n' % osp.join('data', 'obj.names'))
+            f.write('backup = backup/\n')

testbed/openvinotoolkit__datumaro/tests/test_project.py

@@ -0,0 +1,578 @@
+import numpy as np
+import os
+import os.path as osp
+
+from unittest import TestCase
+
+from datumaro.components.project import Project, Environment, Dataset
+from datumaro.components.config_model import Source, Model
+from datumaro.components.launcher import Launcher, ModelTransform
+from datumaro.components.extractor import (Extractor, DatasetItem,
+    Label, Mask, Points, Polygon, PolyLine, Bbox, Caption,
+    LabelCategories, AnnotationType
+)
+from datumaro.util.image import Image
+from datumaro.components.config import Config, DefaultConfig, SchemaBuilder
+from datumaro.components.dataset_filter import \
+    XPathDatasetFilter, XPathAnnotationsFilter, DatasetItemEncoder
+from datumaro.util.test_utils import TestDir, compare_datasets
+
+
+class ProjectTest(TestCase):
+    def test_project_generate(self):
+        src_config = Config({
+            'project_name': 'test_project',
+            'format_version': 1,
+        })
+
+        with TestDir() as test_dir:
+            project_path = test_dir
+            Project.generate(project_path, src_config)
+
+            self.assertTrue(osp.isdir(project_path))
+
+            result_config = Project.load(project_path).config
+            self.assertEqual(
+                src_config.project_name, result_config.project_name)
+            self.assertEqual(
+                src_config.format_version, result_config.format_version)
+
+    @staticmethod
+    def test_default_ctor_is_ok():
+        Project()
+
+    @staticmethod
+    def test_empty_config_is_ok():
+        Project(Config())
+
+    def test_add_source(self):
+        source_name = 'source'
+        origin = Source({
+            'url': 'path',
+            'format': 'ext'
+        })
+        project = Project()
+
+        project.add_source(source_name, origin)
+
+        added = project.get_source(source_name)
+        self.assertIsNotNone(added)
+        self.assertEqual(added, origin)
+
+    def test_added_source_can_be_saved(self):
+        source_name = 'source'
+        origin = Source({
+            'url': 'path',
+        })
+        project = Project()
+        project.add_source(source_name, origin)
+
+        saved = project.config
+
+        self.assertEqual(origin, saved.sources[source_name])
+
+    def test_added_source_can_be_dumped(self):
+        source_name = 'source'
+        origin = Source({
+            'url': 'path',
+        })
+        project = Project()
+        project.add_source(source_name, origin)
+
+        with TestDir() as test_dir:
+            project.save(test_dir)
+
+            loaded = Project.load(test_dir)
+            loaded = loaded.get_source(source_name)
+            self.assertEqual(origin, loaded)
+
+    def test_can_import_with_custom_importer(self):
+        class TestImporter:
+            def __call__(self, path, subset=None):
+                return Project({
+                    'project_filename': path,
+                    'subsets': [ subset ]
+                })
+
+        path = 'path'
+        importer_name = 'test_importer'
+
+        env = Environment()
+        env.importers.register(importer_name, TestImporter)
+
+        project = Project.import_from(path, importer_name, env,
+            subset='train')
+
+        self.assertEqual(path, project.config.project_filename)
+        self.assertListEqual(['train'], project.config.subsets)
+
+    def test_can_dump_added_model(self):
+        model_name = 'model'
+
+        project = Project()
+        saved = Model({ 'launcher': 'name' })
+        project.add_model(model_name, saved)
+
+        with TestDir() as test_dir:
+            project.save(test_dir)
+
+            loaded = Project.load(test_dir)
+            loaded = loaded.get_model(model_name)
+            self.assertEqual(saved, loaded)
+
+    def test_can_have_project_source(self):
+        with TestDir() as test_dir:
+            Project.generate(test_dir)
+
+            project2 = Project()
+            project2.add_source('project1', {
+                'url': test_dir,
+            })
+            dataset = project2.make_dataset()
+
+            self.assertTrue('project1' in dataset.sources)
+
+    def test_can_batch_launch_custom_model(self):
+        dataset = Dataset.from_iterable([
+            DatasetItem(id=i, subset='train', image=np.array([i]))
+            for i in range(5)
+        ], categories=['label'])
+
+        class TestLauncher(Launcher):
+            def launch(self, inputs):
+                for i, inp in enumerate(inputs):
+                    yield [ Label(0, attributes={'idx': i, 'data': inp.item()}) ]
+
+        model_name = 'model'
+        launcher_name = 'custom_launcher'
+
+        project = Project()
+        project.env.launchers.register(launcher_name, TestLauncher)
+        project.add_model(model_name, { 'launcher': launcher_name })
+        model = project.make_executable_model(model_name)
+
+        batch_size = 3
+        executor = ModelTransform(dataset, model, batch_size=batch_size)
+
+        for item in executor:
+            self.assertEqual(1, len(item.annotations))
+            self.assertEqual(int(item.id) % batch_size,
+                item.annotations[0].attributes['idx'])
+            self.assertEqual(int(item.id),
+                item.annotations[0].attributes['data'])
+
+    def test_can_do_transform_with_custom_model(self):
+        class TestExtractorSrc(Extractor):
+            def __iter__(self):
+                for i in range(2):
+                    yield DatasetItem(id=i, image=np.ones([2, 2, 3]) * i,
+                        annotations=[Label(i)])
+
+            def categories(self):
+                label_cat = LabelCategories()
+                label_cat.add('0')
+                label_cat.add('1')
+                return { AnnotationType.label: label_cat }
+
+        class TestLauncher(Launcher):
+            def launch(self, inputs):
+                for inp in inputs:
+                    yield [ Label(inp[0, 0, 0]) ]
+
+        class TestExtractorDst(Extractor):
+            def __init__(self, url):
+                super().__init__()
+                self.items = [osp.join(url, p) for p in sorted(os.listdir(url))]
+
+            def __iter__(self):
+                for path in self.items:
+                    with open(path, 'r') as f:
+                        index = osp.splitext(osp.basename(path))[0]
+                        label = int(f.readline().strip())
+                        yield DatasetItem(id=index, annotations=[Label(label)])
+
+        model_name = 'model'
+        launcher_name = 'custom_launcher'
+        extractor_name = 'custom_extractor'
+
+        project = Project()
+        project.env.launchers.register(launcher_name, TestLauncher)
+        project.env.extractors.register(extractor_name, TestExtractorSrc)
+        project.add_model(model_name, { 'launcher': launcher_name })
+        project.add_source('source', { 'format': extractor_name })
+
+        with TestDir() as test_dir:
+            project.make_dataset().apply_model(model=model_name,
+                save_dir=test_dir)
+
+            result = Project.load(test_dir)
+            result.env.extractors.register(extractor_name, TestExtractorDst)
+            it = iter(result.make_dataset())
+            item1 = next(it)
+            item2 = next(it)
+            self.assertEqual(0, item1.annotations[0].label)
+            self.assertEqual(1, item2.annotations[0].label)
+
+    def test_source_datasets_can_be_merged(self):
+        class TestExtractor(Extractor):
+            def __init__(self, url, n=0, s=0):
+                super().__init__(length=n)
+                self.n = n
+                self.s = s
+
+            def __iter__(self):
+                for i in range(self.n):
+                    yield DatasetItem(id=self.s + i, subset='train')
+
+        e_name1 = 'e1'
+        e_name2 = 'e2'
+        n1 = 2
+        n2 = 4
+
+        project = Project()
+        project.env.extractors.register(e_name1, lambda p: TestExtractor(p, n=n1))
+        project.env.extractors.register(e_name2, lambda p: TestExtractor(p, n=n2, s=n1))
+        project.add_source('source1', { 'format': e_name1 })
+        project.add_source('source2', { 'format': e_name2 })
+
+        dataset = project.make_dataset()
+
+        self.assertEqual(n1 + n2, len(dataset))
+
+    def test_cant_merge_different_categories(self):
+        class TestExtractor1(Extractor):
+            def __iter__(self):
+                return iter([])
+
+            def categories(self):
+                return { AnnotationType.label:
+                    LabelCategories.from_iterable(['a', 'b']) }
+
+        class TestExtractor2(Extractor):
+            def __iter__(self):
+                return iter([])
+
+            def categories(self):
+                return { AnnotationType.label:
+                    LabelCategories.from_iterable(['b', 'a']) }
+
+        e_name1 = 'e1'
+        e_name2 = 'e2'
+
+        project = Project()
+        project.env.extractors.register(e_name1, TestExtractor1)
+        project.env.extractors.register(e_name2, TestExtractor2)
+        project.add_source('source1', { 'format': e_name1 })
+        project.add_source('source2', { 'format': e_name2 })
+
+        with self.assertRaisesRegex(Exception, "different categories"):
+            project.make_dataset()
+
+    def test_project_filter_can_be_applied(self):
+        class TestExtractor(Extractor):
+            def __iter__(self):
+                for i in range(10):
+                    yield DatasetItem(id=i, subset='train')
+
+        e_type = 'type'
+        project = Project()
+        project.env.extractors.register(e_type, TestExtractor)
+        project.add_source('source', { 'format': e_type })
+
+        dataset = project.make_dataset().filter('/item[id < 5]')
+
+        self.assertEqual(5, len(dataset))
+
+    def test_can_save_and_load_own_dataset(self):
+        with TestDir() as test_dir:
+            src_project = Project()
+            src_dataset = src_project.make_dataset()
+            item = DatasetItem(id=1)
+            src_dataset.put(item)
+            src_dataset.save(test_dir)
+
+            loaded_project = Project.load(test_dir)
+            loaded_dataset = loaded_project.make_dataset()
+
+            self.assertEqual(list(src_dataset), list(loaded_dataset))
+
+    def test_project_own_dataset_can_be_modified(self):
+        project = Project()
+        dataset = project.make_dataset()
+
+        item = DatasetItem(id=1)
+        dataset.put(item)
+
+        self.assertEqual(item, next(iter(dataset)))
+
+    def test_project_compound_child_can_be_modified_recursively(self):
+        with TestDir() as test_dir:
+            child1 = Project({
+                'project_dir': osp.join(test_dir, 'child1'),
+            })
+            child1.save()
+
+            child2 = Project({
+                'project_dir': osp.join(test_dir, 'child2'),
+            })
+            child2.save()
+
+            parent = Project()
+            parent.add_source('child1', {
+                'url': child1.config.project_dir
+            })
+            parent.add_source('child2', {
+                'url': child2.config.project_dir
+            })
+            dataset = parent.make_dataset()
+
+            item1 = DatasetItem(id='ch1', path=['child1'])
+            item2 = DatasetItem(id='ch2', path=['child2'])
+            dataset.put(item1)
+            dataset.put(item2)
+
+            self.assertEqual(2, len(dataset))
+            self.assertEqual(1, len(dataset.sources['child1']))
+            self.assertEqual(1, len(dataset.sources['child2']))
+
+    def test_project_can_merge_item_annotations(self):
+        class TestExtractor1(Extractor):
+            def __iter__(self):
+                yield DatasetItem(id=1, subset='train', annotations=[
+                    Label(2, id=3),
+                    Label(3, attributes={ 'x': 1 }),
+                ])
+
+        class TestExtractor2(Extractor):
+            def __iter__(self):
+                yield DatasetItem(id=1, subset='train', annotations=[
+                    Label(3, attributes={ 'x': 1 }),
+                    Label(4, id=4),
+                ])
+
+        project = Project()
+        project.env.extractors.register('t1', TestExtractor1)
+        project.env.extractors.register('t2', TestExtractor2)
+        project.add_source('source1', { 'format': 't1' })
+        project.add_source('source2', { 'format': 't2' })
+
+        merged = project.make_dataset()
+
+        self.assertEqual(1, len(merged))
+
+        item = next(iter(merged))
+        self.assertEqual(3, len(item.annotations))
+
+class DatasetFilterTest(TestCase):
+    @staticmethod
+    def test_item_representations():
+        item = DatasetItem(id=1, subset='subset', path=['a', 'b'],
+            image=np.ones((5, 4, 3)),
+            annotations=[
+                Label(0, attributes={'a1': 1, 'a2': '2'}, id=1, group=2),
+                Caption('hello', id=1),
+                Caption('world', group=5),
+                Label(2, id=3, attributes={ 'x': 1, 'y': '2' }),
+                Bbox(1, 2, 3, 4, label=4, id=4, attributes={ 'a': 1.0 }),
+                Bbox(5, 6, 7, 8, id=5, group=5),
+                Points([1, 2, 2, 0, 1, 1], label=0, id=5),
+                Mask(id=5, image=np.ones((3, 2))),
+                Mask(label=3, id=5, image=np.ones((2, 3))),
+                PolyLine([1, 2, 3, 4, 5, 6, 7, 8], id=11),
+                Polygon([1, 2, 3, 4, 5, 6, 7, 8]),
+            ]
+        )
+
+        encoded = DatasetItemEncoder.encode(item)
+        DatasetItemEncoder.to_string(encoded)
+
+    def test_item_filter_can_be_applied(self):
+        class TestExtractor(Extractor):
+            def __iter__(self):
+                for i in range(4):
+                    yield DatasetItem(id=i, subset='train')
+
+        extractor = TestExtractor()
+
+        filtered = XPathDatasetFilter(extractor, '/item[id > 1]')
+
+        self.assertEqual(2, len(filtered))
+
+    def test_annotations_filter_can_be_applied(self):
+        class SrcExtractor(Extractor):
+            def __iter__(self):
+                return iter([
+                    DatasetItem(id=0),
+                    DatasetItem(id=1, annotations=[
+                        Label(0),
+                        Label(1),
+                    ]),
+                    DatasetItem(id=2, annotations=[
+                        Label(0),
+                        Label(2),
+                    ]),
+                ])
+
+        class DstExtractor(Extractor):
+            def __iter__(self):
+                return iter([
+                    DatasetItem(id=0),
+                    DatasetItem(id=1, annotations=[
+                        Label(0),
+                    ]),
+                    DatasetItem(id=2, annotations=[
+                        Label(0),
+                    ]),
+                ])
+
+        extractor = SrcExtractor()
+
+        filtered = XPathAnnotationsFilter(extractor,
+            '/item/annotation[label_id = 0]')
+
+        self.assertListEqual(list(filtered), list(DstExtractor()))
+
+    def test_annotations_filter_can_remove_empty_items(self):
+        class SrcExtractor(Extractor):
+            def __iter__(self):
+                return iter([
+                    DatasetItem(id=0),
+                    DatasetItem(id=1, annotations=[
+                        Label(0),
+                        Label(1),
+                    ]),
+                    DatasetItem(id=2, annotations=[
+                        Label(0),
+                        Label(2),
+                    ]),
+                ])
+
+        class DstExtractor(Extractor):
+            def __iter__(self):
+                return iter([
+                    DatasetItem(id=2, annotations=[
+                        Label(2),
+                    ]),
+                ])
+
+        extractor = SrcExtractor()
+
+        filtered = XPathAnnotationsFilter(extractor,
+            '/item/annotation[label_id = 2]', remove_empty=True)
+
+        self.assertListEqual(list(filtered), list(DstExtractor()))
+
+class ConfigTest(TestCase):
+    def test_can_produce_multilayer_config_from_dict(self):
+        schema_low = SchemaBuilder() \
+            .add('options', dict) \
+            .build()
+        schema_mid = SchemaBuilder() \
+            .add('desc', lambda: Config(schema=schema_low)) \
+            .build()
+        schema_top = SchemaBuilder() \
+            .add('container', lambda: DefaultConfig(
+                lambda v: Config(v, schema=schema_mid))) \
+            .build()
+
+        value = 1
+        source = Config({
+            'container': {
+                'elem': {
+                    'desc': {
+                        'options': {
+                            'k': value
+                        }
+                    }
+                }
+            }
+        }, schema=schema_top)
+
+        self.assertEqual(value, source.container['elem'].desc.options['k'])
+
+class ExtractorTest(TestCase):
+    def test_custom_extractor_can_be_created(self):
+        class CustomExtractor(Extractor):
+            def __iter__(self):
+                return iter([
+                    DatasetItem(id=0, subset='train'),
+                    DatasetItem(id=1, subset='train'),
+                    DatasetItem(id=2, subset='train'),
+
+                    DatasetItem(id=3, subset='test'),
+                    DatasetItem(id=4, subset='test'),
+
+                    DatasetItem(id=1),
+                    DatasetItem(id=2),
+                    DatasetItem(id=3),
+                ])
+
+        extractor_name = 'ext1'
+        project = Project()
+        project.env.extractors.register(extractor_name, CustomExtractor)
+        project.add_source('src1', {
+            'url': 'path',
+            'format': extractor_name,
+        })
+
+        dataset = project.make_dataset()
+
+        compare_datasets(self, CustomExtractor(), dataset)
+
+class DatasetTest(TestCase):
+    def test_create_from_extractors(self):
+        class SrcExtractor1(Extractor):
+            def __iter__(self):
+                return iter([
+                    DatasetItem(id=1, subset='train', annotations=[
+                        Bbox(1, 2, 3, 4),
+                        Label(4),
+                    ]),
+                    DatasetItem(id=1, subset='val', annotations=[
+                        Label(4),
+                    ]),
+                ])
+
+        class SrcExtractor2(Extractor):
+            def __iter__(self):
+                return iter([
+                    DatasetItem(id=1, subset='val', annotations=[
+                        Label(5),
+                    ]),
+                ])
+
+        class DstExtractor(Extractor):
+            def __iter__(self):
+                return iter([
+                    DatasetItem(id=1, subset='train', annotations=[
+                        Bbox(1, 2, 3, 4),
+                        Label(4),
+                    ]),
+                    DatasetItem(id=1, subset='val', annotations=[
+                        Label(4),
+                        Label(5),
+                    ]),
+                ])
+
+        dataset = Dataset.from_extractors(SrcExtractor1(), SrcExtractor2())
+
+        compare_datasets(self, DstExtractor(), dataset)
+
+
+class DatasetItemTest(TestCase):
+    def test_ctor_requires_id(self):
+        with self.assertRaises(Exception):
+            # pylint: disable=no-value-for-parameter
+            DatasetItem()
+            # pylint: enable=no-value-for-parameter
+
+    @staticmethod
+    def test_ctors_with_image():
+        for args in [
+            { 'id': 0, 'image': None },
+            { 'id': 0, 'image': 'path.jpg' },
+            { 'id': 0, 'image': np.array([1, 2, 3]) },
+            { 'id': 0, 'image': lambda f: np.array([1, 2, 3]) },
+            { 'id': 0, 'image': Image(data=np.array([1, 2, 3])) },
+        ]:
+            DatasetItem(**args)