Add files using upload-large-folder tool

testbed/openvinotoolkit__datumaro/.bandit

@@ -0,0 +1,8 @@
+[bandit]
+# B101 : assert_used
+# B102 : exec_used
+# B320 : xml_bad_etree
+# B404 : import_subprocess
+# B406 : import_xml_sax
+# B410 : import_lxml
+skips: B101,B102,B320,B404,B406,B410

testbed/openvinotoolkit__datumaro/.coveragerc

@@ -0,0 +1,34 @@
+[run]
+branch = true
+# relative_files = true # does not work?
+
+source =
+    datumaro/
+
+omit =
+    datumaro/__main__.py
+    datumaro/version.py
+    tests/*
+
+[report]
+# Regexes for lines to exclude from consideration
+exclude_lines =
+    # Have to re-enable the standard pragma
+    pragma: no cover
+
+    # Don't complain about missing debug-only code:
+    def __repr__
+    if\s+[\w\.()]+\.isEnabledFor\(log\.DEBUG\):
+
+    # Don't complain if tests don't hit defensive assertion code:
+    raise AssertionError
+    raise NotImplementedError
+
+    # Don't complain if non-runnable code isn't run:
+    if 0:
+    if __name__ == .__main__.:
+
+# don't fail on the code that can be found
+ignore_errors = true
+
+skip_empty = true

testbed/openvinotoolkit__datumaro/.gitattributes

@@ -0,0 +1,29 @@
+*               text=auto whitespace=trailing-space,space-before-tab,-indent-with-non-tab,tab-in-indent,tabwidth=4
+
+.git*           text export-ignore
+
+*.txt           text
+*.htm           text
+*.html          text
+*.js            text
+*.py            text
+*.css           text
+*.md            text
+*.yml           text
+Dockerfile      text
+LICENSE         text
+*.conf          text
+*.mimetypes     text
+*.sh            text eol=lf
+
+*.avi           binary
+*.bmp           binary
+*.exr           binary
+*.ico           binary
+*.jpeg          binary
+*.jpg           binary
+*.png           binary
+*.gif           binary
+*.ttf           binary
+*.pdf           binary
+

testbed/openvinotoolkit__datumaro/.gitignore

@@ -0,0 +1,57 @@
+.DS_Store
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Sphinx documentation
+docs/_build/

testbed/openvinotoolkit__datumaro/.pylintrc

@@ -0,0 +1,420 @@
+[MASTER]
+
+# Specify a configuration file.
+#rcfile=
+
+# Python code to execute, usually for sys.path manipulation such as
+# pygtk.require().
+#init-hook=
+
+# Add files or directories to the blacklist. They should be base names, not
+# paths.
+ignore=CVS
+
+# Add files or directories matching the regex patterns to the blacklist. The
+# regex matches against base names, not paths.
+ignore-patterns=
+
+# Pickle collected data for later comparisons.
+persistent=yes
+
+# List of plugins (as comma separated values of python modules names) to load,
+# usually to register additional checkers.
+load-plugins=
+
+# Use multiple processes to speed up Pylint.
+jobs=1
+
+# Allow loading of arbitrary C extensions. Extensions are imported into the
+# active Python interpreter and may run arbitrary code.
+unsafe-load-any-extension=no
+
+# A comma-separated list of package or module names from where C extensions may
+# be loaded. Extensions are loading into the active Python interpreter and may
+# run arbitrary code
+extension-pkg-whitelist=
+
+# Allow optimization of some AST trees. This will activate a peephole AST
+# optimizer, which will apply various small optimizations. For instance, it can
+# be used to obtain the result of joining multiple strings with the addition
+# operator. Joining a lot of strings can lead to a maximum recursion error in
+# Pylint and this flag can prevent that. It has one side effect, the resulting
+# AST will be different than the one from reality. This option is deprecated
+# and it will be removed in Pylint 2.0.
+optimize-ast=no
+
+
+[MESSAGES CONTROL]
+
+# Only show warnings with the listed confidence levels. Leave empty to show
+# all. Valid levels: HIGH, INFERENCE, INFERENCE_FAILURE, UNDEFINED
+confidence=
+
+# Enable the message, report, category or checker with the given id(s). You can
+# either give multiple identifier separated by comma (,) or put this option
+# multiple time (only on the command line, not in the configuration file where
+# it should appear only once). See also the "--disable" option for examples.
+disable=all
+enable= E0001,E0100,E0101,E0102,E0103,E0104,E0105,E0106,E0107,E0110,
+        E0113,E0114,E0115,E0116,E0117,E0108,E0202,E0203,E0211,E0236,
+        E0238,E0239,E0240,E0241,E0301,E0302,E0601,E0603,E0604,E0701,
+        E0702,E0703,E0704,E0710,E0711,E0712,E1003,E1102,E1111,E0112,
+        E1120,E1121,E1123,E1124,E1125,E1126,E1127,E1132,E1200,E1201,
+        E1205,E1206,E1300,E1301,E1302,E1303,E1304,E1305,E1306,
+        C0123,C0200,C0303,C1001,
+        W0101,W0102,W0104,W0105,W0106,W0107,W0108,W0109,W0110,W0120,
+        W0122,W0124,W0150,W0199,W0221,W0222,W0233,W0404,W0410,W0601,
+        W0602,W0604,W0611,W0612,W0622,W0623,W0702,W0705,W0711,W1300,
+        W1301,W1302,W1303,,W1305,W1306,W1307
+        R0102,R0202,R0203
+
+
+# Disable the message, report, category or checker with the given id(s). You
+# can either give multiple identifiers separated by comma (,) or put this
+# option multiple times (only on the command line, not in the configuration
+# file where it should appear only once).You can also use "--disable=all" to
+# disable everything first and then reenable specific checks. For example, if
+# you want to run only the similarities checker, you can use "--disable=all
+# --enable=similarities". If you want to run only the classes checker, but have
+# no Warning level messages displayed, use"--disable=all --enable=classes
+# --disable=W"
+#disable=old-octal-literal,basestring-builtin,no-absolute-import,old-division,coerce-method,long-suffix,reload-builtin,unichr-builtin,indexing-exception,raising-string,dict-iter-method,metaclass-assignment,filter-builtin-not-iterating,import-star-module-level,next-method-called,cmp-method,raw_input-builtin,old-raise-syntax,cmp-builtin,apply-builtin,getslice-method,input-builtin,backtick,coerce-builtin,range-builtin-not-iterating,xrange-builtin,using-cmp-argument,buffer-builtin,hex-method,execfile-builtin,unpacking-in-except,standarderror-builtin,round-builtin,nonzero-method,unicode-builtin,reduce-builtin,file-builtin,dict-view-method,old-ne-operator,print-statement,suppressed-message,oct-method,useless-suppression,delslice-method,long-builtin,setslice-method,zip-builtin-not-iterating,map-builtin-not-iterating,intern-builtin,parameter-unpacking
+
+
+[REPORTS]
+
+# Set the output format. Available formats are text, parseable, colorized, msvs
+# (visual studio) and html. You can also give a reporter class, eg
+# mypackage.mymodule.MyReporterClass.
+output-format=text
+
+# Put messages in a separate file for each module / package specified on the
+# command line instead of printing them on stdout. Reports (if any) will be
+# written in a file name "pylint_global.[txt|html]". This option is deprecated
+# and it will be removed in Pylint 2.0.
+files-output=no
+
+# Tells whether to display a full report or only the messages
+reports=yes
+
+# Python expression which should return a note less than 10 (10 is the highest
+# note). You have access to the variables errors warning, statement which
+# respectively contain the number of errors / warnings messages and the total
+# number of statements analyzed. This is used by the global evaluation report
+# (RP0004).
+evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)
+
+# Template used to display messages. This is a python new-style format string
+# used to format the message information. See doc for all details
+#msg-template=
+
+
+[BASIC]
+
+# Good variable names which should always be accepted, separated by a comma
+good-names=i,j,k,ex,Run,_
+
+# Bad variable names which should always be refused, separated by a comma
+bad-names=foo,bar,baz,toto,tutu,tata
+
+# Colon-delimited sets of names that determine each other's naming style when
+# the name regexes allow several styles.
+name-group=
+
+# Include a hint for the correct naming format with invalid-name
+include-naming-hint=no
+
+# List of decorators that produce properties, such as abc.abstractproperty. Add
+# to this list to register other decorators that produce valid properties.
+property-classes=abc.abstractproperty
+
+# Regular expression matching correct constant names
+const-rgx=(([A-Z_][A-Z0-9_]*)|(__.*__))$
+
+# Naming hint for constant names
+const-name-hint=(([A-Z_][A-Z0-9_]*)|(__.*__))$
+
+# Regular expression matching correct class names
+class-rgx=[A-Z_][a-zA-Z0-9]+$
+
+# Naming hint for class names
+class-name-hint=[A-Z_][a-zA-Z0-9]+$
+
+# Regular expression matching correct argument names
+argument-rgx=[a-z_][a-z0-9_]{2,30}$
+
+# Naming hint for argument names
+argument-name-hint=[a-z_][a-z0-9_]{2,30}$
+
+# Regular expression matching correct variable names
+variable-rgx=[a-z_][a-z0-9_]{2,30}$
+
+# Naming hint for variable names
+variable-name-hint=[a-z_][a-z0-9_]{2,30}$
+
+# Regular expression matching correct class attribute names
+class-attribute-rgx=([A-Za-z_][A-Za-z0-9_]{2,30}|(__.*__))$
+
+# Naming hint for class attribute names
+class-attribute-name-hint=([A-Za-z_][A-Za-z0-9_]{2,30}|(__.*__))$
+
+# Regular expression matching correct method names
+method-rgx=[a-z_][a-z0-9_]{2,30}$
+
+# Naming hint for method names
+method-name-hint=[a-z_][a-z0-9_]{2,30}$
+
+# Regular expression matching correct module names
+module-rgx=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$
+
+# Naming hint for module names
+module-name-hint=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$
+
+# Regular expression matching correct function names
+function-rgx=[a-z_][a-z0-9_]{2,30}$
+
+# Naming hint for function names
+function-name-hint=[a-z_][a-z0-9_]{2,30}$
+
+# Regular expression matching correct attribute names
+attr-rgx=[a-z_][a-z0-9_]{2,30}$
+
+# Naming hint for attribute names
+attr-name-hint=[a-z_][a-z0-9_]{2,30}$
+
+# Regular expression matching correct inline iteration names
+inlinevar-rgx=[A-Za-z_][A-Za-z0-9_]*$
+
+# Naming hint for inline iteration names
+inlinevar-name-hint=[A-Za-z_][A-Za-z0-9_]*$
+
+# Regular expression which should only match function or class names that do
+# not require a docstring.
+no-docstring-rgx=^_
+
+# Minimum line length for functions/classes that require docstrings, shorter
+# ones are exempt.
+docstring-min-length=-1
+
+
+[ELIF]
+
+# Maximum number of nested blocks for function / method body
+max-nested-blocks=5
+
+
+[FORMAT]
+
+# Maximum number of characters on a single line.
+max-line-length=80
+
+# Regexp for a line that is allowed to be longer than the limit.
+ignore-long-lines=^\s*(# )?<?https?://\S+>?$
+
+# Allow the body of an if to be on the same line as the test if there is no
+# else.
+single-line-if-stmt=no
+
+# List of optional constructs for which whitespace checking is disabled. `dict-
+# separator` is used to allow tabulation in dicts, etc.: {1  : 1,\n222: 2}.
+# `trailing-comma` allows a space between comma and closing bracket: (a, ).
+# `empty-line` allows space-only lines.
+no-space-check=trailing-comma,dict-separator
+
+# Maximum number of lines in a module
+max-module-lines=1000
+
+# String used as indentation unit. This is usually "    " (4 spaces) or "\t" (1
+# tab).
+indent-string='    '
+
+# Number of spaces of indent required inside a hanging  or continued line.
+indent-after-paren=4
+
+# Expected format of line ending, e.g. empty (any line ending), LF or CRLF.
+expected-line-ending-format=
+
+
+[LOGGING]
+
+# Logging modules to check that the string format arguments are in logging
+# function parameter format
+logging-modules=logging
+
+
+[MISCELLANEOUS]
+
+# List of note tags to take in consideration, separated by a comma.
+notes=FIXME,XXX,TODO
+
+
+[SIMILARITIES]
+
+# Minimum lines number of a similarity.
+min-similarity-lines=4
+
+# Ignore comments when computing similarities.
+ignore-comments=yes
+
+# Ignore docstrings when computing similarities.
+ignore-docstrings=yes
+
+# Ignore imports when computing similarities.
+ignore-imports=no
+
+
+[SPELLING]
+
+# Spelling dictionary name. Available dictionaries: none. To make it working
+# install python-enchant package.
+spelling-dict=
+
+# List of comma separated words that should not be checked.
+spelling-ignore-words=
+
+# A path to a file that contains private dictionary; one word per line.
+spelling-private-dict-file=
+
+# Tells whether to store unknown words to indicated private dictionary in
+# --spelling-private-dict-file option instead of raising a message.
+spelling-store-unknown-words=no
+
+
+[TYPECHECK]
+
+# Tells whether missing members accessed in mixin class should be ignored. A
+# mixin class is detected if its name ends with "mixin" (case insensitive).
+ignore-mixin-members=yes
+
+# List of module names for which member attributes should not be checked
+# (useful for modules/projects where namespaces are manipulated during runtime
+# and thus existing member attributes cannot be deduced by static analysis. It
+# supports qualified module names, as well as Unix pattern matching.
+ignored-modules=
+
+# List of class names for which member attributes should not be checked (useful
+# for classes with dynamically set attributes). This supports the use of
+# qualified names.
+ignored-classes=optparse.Values,thread._local,_thread._local
+
+# List of members which are set dynamically and missed by pylint inference
+# system, and so shouldn't trigger E1101 when accessed. Python regular
+# expressions are accepted.
+generated-members=
+
+# List of decorators that produce context managers, such as
+# contextlib.contextmanager. Add to this list to register other decorators that
+# produce valid context managers.
+contextmanager-decorators=contextlib.contextmanager
+
+
+[VARIABLES]
+
+# Tells whether we should check for unused import in __init__ files.
+init-import=no
+
+# A regular expression matching the name of dummy variables (i.e. expectedly
+# not used).
+dummy-variables-rgx=(_+[a-zA-Z0-9]*?$)|dummy
+
+# List of additional names supposed to be defined in builtins. Remember that
+# you should avoid to define new builtins when possible.
+additional-builtins=
+
+# List of strings which can identify a callback function by name. A callback
+# name must start or end with one of those strings.
+callbacks=cb_,_cb
+
+# List of qualified module names which can have objects that can redefine
+# builtins.
+redefining-builtins-modules=six.moves,future.builtins
+
+
+[CLASSES]
+
+# List of method names used to declare (i.e. assign) instance attributes.
+defining-attr-methods=__init__,__new__,setUp
+
+# List of valid names for the first argument in a class method.
+valid-classmethod-first-arg=cls
+
+# List of valid names for the first argument in a metaclass class method.
+valid-metaclass-classmethod-first-arg=mcs
+
+# List of member names, which should be excluded from the protected access
+# warning.
+exclude-protected=_asdict,_fields,_replace,_source,_make
+
+
+[DESIGN]
+
+# Maximum number of arguments for function / method
+max-args=5
+
+# Argument names that match this expression will be ignored. Default to name
+# with leading underscore
+ignored-argument-names=_.*
+
+# Maximum number of locals for function / method body
+max-locals=15
+
+# Maximum number of return / yield for function / method body
+max-returns=6
+
+# Maximum number of branch for function / method body
+max-branches=12
+
+# Maximum number of statements in function / method body
+max-statements=50
+
+# Maximum number of parents for a class (see R0901).
+max-parents=7
+
+# Maximum number of attributes for a class (see R0902).
+max-attributes=7
+
+# Minimum number of public methods for a class (see R0903).
+min-public-methods=2
+
+# Maximum number of public methods for a class (see R0904).
+max-public-methods=20
+
+# Maximum number of boolean expressions in a if statement
+max-bool-expr=5
+
+
+[IMPORTS]
+
+# Deprecated modules which should not be used, separated by a comma
+deprecated-modules=optparse
+
+# Create a graph of every (i.e. internal and external) dependencies in the
+# given file (report RP0402 must not be disabled)
+import-graph=
+
+# Create a graph of external dependencies in the given file (report RP0402 must
+# not be disabled)
+ext-import-graph=
+
+# Create a graph of internal dependencies in the given file (report RP0402 must
+# not be disabled)
+int-import-graph=
+
+# Force import order to recognize a module as part of the standard
+# compatibility libraries.
+known-standard-library=
+
+# Force import order to recognize a module as part of a third party library.
+known-third-party=enchant
+
+# Analyse import fallback blocks. This can be used to support both Python 2 and
+# 3 compatible code, which means that the block might have code that exists
+# only in one or another interpreter, leading to false positives when analysed.
+analyse-fallback-blocks=no
+
+
+[EXCEPTIONS]
+
+# Exceptions that will emit a warning when being caught. Defaults to
+# "Exception"
+overgeneral-exceptions=Exception

testbed/openvinotoolkit__datumaro/.travis.yml

@@ -0,0 +1,37 @@
+language: python
+
+cache: pip
+
+python:
+  - '3.6'
+  - '3.7'
+  - '3.8'
+
+matrix:
+  include:
+    - dist: xenial
+
+    # measure coverage here
+    - dist: bionic
+      python: '3.6'
+      before_install:
+        - pip install coverage
+      script:
+        - coverage run -m unittest discover -v
+        - coverage run -a datum.py -h
+      after_success:
+        - coverage xml
+        - bash <(curl -Ls https://coverage.codacy.com/get.sh) report -r coverage.xml
+
+    - dist: bionic
+      python: '3.7'
+    - dist: bionic
+      python: '3.8'
+
+install:
+  - pip install -e ./
+  - pip install tensorflow
+
+script:
+  - python -m unittest discover -v
+  - datum -h

testbed/openvinotoolkit__datumaro/CHANGELOG.md

@@ -0,0 +1,145 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+
+## [Unreleased]
+### Added
+- Task-specific Splitter (<https://github.com/openvinotoolkit/datumaro/pull/68>)
+- `WiderFace` dataset format (<https://github.com/openvinotoolkit/datumaro/pull/65>)
+- Function to transform annotations to labels (<https://github.com/openvinotoolkit/datumaro/pull/66>)
+- `VGGFace2` dataset format (<https://github.com/openvinotoolkit/datumaro/pull/69>)
+
+### Changed
+-
+
+### Deprecated
+-
+
+### Removed
+-
+
+### Fixed
+-
+
+### Security
+-
+
+## 12/10/2020 - Release v0.1.4
+### Added
+- `CamVid` dataset format (<https://github.com/openvinotoolkit/datumaro/pull/57>)
+- Ability to install `opencv-python-headless` dependency with `DATUMARO_HEADLESS=1`
+  enviroment variable instead of `opencv-python` (<https://github.com/openvinotoolkit/datumaro/pull/62>)
+
+### Changed
+- Allow empty supercategory in COCO (<https://github.com/openvinotoolkit/datumaro/pull/54>)
+- Allow Pascal VOC to search in subdirectories (<https://github.com/openvinotoolkit/datumaro/pull/50>)
+
+### Deprecated
+-
+
+### Removed
+-
+
+### Fixed
+-
+
+### Security
+-
+
+## 10/28/2020 - Release v0.1.3
+### Added
+- `ImageNet` and `ImageNetTxt` dataset formats (<https://github.com/openvinotoolkit/datumaro/pull/41>)
+
+### Changed
+-
+
+### Deprecated
+-
+
+### Removed
+-
+
+### Fixed
+- Default `label-map` parameter value for VOC converter (<https://github.com/openvinotoolkit/datumaro/pull/34>)
+- Randomness of random split transform (<https://github.com/openvinotoolkit/datumaro/pull/38>)
+- `Transform.subsets()` method (<https://github.com/openvinotoolkit/datumaro/pull/38>)
+- Supported unknown image formats in TF Detection API converter (<https://github.com/openvinotoolkit/datumaro/pull/40>)
+- Supported empty attribute values in CVAT extractor (<https://github.com/openvinotoolkit/datumaro/pull/45>)
+
+### Security
+-
+
+
+## 10/05/2020 - Release v0.1.2
+### Added
+- `ByteImage` class to represent encoded images in memory and avoid recoding on save (<https://github.com/openvinotoolkit/datumaro/pull/27>)
+
+### Changed
+- Implementation of format plugins simplified (<https://github.com/openvinotoolkit/datumaro/pull/22>)
+- `default` is now a default subset name, instead of `None`. The values are interchangeable. (<https://github.com/openvinotoolkit/datumaro/pull/22>)
+- Improved performance of transforms (<https://github.com/openvinotoolkit/datumaro/pull/22>)
+
+### Deprecated
+-
+
+### Removed
+- `image/depth` value from VOC export (<https://github.com/openvinotoolkit/datumaro/pull/27>)
+
+### Fixed
+- Zero division errors in dataset statistics (<https://github.com/openvinotoolkit/datumaro/pull/31>)
+
+### Security
+-
+
+
+## 09/24/2020 - Release v0.1.1
+### Added
+- `reindex` option in COCO and CVAT converters (<https://github.com/openvinotoolkit/datumaro/pull/18>)
+- Support for relative paths in LabelMe format (<https://github.com/openvinotoolkit/datumaro/pull/19>)
+- MOTS png mask format support (<https://github.com/openvinotoolkit/datumaro/21>)
+
+### Changed
+-
+
+### Deprecated
+-
+
+### Removed
+-
+
+### Fixed
+-
+
+### Security
+-
+
+
+## 09/10/2020 - Release v0.1.0
+### Added
+- Initial release
+
+## Template
+```
+## [Unreleased]
+### Added
+-
+
+### Changed
+-
+
+### Deprecated
+-
+
+### Removed
+-
+
+### Fixed
+-
+
+### Security
+-
+```

testbed/openvinotoolkit__datumaro/CONTRIBUTING.md

@@ -0,0 +1,99 @@
+## Table of Contents
+
+- [Installation](#installation)
+- [Usage](#usage)
+- [Testing](#testing)
+- [Design](#design-and-code-structure)
+
+## Installation
+
+### Prerequisites
+
+- Python (3.5+)
+
+``` bash
+git clone https://github.com/openvinotoolkit/datumaro
+```
+
+Optionally, install a virtual environment (recommended):
+
+``` bash
+python -m pip install virtualenv
+python -m virtualenv venv
+. venv/bin/activate
+```
+
+Then install all dependencies:
+
+``` bash
+while read -r p; do pip install $p; done < requirements.txt
+```
+
+If you're working inside of a CVAT environment:
+``` bash
+. .env/bin/activate
+while read -r p; do pip install $p; done < datumaro/requirements.txt
+```
+
+Install Datumaro:
+``` bash
+pip install -e /path/to/the/cloned/repo/
+```
+
+**Optional dependencies**
+
+These components are only required for plugins and not installed by default:
+
+- OpenVINO
+- Accuracy Checker
+- TensorFlow
+- PyTorch
+- MxNet
+- Caffe
+
+## Usage
+
+``` bash
+datum --help
+python -m datumaro --help
+python datumaro/ --help
+python datum.py --help
+```
+
+``` python
+import datumaro
+```
+
+## Testing
+
+It is expected that all Datumaro functionality is covered and checked by
+unit tests. Tests are placed in `tests/` directory.
+
+To run tests use:
+
+``` bash
+python -m unittest discover -s tests
+```
+
+If you're working inside of a CVAT environment, you can also use:
+
+``` bash
+python manage.py test datumaro/
+```
+
+## Design and code structure
+
+- [Design document](docs/design.md)
+- [Developer guide](docs/developer_guide.md)
+
+## Code style
+
+Try to be readable and consistent with the existing codebase.
+The project mostly follows PEP8 with little differences.
+Continuation lines have a standard indentation step by default,
+or any other, if it improves readability. For long conditionals use 2 steps.
+No trailing whitespaces, 80 characters per line.
+
+## Environment
+
+The recommended editor is VS Code with the Python plugin.

testbed/openvinotoolkit__datumaro/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (C) 2019-2020 Intel Corporation
+ 
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom
+the Software is furnished to do so, subject to the following conditions:
+ 
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES
+OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+OR OTHER DEALINGS IN THE SOFTWARE.
+ 

testbed/openvinotoolkit__datumaro/README.md

@@ -0,0 +1,230 @@
+# Dataset Management Framework (Datumaro)
+
+[![Build Status](https://travis-ci.org/openvinotoolkit/datumaro.svg?branch=develop)](https://travis-ci.org/openvinotoolkit/datumaro)
+[![Codacy Badge](https://api.codacy.com/project/badge/Grade/759d2d873b59495aa3d3f8c51b786246)](https://app.codacy.com/gh/openvinotoolkit/datumaro?utm_source=github.com&utm_medium=referral&utm_content=openvinotoolkit/datumaro&utm_campaign=Badge_Grade_Dashboard)
+[![Codacy Badge](https://app.codacy.com/project/badge/Coverage/9511b691ff134e739ea6fc524f7cc760)](https://www.codacy.com/gh/openvinotoolkit/datumaro?utm_source=github.com&utm_medium=referral&utm_content=openvinotoolkit/datumaro&utm_campaign=Badge_Coverage)
+
+A framework and CLI tool to build, transform, and analyze datasets.
+
+<!--lint disable fenced-code-flag-->
+```
+VOC dataset                                  ---> Annotation tool
+     +                                     /
+COCO dataset -----> Datumaro ---> dataset ------> Model training
+     +                                     \
+CVAT annotations                             ---> Publication, statistics etc.
+```
+<!--lint enable fenced-code-flag-->
+
+# Table of Contents
+
+- [Examples](#examples)
+- [Features](#features)
+- [Installation](#installation)
+- [Usage](#usage)
+- [User manual](docs/user_manual.md)
+- [Contributing](#contributing)
+
+## Examples
+
+[(Back to top)](#table-of-contents)
+
+<!--lint disable list-item-indent-->
+<!--lint disable list-item-bullet-indent-->
+
+- Convert PASCAL VOC dataset to COCO format, keep only images with `cat` class presented:
+  ```bash
+  # Download VOC dataset:
+  # http://host.robots.ox.ac.uk/pascal/VOC/voc2012/VOCtrainval_11-May-2012.tar
+  datum convert --input-format voc --input-path <path/to/voc> \
+                --output-format coco \
+                --filter '/item[annotation/label="cat"]'
+  ```
+
+- Convert only non-`occluded` annotations from a [CVAT](https://github.com/opencv/cvat) project to TFrecord:
+  ```bash
+  # export Datumaro dataset in CVAT UI, extract somewhere, go to the project dir
+  datum project filter -e '/item/annotation[occluded="False"]' \
+    --mode items+anno --output-dir not_occluded
+  datum project export --project not_occluded \
+    --format tf_detection_api -- --save-images
+  ```
+
+- Annotate MS COCO dataset, extract image subset, re-annotate it in [CVAT](https://github.com/opencv/cvat), update old dataset:
+  ```bash
+  # Download COCO dataset http://cocodataset.org/#download
+  # Put images to coco/images/ and annotations to coco/annotations/
+  datum project import --format coco --input-path <path/to/coco>
+  datum project export --filter '/image[images_I_dont_like]' --format cvat \
+    --output-dir reannotation
+  # import dataset and images to CVAT, re-annotate
+  # export Datumaro project, extract to 'reannotation-upd'
+  datum project project merge reannotation-upd
+  datum project export --format coco
+  ```
+
+- Annotate instance polygons in [CVAT](https://github.com/opencv/cvat), export as masks in COCO:
+  ```bash
+  datum convert --input-format cvat --input-path <path/to/cvat.xml> \
+                --output-format coco -- --segmentation-mode masks
+  ```
+
+- Apply an OpenVINO detection model to some COCO-like dataset,
+  then compare annotations with ground truth and visualize in TensorBoard:
+  ```bash
+  datum project import --format coco --input-path <path/to/coco>
+  # create model results interpretation script
+  datum model add mymodel openvino \
+    --weights model.bin --description model.xml \
+    --interpretation-script parse_results.py
+  datum model run --model mymodel --output-dir mymodel_inference/
+  datum project diff mymodel_inference/ --format tensorboard --output-dir diff
+  ```
+
+- Change colors in PASCAL VOC-like `.png` masks:
+  ```bash
+  datum project import --format voc --input-path <path/to/voc/dataset>
+
+  # Create a color map file with desired colors:
+  #
+  # label : color_rgb : parts : actions
+  # cat:0,0,255::
+  # dog:255,0,0::
+  #
+  # Save as mycolormap.txt
+
+  datum project export --format voc_segmentation -- --label-map mycolormap.txt
+  # add "--apply-colormap=0" to save grayscale (indexed) masks
+  # check "--help" option for more info
+  # use "datum --loglevel debug" for extra conversion info
+  ```
+
+<!--lint enable list-item-bullet-indent-->
+<!--lint enable list-item-indent-->
+
+## Features
+
+[(Back to top)](#table-of-contents)
+
+- Dataset reading, writing, conversion in any direction. Supported formats:
+  - [COCO](http://cocodataset.org/#format-data) (`image_info`, `instances`, `person_keypoints`, `captions`, `labels`*)
+  - [PASCAL VOC](http://host.robots.ox.ac.uk/pascal/VOC/voc2012/htmldoc/index.html) (`classification`, `detection`, `segmentation`, `action_classification`, `person_layout`)
+  - [YOLO](https://github.com/AlexeyAB/darknet#how-to-train-pascal-voc-data) (`bboxes`)
+  - [TF Detection API](https://github.com/tensorflow/models/blob/master/research/object_detection/g3doc/using_your_own_dataset.md) (`bboxes`, `masks`)
+  - [WIDER Face](http://shuoyang1213.me/WIDERFACE/) (`bboxes`)
+  - [VGGFace2](https://github.com/ox-vgg/vgg_face2) (`landmarks`, `bboxes`)
+  - [MOT sequences](https://arxiv.org/pdf/1906.04567.pdf)
+  - [MOTS PNG](https://www.vision.rwth-aachen.de/page/mots)
+  - [ImageNet](http://image-net.org/)
+  - [CamVid](http://mi.eng.cam.ac.uk/research/projects/VideoRec/CamVid/)
+  - [CVAT](https://github.com/opencv/cvat/blob/develop/cvat/apps/documentation/xml_format.md)
+  - [LabelMe](http://labelme.csail.mit.edu/Release3.0)
+- Dataset building
+  - Merging multiple datasets into one
+  - Dataset filtering by a custom criteria:
+    - remove polygons of a certain class
+    - remove images without annotations of a specific class
+    - remove `occluded` annotations from images
+    - keep only vertically-oriented images
+    - remove small area bounding boxes from annotations
+  - Annotation conversions, for instance:
+    - polygons to instance masks and vise-versa
+    - apply a custom colormap for mask annotations
+    - rename or remove dataset labels
+- Dataset quality checking
+  - Simple checking for errors
+  - Comparison with model infernece
+  - Merging and comparison of multiple datasets
+- Dataset comparison
+- Dataset statistics (image mean and std, annotation statistics)
+- Model integration
+  - Inference (OpenVINO, Caffe, PyTorch, TensorFlow, MxNet, etc.)
+  - Explainable AI ([RISE algorithm](https://arxiv.org/abs/1806.07421))
+
+> Check [the design document](docs/design.md) for a full list of features.
+> Check [the user manual](docs/user_manual.md) for usage instructions.
+
+## Installation
+
+[(Back to top)](#table-of-contents)
+
+### Dependencies
+
+- Python (3.6+)
+- Optional: OpenVINO, TensforFlow, PyTorch, MxNet, Caffe, Accuracy Checker
+
+Optionally, create a virtual environment:
+
+``` bash
+python -m pip install virtualenv
+python -m virtualenv venv
+. venv/bin/activate
+```
+
+Install Datumaro package:
+
+``` bash
+pip install 'git+https://github.com/openvinotoolkit/datumaro'
+```
+
+## Usage
+
+[(Back to top)](#table-of-contents)
+
+There are several options available:
+- [A standalone command-line tool](#standalone-tool)
+- [A python module](#python-module)
+
+### Standalone tool
+
+Datuaro as a standalone tool allows to do various dataset operations from
+the command line interface:
+
+``` bash
+datum --help
+python -m datumaro --help
+```
+
+### Python module
+
+Datumaro can be used in custom scripts as a Python module. Used this way, it
+allows to use its features from an existing codebase, enabling dataset
+reading, exporting and iteration capabilities, simplifying integration of custom
+formats and providing high performance operations:
+
+``` python
+from datumaro.components.project import Project # project-related things
+import datumaro.components.extractor # annotations and high-level interfaces
+
+# load a Datumaro project
+project = Project.load('directory')
+
+# create a dataset
+dataset = project.make_dataset()
+
+# keep only annotated images
+dataset = dataset.select(lambda item: len(item.annotations) != 0)
+
+# change dataset labels
+dataset = dataset.transform(project.env.transforms.get('remap_labels'),
+  {'cat': 'dog', # rename cat to dog
+    'truck': 'car', # rename truck to car
+    'person': '', # remove this label
+  }, default='delete')
+
+for item in dataset:
+  print(item.id, item.annotations)
+
+# export the resulting dataset in COCO format
+project.env.converters.get('coco').convert(dataset, save_dir='dst/dir')
+```
+
+> Check our [developer guide](docs/developer_guide.md) for additional information.
+
+## Contributing
+
+[(Back to top)](#table-of-contents)
+
+Feel free to [open an Issue](https://github.com/openvinotoolkit/datumaro/issues/new), if you
+think something needs to be changed. You are welcome to participate in development,
+instructions are available in our [contribution guide](CONTRIBUTING.md).

testbed/openvinotoolkit__datumaro/datum.py

@@ -0,0 +1,8 @@
+#!/usr/bin/env python
+import sys
+
+from datumaro.cli.__main__ import main
+
+
+if __name__ == '__main__':
+    sys.exit(main())

testbed/openvinotoolkit__datumaro/datumaro/__init__.py

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

testbed/openvinotoolkit__datumaro/datumaro/__main__.py

@@ -0,0 +1,12 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+import sys
+
+from datumaro.cli.__main__ import main
+
+
+if __name__ == '__main__':
+    sys.exit(main())

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

@@ -0,0 +1,124 @@
+
+# Copyright (C) 2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+import argparse
+import json
+import logging as log
+import os.path as osp
+from collections import OrderedDict
+
+from datumaro.components.project import Project
+from datumaro.components.operations import (IntersectMerge,
+    QualityError, MergeError)
+
+from ..util import at_least, MultilineFormatter, CliException
+from ..util.project import generate_next_file_name, load_project
+
+
+def build_parser(parser_ctor=argparse.ArgumentParser):
+    parser = parser_ctor(help="Merge few projects",
+        description="""
+            Merges multiple datasets into one. This can be useful if you
+            have few annotations and wish to merge them,
+            taking into consideration potential overlaps and conflicts.
+            This command can try to find a common ground by voting or
+            return a list of conflicts.|n
+            |n
+            Examples:|n
+            - Merge annotations from 3 (or more) annotators:|n
+            |s|smerge project1/ project2/ project3/|n
+            - Check groups of the merged dataset for consistence:|n
+            |s|s|slook for groups consising of 'person', 'hand' 'head', 'foot'|n
+            |s|smerge project1/ project2/ -g 'person,hand?,head,foot?'
+        """,
+        formatter_class=MultilineFormatter)
+
+    def _group(s):
+        return s.split(',')
+
+    parser.add_argument('project', nargs='+', action=at_least(2),
+        help="Path to a project (repeatable)")
+    parser.add_argument('-iou', '--iou-thresh', default=0.25, type=float,
+        help="IoU match threshold for segments (default: %(default)s)")
+    parser.add_argument('-oconf', '--output-conf-thresh',
+        default=0.0, type=float,
+        help="Confidence threshold for output "
+            "annotations (default: %(default)s)")
+    parser.add_argument('--quorum', default=0, type=int,
+        help="Minimum count for a label and attribute voting "
+            "results to be counted (default: %(default)s)")
+    parser.add_argument('-g', '--groups', action='append', type=_group,
+        default=[],
+        help="A comma-separated list of labels in "
+            "annotation groups to check. '?' postfix can be added to a label to"
+            "make it optional in the group (repeatable)")
+    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.set_defaults(command=merge_command)
+
+    return parser
+
+def merge_command(args):
+    source_projects = [load_project(p) for p in args.project]
+
+    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('merged')
+
+    source_datasets = []
+    for p in source_projects:
+        log.debug("Loading project '%s' dataset", p.config.project_name)
+        source_datasets.append(p.make_dataset())
+
+    merger = IntersectMerge(conf=IntersectMerge.Conf(
+        pairwise_dist=args.iou_thresh, groups=args.groups,
+        output_conf_thresh=args.output_conf_thresh, quorum=args.quorum
+    ))
+    merged_dataset = merger(source_datasets)
+
+    merged_project = Project()
+    output_dataset = merged_project.make_dataset()
+    output_dataset.define_categories(merged_dataset.categories())
+    merged_dataset = output_dataset.update(merged_dataset)
+    merged_dataset.save(save_dir=dst_dir)
+
+    report_path = osp.join(dst_dir, 'merge_report.json')
+    save_merge_report(merger, report_path)
+
+    dst_dir = osp.abspath(dst_dir)
+    log.info("Merge results have been saved to '%s'" % dst_dir)
+    log.info("Report has been saved to '%s'" % report_path)
+
+    return 0
+
+def save_merge_report(merger, path):
+    item_errors = OrderedDict()
+    source_errors = OrderedDict()
+    all_errors = []
+
+    for e in merger.errors:
+        if isinstance(e, QualityError):
+            item_errors[str(e.item_id)] = item_errors.get(str(e.item_id), 0) + 1
+        elif isinstance(e, MergeError):
+            for s in e.sources:
+                source_errors[s] = source_errors.get(s, 0) + 1
+            item_errors[str(e.item_id)] = item_errors.get(str(e.item_id), 0) + 1
+
+        all_errors.append(str(e))
+
+    errors = OrderedDict([
+        ('Item errors', item_errors),
+        ('Source errors', source_errors),
+        ('All errors', all_errors),
+    ])
+
+    with open(path, 'w') as f:
+        json.dump(errors, f, indent=4)

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

@@ -0,0 +1,37 @@
+
+# Copyright (C) 2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+import os.path as osp
+import yaml
+
+from datumaro.components.cli_plugin import CliPlugin
+from datumaro.components.launcher import Launcher
+
+from .details.ac import GenericAcLauncher as _GenericAcLauncher
+
+
+class AcLauncher(Launcher, CliPlugin):
+    """
+    Generic model launcher with Accuracy Checker backend.
+    """
+
+    @classmethod
+    def build_cmdline_parser(cls, **kwargs):
+        parser = super().build_cmdline_parser(**kwargs)
+        parser.add_argument('-c', '--config', type=osp.abspath, required=True,
+            help="Path to the launcher configuration file (.yml)")
+        return parser
+
+    def __init__(self, config, model_dir=None):
+        model_dir = model_dir or ''
+        with open(osp.join(model_dir, config), 'r') as f:
+            config = yaml.safe_load(f)
+        self._launcher = _GenericAcLauncher.from_config(config)
+
+    def launch(self, inputs):
+        return self._launcher.launch(inputs)
+
+    def categories(self):
+        return self._launcher.categories()

testbed/openvinotoolkit__datumaro/datumaro/plugins/camvid_format.py

@@ -0,0 +1,344 @@
+
+# Copyright (C) 2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+import os
+import os.path as osp
+from collections import OrderedDict
+from enum import Enum
+from glob import glob
+
+import numpy as np
+from datumaro.components.converter import Converter
+from datumaro.components.extractor import (AnnotationType, CompiledMask,
+    DatasetItem, Importer, LabelCategories, Mask,
+    MaskCategories, SourceExtractor)
+from datumaro.util import find, str_to_bool
+from datumaro.util.image import save_image
+from datumaro.util.mask_tools import lazy_mask, paint_mask, generate_colormap
+
+
+CamvidLabelMap = OrderedDict([
+    ('Void', (0, 0, 0)),
+    ('Animal', (64, 128, 64)),
+    ('Archway', (192, 0, 128)),
+    ('Bicyclist', (0, 128, 192)),
+    ('Bridge', (0, 128, 64)),
+    ('Building', (128, 0, 0)),
+    ('Car', (64, 0, 128)),
+    ('CartLuggagePram', (64, 0, 192)),
+    ('Child', (192, 128, 64)),
+    ('Column_Pole', (192, 192, 128)),
+    ('Fence', (64, 64, 128)),
+    ('LaneMkgsDriv', (128, 0, 192)),
+    ('LaneMkgsNonDriv', (192, 0, 64)),
+    ('Misc_Text', (128, 128, 64)),
+    ('MotorcycycleScooter', (192, 0, 192)),
+    ('OtherMoving', (128, 64, 64)),
+    ('ParkingBlock', (64, 192, 128)),
+    ('Pedestrian', (64, 64, 0)),
+    ('Road', (128, 64, 128)),
+    ('RoadShoulder', (128, 128, 192)),
+    ('Sidewalk', (0, 0, 192)),
+    ('SignSymbol', (192, 128, 128)),
+    ('Sky', (128, 128, 128)),
+    ('SUVPickupTruck', (64, 128, 192)),
+    ('TrafficCone', (0, 0, 64)),
+    ('TrafficLight', (0, 64, 64)),
+    ('Train', (192, 64, 128)),
+    ('Tree', (128, 128, 0)),
+    ('Truck_Bus', (192, 128, 192)),
+    ('Tunnel', (64, 0, 64)),
+    ('VegetationMisc', (192, 192, 0)),
+    ('Wall', (64, 192, 0))
+])
+
+class CamvidPath:
+    LABELMAP_FILE = 'label_colors.txt'
+    SEGM_DIR = "annot"
+    IMAGE_EXT = '.png'
+
+
+def parse_label_map(path):
+    if not path:
+        return None
+
+    label_map = OrderedDict()
+    with open(path, 'r') as f:
+        for line in f:
+            # skip empty and commented lines
+            line = line.strip()
+            if not line or line and line[0] == '#':
+                continue
+
+            # color, name
+            label_desc = line.strip().split()
+
+            if 2 < len(label_desc):
+                name = label_desc[3]
+                color = tuple([int(c) for c in label_desc[:-1]])
+            else:
+                name = label_desc[0]
+                color = None
+
+            if name in label_map:
+                raise ValueError("Label '%s' is already defined" % name)
+
+            label_map[name] = color
+    return label_map
+
+def write_label_map(path, label_map):
+    with open(path, 'w') as f:
+        for label_name, label_desc in label_map.items():
+            if label_desc:
+                color_rgb = ' '.join(str(c) for c in label_desc)
+            else:
+                color_rgb = ''
+            f.write('%s %s\n' % (color_rgb, label_name))
+
+def make_camvid_categories(label_map=None):
+    if label_map is None:
+        label_map = CamvidLabelMap
+
+    # There must always be a label with color (0, 0, 0) at index 0
+    bg_label = find(label_map.items(), lambda x: x[1] == (0, 0, 0))
+    if bg_label is not None:
+        bg_label = bg_label[0]
+    else:
+        bg_label = 'background'
+        if bg_label not in label_map:
+            has_colors = any(v is not None for v in label_map.values())
+            color = (0, 0, 0) if has_colors else None
+            label_map[bg_label] = color
+    label_map.move_to_end(bg_label, last=False)
+
+    categories = {}
+    label_categories = LabelCategories()
+    for label, desc in label_map.items():
+        label_categories.add(label)
+    categories[AnnotationType.label] = label_categories
+
+    has_colors = any(v is not None for v in label_map.values())
+    if not has_colors: # generate new colors
+        colormap = generate_colormap(len(label_map))
+    else: # only copy defined colors
+        label_id = lambda label: label_categories.find(label)[0]
+        colormap = { label_id(name): (desc[0], desc[1], desc[2])
+            for name, desc in label_map.items() }
+    mask_categories = MaskCategories(colormap)
+    mask_categories.inverse_colormap # pylint: disable=pointless-statement
+    categories[AnnotationType.mask] = mask_categories
+    return categories
+
+
+class CamvidExtractor(SourceExtractor):
+    def __init__(self, path):
+        assert osp.isfile(path), path
+        self._path = path
+        self._dataset_dir = osp.dirname(path)
+        super().__init__(subset=osp.splitext(osp.basename(path))[0])
+
+        self._categories = self._load_categories(self._dataset_dir)
+        self._items = list(self._load_items(path).values())
+
+    def _load_categories(self, path):
+        label_map = None
+        label_map_path = osp.join(path, CamvidPath.LABELMAP_FILE)
+        if osp.isfile(label_map_path):
+            label_map = parse_label_map(label_map_path)
+        else:
+            label_map = CamvidLabelMap
+        self._labels = [label for label in label_map]
+        return make_camvid_categories(label_map)
+
+    def _load_items(self, path):
+        items = {}
+        with open(path, encoding='utf-8') as f:
+            for line in f:
+                objects = line.split()
+                image = objects[0]
+                item_id = ('/'.join(image.split('/')[2:]))[:-len(CamvidPath.IMAGE_EXT)]
+                image_path = osp.join(self._dataset_dir,
+                    (image, image[1:])[image[0] == '/'])
+                item_annotations = []
+                if 1 < len(objects):
+                    gt = objects[1]
+                    gt_path = osp.join(self._dataset_dir,
+                        (gt, gt[1:]) [gt[0] == '/'])
+                    inverse_cls_colormap = \
+                        self._categories[AnnotationType.mask].inverse_colormap
+                    mask = lazy_mask(gt_path, inverse_cls_colormap)
+                    # loading mask through cache
+                    mask = mask()
+                    classes = np.unique(mask)
+                    labels = self._categories[AnnotationType.label]._indices
+                    labels = { labels[label_name]: label_name
+                        for label_name in labels }
+                    for label_id in classes:
+                        if labels[label_id] in self._labels:
+                            image = self._lazy_extract_mask(mask, label_id)
+                            item_annotations.append(Mask(image=image, label=label_id))
+                items[item_id] = DatasetItem(id=item_id, subset=self._subset,
+                    image=image_path, annotations=item_annotations)
+        return items
+
+    @staticmethod
+    def _lazy_extract_mask(mask, c):
+        return lambda: mask == c
+
+
+class CamvidImporter(Importer):
+    @classmethod
+    def find_sources(cls, path):
+        subset_paths = [p for p in glob(osp.join(path, '**.txt'), recursive=True)
+            if osp.basename(p) != CamvidPath.LABELMAP_FILE]
+        sources = []
+        for subset_path in subset_paths:
+            sources += cls._find_sources_recursive(
+                subset_path, '.txt', 'camvid')
+        return sources
+
+
+LabelmapType = Enum('LabelmapType', ['camvid', 'source'])
+
+class CamvidConverter(Converter):
+    DEFAULT_IMAGE_EXT = '.png'
+
+    @classmethod
+    def build_cmdline_parser(cls, **kwargs):
+        parser = super().build_cmdline_parser(**kwargs)
+
+        parser.add_argument('--apply-colormap', type=str_to_bool, default=True,
+            help="Use colormap for class masks (default: %(default)s)")
+        parser.add_argument('--label-map', type=cls._get_labelmap, default=None,
+            help="Labelmap file path or one of %s" % \
+                ', '.join(t.name for t in LabelmapType))
+
+    def __init__(self, extractor, save_dir,
+            apply_colormap=True, label_map=None, **kwargs):
+        super().__init__(extractor, save_dir, **kwargs)
+
+        self._apply_colormap = apply_colormap
+
+        if label_map is None:
+            label_map = LabelmapType.source.name
+        self._load_categories(label_map)
+
+    def apply(self):
+        subset_dir = self._save_dir
+        os.makedirs(subset_dir, exist_ok=True)
+
+        for subset_name, subset in self._extractor.subsets().items():
+            segm_list = {}
+            for item in subset:
+                masks = [a for a in item.annotations
+                    if a.type == AnnotationType.mask]
+
+                if masks:
+                    compiled_mask = CompiledMask.from_instance_masks(masks,
+                        instance_labels=[self._label_id_mapping(m.label)
+                            for m in masks])
+
+                    self.save_segm(osp.join(subset_dir,
+                            subset_name + CamvidPath.SEGM_DIR,
+                            item.id + CamvidPath.IMAGE_EXT),
+                        compiled_mask.class_mask)
+                    segm_list[item.id] = True
+                else:
+                    segm_list[item.id] = False
+
+                if self._save_images:
+                    self._save_image(item, osp.join(subset_dir, subset_name,
+                        item.id + CamvidPath.IMAGE_EXT))
+
+            self.save_segm_lists(subset_name, segm_list)
+        self.save_label_map()
+
+    def save_segm(self, path, mask, colormap=None):
+        if self._apply_colormap:
+            if colormap is None:
+                colormap = self._categories[AnnotationType.mask].colormap
+            mask = paint_mask(mask, colormap)
+        save_image(path, mask, create_dir=True)
+
+    def save_segm_lists(self, subset_name, segm_list):
+        if not segm_list:
+            return
+
+        ann_file = osp.join(self._save_dir, subset_name + '.txt')
+        with open(ann_file, 'w') as f:
+            for item in segm_list:
+                if segm_list[item]:
+                    path_mask = '/%s/%s' % (subset_name + CamvidPath.SEGM_DIR,
+                        item + CamvidPath.IMAGE_EXT)
+                else:
+                    path_mask = ''
+                f.write('/%s/%s %s\n' % (subset_name,
+                    item + CamvidPath.IMAGE_EXT, path_mask))
+
+    def save_label_map(self):
+        path = osp.join(self._save_dir, CamvidPath.LABELMAP_FILE)
+        labels = self._extractor.categories()[AnnotationType.label]._indices
+        if len(self._label_map) > len(labels):
+            self._label_map.pop('background')
+        write_label_map(path, self._label_map)
+
+    def _load_categories(self, label_map_source):
+        if label_map_source == LabelmapType.camvid.name:
+            # use the default Camvid colormap
+            label_map = CamvidLabelMap
+
+        elif label_map_source == LabelmapType.source.name and \
+                AnnotationType.mask not in self._extractor.categories():
+            # generate colormap for input labels
+            labels = self._extractor.categories() \
+                .get(AnnotationType.label, LabelCategories())
+            label_map = OrderedDict((item.name, None)
+                for item in labels.items)
+
+        elif label_map_source == LabelmapType.source.name and \
+                AnnotationType.mask in self._extractor.categories():
+            # use source colormap
+            labels = self._extractor.categories()[AnnotationType.label]
+            colors = self._extractor.categories()[AnnotationType.mask]
+            label_map = OrderedDict()
+            for idx, item in enumerate(labels.items):
+                color = colors.colormap.get(idx)
+                if color is not None:
+                    label_map[item.name] = color
+
+        elif isinstance(label_map_source, dict):
+            label_map = OrderedDict(
+                sorted(label_map_source.items(), key=lambda e: e[0]))
+
+        elif isinstance(label_map_source, str) and osp.isfile(label_map_source):
+            label_map = parse_label_map(label_map_source)
+
+        else:
+            raise Exception("Wrong labelmap specified, "
+                "expected one of %s or a file path" % \
+                ', '.join(t.name for t in LabelmapType))
+
+        self._categories = make_camvid_categories(label_map)
+        self._label_map = label_map
+        self._label_id_mapping = self._make_label_id_map()
+
+    def _make_label_id_map(self):
+        source_labels = {
+            id: label.name for id, label in
+            enumerate(self._extractor.categories().get(
+                AnnotationType.label, LabelCategories()).items)
+        }
+        target_labels = {
+            label.name: id for id, label in
+            enumerate(self._categories[AnnotationType.label].items)
+        }
+        id_mapping = {
+            src_id: target_labels.get(src_label, 0)
+            for src_id, src_label in source_labels.items()
+        }
+
+        def map_id(src_id):
+            return id_mapping.get(src_id, 0)
+        return map_id

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

@@ -0,0 +1,9 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+class CvatPath:
+    IMAGES_DIR = 'images'
+
+    IMAGE_EXT = '.jpg'

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

@@ -0,0 +1,258 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+# pylint: disable=no-self-use
+
+import json
+import numpy as np
+import os
+import os.path as osp
+
+from datumaro.components.converter import Converter
+from datumaro.components.extractor import (
+    DEFAULT_SUBSET_NAME, Annotation, _Shape,
+    Label, Mask, RleMask, Points, Polygon, PolyLine, Bbox, Caption,
+    LabelCategories, MaskCategories, PointsCategories
+)
+from datumaro.util import cast
+import pycocotools.mask as mask_utils
+
+from .format import DatumaroPath
+
+
+class _SubsetWriter:
+    def __init__(self, name, context):
+        self._name = name
+        self._context = context
+
+        self._data = {
+            'info': {},
+            'categories': {},
+            'items': [],
+        }
+
+    @property
+    def categories(self):
+        return self._data['categories']
+
+    @property
+    def items(self):
+        return self._data['items']
+
+    def write_item(self, item):
+        annotations = []
+        item_desc = {
+            'id': item.id,
+            'annotations': annotations,
+        }
+        if item.attributes:
+            item_desc['attr'] = item.attributes
+        if item.path:
+            item_desc['path'] = item.path
+        if item.has_image:
+            path = item.image.path
+            if self._context._save_images:
+                path = self._context._make_image_filename(item)
+                self._context._save_image(item, path)
+
+            item_desc['image'] = {
+                'size': item.image.size,
+                'path': path,
+            }
+        self.items.append(item_desc)
+
+        for ann in item.annotations:
+            if isinstance(ann, Label):
+                converted_ann = self._convert_label_object(ann)
+            elif isinstance(ann, Mask):
+                converted_ann = self._convert_mask_object(ann)
+            elif isinstance(ann, Points):
+                converted_ann = self._convert_points_object(ann)
+            elif isinstance(ann, PolyLine):
+                converted_ann = self._convert_polyline_object(ann)
+            elif isinstance(ann, Polygon):
+                converted_ann = self._convert_polygon_object(ann)
+            elif isinstance(ann, Bbox):
+                converted_ann = self._convert_bbox_object(ann)
+            elif isinstance(ann, Caption):
+                converted_ann = self._convert_caption_object(ann)
+            else:
+                raise NotImplementedError()
+            annotations.append(converted_ann)
+
+    def write_categories(self, categories):
+        for ann_type, desc in categories.items():
+            if isinstance(desc, LabelCategories):
+                converted_desc = self._convert_label_categories(desc)
+            elif isinstance(desc, MaskCategories):
+                converted_desc = self._convert_mask_categories(desc)
+            elif isinstance(desc, PointsCategories):
+                converted_desc = self._convert_points_categories(desc)
+            else:
+                raise NotImplementedError()
+            self.categories[ann_type.name] = converted_desc
+
+    def write(self, save_dir):
+        with open(osp.join(save_dir, '%s.json' % (self._name)), 'w') as f:
+            json.dump(self._data, f)
+
+    def _convert_annotation(self, obj):
+        assert isinstance(obj, Annotation)
+
+        ann_json = {
+            'id': cast(obj.id, int),
+            'type': cast(obj.type.name, str),
+            'attributes': obj.attributes,
+            'group': cast(obj.group, int, 0),
+        }
+        return ann_json
+
+    def _convert_label_object(self, obj):
+        converted = self._convert_annotation(obj)
+
+        converted.update({
+            'label_id': cast(obj.label, int),
+        })
+        return converted
+
+    def _convert_mask_object(self, obj):
+        converted = self._convert_annotation(obj)
+
+        if isinstance(obj, RleMask):
+            rle = obj.rle
+        else:
+            rle = mask_utils.encode(
+                np.require(obj.image, dtype=np.uint8, requirements='F'))
+
+        converted.update({
+            'label_id': cast(obj.label, int),
+            'rle': {
+                # serialize as compressed COCO mask
+                'counts': rle['counts'].decode('ascii'),
+                'size': list(int(c) for c in rle['size']),
+            },
+            'z_order': obj.z_order,
+        })
+        return converted
+
+    def _convert_shape_object(self, obj):
+        assert isinstance(obj, _Shape)
+        converted = self._convert_annotation(obj)
+
+        converted.update({
+            'label_id': cast(obj.label, int),
+            'points': [float(p) for p in obj.points],
+            'z_order': obj.z_order,
+        })
+        return converted
+
+    def _convert_polyline_object(self, obj):
+        return self._convert_shape_object(obj)
+
+    def _convert_polygon_object(self, obj):
+        return self._convert_shape_object(obj)
+
+    def _convert_bbox_object(self, obj):
+        converted = self._convert_shape_object(obj)
+        converted.pop('points', None)
+        converted['bbox'] = [float(p) for p in obj.get_bbox()]
+        return converted
+
+    def _convert_points_object(self, obj):
+        converted = self._convert_shape_object(obj)
+
+        converted.update({
+            'visibility': [int(v.value) for v in obj.visibility],
+        })
+        return converted
+
+    def _convert_caption_object(self, obj):
+        converted = self._convert_annotation(obj)
+
+        converted.update({
+            'caption': cast(obj.caption, str),
+        })
+        return converted
+
+    def _convert_label_categories(self, obj):
+        converted = {
+            'labels': [],
+        }
+        for label in obj.items:
+            converted['labels'].append({
+                'name': cast(label.name, str),
+                'parent': cast(label.parent, str),
+            })
+        return converted
+
+    def _convert_mask_categories(self, obj):
+        converted = {
+            'colormap': [],
+        }
+        for label_id, color in obj.colormap.items():
+            converted['colormap'].append({
+                'label_id': int(label_id),
+                'r': int(color[0]),
+                'g': int(color[1]),
+                'b': int(color[2]),
+            })
+        return converted
+
+    def _convert_points_categories(self, obj):
+        converted = {
+            'items': [],
+        }
+        for label_id, item in obj.items.items():
+            converted['items'].append({
+                'label_id': int(label_id),
+                'labels': [cast(label, str) for label in item.labels],
+                'joints': [list(map(int, j)) for j in item.joints],
+            })
+        return converted
+
+class DatumaroConverter(Converter):
+    DEFAULT_IMAGE_EXT = DatumaroPath.IMAGE_EXT
+
+    def apply(self):
+        os.makedirs(self._save_dir, exist_ok=True)
+
+        images_dir = osp.join(self._save_dir, DatumaroPath.IMAGES_DIR)
+        os.makedirs(images_dir, exist_ok=True)
+        self._images_dir = images_dir
+
+        annotations_dir = osp.join(self._save_dir, DatumaroPath.ANNOTATIONS_DIR)
+        os.makedirs(annotations_dir, exist_ok=True)
+        self._annotations_dir = annotations_dir
+
+        subsets = {s: _SubsetWriter(s, self) for s in self._extractor.subsets()}
+        for subset, writer in subsets.items():
+            writer.write_categories(self._extractor.categories())
+
+        for item in self._extractor:
+            subset = item.subset or DEFAULT_SUBSET_NAME
+            writer = subsets[subset]
+
+            writer.write_item(item)
+
+        for subset, writer in subsets.items():
+            writer.write(annotations_dir)
+
+    def _save_image(self, item, path=None):
+        super()._save_image(item,
+            osp.join(self._images_dir, self._make_image_filename(item)))
+
+class DatumaroProjectConverter(Converter):
+    @classmethod
+    def convert(cls, extractor, save_dir, **kwargs):
+        os.makedirs(save_dir, exist_ok=True)
+
+        from datumaro.components.project import Project
+        project = Project.generate(save_dir,
+            config=kwargs.pop('project_config', None))
+
+        DatumaroConverter.convert(extractor,
+            save_dir=osp.join(
+                project.config.project_dir, project.config.dataset_dir),
+            **kwargs)

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

@@ -0,0 +1,12 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+class DatumaroPath:
+    IMAGES_DIR = 'images'
+    ANNOTATIONS_DIR = 'annotations'
+    MASKS_DIR = 'masks'
+
+    IMAGE_EXT = '.jpg'
+    MASK_EXT = '.png'

testbed/openvinotoolkit__datumaro/datumaro/plugins/image_dir.py

@@ -0,0 +1,52 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+import logging as log
+import os
+import os.path as osp
+
+from datumaro.components.extractor import DatasetItem, SourceExtractor, Importer
+from datumaro.components.converter import Converter
+from datumaro.util.image import Image
+
+
+class ImageDirImporter(Importer):
+    @classmethod
+    def find_sources(cls, path):
+        if not osp.isdir(path):
+            return []
+        return [{ 'url': path, 'format': 'image_dir' }]
+
+class ImageDirExtractor(SourceExtractor):
+    def __init__(self, url):
+        super().__init__()
+
+        assert osp.isdir(url), url
+
+        for dirpath, _, filenames in os.walk(url):
+            for name in filenames:
+                path = osp.join(dirpath, name)
+                image = Image(path=path)
+                try:
+                    # force loading
+                    image.data # pylint: disable=pointless-statement
+                except Exception:
+                    continue
+
+                item_id = osp.relpath(osp.splitext(path)[0], url)
+                self._items.append(DatasetItem(id=item_id, image=image))
+
+class ImageDirConverter(Converter):
+    DEFAULT_IMAGE_EXT = '.jpg'
+
+    def apply(self):
+        os.makedirs(self._save_dir, exist_ok=True)
+
+        for item in self._extractor:
+            if item.has_image:
+                self._save_image(item,
+                    osp.join(self._save_dir, self._make_image_filename(item)))
+            else:
+                log.debug("Item '%s' has no image info", item.id)

testbed/openvinotoolkit__datumaro/datumaro/plugins/imagenet_format.py

@@ -0,0 +1,90 @@
+
+# Copyright (C) 2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+from glob import glob
+import logging as log
+import os
+import os.path as osp
+
+from datumaro.components.extractor import (DatasetItem, Label,
+    LabelCategories, AnnotationType, SourceExtractor, Importer
+)
+from datumaro.components.converter import Converter
+
+
+class ImagenetPath:
+    IMAGES_EXT = '.jpg'
+    IMAGES_DIR_NO_LABEL = 'no_label'
+
+
+class ImagenetExtractor(SourceExtractor):
+    def __init__(self, path, subset=None):
+        assert osp.isdir(path), path
+        super().__init__(subset=subset)
+
+        self._categories = self._load_categories(path)
+        self._items = list(self._load_items(path).values())
+
+    def _load_categories(self, path):
+        label_cat = LabelCategories()
+        for images_dir in sorted(os.listdir(path)):
+            if images_dir != ImagenetPath.IMAGES_DIR_NO_LABEL:
+                label_cat.add(images_dir)
+        return { AnnotationType.label: label_cat }
+
+    def _load_items(self, path):
+        items = {}
+        for image_path in glob(osp.join(path, '*', '*')):
+            if osp.splitext(image_path)[1] != ImagenetPath.IMAGES_EXT:
+                continue
+            label = osp.basename(osp.dirname(image_path))
+            image_name = osp.splitext(osp.basename(image_path))[0][len(label) + 1:]
+            item = items.get(image_name)
+            if item is None:
+                item = DatasetItem(id=image_name, subset=self._subset,
+                    image=image_path)
+            annotations = item.annotations
+            if label != ImagenetPath.IMAGES_DIR_NO_LABEL:
+                label = self._categories[AnnotationType.label].find(label)[0]
+                annotations.append(Label(label=label))
+            items[image_name] = item
+        return items
+
+
+class ImagenetImporter(Importer):
+    @classmethod
+    def find_sources(cls, path):
+        if not osp.isdir(path):
+            return []
+        return [{ 'url': path, 'format': 'imagenet' }]
+
+
+class ImagenetConverter(Converter):
+    DEFAULT_IMAGE_EXT = ImagenetPath.IMAGES_EXT
+
+    def apply(self):
+        if 1 < len(self._extractor.subsets()):
+            log.warning("ImageNet format supports exporting only a single "
+                "subset, subset information will not be used.")
+
+        subset_dir = self._save_dir
+        extractor = self._extractor
+        labels = {}
+        for item in self._extractor:
+            image_name = item.id
+            labels[image_name] = [p.label for p in item.annotations
+                if p.type == AnnotationType.label]
+            for label in labels[image_name]:
+                label_name = extractor.categories()[AnnotationType.label][label].name
+                self._save_image(item, osp.join(subset_dir, label_name,
+                    '%s_%s%s' % \
+                    (label_name, image_name, ImagenetPath.IMAGES_EXT)
+                ))
+
+            if not labels[image_name]:
+                self._save_image(item, osp.join(subset_dir,
+                    ImagenetPath.IMAGES_DIR_NO_LABEL,
+                    ImagenetPath.IMAGES_DIR_NO_LABEL + '_' +
+                    image_name + ImagenetPath.IMAGES_EXT))

testbed/openvinotoolkit__datumaro/datumaro/plugins/imagenet_txt_format.py

@@ -0,0 +1,105 @@
+
+# Copyright (C) 2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+from glob import glob
+import os
+import os.path as osp
+
+from datumaro.components.extractor import (DatasetItem, Label,
+    LabelCategories, AnnotationType, SourceExtractor, Importer
+)
+from datumaro.components.converter import Converter
+
+
+class ImagenetTxtPath:
+    LABELS_FILE = 'synsets.txt'
+    IMAGE_DIR = 'images'
+
+class ImagenetTxtExtractor(SourceExtractor):
+    def __init__(self, path, labels=None, image_dir=None):
+        assert osp.isfile(path), path
+        super().__init__(subset=osp.splitext(osp.basename(path))[0])
+
+        if not image_dir:
+            image_dir = ImagenetTxtPath.IMAGE_DIR
+        self.image_dir = osp.join(osp.dirname(path), image_dir)
+
+        if labels is None:
+            labels = osp.join(osp.dirname(path), ImagenetTxtPath.LABELS_FILE)
+            labels = self._parse_labels(labels)
+        else:
+            assert all(isinstance(e, str) for e in labels)
+
+        self._categories = self._load_categories(labels)
+        self._items = list(self._load_items(path).values())
+
+    @staticmethod
+    def _parse_labels(path):
+        with open(path, encoding='utf-8') as labels_file:
+            return [s.strip() for s in labels_file]
+
+    def _load_categories(self, labels):
+        return { AnnotationType.label: LabelCategories().from_iterable(labels) }
+
+    def _load_items(self, path):
+        items = {}
+        with open(path, encoding='utf-8') as f:
+            for line in f:
+                item = line.split()
+                item_id = item[0]
+                label_ids = [int(id) for id in item[1:]]
+                anno = []
+                for label in label_ids:
+                    assert 0 <= label and \
+                        label < len(self._categories[AnnotationType.label]), \
+                        "Image '%s': unknown label id '%s'" % (item_id, label)
+                    anno.append(Label(label))
+                items[item_id] = DatasetItem(id=item_id, subset=self._subset,
+                    image=osp.join(self.image_dir, item_id + '.jpg'),
+                    annotations=anno)
+        return items
+
+
+class ImagenetTxtImporter(Importer):
+    @classmethod
+    def find_sources(cls, path):
+        subset_paths = [p for p in glob(osp.join(path, '*.txt'))
+            if osp.basename(p) != ImagenetTxtPath.LABELS_FILE]
+        sources = []
+        for subset_path in subset_paths:
+            sources += cls._find_sources_recursive(
+                subset_path, '.txt', 'imagenet_txt')
+        return sources
+
+
+class ImagenetTxtConverter(Converter):
+    DEFAULT_IMAGE_EXT = '.jpg'
+
+    def apply(self):
+        subset_dir = self._save_dir
+        os.makedirs(subset_dir, exist_ok=True)
+
+        extractor = self._extractor
+        for subset_name, subset in self._extractor.subsets().items():
+            annotation_file = osp.join(subset_dir, '%s.txt' % subset_name)
+            labels = {}
+            for item in subset:
+                labels[item.id] = [str(p.label) for p in item.annotations
+                    if p.type == AnnotationType.label]
+
+                if self._save_images and item.has_image:
+                    self._save_image(item,
+                        osp.join(self._save_dir, ImagenetTxtPath.IMAGE_DIR,
+                            self._make_image_filename(item)))
+
+            with open(annotation_file, 'w', encoding='utf-8') as f:
+                f.writelines(['%s %s\n' % (item_id, ' '.join(labels[item_id]))
+                    for item_id in labels])
+
+        labels_file = osp.join(subset_dir, ImagenetTxtPath.LABELS_FILE)
+        with open(labels_file, 'w', encoding='utf-8') as f:
+            f.write('\n'.join(l.name
+                for l in extractor.categories()[AnnotationType.label])
+            )

testbed/openvinotoolkit__datumaro/datumaro/plugins/labelme_format.py

@@ -0,0 +1,393 @@
+# Copyright (C) 2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+from collections import defaultdict
+from defusedxml import ElementTree
+import logging as log
+import numpy as np
+import os
+import os.path as osp
+
+from datumaro.components.extractor import (SourceExtractor, Importer,
+    DatasetItem, AnnotationType, Mask, Bbox, Polygon, LabelCategories
+)
+from datumaro.components.converter import Converter
+from datumaro.util.image import Image, save_image
+from datumaro.util.mask_tools import load_mask, find_mask_bbox
+
+
+class LabelMePath:
+    MASKS_DIR = 'Masks'
+    IMAGE_EXT = '.jpg'
+
+class LabelMeExtractor(SourceExtractor):
+    def __init__(self, path, subset_name=None):
+        assert osp.isdir(path), path
+        super().__init__(subset=subset_name)
+
+        items, categories = self._parse(path)
+        self._categories = categories
+        self._items = items
+
+    def _parse(self, path):
+        categories = {
+            AnnotationType.label: LabelCategories(attributes={
+                'occluded', 'username'
+            })
+        }
+
+        items = []
+        for p in os.listdir(path):
+            if not p.endswith('.xml'):
+                continue
+            root = ElementTree.parse(osp.join(path, p))
+
+            item_id = osp.join(root.find('folder').text or '',
+                root.find('filename').text)
+            image_path = osp.join(path, item_id)
+            image_size = None
+            imagesize_elem = root.find('imagesize')
+            if imagesize_elem is not None:
+                width_elem = imagesize_elem.find('ncols')
+                height_elem = imagesize_elem.find('nrows')
+                image_size = (int(height_elem.text), int(width_elem.text))
+            image = Image(path=image_path, size=image_size)
+
+            annotations = self._parse_annotations(root, path, categories)
+
+            items.append(DatasetItem(id=osp.splitext(item_id)[0],
+                subset=self._subset, image=image, annotations=annotations))
+        return items, categories
+
+    @classmethod
+    def _parse_annotations(cls, xml_root, dataset_root, categories):
+        def parse_attributes(attr_str):
+            parsed = []
+            if not attr_str:
+                return parsed
+
+            for attr in [a.strip() for a in attr_str.split(',') if a.strip()]:
+                if '=' in attr:
+                    name, value = attr.split('=', maxsplit=1)
+                    if value.lower() in {'true', 'false'}:
+                        value = value.lower() == 'true'
+                    else:
+                        try:
+                            value = float(value)
+                        except ValueError:
+                            pass
+                    parsed.append((name, value))
+                else:
+                    parsed.append((attr, True))
+
+            return parsed
+
+        label_cat = categories[AnnotationType.label]
+        def get_label_id(label):
+            if not label:
+                return None
+            idx, _ = label_cat.find(label)
+            if idx is None:
+                idx = label_cat.add(label)
+            return idx
+
+        image_annotations = []
+
+        parsed_annotations = dict()
+        group_assignments = dict()
+        root_annotations = set()
+        for obj_elem in xml_root.iter('object'):
+            obj_id = int(obj_elem.find('id').text)
+
+            ann_items = []
+
+            label = get_label_id(obj_elem.find('name').text)
+
+            attributes = []
+            attributes_elem = obj_elem.find('attributes')
+            if attributes_elem is not None and attributes_elem.text:
+                attributes = parse_attributes(attributes_elem.text)
+
+            occluded = False
+            occluded_elem = obj_elem.find('occluded')
+            if occluded_elem is not None and occluded_elem.text:
+                occluded = (occluded_elem.text == 'yes')
+            attributes.append(('occluded', occluded))
+
+            deleted = False
+            deleted_elem = obj_elem.find('deleted')
+            if deleted_elem is not None and deleted_elem.text:
+                deleted = bool(int(deleted_elem.text))
+
+            user = ''
+
+            poly_elem = obj_elem.find('polygon')
+            segm_elem = obj_elem.find('segm')
+            type_elem = obj_elem.find('type') # the only value is 'bounding_box'
+            if poly_elem is not None:
+                user_elem = poly_elem.find('username')
+                if user_elem is not None and user_elem.text:
+                    user = user_elem.text
+                attributes.append(('username', user))
+
+                points = []
+                for point_elem in poly_elem.iter('pt'):
+                    x = float(point_elem.find('x').text)
+                    y = float(point_elem.find('y').text)
+                    points.append(x)
+                    points.append(y)
+
+                if type_elem is not None and type_elem.text == 'bounding_box':
+                    xmin = min(points[::2])
+                    xmax = max(points[::2])
+                    ymin = min(points[1::2])
+                    ymax = max(points[1::2])
+                    ann_items.append(Bbox(xmin, ymin, xmax - xmin, ymax - ymin,
+                        label=label, attributes=attributes, id=obj_id,
+                    ))
+                else:
+                    ann_items.append(Polygon(points,
+                        label=label, attributes=attributes, id=obj_id,
+                    ))
+            elif segm_elem is not None:
+                user_elem = segm_elem.find('username')
+                if user_elem is not None and user_elem.text:
+                    user = user_elem.text
+                attributes.append(('username', user))
+
+                mask_path = osp.join(dataset_root, LabelMePath.MASKS_DIR,
+                    segm_elem.find('mask').text)
+                if not osp.isfile(mask_path):
+                    raise Exception("Can't find mask at '%s'" % mask_path)
+                mask = load_mask(mask_path)
+                mask = np.any(mask, axis=2)
+                ann_items.append(Mask(image=mask, label=label, id=obj_id,
+                    attributes=attributes))
+
+            if not deleted:
+                parsed_annotations[obj_id] = ann_items
+
+            # Find parents and children
+            parts_elem = obj_elem.find('parts')
+            if parts_elem is not None:
+                children_ids = []
+                hasparts_elem = parts_elem.find('hasparts')
+                if hasparts_elem is not None and hasparts_elem.text:
+                    children_ids = [int(c) for c in hasparts_elem.text.split(',')]
+
+                parent_ids = []
+                ispartof_elem = parts_elem.find('ispartof')
+                if ispartof_elem is not None and ispartof_elem.text:
+                    parent_ids = [int(c) for c in ispartof_elem.text.split(',')]
+
+                if children_ids and not parent_ids and hasparts_elem.text:
+                    root_annotations.add(obj_id)
+                group_assignments[obj_id] = [None, children_ids]
+
+        # assign single group to all grouped annotations
+        current_group_id = 0
+        annotations_to_visit = list(root_annotations)
+        while annotations_to_visit:
+            ann_id = annotations_to_visit.pop()
+            ann_assignment = group_assignments[ann_id]
+            group_id, children_ids = ann_assignment
+            if group_id:
+                continue
+
+            if ann_id in root_annotations:
+                current_group_id += 1 # start a new group
+
+            group_id = current_group_id
+            ann_assignment[0] = group_id
+
+            # continue with children
+            annotations_to_visit.extend(children_ids)
+
+        assert current_group_id == len(root_annotations)
+
+        for ann_id, ann_items in parsed_annotations.items():
+            group_id = 0
+            if ann_id in group_assignments:
+                ann_assignment = group_assignments[ann_id]
+                group_id = ann_assignment[0]
+
+            for ann_item in ann_items:
+                if group_id:
+                    ann_item.group = group_id
+
+                image_annotations.append(ann_item)
+
+        return image_annotations
+
+
+class LabelMeImporter(Importer):
+    EXTRACTOR = 'label_me'
+
+    @classmethod
+    def find_sources(cls, path):
+        subset_paths = []
+        if not osp.isdir(path):
+            return []
+
+        path = osp.normpath(path)
+
+        def has_annotations(d):
+            return len([p for p in os.listdir(d) if p.endswith('.xml')]) != 0
+
+        if has_annotations(path):
+            subset_paths.append({'url': path, 'format': cls.EXTRACTOR})
+        else:
+            for d in os.listdir(path):
+                subset = d
+                d = osp.join(path, d)
+                if osp.isdir(d) and has_annotations(d):
+                    subset_paths.append({'url': d, 'format': cls.EXTRACTOR,
+                        'options': {'subset_name': subset}
+                    })
+        return subset_paths
+
+
+class LabelMeConverter(Converter):
+    DEFAULT_IMAGE_EXT = LabelMePath.IMAGE_EXT
+
+    def apply(self):
+        for subset_name, subset in self._extractor.subsets().items():
+            subset_dir = osp.join(self._save_dir, subset_name)
+            os.makedirs(subset_dir, exist_ok=True)
+            os.makedirs(osp.join(subset_dir, LabelMePath.MASKS_DIR),
+                exist_ok=True)
+
+            for index, item in enumerate(subset):
+                self._save_item(item, subset_dir, index)
+
+    def _get_label(self, label_id):
+        if label_id is None:
+            return ''
+        return self._extractor.categories()[AnnotationType.label][label_id].name
+
+    def _save_item(self, item, subset_dir, index):
+        from lxml import etree as ET
+
+        log.debug("Converting item '%s'", item.id)
+
+        image_filename = 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_filename))
+            else:
+                log.debug("Item '%s' has no image", item.id)
+
+        root_elem = ET.Element('annotation')
+        ET.SubElement(root_elem, 'filename').text = osp.basename(image_filename)
+        ET.SubElement(root_elem, 'folder').text = osp.dirname(image_filename)
+
+        source_elem = ET.SubElement(root_elem, 'source')
+        ET.SubElement(source_elem, 'sourceImage').text = ''
+        ET.SubElement(source_elem, 'sourceAnnotation').text = 'Datumaro'
+
+        if item.has_image:
+            image_elem = ET.SubElement(root_elem, 'imagesize')
+            image_size = item.image.size
+            ET.SubElement(image_elem, 'nrows').text = str(image_size[0])
+            ET.SubElement(image_elem, 'ncols').text = str(image_size[1])
+
+        groups = defaultdict(list)
+
+        obj_id = 0
+        for ann in item.annotations:
+            if not ann.type in { AnnotationType.polygon,
+                    AnnotationType.bbox, AnnotationType.mask }:
+                continue
+
+            obj_elem = ET.SubElement(root_elem, 'object')
+            ET.SubElement(obj_elem, 'name').text = self._get_label(ann.label)
+            ET.SubElement(obj_elem, 'deleted').text = '0'
+            ET.SubElement(obj_elem, 'verified').text = '0'
+            ET.SubElement(obj_elem, 'occluded').text = \
+                'yes' if ann.attributes.pop('occluded', '') == True else 'no'
+            ET.SubElement(obj_elem, 'date').text = ''
+            ET.SubElement(obj_elem, 'id').text = str(obj_id)
+
+            parts_elem = ET.SubElement(obj_elem, 'parts')
+            if ann.group:
+                groups[ann.group].append((obj_id, parts_elem))
+            else:
+                ET.SubElement(parts_elem, 'hasparts').text = ''
+                ET.SubElement(parts_elem, 'ispartof').text = ''
+
+            if ann.type == AnnotationType.bbox:
+                ET.SubElement(obj_elem, 'type').text = 'bounding_box'
+
+                poly_elem = ET.SubElement(obj_elem, 'polygon')
+                x0, y0, x1, y1 = ann.points
+                points = [ (x0, y0), (x1, y0), (x1, y1), (x0, y1) ]
+                for x, y in points:
+                    point_elem = ET.SubElement(poly_elem, 'pt')
+                    ET.SubElement(point_elem, 'x').text = '%.2f' % x
+                    ET.SubElement(point_elem, 'y').text = '%.2f' % y
+
+                ET.SubElement(poly_elem, 'username').text = \
+                    str(ann.attributes.pop('username', ''))
+            elif ann.type == AnnotationType.polygon:
+                poly_elem = ET.SubElement(obj_elem, 'polygon')
+                for x, y in zip(ann.points[::2], ann.points[1::2]):
+                    point_elem = ET.SubElement(poly_elem, 'pt')
+                    ET.SubElement(point_elem, 'x').text = '%.2f' % x
+                    ET.SubElement(point_elem, 'y').text = '%.2f' % y
+
+                ET.SubElement(poly_elem, 'username').text = \
+                    str(ann.attributes.pop('username', ''))
+            elif ann.type == AnnotationType.mask:
+                mask_filename = '%s_mask_%s.png' % \
+                    (item.id.replace('/', '_'), obj_id)
+                save_image(osp.join(subset_dir, LabelMePath.MASKS_DIR,
+                        mask_filename),
+                    self._paint_mask(ann.image))
+
+                segm_elem = ET.SubElement(obj_elem, 'segm')
+                ET.SubElement(segm_elem, 'mask').text = mask_filename
+
+                bbox = find_mask_bbox(ann.image)
+                box_elem = ET.SubElement(segm_elem, 'box')
+                ET.SubElement(box_elem, 'xmin').text = '%.2f' % bbox[0]
+                ET.SubElement(box_elem, 'ymin').text = '%.2f' % bbox[1]
+                ET.SubElement(box_elem, 'xmax').text = \
+                    '%.2f' % (bbox[0] + bbox[2])
+                ET.SubElement(box_elem, 'ymax').text = \
+                    '%.2f' % (bbox[1] + bbox[3])
+
+                ET.SubElement(segm_elem, 'username').text = \
+                    str(ann.attributes.pop('username', ''))
+            else:
+                raise NotImplementedError("Unknown shape type '%s'" % ann.type)
+
+            attrs = []
+            for k, v in ann.attributes.items():
+                attrs.append('%s=%s' % (k, v))
+            ET.SubElement(obj_elem, 'attributes').text = ', '.join(attrs)
+
+            obj_id += 1
+
+        for _, group in groups.items():
+            leader_id, leader_parts_elem = group[0]
+            leader_parts = [str(o_id) for o_id, _ in group[1:]]
+            ET.SubElement(leader_parts_elem, 'hasparts').text = \
+                ','.join(leader_parts)
+            ET.SubElement(leader_parts_elem, 'ispartof').text = ''
+
+            for obj_id, parts_elem in group[1:]:
+                ET.SubElement(parts_elem, 'hasparts').text = ''
+                ET.SubElement(parts_elem, 'ispartof').text = str(leader_id)
+
+        xml_path = osp.join(subset_dir, 'item_%09d.xml' % index)
+        with open(xml_path, 'w', encoding='utf-8') as f:
+            xml_data = ET.tostring(root_elem, encoding='unicode',
+                pretty_print=True)
+            f.write(xml_data)
+
+    @staticmethod
+    def _paint_mask(mask):
+        # TODO: check if mask colors are random
+        return np.array([[0, 0, 0, 0], [255, 203, 0, 153]],
+            dtype=np.uint8)[mask.astype(np.uint8)]

testbed/openvinotoolkit__datumaro/datumaro/plugins/mot_format.py

@@ -0,0 +1,271 @@
+# Copyright (C) 2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+# The Multiple Object Tracking Benchmark challenge format support
+# Format description: https://arxiv.org/pdf/1906.04567.pdf
+# Another description: https://motchallenge.net/instructions
+
+from collections import OrderedDict
+import csv
+from enum import Enum
+import logging as log
+import os
+import os.path as osp
+
+from datumaro.components.extractor import (SourceExtractor, Importer,
+    DatasetItem, AnnotationType, Bbox, LabelCategories
+)
+from datumaro.components.converter import Converter
+from datumaro.util import cast
+from datumaro.util.image import Image
+
+
+MotLabel = Enum('MotLabel', [
+    ('pedestrian', 1),
+    ('person on vehicle', 2),
+    ('car', 3),
+    ('bicycle', 4),
+    ('motorbike', 5),
+    ('non motorized vehicle', 6),
+    ('static person', 7),
+    ('distractor', 8),
+    ('occluder', 9),
+    ('occluder on the ground', 10),
+    ('occluder full', 11),
+    ('reflection', 12),
+])
+
+class MotPath:
+    IMAGE_DIR = 'img1'
+    SEQINFO_FILE = 'seqinfo.ini'
+    LABELS_FILE = 'labels.txt'
+    GT_FILENAME = 'gt.txt'
+    DET_FILENAME = 'det.txt'
+
+    IMAGE_EXT = '.jpg'
+
+    FIELDS = [
+        'frame_id',
+        'track_id',
+        'x',
+        'y',
+        'w',
+        'h',
+        'confidence', # or 'not ignored' flag for GT anns
+        'class_id',
+        'visibility'
+    ]
+
+
+class MotSeqExtractor(SourceExtractor):
+    def __init__(self, path, labels=None, occlusion_threshold=0, is_gt=None):
+        super().__init__()
+
+        assert osp.isfile(path)
+        seq_root = osp.dirname(osp.dirname(path))
+        self._image_dir = ''
+        if osp.isdir(osp.join(seq_root, MotPath.IMAGE_DIR)):
+            self._image_dir = osp.join(seq_root, MotPath.IMAGE_DIR)
+
+        seq_info = osp.join(seq_root, MotPath.SEQINFO_FILE)
+        if osp.isfile(seq_info):
+            seq_info = self._parse_seq_info(seq_info)
+            self._image_dir = osp.join(seq_root, seq_info['imdir'])
+        else:
+            seq_info = None
+        self._seq_info = seq_info
+
+        self._occlusion_threshold = float(occlusion_threshold)
+
+        assert is_gt in {None, True, False}
+        if is_gt is None:
+            if osp.basename(path) == MotPath.DET_FILENAME:
+                is_gt = False
+            else:
+                is_gt = True
+        self._is_gt = is_gt
+
+        if labels is None:
+            labels = osp.join(osp.dirname(path), MotPath.LABELS_FILE)
+            if not osp.isfile(labels):
+                labels = [lbl.name for lbl in MotLabel]
+        if isinstance(labels, str):
+            labels = self._parse_labels(labels)
+        elif isinstance(labels, list):
+            assert all(isinstance(lbl, str) for lbl in labels), labels
+        else:
+            raise TypeError("Unexpected type of 'labels' argument: %s" % labels)
+        self._categories = self._load_categories(labels)
+        self._items = list(self._load_items(path).values())
+
+    @staticmethod
+    def _parse_labels(path):
+        with open(path, encoding='utf-8') as labels_file:
+            return [s.strip() for s in labels_file]
+
+    def _load_categories(self, labels):
+        attributes = ['track_id']
+        if self._is_gt:
+            attributes += ['occluded', 'visibility', 'ignored']
+        else:
+            attributes += ['score']
+        label_cat = LabelCategories(attributes=attributes)
+        for label in labels:
+            label_cat.add(label)
+
+        return { AnnotationType.label: label_cat }
+
+    def _load_items(self, path):
+        labels_count = len(self._categories[AnnotationType.label].items)
+        items = OrderedDict()
+
+        if self._seq_info:
+            for frame_id in range(self._seq_info['seqlength']):
+                items[frame_id] = DatasetItem(
+                    id=frame_id,
+                    subset=self._subset,
+                    image=Image(
+                        path=osp.join(self._image_dir,
+                            '%06d%s' % (frame_id, self._seq_info['imext'])),
+                        size=(self._seq_info['imheight'], self._seq_info['imwidth'])
+                    )
+                )
+        elif osp.isdir(self._image_dir):
+            for p in os.listdir(self._image_dir):
+                if p.endswith(MotPath.IMAGE_EXT):
+                    frame_id = int(osp.splitext(p)[0])
+                    items[frame_id] = DatasetItem(
+                        id=frame_id,
+                        subset=self._subset,
+                        image=osp.join(self._image_dir, p),
+                    )
+
+        with open(path, newline='', encoding='utf-8') as csv_file:
+            # NOTE: Different MOT files have different count of fields
+            # (7, 9 or 10). This is handled by reader:
+            # - all extra fields go to a separate field
+            # - all unmet fields have None values
+            for row in csv.DictReader(csv_file, fieldnames=MotPath.FIELDS):
+                frame_id = int(row['frame_id'])
+                item = items.get(frame_id)
+                if item is None:
+                    item = DatasetItem(id=frame_id, subset=self._subset)
+                annotations = item.annotations
+
+                x, y = float(row['x']), float(row['y'])
+                w, h = float(row['w']), float(row['h'])
+                label_id = row.get('class_id')
+                if label_id and label_id != '-1':
+                    label_id = int(label_id) - 1
+                    assert label_id < labels_count, label_id
+                else:
+                    label_id = None
+
+                attributes = {}
+
+                # Annotations for detection task are not related to any track
+                track_id = int(row['track_id'])
+                if 0 < track_id:
+                    attributes['track_id'] = track_id
+
+                confidence = cast(row.get('confidence'), float, 1)
+                visibility = cast(row.get('visibility'), float, 1)
+                if self._is_gt:
+                    attributes['visibility'] = visibility
+                    attributes['occluded'] = \
+                        visibility <= self._occlusion_threshold
+                    attributes['ignored'] = confidence == 0
+                else:
+                    attributes['score'] = float(confidence)
+
+                annotations.append(Bbox(x, y, w, h, label=label_id,
+                    attributes=attributes))
+
+                items[frame_id] = item
+        return items
+
+    @classmethod
+    def _parse_seq_info(cls, path):
+        fields = {}
+        with open(path, encoding='utf-8') as f:
+            for line in f:
+                entry = line.lower().strip().split('=', maxsplit=1)
+                if len(entry) == 2:
+                    fields[entry[0]] = entry[1]
+        cls._check_seq_info(fields)
+        for k in { 'framerate', 'seqlength', 'imwidth', 'imheight' }:
+            fields[k] = int(fields[k])
+        return fields
+
+    @staticmethod
+    def _check_seq_info(seq_info):
+        assert set(seq_info) == {'name', 'imdir', 'framerate', 'seqlength', 'imwidth', 'imheight', 'imext'}, seq_info
+
+class MotSeqImporter(Importer):
+    @classmethod
+    def find_sources(cls, path):
+        return cls._find_sources_recursive(path, '.txt', 'mot_seq',
+            filename=osp.join('gt', osp.splitext(MotPath.GT_FILENAME)[0]))
+
+class MotSeqGtConverter(Converter):
+    DEFAULT_IMAGE_EXT = MotPath.IMAGE_EXT
+
+    def apply(self):
+        extractor = self._extractor
+
+        images_dir = osp.join(self._save_dir, MotPath.IMAGE_DIR)
+        os.makedirs(images_dir, exist_ok=True)
+        self._images_dir = images_dir
+
+        anno_dir = osp.join(self._save_dir, 'gt')
+        os.makedirs(anno_dir, exist_ok=True)
+        anno_file = osp.join(anno_dir, MotPath.GT_FILENAME)
+        with open(anno_file, 'w', encoding="utf-8") as csv_file:
+            writer = csv.DictWriter(csv_file, fieldnames=MotPath.FIELDS)
+
+            track_id_mapping = {-1: -1}
+            for idx, item in enumerate(extractor):
+                log.debug("Converting item '%s'", item.id)
+
+                frame_id = cast(item.id, int, 1 + idx)
+
+                for anno in item.annotations:
+                    if anno.type != AnnotationType.bbox:
+                        continue
+
+                    track_id = int(anno.attributes.get('track_id', -1))
+                    if track_id not in track_id_mapping:
+                        track_id_mapping[track_id] = len(track_id_mapping)
+                    track_id = track_id_mapping[track_id]
+
+                    writer.writerow({
+                        'frame_id': frame_id,
+                        'track_id': track_id,
+                        'x': anno.x,
+                        'y': anno.y,
+                        'w': anno.w,
+                        'h': anno.h,
+                        'confidence': int(anno.attributes.get('ignored') != True),
+                        'class_id': 1 + cast(anno.label, int, -2),
+                        'visibility': float(
+                            anno.attributes.get('visibility',
+                                1 - float(
+                                    anno.attributes.get('occluded', False)
+                                )
+                            )
+                        )
+                    })
+
+                if self._save_images:
+                    if item.has_image and item.image.has_data:
+                        self._save_image(item, osp.join(self._images_dir,
+                            '%06d%s' % (frame_id, self._find_image_ext(item))))
+                    else:
+                        log.debug("Item '%s' has no image", item.id)
+
+        labels_file = osp.join(anno_dir, MotPath.LABELS_FILE)
+        with open(labels_file, 'w', encoding='utf-8') as f:
+            f.write('\n'.join(l.name
+                for l in extractor.categories()[AnnotationType.label])
+            )

testbed/openvinotoolkit__datumaro/datumaro/plugins/mots_format.py

@@ -0,0 +1,145 @@
+# Copyright (C) 2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+# Implements MOTS format https://www.vision.rwth-aachen.de/page/mots
+
+from enum import Enum
+from glob import glob
+import logging as log
+import numpy as np
+import os
+import os.path as osp
+
+from datumaro.components.extractor import (SourceExtractor, Importer,
+    DatasetItem, AnnotationType, Mask, LabelCategories
+)
+from datumaro.components.converter import Converter
+from datumaro.util.image import load_image, save_image
+from datumaro.util.mask_tools import merge_masks
+
+
+class MotsPath:
+    MASKS_DIR = 'instances'
+    IMAGE_DIR = 'images'
+    IMAGE_EXT = '.jpg'
+    LABELS_FILE = 'labels.txt'
+    MAX_INSTANCES = 1000
+
+MotsLabels = Enum('MotsLabels', [
+    ('background', 0),
+    ('car', 1),
+    ('pedestrian', 2),
+    ('ignored', 10),
+])
+
+class MotsPngExtractor(SourceExtractor):
+    @staticmethod
+    def detect_dataset(path):
+        if osp.isdir(osp.join(path, MotsPath.MASKS_DIR)):
+            return [{'url': path, 'format': 'mots_png'}]
+        return []
+
+    def __init__(self, path, subset_name=None):
+        assert osp.isdir(path), path
+        super().__init__(subset=subset_name)
+        self._images_dir = osp.join(path, 'images')
+        self._anno_dir = osp.join(path, MotsPath.MASKS_DIR)
+        self._categories = self._parse_categories(
+            osp.join(self._anno_dir, MotsPath.LABELS_FILE))
+        self._items = self._parse_items()
+
+    def _parse_categories(self, path):
+        if osp.isfile(path):
+            with open(path) as f:
+                labels = [l.strip() for l in f]
+        else:
+            labels = [l.name for l in MotsLabels]
+        return { AnnotationType.label: LabelCategories.from_iterable(labels) }
+
+    def _parse_items(self):
+        items = []
+        for p in sorted(p for p in
+                glob(self._anno_dir + '/**/*.png', recursive=True)):
+            item_id = osp.splitext(osp.relpath(p, self._anno_dir))[0]
+            items.append(DatasetItem(id=item_id, subset=self._subset,
+                image=osp.join(self._images_dir, item_id + MotsPath.IMAGE_EXT),
+                annotations=self._parse_annotations(p)))
+        return items
+
+    @staticmethod
+    def _lazy_extract_mask(mask, v):
+        return lambda: mask == v
+
+    def _parse_annotations(self, path):
+        combined_mask = load_image(path, dtype=np.uint16)
+        masks = []
+        for obj_id in np.unique(combined_mask):
+            class_id, instance_id = divmod(obj_id, MotsPath.MAX_INSTANCES)
+            z_order = 0
+            if class_id == 0:
+                continue # background
+            if class_id == 10 and \
+                    len(self._categories[AnnotationType.label]) < 10:
+                z_order = 1
+                class_id = self._categories[AnnotationType.label].find(
+                    MotsLabels.ignored.name)[0]
+            else:
+                class_id -= 1
+            masks.append(Mask(self._lazy_extract_mask(combined_mask, obj_id),
+                label=class_id, z_order=z_order,
+                attributes={'track_id': instance_id}))
+        return masks
+
+
+class MotsImporter(Importer):
+    @classmethod
+    def find_sources(cls, path):
+        subsets = MotsPngExtractor.detect_dataset(path)
+        if not subsets:
+            for p in os.listdir(path):
+                detected = MotsPngExtractor.detect_dataset(osp.join(path, p))
+                for s in detected:
+                    s.setdefault('options', {})['subset_name'] = p
+                subsets.extend(detected)
+        return subsets
+
+
+class MotsPngConverter(Converter):
+    DEFAULT_IMAGE_EXT = MotsPath.IMAGE_EXT
+
+    def apply(self):
+        for subset_name, subset in self._extractor.subsets().items():
+            subset_dir = osp.join(self._save_dir, subset_name)
+            images_dir = osp.join(subset_dir, MotsPath.IMAGE_DIR)
+            anno_dir = osp.join(subset_dir, MotsPath.MASKS_DIR)
+            os.makedirs(anno_dir, exist_ok=True)
+
+            for item in subset:
+                log.debug("Converting item '%s'", item.id)
+
+                if self._save_images:
+                    if item.has_image and item.image.has_data:
+                        self._save_image(item,
+                            osp.join(images_dir, self._make_image_filename(item)))
+                    else:
+                        log.debug("Item '%s' has no image", item.id)
+
+                self._save_annotations(item, anno_dir)
+
+            with open(osp.join(anno_dir, MotsPath.LABELS_FILE), 'w') as f:
+                f.write('\n'.join(l.name
+                    for l in subset.categories()[AnnotationType.label].items))
+
+    def _save_annotations(self, item, anno_dir):
+        masks = [a for a in item.annotations if a.type == AnnotationType.mask]
+        if not masks:
+            return
+
+        instance_ids = [int(a.attributes['track_id']) for a in masks]
+        masks = sorted(zip(masks, instance_ids), key=lambda e: e[0].z_order)
+        mask = merge_masks([
+            m.image * (MotsPath.MAX_INSTANCES * (1 + m.label) + id)
+            for m, id in masks])
+        save_image(osp.join(anno_dir, item.id + '.png'), mask,
+            create_dir=True, dtype=np.uint16)

testbed/openvinotoolkit__datumaro/datumaro/plugins/openvino_launcher.py

@@ -0,0 +1,188 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+# pylint: disable=exec-used
+
+import cv2
+import logging as log
+import numpy as np
+import os.path as osp
+import shutil
+
+from openvino.inference_engine import IECore
+
+from datumaro.components.cli_plugin import CliPlugin
+from datumaro.components.launcher import Launcher
+
+
+class OpenVinoImporter(CliPlugin):
+    @classmethod
+    def build_cmdline_parser(cls, **kwargs):
+        parser = super().build_cmdline_parser(**kwargs)
+        parser.add_argument('-d', '--description', required=True,
+            help="Path to the model description file (.xml)")
+        parser.add_argument('-w', '--weights', required=True,
+            help="Path to the model weights file (.bin)")
+        parser.add_argument('-i', '--interpreter', required=True,
+            help="Path to the network output interprter script (.py)")
+        parser.add_argument('--device', default='CPU',
+            help="Target device (default: %(default)s)")
+        return parser
+
+    @staticmethod
+    def copy_model(model_dir, model):
+        shutil.copy(model['description'],
+            osp.join(model_dir, osp.basename(model['description'])))
+        model['description'] = osp.basename(model['description'])
+
+        shutil.copy(model['weights'],
+            osp.join(model_dir, osp.basename(model['weights'])))
+        model['weights'] = osp.basename(model['weights'])
+
+        shutil.copy(model['interpreter'],
+            osp.join(model_dir, osp.basename(model['interpreter'])))
+        model['interpreter'] = osp.basename(model['interpreter'])
+
+
+class InterpreterScript:
+    def __init__(self, path):
+        with open(path, 'r') as f:
+            script = f.read()
+
+        context = {}
+        exec(script, context, context)
+
+        process_outputs = context.get('process_outputs')
+        if not callable(process_outputs):
+            raise Exception("Can't find 'process_outputs' function in "
+                "the interpreter script")
+        self.__dict__['process_outputs'] = process_outputs
+
+        get_categories = context.get('get_categories')
+        assert get_categories is None or callable(get_categories)
+        if get_categories:
+            self.__dict__['get_categories'] = get_categories
+
+    @staticmethod
+    def get_categories():
+        return None
+
+    @staticmethod
+    def process_outputs(inputs, outputs):
+        raise NotImplementedError(
+            "Function should be implemented in the interpreter script")
+
+
+class OpenVinoLauncher(Launcher):
+    cli_plugin = OpenVinoImporter
+
+    def __init__(self, description, weights, interpreter,
+            plugins_path=None, device=None, model_dir=None):
+        model_dir = model_dir or ''
+        if not osp.isfile(description):
+            description = osp.join(model_dir, description)
+        if not osp.isfile(description):
+            raise Exception('Failed to open model description file "%s"' % \
+                (description))
+
+        if not osp.isfile(weights):
+            weights = osp.join(model_dir, weights)
+        if not osp.isfile(weights):
+            raise Exception('Failed to open model weights file "%s"' % \
+                (weights))
+
+        if not osp.isfile(interpreter):
+            interpreter = osp.join(model_dir, interpreter)
+        if not osp.isfile(interpreter):
+            raise Exception('Failed to open model interpreter script file "%s"' % \
+                (interpreter))
+
+        self._interpreter = InterpreterScript(interpreter)
+
+        self._device = device or 'CPU'
+
+        self._ie = IECore()
+        if hasattr(self._ie, 'read_network'):
+            self._network = self._ie.read_network(description, weights)
+        else: # backward compatibility
+            from openvino.inference_engine import IENetwork
+            self._network = IENetwork.from_ir(description, weights)
+        self._check_model_support(self._network, self._device)
+        self._load_executable_net()
+
+    def _check_model_support(self, net, device):
+        supported_layers = set(self._ie.query_network(net, device))
+        not_supported_layers = set(net.layers) - supported_layers
+        if len(not_supported_layers) != 0:
+            log.error("The following layers are not supported " \
+                "by the plugin for device '%s': %s." % \
+                (device, ', '.join(not_supported_layers)))
+            raise NotImplementedError(
+                "Some layers are not supported on the device")
+
+    def _load_executable_net(self, batch_size=1):
+        network = self._network
+
+        iter_inputs = iter(network.inputs)
+        self._input_blob_name = next(iter_inputs)
+        self._output_blob_name = next(iter(network.outputs))
+
+        # NOTE: handling for the inclusion of `image_info` in OpenVino2019
+        self._require_image_info = 'image_info' in network.inputs
+        if self._input_blob_name == 'image_info':
+            self._input_blob_name = next(iter_inputs)
+
+        input_type = network.inputs[self._input_blob_name]
+        self._input_layout = input_type if isinstance(input_type, list) else input_type.shape
+
+        self._input_layout[0] = batch_size
+        network.reshape({self._input_blob_name: self._input_layout})
+        self._batch_size = batch_size
+
+        self._net = self._ie.load_network(network=network, num_requests=1,
+            device_name=self._device)
+
+    def infer(self, inputs):
+        assert len(inputs.shape) == 4, \
+            "Expected an input image in (N, H, W, C) format, got %s" % \
+            (inputs.shape)
+        assert inputs.shape[3] == 3, "Expected BGR input, got %s" % inputs.shape
+
+        n, c, h, w = self._input_layout
+        if inputs.shape[1:3] != (h, w):
+            resized_inputs = np.empty((n, h, w, c), dtype=inputs.dtype)
+            for inp, resized_input in zip(inputs, resized_inputs):
+                cv2.resize(inp, (w, h), resized_input)
+            inputs = resized_inputs
+        inputs = inputs.transpose((0, 3, 1, 2)) # NHWC to NCHW
+        inputs = {self._input_blob_name: inputs}
+        if self._require_image_info:
+            info = np.zeros([1, 3])
+            info[0, 0] = h
+            info[0, 1] = w
+            info[0, 2] = 1.0 # scale
+            inputs['image_info'] = info
+
+        results = self._net.infer(inputs)
+        if len(results) == 1:
+            return results[self._output_blob_name]
+        else:
+            return results
+
+    def launch(self, inputs):
+        batch_size = len(inputs)
+        if self._batch_size < batch_size:
+            self._load_executable_net(batch_size)
+
+        outputs = self.infer(inputs)
+        results = self.process_outputs(inputs, outputs)
+        return results
+
+    def categories(self):
+        return self._interpreter.get_categories()
+
+    def process_outputs(self, inputs, outputs):
+        return self._interpreter.process_outputs(inputs, outputs)
+

testbed/openvinotoolkit__datumaro/datumaro/plugins/splitter.py

@@ -0,0 +1,522 @@
+# Copyright (C) 2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+import logging as log
+import numpy as np
+
+from datumaro.components.extractor import (Transform, AnnotationType,
+    DEFAULT_SUBSET_NAME)
+
+NEAR_ZERO = 1e-7
+
+
+class _TaskSpecificSplit(Transform):
+    def __init__(self, dataset, splits, seed):
+        super().__init__(dataset)
+
+        snames, sratio = self._validate_splits(splits)
+
+        self._snames = snames
+        self._sratio = sratio
+
+        self._seed = seed
+
+        self._subsets = {"train", "val", "test"}  # output subset names
+        self._parts = []
+        self._length = "parent"
+
+        self._initialized = False
+
+    def _set_parts(self, by_splits):
+        self._parts = []
+        for subset in self._subsets:
+            self._parts.append((set(by_splits[subset]), subset))
+
+    @staticmethod
+    def _get_uniq_annotations(dataset):
+        annotations = []
+        for item in dataset:
+            labels = [a for a in item.annotations
+                if a.type == AnnotationType.label]
+            if len(labels) != 1:
+                raise Exception("Item '%s' contains %s labels, "
+                    "but exactly one is expected" % (item.id, len(labels)))
+            annotations.append(labels[0])
+        return annotations
+
+    @staticmethod
+    def _validate_splits(splits, valid=None):
+        snames = []
+        ratios = []
+        if valid is None:
+            valid = ["train", "val", "test"]
+        for subset, ratio in splits:
+            assert subset in valid, \
+                "Subset name must be one of %s, but got %s" % (valid, subset)
+            assert 0.0 <= ratio and ratio <= 1.0, \
+                "Ratio is expected to be in the range " \
+                "[0, 1], but got %s for %s" % (ratio, subset)
+            snames.append(subset)
+            ratios.append(float(ratio))
+        ratios = np.array(ratios)
+
+        total_ratio = np.sum(ratios)
+        if not abs(total_ratio - 1.0) <= NEAR_ZERO:
+            raise Exception(
+                "Sum of ratios is expected to be 1, got %s, which is %s"
+                % (splits, total_ratio)
+            )
+        return snames, ratios
+
+    @staticmethod
+    def _get_required(ratio):
+        min_value = np.max(ratio)
+        for i in ratio:
+            if NEAR_ZERO < i and i < min_value:
+                min_value = i
+        required = int(np.around(1.0) / min_value)
+        return required
+
+    @staticmethod
+    def _get_sections(dataset_size, ratio):
+        n_splits = [int(np.around(dataset_size * r)) for r in ratio[:-1]]
+        n_splits.append(dataset_size - np.sum(n_splits))
+
+        # if there are splits with zero samples even if ratio is not 0,
+        # borrow one from the split who has one or more.
+        for ii, num_split in enumerate(n_splits):
+            if num_split == 0 and NEAR_ZERO < ratio[ii]:
+                midx = np.argmax(n_splits)
+                if n_splits[midx] > 0:
+                    n_splits[ii] += 1
+                    n_splits[midx] -= 1
+        sections = np.add.accumulate(n_splits[:-1])
+        return sections
+
+    @staticmethod
+    def _group_by_attr(items):
+        """
+        Args:
+            items: list of (idx, ann). ann is the annotation from Label object.
+        Returns:
+            by_attributes: dict of { combination-of-attrs : list of index }
+        """
+        # group by attributes
+        by_attributes = dict()
+        for idx, ann in items:
+            attributes = tuple(sorted(ann.attributes.items()))
+            if attributes not in by_attributes:
+                by_attributes[attributes] = []
+            by_attributes[attributes].append(idx)
+        return by_attributes
+
+    def _split_by_attr(self, datasets, snames, ratio, out_splits,
+            dataset_key="label"):
+        required = self._get_required(ratio)
+        for key, items in datasets.items():
+            np.random.shuffle(items)
+            by_attributes = self._group_by_attr(items)
+            for attributes, indice in by_attributes.items():
+                gname = "%s: %s, attrs: %s" % (dataset_key, key, attributes)
+                splits = self._split_indice(indice, gname, ratio, required)
+                for subset, split in zip(snames, splits):
+                    if 0 < len(split):
+                        out_splits[subset].extend(split)
+
+    def _split_indice(self, indice, group_name, ratio, required):
+        filtered_size = len(indice)
+        if filtered_size < required:
+            log.warning("Not enough samples for a group, '%s'" % group_name)
+        sections = self._get_sections(filtered_size, ratio)
+        splits = np.array_split(indice, sections)
+        return splits
+
+    def _find_split(self, index):
+        for subset_indices, subset in self._parts:
+            if index in subset_indices:
+                return subset
+        return DEFAULT_SUBSET_NAME  # all the possible remainder --> default
+
+    def _split_dataset(self):
+        raise NotImplementedError()
+
+    def __iter__(self):
+        # lazy splitting
+        if self._initialized is False:
+            self._split_dataset()
+            self._initialized = True
+        for i, item in enumerate(self._extractor):
+            yield self.wrap_item(item, subset=self._find_split(i))
+
+
+class ClassificationSplit(_TaskSpecificSplit):
+    """
+    Splits dataset into train/val/test set in class-wise manner. |n
+    |n
+    Notes:|n
+    - Single label is expected for each DatasetItem.|n
+    - If there are not enough images in some class or attributes group,
+      the split ratio can't be guaranteed.|n
+    """
+
+    def __init__(self, dataset, splits, seed=None):
+        """
+        Parameters
+        ----------
+        dataset : Dataset
+        splits : list
+            A list of (subset(str), ratio(float))
+            Subset is expected to be one of ["train", "val", "test"].
+            The sum of ratios is expected to be 1.
+        seed : int, optional
+        """
+        super().__init__(dataset, splits, seed)
+
+    def _split_dataset(self):
+        np.random.seed(self._seed)
+
+        # support only single label for a DatasetItem
+        # 1. group by label
+        by_labels = dict()
+        annotations = self._get_uniq_annotations(self._extractor)
+        for idx, ann in enumerate(annotations):
+            label = getattr(ann, 'label', None)
+            if label not in by_labels:
+                by_labels[label] = []
+            by_labels[label].append((idx, ann))
+
+        by_splits = dict()
+        for subset in self._subsets:
+            by_splits[subset] = []
+
+        # 2. group by attributes
+        self._split_by_attr(by_labels, self._snames, self._sratio, by_splits)
+        self._set_parts(by_splits)
+
+
+class MatchingReIDSplit(_TaskSpecificSplit):
+    """
+    Splits dataset for matching, especially re-id task.|n
+    First, splits dataset into 'train+val' and 'test' sets by person id.|n
+    Note that this splitting is not by DatasetItem. |n
+    Then, tags 'test' into 'gallery'/'query' in class-wise random manner.|n
+    Then, splits 'train+val' into 'train'/'val' sets in the same way.|n
+    Therefore, the final subsets would be 'train', 'val', 'test'. |n
+    And 'gallery', 'query' are tagged using anntoation group.|n
+    You can get the 'gallery' and 'query' sets using 'get_subset_by_group'.|n
+    Notes:|n
+    - Single label is expected for each DatasetItem.|n
+    - Each label is expected to have attribute representing the person id. |n
+    """
+
+    _group_map = dict()
+
+    def __init__(self, dataset, splits, test_splits, pid_name="PID", seed=None):
+        """
+        Parameters
+        ----------
+        dataset : Dataset
+        splits : list
+            A list of (subset(str), ratio(float))
+            Subset is expected to be one of ["train", "val", "test"].
+            The sum of ratios is expected to be 1.
+        test_splits : list
+            A list of (subset(str), ratio(float))
+            Subset is expected to be one of ["gallery", "query"].
+            The sum of ratios is expected to be 1.
+        pid_name: str
+            attribute name representing the person id. (default: PID)
+        seed : int, optional
+        """
+        super().__init__(dataset, splits, seed)
+
+        self._test_splits = test_splits
+        self._pid_name = pid_name
+
+    def _split_dataset(self):
+        np.random.seed(self._seed)
+
+        id_snames, id_ratio = self._snames, self._sratio
+
+        pid_name = self._pid_name
+        dataset = self._extractor
+
+        groups = set()
+
+        # group by PID(pid_name)
+        by_pid = dict()
+        annotations = self._get_uniq_annotations(dataset)
+        for idx, ann in enumerate(annotations):
+            attributes = dict(ann.attributes.items())
+            assert pid_name in attributes, \
+                "'%s' is expected as an attribute name" % pid_name
+            person_id = attributes[pid_name]
+            if person_id not in by_pid:
+                by_pid[person_id] = []
+            by_pid[person_id].append((idx, ann))
+            groups.add(ann.group)
+
+        max_group_id = max(groups)
+        self._group_map["gallery"] = max_group_id + 1
+        self._group_map["query"] = max_group_id + 2
+
+        required = self._get_required(id_ratio)
+        if len(by_pid) < required:
+            log.warning("There's not enough IDs, which is %s, "
+                "so train/val/test ratio can't be guaranteed."
+                % len(by_pid)
+            )
+
+        # 1. split dataset into trval and test
+        #    IDs in test set should not exist in train/val set.
+        test = id_ratio[id_snames.index("test")] if "test" in id_snames else 0
+        if NEAR_ZERO < test:  # has testset
+            split_ratio = np.array([test, 1.0 - test])
+            person_ids = list(by_pid.keys())
+            np.random.shuffle(person_ids)
+            sections = self._get_sections(len(person_ids), split_ratio)
+            splits = np.array_split(person_ids, sections)
+            testset = {pid: by_pid[pid] for pid in splits[0]}
+            trval = {pid: by_pid[pid] for pid in splits[1]}
+
+            # follow the ratio of datasetitems as possible.
+            # naive heuristic: exchange the best item one by one.
+            expected_count = int(len(self._extractor) * split_ratio[0])
+            testset_total = int(np.sum([len(v) for v in testset.values()]))
+            self._rebalancing(testset, trval, expected_count, testset_total)
+        else:
+            testset = dict()
+            trval = by_pid
+
+        by_splits = dict()
+        for subset in self._subsets:
+            by_splits[subset] = []
+
+        # 2. split 'test' into 'gallery' and 'query'
+        if 0 < len(testset):
+            for person_id, items in testset.items():
+                indice = [idx for idx, _ in items]
+                by_splits["test"].extend(indice)
+
+            valid = ["gallery", "query"]
+            test_splits = self._test_splits
+            test_snames, test_ratio = self._validate_splits(test_splits, valid)
+            by_groups = {s: [] for s in test_snames}
+            self._split_by_attr(testset, test_snames, test_ratio, by_groups,
+                dataset_key=pid_name)
+
+            # tag using group
+            for idx, item in enumerate(self._extractor):
+                for subset, split in by_groups.items():
+                    if idx in split:
+                        group_id = self._group_map[subset]
+                        item.annotations[0].group = group_id
+                        break
+
+        # 3. split 'trval' into  'train' and 'val'
+        trval_snames = ["train", "val"]
+        trval_ratio = []
+        for subset in trval_snames:
+            if subset in id_snames:
+                val = id_ratio[id_snames.index(subset)]
+            else:
+                val = 0.0
+            trval_ratio.append(val)
+        trval_ratio = np.array(trval_ratio)
+        total_ratio = np.sum(trval_ratio)
+        if total_ratio < NEAR_ZERO:
+            trval_splits = list(zip(["train", "val"], trval_ratio))
+            log.warning("Sum of ratios is expected to be positive, "
+                "got %s, which is %s"
+                % (trval_splits, total_ratio)
+            )
+        else:
+            trval_ratio /= total_ratio  # normalize
+            self._split_by_attr(trval, trval_snames, trval_ratio, by_splits,
+                dataset_key=pid_name)
+
+        self._set_parts(by_splits)
+
+    @staticmethod
+    def _rebalancing(test, trval, expected_count, testset_total):
+        diffs = dict()
+        for id_test, items_test in test.items():
+            count_test = len(items_test)
+            for id_trval, items_trval in trval.items():
+                count_trval = len(items_trval)
+                diff = count_trval - count_test
+                if diff == 0:
+                    continue  # exchange has no effect
+                if diff not in diffs:
+                    diffs[diff] = [(id_test, id_trval)]
+                else:
+                    diffs[diff].append((id_test, id_trval))
+        exchanges = []
+        while True:
+            target_diff = expected_count - testset_total
+            # find nearest diff.
+            keys = np.array(list(diffs.keys()))
+            idx = (np.abs(keys - target_diff)).argmin()
+            nearest = keys[idx]
+            if abs(target_diff) <= abs(target_diff - nearest):
+                break
+            choice = np.random.choice(range(len(diffs[nearest])))
+            pid_test, pid_trval = diffs[nearest][choice]
+            testset_total += nearest
+            new_diffs = dict()
+            for diff, person_ids in diffs.items():
+                new_list = []
+                for id1, id2 in person_ids:
+                    if id1 == pid_test or id2 == pid_trval:
+                        continue
+                    new_list.append((id1, id2))
+                if 0 < len(new_list):
+                    new_diffs[diff] = new_list
+            diffs = new_diffs
+            exchanges.append((pid_test, pid_trval))
+        # exchange
+        for pid_test, pid_trval in exchanges:
+            test[pid_trval] = trval.pop(pid_trval)
+            trval[pid_test] = test.pop(pid_test)
+
+    def get_subset_by_group(self, group: str):
+        available = list(self._group_map.keys())
+        assert group in self._group_map, \
+            "Unknown group '%s', available groups: %s" \
+            % (group, available)
+        group_id = self._group_map[group]
+        return self.select(lambda item: item.annotations[0].group == group_id)
+
+
+class DetectionSplit(_TaskSpecificSplit):
+    """
+    Splits dataset into train/val/test set for detection task.|n
+    For detection dataset, each image can have multiple bbox annotations.|n
+    Since one DataItem can't be included in multiple subsets at the same time,
+    the dataset can't be divided according to the bbox annotations.|n
+    Thus, we split dataset based on DatasetItem
+    while preserving label distribution as possible.|n
+    |n
+    Notes:|n
+    - Each DatsetItem is expected to have one or more Bbox annotations.|n
+    - Label annotations are ignored. We only focus on the Bbox annotations.|n
+    """
+
+    def __init__(self, dataset, splits, seed=None):
+        """
+        Parameters
+        ----------
+        dataset : Dataset
+        splits : list
+            A list of (subset(str), ratio(float))
+            Subset is expected to be one of ["train", "val", "test"].
+            The sum of ratios is expected to be 1.
+        seed : int, optional
+        """
+        super().__init__(dataset, splits, seed)
+
+    @staticmethod
+    def _group_by_bbox_labels(dataset):
+        by_labels = dict()
+        for idx, item in enumerate(dataset):
+            bbox_anns = [a for a in item.annotations
+                if a.type == AnnotationType.bbox]
+            assert 0 < len(bbox_anns), \
+                "Expected more than one bbox annotation in the dataset"
+            for ann in bbox_anns:
+                label = getattr(ann, 'label', None)
+                if label not in by_labels:
+                    by_labels[label] = [(idx, ann)]
+                else:
+                    by_labels[label].append((idx, ann))
+        return by_labels
+
+    def _split_dataset(self):
+        np.random.seed(self._seed)
+
+        subsets, sratio = self._snames, self._sratio
+
+        # 1. group by bbox label
+        by_labels = self._group_by_bbox_labels(self._extractor)
+
+        # 2. group by attributes
+        by_combinations = dict()
+        for label, items in by_labels.items():
+            by_attributes = self._group_by_attr(items)
+            for attributes, indice in by_attributes.items():
+                gname = "label: %s, attributes: %s" % (label, attributes)
+                by_combinations[gname] = indice
+
+        # total number of GT samples per label-attr combinations
+        n_combs = {k: len(v) for k, v in by_combinations.items()}
+
+        # 3-1. initially count per-image GT samples
+        scores_all = {}
+        init_scores = {}
+        for idx, _ in enumerate(self._extractor):
+            counts = {k: v.count(idx) for k, v in by_combinations.items()}
+            scores_all[idx] = counts
+            init_scores[idx] = np.sum(
+                [v / n_combs[k] for k, v in counts.items()]
+            )
+
+        by_splits = dict()
+        for sname in self._subsets:
+            by_splits[sname] = []
+
+        total = len(self._extractor)
+        target_size = dict()
+        expected = []  # expected numbers of per split GT samples
+        for sname, ratio in zip(subsets, sratio):
+            target_size[sname] = total * ratio
+            expected.append(
+                (sname, {k: v * ratio for k, v in n_combs.items()})
+            )
+
+        ##
+        # functions for keep the # of annotations not exceed the expected num
+        def compute_penalty(counts, n_combs):
+            p = 0
+            for k, v in counts.items():
+                p += max(0, (v / n_combs[k]) - 1.0)
+            return p
+
+        def update_nc(counts, n_combs):
+            for k, v in counts.items():
+                n_combs[k] = max(0, n_combs[k] - v)
+                if n_combs[k] == 0:
+                    n_combs[k] = -1
+            return n_combs
+
+        ##
+
+        # 3-2. assign each DatasetItem to a split, one by one
+        for idx, _ in sorted(
+            init_scores.items(), key=lambda item: item[1], reverse=True
+        ):
+            counts = scores_all[idx]
+
+            # shuffling split order to add randomness
+            # when two or more splits have the same penalty value
+            np.random.shuffle(expected)
+
+            pp = []
+            for sname, nc in expected:
+                if target_size[sname] <= len(by_splits[sname]):
+                    # the split has enough images,
+                    # stop adding more images to this split
+                    pp.append(1e08)
+                else:
+                    # compute penalty based on the number of GT samples
+                    # added in the split
+                    pp.append(compute_penalty(counts, nc))
+
+            # we push an image to a split with the minimum penalty
+            midx = np.argmin(pp)
+
+            sname, nc = expected[midx]
+            by_splits[sname].append(idx)
+            update_nc(counts, nc)
+
+        self._set_parts(by_splits)

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

@@ -0,0 +1,212 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+import codecs
+from collections import OrderedDict
+import hashlib
+import logging as log
+import os
+import os.path as osp
+import string
+
+from datumaro.components.extractor import (AnnotationType, DEFAULT_SUBSET_NAME,
+    LabelCategories
+)
+from datumaro.components.converter import Converter
+from datumaro.util.image import encode_image, ByteImage
+from datumaro.util.annotation_util import (max_bbox,
+    find_group_leader, find_instances)
+from datumaro.util.mask_tools import merge_masks
+from datumaro.util.tf_util import import_tf as _import_tf
+
+from .format import DetectionApiPath
+tf = _import_tf()
+
+
+# filter out non-ASCII characters, otherwise training will crash
+_printable = set(string.printable)
+def _make_printable(s):
+    return ''.join(filter(lambda x: x in _printable, s))
+
+def int64_feature(value):
+    return tf.train.Feature(int64_list=tf.train.Int64List(value=[value]))
+
+def int64_list_feature(value):
+    return tf.train.Feature(int64_list=tf.train.Int64List(value=value))
+
+def bytes_feature(value):
+    return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value]))
+
+def bytes_list_feature(value):
+    return tf.train.Feature(bytes_list=tf.train.BytesList(value=value))
+
+def float_list_feature(value):
+    return tf.train.Feature(float_list=tf.train.FloatList(value=value))
+
+class TfDetectionApiConverter(Converter):
+    DEFAULT_IMAGE_EXT = DetectionApiPath.DEFAULT_IMAGE_EXT
+
+    @classmethod
+    def build_cmdline_parser(cls, **kwargs):
+        parser = super().build_cmdline_parser(**kwargs)
+        parser.add_argument('--save-masks', action='store_true',
+            help="Include instance masks (default: %(default)s)")
+        return parser
+
+    def __init__(self, extractor, save_dir, save_masks=False, **kwargs):
+        super().__init__(extractor, save_dir, **kwargs)
+
+        self._save_masks = save_masks
+
+    def apply(self):
+        os.makedirs(self._save_dir, exist_ok=True)
+
+        label_categories = self._extractor.categories().get(AnnotationType.label,
+            LabelCategories())
+        get_label = lambda label_id: label_categories.items[label_id].name \
+            if label_id is not None else ''
+        label_ids = OrderedDict((label.name, 1 + idx)
+            for idx, label in enumerate(label_categories.items))
+        map_label_id = lambda label_id: label_ids.get(get_label(label_id), 0)
+        self._get_label = get_label
+        self._get_label_id = map_label_id
+
+        for subset_name, subset in self._extractor.subsets().items():
+            labelmap_path = osp.join(self._save_dir, DetectionApiPath.LABELMAP_FILE)
+            with codecs.open(labelmap_path, 'w', encoding='utf8') as f:
+                for label, idx in label_ids.items():
+                    f.write(
+                        'item {\n' +
+                        ('\tid: %s\n' % (idx)) +
+                        ("\tname: '%s'\n" % (label)) +
+                        '}\n\n'
+                    )
+
+            anno_path = osp.join(self._save_dir, '%s.tfrecord' % (subset_name))
+            with tf.io.TFRecordWriter(anno_path) as writer:
+                for item in subset:
+                    tf_example = self._make_tf_example(item)
+                    writer.write(tf_example.SerializeToString())
+
+    @staticmethod
+    def _find_instances(annotations):
+        return find_instances(a for a in annotations
+            if a.type in { AnnotationType.bbox, AnnotationType.mask })
+
+    def _find_instance_parts(self, group, img_width, img_height):
+        boxes = [a for a in group if a.type == AnnotationType.bbox]
+        masks = [a for a in group if a.type == AnnotationType.mask]
+
+        anns = boxes + masks
+        leader = find_group_leader(anns)
+        bbox = max_bbox(anns)
+
+        mask = None
+        if self._save_masks:
+            mask = merge_masks([m.image for m in masks])
+
+        return [leader, mask, bbox]
+
+    def _export_instances(self, instances, width, height):
+        xmins = [] # List of normalized left x coordinates of bounding boxes (1 per box)
+        xmaxs = [] # List of normalized right x coordinates of bounding boxes (1 per box)
+        ymins = [] # List of normalized top y coordinates of bounding boxes (1 per box)
+        ymaxs = [] # List of normalized bottom y coordinates of bounding boxes (1 per box)
+        classes_text = [] # List of class names of bounding boxes (1 per box)
+        classes = [] # List of class ids of bounding boxes (1 per box)
+        masks = [] # List of PNG-encoded instance masks (1 per box)
+
+        for leader, mask, box in instances:
+            label = _make_printable(self._get_label(leader.label))
+            classes_text.append(label.encode('utf-8'))
+            classes.append(self._get_label_id(leader.label))
+
+            xmins.append(box[0] / width)
+            xmaxs.append((box[0] + box[2]) / width)
+            ymins.append(box[1] / height)
+            ymaxs.append((box[1] + box[3]) / height)
+
+            if self._save_masks:
+                if mask is not None:
+                    mask = encode_image(mask, '.png')
+                else:
+                    mask = b''
+                masks.append(mask)
+
+        result = {}
+        if classes:
+            result = {
+                'image/object/bbox/xmin': float_list_feature(xmins),
+                'image/object/bbox/xmax': float_list_feature(xmaxs),
+                'image/object/bbox/ymin': float_list_feature(ymins),
+                'image/object/bbox/ymax': float_list_feature(ymaxs),
+                'image/object/class/text': bytes_list_feature(classes_text),
+                'image/object/class/label': int64_list_feature(classes),
+            }
+            if masks:
+                result['image/object/mask'] = bytes_list_feature(masks)
+        return result
+
+    def _make_tf_example(self, item):
+        features = {
+            'image/source_id': bytes_feature(
+                str(item.attributes.get('source_id') or '').encode('utf-8')
+            ),
+        }
+
+        filename = self._make_image_filename(item)
+        features['image/filename'] = bytes_feature(filename.encode('utf-8'))
+
+        if not item.has_image:
+            raise Exception("Failed to export dataset item '%s': "
+                "item has no image info" % item.id)
+        height, width = item.image.size
+
+        features.update({
+            'image/height': int64_feature(height),
+            'image/width': int64_feature(width),
+        })
+
+        features.update({
+            'image/encoded': bytes_feature(b''),
+            'image/format': bytes_feature(b''),
+            'image/key/sha256': bytes_feature(b''),
+        })
+        if self._save_images:
+            if item.has_image and item.image.has_data:
+                buffer, fmt = self._save_image(item, filename)
+                key = hashlib.sha256(buffer).hexdigest()
+
+                features.update({
+                    'image/encoded': bytes_feature(buffer),
+                    'image/format': bytes_feature(fmt.encode('utf-8')),
+                    'image/key/sha256': bytes_feature(key.encode('utf8')),
+                })
+            else:
+                log.warning("Item '%s' has no image" % item.id)
+
+        instances = self._find_instances(item.annotations)
+        instances = [self._find_instance_parts(i, width, height) for i in instances]
+        features.update(self._export_instances(instances, width, height))
+
+        tf_example = tf.train.Example(
+            features=tf.train.Features(feature=features))
+
+        return tf_example
+
+    def _save_image(self, item, path=None):
+        src_ext = item.image.ext.lower()
+        dst_ext = osp.splitext(osp.basename(path))[1].lower()
+        fmt = DetectionApiPath.IMAGE_EXT_FORMAT.get(dst_ext, '')
+        if not fmt:
+            log.warning("Item '%s': can't find format string for the '%s' "
+                "image extension, the corresponding field will be empty." % \
+                (item.id, dst_ext))
+
+        if src_ext == dst_ext and isinstance(item.image, ByteImage):
+            buffer = item.image.get_bytes()
+        else:
+            buffer = encode_image(item.image.data, dst_ext)
+        return buffer, fmt

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

@@ -0,0 +1,187 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+from collections import OrderedDict
+import numpy as np
+import os.path as osp
+import re
+
+from datumaro.components.extractor import (SourceExtractor, DatasetItem,
+    AnnotationType, Bbox, Mask, LabelCategories, Importer
+)
+from datumaro.util.image import ByteImage, decode_image, lazy_image
+from datumaro.util.tf_util import import_tf as _import_tf
+
+from .format import DetectionApiPath
+tf = _import_tf()
+
+
+def clamp(value, _min, _max):
+    return max(min(_max, value), _min)
+
+class TfDetectionApiExtractor(SourceExtractor):
+    def __init__(self, path):
+        assert osp.isfile(path), path
+        images_dir = ''
+        root_dir = osp.dirname(osp.abspath(path))
+        if osp.basename(root_dir) == DetectionApiPath.ANNOTATIONS_DIR:
+            root_dir = osp.dirname(root_dir)
+            images_dir = osp.join(root_dir, DetectionApiPath.IMAGES_DIR)
+            if not osp.isdir(images_dir):
+                images_dir = ''
+
+        super().__init__(subset=osp.splitext(osp.basename(path))[0])
+
+        items, labels = self._parse_tfrecord_file(path, self._subset, images_dir)
+        self._items = items
+        self._categories = self._load_categories(labels)
+
+    @staticmethod
+    def _load_categories(labels):
+        label_categories = LabelCategories().from_iterable(
+            e[0] for e in sorted(labels.items(), key=lambda item: item[1])
+        )
+        return { AnnotationType.label: label_categories }
+
+    @classmethod
+    def _parse_labelmap(cls, text):
+        id_pattern = r'(?:id\s*:\s*(?P<id>\d+))'
+        name_pattern = r'(?:name\s*:\s*[\'\"](?P<name>.*?)[\'\"])'
+        entry_pattern = r'(\{(?:[\s\n]*(?:%(id)s|%(name)s)[\s\n]*){2}\})+' % \
+            {'id': id_pattern, 'name': name_pattern}
+        matches = re.finditer(entry_pattern, text)
+
+        labelmap = {}
+        for match in matches:
+            label_id = match.group('id')
+            label_name = match.group('name')
+            if label_id is not None and label_name is not None:
+                labelmap[label_name] = int(label_id)
+
+        return labelmap
+
+    @classmethod
+    def _parse_tfrecord_file(cls, filepath, subset, images_dir):
+        dataset = tf.data.TFRecordDataset(filepath)
+        features = {
+            'image/filename': tf.io.FixedLenFeature([], tf.string),
+            'image/source_id': tf.io.FixedLenFeature([], tf.string),
+            'image/height': tf.io.FixedLenFeature([], tf.int64),
+            'image/width': tf.io.FixedLenFeature([], tf.int64),
+            'image/encoded': tf.io.FixedLenFeature([], tf.string),
+            'image/format': tf.io.FixedLenFeature([], tf.string),
+
+            # use varlen to avoid errors when this field is missing
+            'image/key/sha256': tf.io.VarLenFeature(tf.string),
+
+            # Object boxes and classes.
+            'image/object/bbox/xmin': tf.io.VarLenFeature(tf.float32),
+            'image/object/bbox/xmax': tf.io.VarLenFeature(tf.float32),
+            'image/object/bbox/ymin': tf.io.VarLenFeature(tf.float32),
+            'image/object/bbox/ymax': tf.io.VarLenFeature(tf.float32),
+            'image/object/class/label': tf.io.VarLenFeature(tf.int64),
+            'image/object/class/text': tf.io.VarLenFeature(tf.string),
+            'image/object/mask': tf.io.VarLenFeature(tf.string),
+        }
+
+        dataset_labels = OrderedDict()
+        labelmap_path = osp.join(osp.dirname(filepath),
+            DetectionApiPath.LABELMAP_FILE)
+        if osp.exists(labelmap_path):
+            with open(labelmap_path, 'r', encoding='utf-8') as f:
+                labelmap_text = f.read()
+            dataset_labels.update({ label: id - 1
+                for label, id in cls._parse_labelmap(labelmap_text).items()
+            })
+
+        dataset_items = []
+
+        for record in dataset:
+            parsed_record = tf.io.parse_single_example(record, features)
+            frame_id = parsed_record['image/source_id'].numpy().decode('utf-8')
+            frame_filename = \
+                parsed_record['image/filename'].numpy().decode('utf-8')
+            frame_height = tf.cast(
+                parsed_record['image/height'], tf.int64).numpy().item()
+            frame_width = tf.cast(
+                parsed_record['image/width'], tf.int64).numpy().item()
+            frame_image = parsed_record['image/encoded'].numpy()
+            xmins = tf.sparse.to_dense(
+                parsed_record['image/object/bbox/xmin']).numpy()
+            ymins = tf.sparse.to_dense(
+                parsed_record['image/object/bbox/ymin']).numpy()
+            xmaxs = tf.sparse.to_dense(
+                parsed_record['image/object/bbox/xmax']).numpy()
+            ymaxs = tf.sparse.to_dense(
+                parsed_record['image/object/bbox/ymax']).numpy()
+            label_ids = tf.sparse.to_dense(
+                parsed_record['image/object/class/label']).numpy()
+            labels = tf.sparse.to_dense(
+                parsed_record['image/object/class/text'],
+                default_value=b'').numpy()
+            masks = tf.sparse.to_dense(
+                parsed_record['image/object/mask'],
+                default_value=b'').numpy()
+
+            for label, label_id in zip(labels, label_ids):
+                label = label.decode('utf-8')
+                if not label:
+                    continue
+                if label_id <= 0:
+                    continue
+                if label in dataset_labels:
+                    continue
+                dataset_labels[label] = label_id - 1
+
+            item_id = osp.splitext(frame_filename)[0]
+
+            annotations = []
+            for shape_id, shape in enumerate(
+                    np.dstack((labels, xmins, ymins, xmaxs, ymaxs))[0]):
+                label = shape[0].decode('utf-8')
+
+                mask = None
+                if len(masks) != 0:
+                    mask = masks[shape_id]
+
+                if mask is not None:
+                    if isinstance(mask, bytes):
+                        mask = lazy_image(mask, decode_image)
+                    annotations.append(Mask(image=mask,
+                        label=dataset_labels.get(label)
+                    ))
+                else:
+                    x = clamp(shape[1] * frame_width, 0, frame_width)
+                    y = clamp(shape[2] * frame_height, 0, frame_height)
+                    w = clamp(shape[3] * frame_width, 0, frame_width) - x
+                    h = clamp(shape[4] * frame_height, 0, frame_height) - y
+                    annotations.append(Bbox(x, y, w, h,
+                        label=dataset_labels.get(label)
+                    ))
+
+            image_size = None
+            if frame_height and frame_width:
+                image_size = (frame_height, frame_width)
+
+            image_params = {}
+            if frame_image:
+                image_params['data'] = frame_image
+            if frame_filename:
+                image_params['path'] = osp.join(images_dir, frame_filename)
+
+            image = None
+            if image_params:
+                image = ByteImage(**image_params, size=image_size)
+
+            dataset_items.append(DatasetItem(id=item_id, subset=subset,
+                image=image, annotations=annotations,
+                attributes={'source_id': frame_id}))
+
+        return dataset_items, dataset_labels
+
+class TfDetectionApiImporter(Importer):
+    @classmethod
+    def find_sources(cls, path):
+        return cls._find_sources_recursive(path, '.tfrecord', 'tf_detection_api')

testbed/openvinotoolkit__datumaro/datumaro/plugins/transforms.py

@@ -0,0 +1,559 @@
+# Copyright (C) 2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+from collections import Counter
+from enum import Enum
+import logging as log
+import os.path as osp
+import random
+import re
+
+import pycocotools.mask as mask_utils
+
+from datumaro.components.extractor import (Transform, AnnotationType,
+    RleMask, Polygon, Bbox, Label, DEFAULT_SUBSET_NAME,
+    LabelCategories, MaskCategories, PointsCategories
+)
+from datumaro.components.cli_plugin import CliPlugin
+import datumaro.util.mask_tools as mask_tools
+from datumaro.util.annotation_util import find_group_leader, find_instances
+
+
+class CropCoveredSegments(Transform, CliPlugin):
+    def transform_item(self, item):
+        annotations = []
+        segments = []
+        for ann in item.annotations:
+            if ann.type in {AnnotationType.polygon, AnnotationType.mask}:
+                segments.append(ann)
+            else:
+                annotations.append(ann)
+        if not segments:
+            return item
+
+        if not item.has_image:
+            raise Exception("Image info is required for this transform")
+        h, w = item.image.size
+        segments = self.crop_segments(segments, w, h)
+
+        annotations += segments
+        return self.wrap_item(item, annotations=annotations)
+
+    @classmethod
+    def crop_segments(cls, segment_anns, img_width, img_height):
+        segment_anns = sorted(segment_anns, key=lambda x: x.z_order)
+
+        segments = []
+        for s in segment_anns:
+            if s.type == AnnotationType.polygon:
+                segments.append(s.points)
+            elif s.type == AnnotationType.mask:
+                if isinstance(s, RleMask):
+                    rle = s.rle
+                else:
+                    rle = mask_tools.mask_to_rle(s.image)
+                segments.append(rle)
+
+        segments = mask_tools.crop_covered_segments(
+            segments, img_width, img_height)
+
+        new_anns = []
+        for ann, new_segment in zip(segment_anns, segments):
+            fields = {'z_order': ann.z_order, 'label': ann.label,
+                'id': ann.id, 'group': ann.group, 'attributes': ann.attributes
+            }
+            if ann.type == AnnotationType.polygon:
+                if fields['group'] is None:
+                    fields['group'] = cls._make_group_id(
+                        segment_anns + new_anns, fields['id'])
+                for polygon in new_segment:
+                    new_anns.append(Polygon(points=polygon, **fields))
+            else:
+                rle = mask_tools.mask_to_rle(new_segment)
+                rle = mask_utils.frPyObjects(rle, *rle['size'])
+                new_anns.append(RleMask(rle=rle, **fields))
+
+        return new_anns
+
+    @staticmethod
+    def _make_group_id(anns, ann_id):
+        if ann_id:
+            return ann_id
+        max_gid = max(anns, default=0, key=lambda x: x.group)
+        return max_gid + 1
+
+class MergeInstanceSegments(Transform, CliPlugin):
+    """
+    Replaces instance masks and, optionally, polygons with a single mask.
+    """
+
+    @classmethod
+    def build_cmdline_parser(cls, **kwargs):
+        parser = super().build_cmdline_parser(**kwargs)
+        parser.add_argument('--include-polygons', action='store_true',
+            help="Include polygons")
+        return parser
+
+    def __init__(self, extractor, include_polygons=False):
+        super().__init__(extractor)
+
+        self._include_polygons = include_polygons
+
+    def transform_item(self, item):
+        annotations = []
+        segments = []
+        for ann in item.annotations:
+            if ann.type in {AnnotationType.polygon, AnnotationType.mask}:
+                segments.append(ann)
+            else:
+                annotations.append(ann)
+        if not segments:
+            return item
+
+        if not item.has_image:
+            raise Exception("Image info is required for this transform")
+        h, w = item.image.size
+        instances = self.find_instances(segments)
+        segments = [self.merge_segments(i, w, h, self._include_polygons)
+            for i in instances]
+        segments = sum(segments, [])
+
+        annotations += segments
+        return self.wrap_item(item, annotations=annotations)
+
+    @classmethod
+    def merge_segments(cls, instance, img_width, img_height,
+            include_polygons=False):
+        polygons = [a for a in instance if a.type == AnnotationType.polygon]
+        masks = [a for a in instance if a.type == AnnotationType.mask]
+        if not polygons and not masks:
+            return []
+
+        leader = find_group_leader(polygons + masks)
+        instance = []
+
+        # Build the resulting mask
+        mask = None
+
+        if include_polygons and polygons:
+            polygons = [p.points for p in polygons]
+            mask = mask_tools.rles_to_mask(polygons, img_width, img_height)
+        else:
+            instance += polygons # keep unused polygons
+
+        if masks:
+            masks = [m.image for m in masks]
+            if mask is not None:
+                masks += [mask]
+            mask = mask_tools.merge_masks(masks)
+
+        if mask is None:
+            return instance
+
+        mask = mask_tools.mask_to_rle(mask)
+        mask = mask_utils.frPyObjects(mask, *mask['size'])
+        instance.append(
+            RleMask(rle=mask, label=leader.label, z_order=leader.z_order,
+                id=leader.id, attributes=leader.attributes, group=leader.group
+            )
+        )
+        return instance
+
+    @staticmethod
+    def find_instances(annotations):
+        return find_instances(a for a in annotations
+            if a.type in {AnnotationType.polygon, AnnotationType.mask})
+
+class PolygonsToMasks(Transform, CliPlugin):
+    def transform_item(self, item):
+        annotations = []
+        for ann in item.annotations:
+            if ann.type == AnnotationType.polygon:
+                if not item.has_image:
+                    raise Exception("Image info is required for this transform")
+                h, w = item.image.size
+                annotations.append(self.convert_polygon(ann, h, w))
+            else:
+                annotations.append(ann)
+
+        return self.wrap_item(item, annotations=annotations)
+
+    @staticmethod
+    def convert_polygon(polygon, img_h, img_w):
+        rle = mask_utils.frPyObjects([polygon.points], img_h, img_w)[0]
+
+        return RleMask(rle=rle, label=polygon.label, z_order=polygon.z_order,
+            id=polygon.id, attributes=polygon.attributes, group=polygon.group)
+
+class BoxesToMasks(Transform, CliPlugin):
+    def transform_item(self, item):
+        annotations = []
+        for ann in item.annotations:
+            if ann.type == AnnotationType.bbox:
+                if not item.has_image:
+                    raise Exception("Image info is required for this transform")
+                h, w = item.image.size
+                annotations.append(self.convert_bbox(ann, h, w))
+            else:
+                annotations.append(ann)
+
+        return self.wrap_item(item, annotations=annotations)
+
+    @staticmethod
+    def convert_bbox(bbox, img_h, img_w):
+        rle = mask_utils.frPyObjects([bbox.as_polygon()], img_h, img_w)[0]
+
+        return RleMask(rle=rle, label=bbox.label, z_order=bbox.z_order,
+            id=bbox.id, attributes=bbox.attributes, group=bbox.group)
+
+class MasksToPolygons(Transform, CliPlugin):
+    def transform_item(self, item):
+        annotations = []
+        for ann in item.annotations:
+            if ann.type == AnnotationType.mask:
+                polygons = self.convert_mask(ann)
+                if not polygons:
+                    log.debug("[%s]: item %s: "
+                        "Mask conversion to polygons resulted in too "
+                        "small polygons, which were discarded" % \
+                        (self._get_name(__class__), item.id))
+                annotations.extend(polygons)
+            else:
+                annotations.append(ann)
+
+        return self.wrap_item(item, annotations=annotations)
+
+    @staticmethod
+    def convert_mask(mask):
+        polygons = mask_tools.mask_to_polygons(mask.image)
+
+        return [
+            Polygon(points=p, label=mask.label, z_order=mask.z_order,
+                id=mask.id, attributes=mask.attributes, group=mask.group)
+            for p in polygons
+        ]
+
+class ShapesToBoxes(Transform, CliPlugin):
+    def transform_item(self, item):
+        annotations = []
+        for ann in item.annotations:
+            if ann.type in { AnnotationType.mask, AnnotationType.polygon,
+                AnnotationType.polyline, AnnotationType.points,
+            }:
+                annotations.append(self.convert_shape(ann))
+            else:
+                annotations.append(ann)
+
+        return self.wrap_item(item, annotations=annotations)
+
+    @staticmethod
+    def convert_shape(shape):
+        bbox = shape.get_bbox()
+        return Bbox(*bbox, label=shape.label, z_order=shape.z_order,
+            id=shape.id, attributes=shape.attributes, group=shape.group)
+
+class Reindex(Transform, CliPlugin):
+    @classmethod
+    def build_cmdline_parser(cls, **kwargs):
+        parser = super().build_cmdline_parser(**kwargs)
+        parser.add_argument('-s', '--start', type=int, default=1,
+            help="Start value for item ids")
+        return parser
+
+    def __init__(self, extractor, start=1):
+        super().__init__(extractor)
+        self._length = 'parent'
+        self._start = start
+
+    def __iter__(self):
+        for i, item in enumerate(self._extractor):
+            yield self.wrap_item(item, id=i + self._start)
+
+class MapSubsets(Transform, CliPlugin):
+    @staticmethod
+    def _mapping_arg(s):
+        parts = s.split(':')
+        if len(parts) != 2:
+            import argparse
+            raise argparse.ArgumentTypeError()
+        return parts
+
+    @classmethod
+    def build_cmdline_parser(cls, **kwargs):
+        parser = super().build_cmdline_parser(**kwargs)
+        parser.add_argument('-s', '--subset', action='append',
+            type=cls._mapping_arg, dest='mapping',
+            help="Subset mapping of the form: 'src:dst' (repeatable)")
+        return parser
+
+    def __init__(self, extractor, mapping=None):
+        super().__init__(extractor)
+
+        if mapping is None:
+            mapping = {}
+        elif not isinstance(mapping, dict):
+            mapping = dict(tuple(m) for m in mapping)
+        self._mapping = mapping
+
+        if extractor._subsets:
+            counts = Counter(mapping.get(s, s) or DEFAULT_SUBSET_NAME
+                for s in extractor._subsets)
+            if all(c == 1 for c in counts.values()):
+                self._length = 'parent'
+            self._subsets = set(counts)
+
+    def transform_item(self, item):
+        return self.wrap_item(item,
+            subset=self._mapping.get(item.subset, item.subset))
+
+class RandomSplit(Transform, CliPlugin):
+    """
+    Joins all subsets into one and splits the result into few parts.
+    It is expected that item ids are unique and subset ratios sum up to 1.|n
+    |n
+    Example:|n
+    |s|s%(prog)s --subset train:.67 --subset test:.33
+    """
+
+    # avoid https://bugs.python.org/issue16399
+    _default_split = [('train', 0.67), ('test', 0.33)]
+
+    @staticmethod
+    def _split_arg(s):
+        parts = s.split(':')
+        if len(parts) != 2:
+            import argparse
+            raise argparse.ArgumentTypeError()
+        return (parts[0], float(parts[1]))
+
+    @classmethod
+    def build_cmdline_parser(cls, **kwargs):
+        parser = super().build_cmdline_parser(**kwargs)
+        parser.add_argument('-s', '--subset', action='append',
+            type=cls._split_arg, dest='splits',
+            help="Subsets in the form: '<subset>:<ratio>' "
+                "(repeatable, default: %s)" % dict(cls._default_split))
+        parser.add_argument('--seed', type=int, help="Random seed")
+        return parser
+
+    def __init__(self, extractor, splits, seed=None):
+        super().__init__(extractor)
+
+        if splits is None:
+            splits = self._default_split
+
+        assert 0 < len(splits), "Expected at least one split"
+        assert all(0.0 <= r and r <= 1.0 for _, r in splits), \
+            "Ratios are expected to be in the range [0; 1], but got %s" % splits
+
+        total_ratio = sum(s[1] for s in splits)
+        if not abs(total_ratio - 1.0) <= 1e-7:
+            raise Exception(
+                "Sum of ratios is expected to be 1, got %s, which is %s" %
+                (splits, total_ratio))
+
+        dataset_size = len(extractor)
+        indices = list(range(dataset_size))
+        random.seed(seed)
+        random.shuffle(indices)
+        parts = []
+        s = 0
+        lower_boundary = 0
+        for split_idx, (subset, ratio) in enumerate(splits):
+            s += ratio
+            upper_boundary = int(s * dataset_size)
+            if split_idx == len(splits) - 1:
+                upper_boundary = dataset_size
+            subset_indices = set(indices[lower_boundary : upper_boundary])
+            parts.append((subset_indices, subset))
+            lower_boundary = upper_boundary
+        self._parts = parts
+
+        self._subsets = set(s[0] for s in splits)
+        self._length = 'parent'
+
+    def _find_split(self, index):
+        for subset_indices, subset in self._parts:
+            if index in subset_indices:
+                return subset
+        return subset # all the possible remainder goes to the last split
+
+    def __iter__(self):
+        for i, item in enumerate(self._extractor):
+            yield self.wrap_item(item, subset=self._find_split(i))
+
+class IdFromImageName(Transform, CliPlugin):
+    def transform_item(self, item):
+        if item.has_image and item.image.path:
+            name = osp.splitext(osp.basename(item.image.path))[0]
+            return self.wrap_item(item, id=name)
+        else:
+            log.debug("Can't change item id for item '%s': "
+                "item has no image info" % item.id)
+            return item
+
+class Rename(Transform, CliPlugin):
+    """
+    Renames items in the dataset. Supports regular expressions.
+    The first character in the expression is a delimiter for
+    the pattern and replacement parts. Replacement part can also
+    contain string.format tokens with 'item' object available.|n
+    |n
+    Examples:|n
+    - Replace 'pattern' with 'replacement':|n
+    |s|srename -e '|pattern|replacement|'|n
+    - Remove 'frame_' from item ids:|n
+    |s|srename -e '|frame_(\d+)|\\1|'
+    """
+
+    @classmethod
+    def build_cmdline_parser(cls, **kwargs):
+        parser = super().build_cmdline_parser(**kwargs)
+        parser.add_argument('-e', '--regex',
+            help="Regex for renaming.")
+        return parser
+
+    def __init__(self, extractor, regex):
+        super().__init__(extractor)
+
+        assert regex and isinstance(regex, str)
+        parts = regex.split(regex[0], maxsplit=3)
+        regex, sub = parts[1:3]
+        self._re = re.compile(regex)
+        self._sub = sub
+
+    def transform_item(self, item):
+        return self.wrap_item(item, id=self._re.sub(self._sub, item.id) \
+            .format(item=item))
+
+class RemapLabels(Transform, CliPlugin):
+    """
+    Changes labels in the dataset.|n
+    Examples:|n
+    - Rename 'person' to 'car' and 'cat' to 'dog', keep 'bus', remove others:|n
+    |s|sremap_labels -l person:car -l bus:bus -l cat:dog --default delete
+    """
+
+    DefaultAction = Enum('DefaultAction', ['keep', 'delete'])
+
+    @staticmethod
+    def _split_arg(s):
+        parts = s.split(':')
+        if len(parts) != 2:
+            import argparse
+            raise argparse.ArgumentTypeError()
+        return (parts[0], parts[1])
+
+    @classmethod
+    def build_cmdline_parser(cls, **kwargs):
+        parser = super().build_cmdline_parser(**kwargs)
+        parser.add_argument('-l', '--label', action='append',
+            type=cls._split_arg, dest='mapping',
+            help="Label in the form of: '<src>:<dst>' (repeatable)")
+        parser.add_argument('--default',
+            choices=[a.name for a in cls.DefaultAction],
+            default=cls.DefaultAction.keep.name,
+            help="Action for unspecified labels (default: %(default)s)")
+        return parser
+
+    def __init__(self, extractor, mapping, default=None):
+        super().__init__(extractor)
+
+        assert isinstance(default, (str, self.DefaultAction))
+        if isinstance(default, str):
+            default = self.DefaultAction[default]
+
+        assert isinstance(mapping, (dict, list))
+        if isinstance(mapping, list):
+            mapping = dict(mapping)
+
+        self._categories = {}
+
+        src_label_cat = self._extractor.categories().get(AnnotationType.label)
+        if src_label_cat is not None:
+            self._make_label_id_map(src_label_cat, mapping, default)
+
+        src_mask_cat = self._extractor.categories().get(AnnotationType.mask)
+        if src_mask_cat is not None:
+            assert src_label_cat is not None
+            dst_mask_cat = MaskCategories(attributes=src_mask_cat.attributes)
+            dst_mask_cat.colormap = {
+                id: src_mask_cat.colormap[id]
+                for id, _ in enumerate(src_label_cat.items)
+                if self._map_id(id) or id == 0
+            }
+            self._categories[AnnotationType.mask] = dst_mask_cat
+
+        src_points_cat = self._extractor.categories().get(AnnotationType.points)
+        if src_points_cat is not None:
+            assert src_label_cat is not None
+            dst_points_cat = PointsCategories(attributes=src_points_cat.attributes)
+            dst_points_cat.items = {
+                id: src_points_cat.items[id]
+                for id, item in enumerate(src_label_cat.items)
+                if self._map_id(id) or id == 0
+            }
+            self._categories[AnnotationType.points] = dst_points_cat
+
+    def _make_label_id_map(self, src_label_cat, label_mapping, default_action):
+        dst_label_cat = LabelCategories(attributes=src_label_cat.attributes)
+        id_mapping = {}
+        for src_index, src_label in enumerate(src_label_cat.items):
+            dst_label = label_mapping.get(src_label.name)
+            if not dst_label and default_action == self.DefaultAction.keep:
+                dst_label = src_label.name # keep unspecified as is
+            if not dst_label:
+                continue
+
+            dst_index = dst_label_cat.find(dst_label)[0]
+            if dst_index is None:
+                dst_index = dst_label_cat.add(dst_label,
+                    src_label.parent, src_label.attributes)
+            id_mapping[src_index] = dst_index
+
+        if log.getLogger().isEnabledFor(log.DEBUG):
+            log.debug("Label mapping:")
+            for src_id, src_label in enumerate(src_label_cat.items):
+                if id_mapping.get(src_id):
+                    log.debug("#%s '%s' -> #%s '%s'",
+                        src_id, src_label.name, id_mapping[src_id],
+                        dst_label_cat.items[id_mapping[src_id]].name
+                    )
+                else:
+                    log.debug("#%s '%s' -> <deleted>", src_id, src_label.name)
+
+        self._map_id = lambda src_id: id_mapping.get(src_id, None)
+        self._categories[AnnotationType.label] = dst_label_cat
+
+    def categories(self):
+        return self._categories
+
+    def transform_item(self, item):
+        annotations = []
+        for ann in item.annotations:
+            if ann.type in { AnnotationType.label, AnnotationType.mask,
+                AnnotationType.points, AnnotationType.polygon,
+                AnnotationType.polyline, AnnotationType.bbox
+            } and ann.label is not None:
+                conv_label = self._map_id(ann.label)
+                if conv_label is not None:
+                    annotations.append(ann.wrap(label=conv_label))
+            else:
+                annotations.append(ann.wrap())
+        return item.wrap(annotations=annotations)
+
+class AnnsToLabels(Transform, CliPlugin):
+    """
+    Collects all labels from annotations (of all types) and
+    transforms them into a set of annotations of type Label
+    """
+
+    def transform_item(self, item):
+        labels = set(p.label for p in item.annotations
+            if getattr(p, 'label') != None)
+        annotations = []
+        for label in labels:
+            annotations.append(Label(label=label))
+
+        return item.wrap(annotations=annotations)

testbed/openvinotoolkit__datumaro/datumaro/plugins/vgg_face2_format.py

@@ -0,0 +1,139 @@
+# Copyright (C) 2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+import csv
+import os
+import os.path as osp
+from glob import glob
+
+from datumaro.components.converter import Converter
+from datumaro.components.extractor import (AnnotationType, Bbox, DatasetItem,
+    Importer, Points, LabelCategories, SourceExtractor)
+
+
+class VggFace2Path:
+    ANNOTATION_DIR = "bb_landmark"
+    IMAGE_EXT = '.jpg'
+    BBOXES_FILE = 'loose_bb_'
+    LANDMARKS_FILE = 'loose_landmark_'
+
+class VggFace2Extractor(SourceExtractor):
+    def __init__(self, path):
+        if not osp.isfile(path):
+            raise Exception("Can't read .csv annotation file '%s'" % path)
+        self._path = path
+        self._dataset_dir = osp.dirname(osp.dirname(path))
+
+        subset = osp.splitext(osp.basename(path))[0]
+        if subset.startswith(VggFace2Path.LANDMARKS_FILE):
+            subset = subset.split('_')[2]
+        super().__init__(subset=subset)
+
+        self._load_categories()
+        self._items = list(self._load_items(path).values())
+
+    def _load_categories(self):
+        self._categories[AnnotationType.label] = LabelCategories()
+
+    def _load_items(self, path):
+        items = {}
+        with open(path) as content:
+            landmarks_table = list(csv.DictReader(content))
+
+        for row in landmarks_table:
+            item_id = row['NAME_ID']
+            image_path = osp.join(self._dataset_dir, self._subset,
+                item_id + VggFace2Path.IMAGE_EXT)
+            annotations = []
+            if len([p for p in row if row[p] == '']) == 0 and len(row) == 11:
+                annotations.append(Points(
+                    [float(row[p]) for p in row if p != 'NAME_ID']))
+            if item_id in items and 0 < len(annotations):
+                annotation = items[item_id].annotations
+                annotation.append(annotations[0])
+            else:
+                items[item_id] = DatasetItem(id=item_id, subset=self._subset,
+                    image=image_path, annotations=annotations)
+
+        bboxes_path = osp.join(self._dataset_dir, VggFace2Path.ANNOTATION_DIR,
+            VggFace2Path.BBOXES_FILE + self._subset + '.csv')
+        if osp.isfile(bboxes_path):
+            with open(bboxes_path) as content:
+                bboxes_table = list(csv.DictReader(content))
+            for row in bboxes_table:
+                if len([p for p in row if row[p] == '']) == 0 and len(row) == 5:
+                    item_id = row['NAME_ID']
+                    annotations = items[item_id].annotations
+                    annotations.append(Bbox(int(row['X']), int(row['Y']),
+                        int(row['W']), int(row['H'])))
+        return items
+
+class VggFace2Importer(Importer):
+    @classmethod
+    def find_sources(cls, path):
+        subset_paths = [p for p in glob(osp.join(path,
+            VggFace2Path.ANNOTATION_DIR, '**.csv'), recursive=True)
+            if not osp.basename(p).startswith(VggFace2Path.BBOXES_FILE)]
+        sources = []
+        for subset_path in subset_paths:
+            sources += cls._find_sources_recursive(
+                subset_path, '.csv', 'vgg_face2')
+        return sources
+
+class VggFace2Converter(Converter):
+    DEFAULT_IMAGE_EXT = '.jpg'
+
+    def apply(self):
+        save_dir = self._save_dir
+
+        os.makedirs(save_dir, exist_ok=True)
+        for subset_name, subset in self._extractor.subsets().items():
+            subset_dir = osp.join(save_dir, subset_name)
+            bboxes_table = []
+            landmarks_table = []
+            for item in subset:
+                if item.has_image and self._save_images:
+                    self._save_image(item, osp.join(save_dir, subset_dir,
+                        item.id + VggFace2Path.IMAGE_EXT))
+
+                landmarks = [a for a in item.annotations
+                    if a.type == AnnotationType.points]
+                if landmarks:
+                    for landmark in landmarks:
+                        points = landmark.points
+                        landmarks_table.append({'NAME_ID': item.id,
+                            'P1X': points[0], 'P1Y': points[1],
+                            'P2X': points[2], 'P2Y': points[3],
+                            'P3X': points[4], 'P3Y': points[5],
+                            'P4X': points[6], 'P4Y': points[7],
+                            'P5X': points[8], 'P5Y': points[9]})
+                else:
+                    landmarks_table.append({'NAME_ID': item.id})
+
+                bboxes = [a for a in item.annotations
+                    if a.type == AnnotationType.bbox]
+                if bboxes:
+                    for bbox in bboxes:
+                        bboxes_table.append({'NAME_ID': item.id, 'X': int(bbox.x),
+                            'Y': int(bbox.y), 'W': int(bbox.w), 'H': int(bbox.h)})
+
+            landmarks_path = osp.join(save_dir, VggFace2Path.ANNOTATION_DIR,
+                VggFace2Path.LANDMARKS_FILE + subset_name + '.csv')
+            os.makedirs(osp.dirname(landmarks_path), exist_ok=True)
+            with open(landmarks_path, 'w', newline='') as file:
+                columns = ['NAME_ID', 'P1X', 'P1Y', 'P2X', 'P2Y',
+                    'P3X', 'P3Y', 'P4X', 'P4Y', 'P5X', 'P5Y']
+                writer = csv.DictWriter(file, fieldnames=columns)
+                writer.writeheader()
+                writer.writerows(landmarks_table)
+
+            if bboxes_table:
+                bboxes_path = osp.join(save_dir, VggFace2Path.ANNOTATION_DIR,
+                    VggFace2Path.BBOXES_FILE + subset_name + '.csv')
+                os.makedirs(osp.dirname(bboxes_path), exist_ok=True)
+                with open(bboxes_path, 'w', newline='') as file:
+                    columns = ['NAME_ID', 'X', 'Y', 'W', 'H']
+                    writer = csv.DictWriter(file, fieldnames=columns)
+                    writer.writeheader()
+                    writer.writerows(bboxes_table)

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

@@ -0,0 +1,579 @@
+
+# Copyright (C) 2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+import logging as log
+import os
+import os.path as osp
+from collections import OrderedDict, defaultdict
+from enum import Enum
+from itertools import chain
+
+from lxml import etree as ET
+
+from datumaro.components.converter import Converter
+from datumaro.components.extractor import (DEFAULT_SUBSET_NAME, AnnotationType,
+    CompiledMask, LabelCategories)
+from datumaro.util import find, str_to_bool
+from datumaro.util.image import save_image
+from datumaro.util.mask_tools import paint_mask, remap_mask
+
+from .format import (VocTask, VocPath, VocInstColormap,
+    parse_label_map, make_voc_label_map, make_voc_categories, write_label_map
+)
+
+
+def _convert_attr(name, attributes, type_conv, default=None, warn=True):
+    d = object()
+    value = attributes.get(name, d)
+    if value is d:
+        return default
+
+    try:
+        return type_conv(value)
+    except Exception as e:
+        log.warning("Failed to convert attribute '%s'='%s': %s" % \
+            (name, value, e))
+        return default
+
+def _write_xml_bbox(bbox, parent_elem):
+    x, y, w, h = bbox
+    bbox_elem = ET.SubElement(parent_elem, 'bndbox')
+    ET.SubElement(bbox_elem, 'xmin').text = str(x)
+    ET.SubElement(bbox_elem, 'ymin').text = str(y)
+    ET.SubElement(bbox_elem, 'xmax').text = str(x + w)
+    ET.SubElement(bbox_elem, 'ymax').text = str(y + h)
+    return bbox_elem
+
+
+LabelmapType = Enum('LabelmapType', ['voc', 'source'])
+
+class VocConverter(Converter):
+    DEFAULT_IMAGE_EXT = VocPath.IMAGE_EXT
+
+    @staticmethod
+    def _split_tasks_string(s):
+        return [VocTask[i.strip()] for i in s.split(',')]
+
+    @staticmethod
+    def _get_labelmap(s):
+        if osp.isfile(s):
+            return s
+        try:
+            return LabelmapType[s].name
+        except KeyError:
+            import argparse
+            raise argparse.ArgumentTypeError()
+
+    @classmethod
+    def build_cmdline_parser(cls, **kwargs):
+        parser = super().build_cmdline_parser(**kwargs)
+
+        parser.add_argument('--apply-colormap', type=str_to_bool, default=True,
+            help="Use colormap for class and instance masks "
+                "(default: %(default)s)")
+        parser.add_argument('--label-map', type=cls._get_labelmap, default=None,
+            help="Labelmap file path or one of %s" % \
+                ', '.join(t.name for t in LabelmapType))
+        parser.add_argument('--allow-attributes',
+            type=str_to_bool, default=True,
+            help="Allow export of attributes (default: %(default)s)")
+        parser.add_argument('--tasks', type=cls._split_tasks_string,
+            help="VOC task filter, comma-separated list of {%s} "
+                "(default: all)" % ', '.join(t.name for t in VocTask))
+
+        return parser
+
+    def __init__(self, extractor, save_dir,
+            tasks=None, apply_colormap=True, label_map=None,
+            allow_attributes=True, **kwargs):
+        super().__init__(extractor, save_dir, **kwargs)
+
+        assert tasks is None or isinstance(tasks, (VocTask, list, set))
+        if tasks is None:
+            tasks = set(VocTask)
+        elif isinstance(tasks, VocTask):
+            tasks = {tasks}
+        else:
+            tasks = set(t if t in VocTask else VocTask[t] for t in tasks)
+        self._tasks = tasks
+
+        self._apply_colormap = apply_colormap
+        self._allow_attributes = allow_attributes
+
+        if label_map is None:
+            label_map = LabelmapType.source.name
+        self._load_categories(label_map)
+
+    def apply(self):
+        self.make_dirs()
+        self.save_subsets()
+        self.save_label_map()
+
+    def make_dirs(self):
+        save_dir = self._save_dir
+        subsets_dir = osp.join(save_dir, VocPath.SUBSETS_DIR)
+        cls_subsets_dir = osp.join(subsets_dir,
+            VocPath.TASK_DIR[VocTask.classification])
+        action_subsets_dir = osp.join(subsets_dir,
+            VocPath.TASK_DIR[VocTask.action_classification])
+        layout_subsets_dir = osp.join(subsets_dir,
+            VocPath.TASK_DIR[VocTask.person_layout])
+        segm_subsets_dir = osp.join(subsets_dir,
+            VocPath.TASK_DIR[VocTask.segmentation])
+        ann_dir = osp.join(save_dir, VocPath.ANNOTATIONS_DIR)
+        img_dir = osp.join(save_dir, VocPath.IMAGES_DIR)
+        segm_dir = osp.join(save_dir, VocPath.SEGMENTATION_DIR)
+        inst_dir = osp.join(save_dir, VocPath.INSTANCES_DIR)
+        images_dir = osp.join(save_dir, VocPath.IMAGES_DIR)
+
+        os.makedirs(subsets_dir, exist_ok=True)
+        os.makedirs(ann_dir, exist_ok=True)
+        os.makedirs(img_dir, exist_ok=True)
+        os.makedirs(segm_dir, exist_ok=True)
+        os.makedirs(inst_dir, exist_ok=True)
+        os.makedirs(images_dir, exist_ok=True)
+
+        self._subsets_dir = subsets_dir
+        self._cls_subsets_dir = cls_subsets_dir
+        self._action_subsets_dir = action_subsets_dir
+        self._layout_subsets_dir = layout_subsets_dir
+        self._segm_subsets_dir = segm_subsets_dir
+        self._ann_dir = ann_dir
+        self._img_dir = img_dir
+        self._segm_dir = segm_dir
+        self._inst_dir = inst_dir
+        self._images_dir = images_dir
+
+    def get_label(self, label_id):
+        return self._extractor. \
+            categories()[AnnotationType.label].items[label_id].name
+
+    def save_subsets(self):
+        for subset_name, subset in self._extractor.subsets().items():
+            class_lists = OrderedDict()
+            clsdet_list = OrderedDict()
+            action_list = OrderedDict()
+            layout_list = OrderedDict()
+            segm_list = OrderedDict()
+
+            for item in subset:
+                log.debug("Converting item '%s'", item.id)
+
+                image_filename = self._make_image_filename(item)
+                if self._save_images:
+                    if item.has_image and item.image.has_data:
+                        self._save_image(item,
+                            osp.join(self._images_dir, image_filename))
+                    else:
+                        log.debug("Item '%s' has no image", item.id)
+
+                labels = []
+                bboxes = []
+                masks = []
+                for a in item.annotations:
+                    if a.type == AnnotationType.label:
+                        labels.append(a)
+                    elif a.type == AnnotationType.bbox:
+                        bboxes.append(a)
+                    elif a.type == AnnotationType.mask:
+                        masks.append(a)
+
+                if self._tasks is None and bboxes or \
+                        self._tasks & {VocTask.detection, VocTask.person_layout,
+                            VocTask.action_classification}:
+                    root_elem = ET.Element('annotation')
+                    if '_' in item.id:
+                        folder = item.id[ : item.id.find('_')]
+                    else:
+                        folder = ''
+                    ET.SubElement(root_elem, 'folder').text = folder
+                    ET.SubElement(root_elem, 'filename').text = image_filename
+
+                    source_elem = ET.SubElement(root_elem, 'source')
+                    ET.SubElement(source_elem, 'database').text = 'Unknown'
+                    ET.SubElement(source_elem, 'annotation').text = 'Unknown'
+                    ET.SubElement(source_elem, 'image').text = 'Unknown'
+
+                    if item.has_image:
+                        h, w = item.image.size
+                        size_elem = ET.SubElement(root_elem, 'size')
+                        ET.SubElement(size_elem, 'width').text = str(w)
+                        ET.SubElement(size_elem, 'height').text = str(h)
+                        ET.SubElement(size_elem, 'depth').text = ''
+
+                    item_segmented = 0 < len(masks)
+                    ET.SubElement(root_elem, 'segmented').text = \
+                        str(int(item_segmented))
+
+                    objects_with_parts = []
+                    objects_with_actions = defaultdict(dict)
+
+                    main_bboxes = []
+                    layout_bboxes = []
+                    for bbox in bboxes:
+                        label = self.get_label(bbox.label)
+                        if self._is_part(label):
+                            layout_bboxes.append(bbox)
+                        elif self._is_label(label):
+                            main_bboxes.append(bbox)
+
+                    for new_obj_id, obj in enumerate(main_bboxes):
+                        attr = obj.attributes
+
+                        obj_elem = ET.SubElement(root_elem, 'object')
+
+                        obj_label = self.get_label(obj.label)
+                        ET.SubElement(obj_elem, 'name').text = obj_label
+
+                        if 'pose' in attr:
+                            ET.SubElement(obj_elem, 'pose').text = \
+                                str(attr['pose'])
+
+                        if 'truncated' in attr:
+                            truncated = _convert_attr('truncated', attr, int, 0)
+                            ET.SubElement(obj_elem, 'truncated').text = \
+                                '%d' % truncated
+
+                        if 'difficult' in attr:
+                            difficult = _convert_attr('difficult', attr, int, 0)
+                            ET.SubElement(obj_elem, 'difficult').text = \
+                                '%d' % difficult
+
+                        if 'occluded' in attr:
+                            occluded = _convert_attr('occluded', attr, int, 0)
+                            ET.SubElement(obj_elem, 'occluded').text = \
+                                '%d' % occluded
+
+                        bbox = obj.get_bbox()
+                        if bbox is not None:
+                            _write_xml_bbox(bbox, obj_elem)
+
+                        for part_bbox in filter(
+                                lambda x: obj.group and obj.group == x.group,
+                                layout_bboxes):
+                            part_elem = ET.SubElement(obj_elem, 'part')
+                            ET.SubElement(part_elem, 'name').text = \
+                                self.get_label(part_bbox.label)
+                            _write_xml_bbox(part_bbox.get_bbox(), part_elem)
+
+                            objects_with_parts.append(new_obj_id)
+
+                        label_actions = self._get_actions(obj_label)
+                        actions_elem = ET.Element('actions')
+                        for action in label_actions:
+                            present = 0
+                            if action in attr:
+                                present = _convert_attr(action, attr,
+                                    lambda v: int(v == True), 0)
+                                ET.SubElement(actions_elem, action).text = \
+                                    '%d' % present
+
+                            objects_with_actions[new_obj_id][action] = present
+                        if len(actions_elem) != 0:
+                            obj_elem.append(actions_elem)
+
+                        if self._allow_attributes:
+                            native_attrs = {'difficult', 'pose',
+                                'truncated', 'occluded' }
+                            native_attrs.update(label_actions)
+
+                            attrs_elem = ET.Element('attributes')
+                            for k, v in attr.items():
+                                if k in native_attrs:
+                                    continue
+                                attr_elem = ET.SubElement(attrs_elem, 'attribute')
+                                ET.SubElement(attr_elem, 'name').text = str(k)
+                                ET.SubElement(attr_elem, 'value').text = str(v)
+                            if len(attrs_elem):
+                                obj_elem.append(attrs_elem)
+
+                    if self._tasks & {VocTask.detection, VocTask.person_layout,
+                            VocTask.action_classification}:
+                        ann_path = osp.join(self._ann_dir, item.id + '.xml')
+                        os.makedirs(osp.dirname(ann_path), exist_ok=True)
+                        with open(ann_path, 'w') as f:
+                            f.write(ET.tostring(root_elem,
+                                encoding='unicode', pretty_print=True))
+
+                    clsdet_list[item.id] = True
+                    layout_list[item.id] = objects_with_parts
+                    action_list[item.id] = objects_with_actions
+
+                for label_ann in labels:
+                    label = self.get_label(label_ann.label)
+                    if not self._is_label(label):
+                        continue
+                    class_list = class_lists.get(item.id, set())
+                    class_list.add(label_ann.label)
+                    class_lists[item.id] = class_list
+
+                    clsdet_list[item.id] = True
+
+                if masks:
+                    compiled_mask = CompiledMask.from_instance_masks(masks,
+                        instance_labels=[self._label_id_mapping(m.label)
+                            for m in masks])
+
+                    self.save_segm(
+                        osp.join(self._segm_dir, item.id + VocPath.SEGM_EXT),
+                        compiled_mask.class_mask)
+                    self.save_segm(
+                        osp.join(self._inst_dir, item.id + VocPath.SEGM_EXT),
+                        compiled_mask.instance_mask,
+                        colormap=VocInstColormap)
+
+                    segm_list[item.id] = True
+
+                if len(item.annotations) == 0:
+                    clsdet_list[item.id] = None
+                    layout_list[item.id] = None
+                    action_list[item.id] = None
+                    segm_list[item.id] = None
+
+            if self._tasks & {VocTask.classification, VocTask.detection,
+                    VocTask.action_classification, VocTask.person_layout}:
+                self.save_clsdet_lists(subset_name, clsdet_list)
+                if self._tasks & {VocTask.classification}:
+                    self.save_class_lists(subset_name, class_lists)
+            if self._tasks & {VocTask.action_classification}:
+                self.save_action_lists(subset_name, action_list)
+            if self._tasks & {VocTask.person_layout}:
+                self.save_layout_lists(subset_name, layout_list)
+            if self._tasks & {VocTask.segmentation}:
+                self.save_segm_lists(subset_name, segm_list)
+
+    def save_action_lists(self, subset_name, action_list):
+        if not action_list:
+            return
+
+        os.makedirs(self._action_subsets_dir, exist_ok=True)
+
+        ann_file = osp.join(self._action_subsets_dir, subset_name + '.txt')
+        with open(ann_file, 'w') as f:
+            for item in action_list:
+                f.write('%s\n' % item)
+
+        if len(action_list) == 0:
+            return
+
+        all_actions = set(chain(*(self._get_actions(l)
+            for l in self._label_map)))
+        for action in all_actions:
+            ann_file = osp.join(self._action_subsets_dir,
+                '%s_%s.txt' % (action, subset_name))
+            with open(ann_file, 'w') as f:
+                for item, objs in action_list.items():
+                    if not objs:
+                        continue
+                    for obj_id, obj_actions in objs.items():
+                        presented = obj_actions[action]
+                        f.write('%s %s % d\n' % \
+                            (item, 1 + obj_id, 1 if presented else -1))
+
+    def save_class_lists(self, subset_name, class_lists):
+        if not class_lists:
+            return
+
+        os.makedirs(self._cls_subsets_dir, exist_ok=True)
+
+        for label in self._label_map:
+            ann_file = osp.join(self._cls_subsets_dir,
+                '%s_%s.txt' % (label, subset_name))
+            with open(ann_file, 'w') as f:
+                for item, item_labels in class_lists.items():
+                    if not item_labels:
+                        continue
+                    item_labels = [self.get_label(l) for l in item_labels]
+                    presented = label in item_labels
+                    f.write('%s % d\n' % (item, 1 if presented else -1))
+
+    def save_clsdet_lists(self, subset_name, clsdet_list):
+        if not clsdet_list:
+            return
+
+        os.makedirs(self._cls_subsets_dir, exist_ok=True)
+
+        ann_file = osp.join(self._cls_subsets_dir, subset_name + '.txt')
+        with open(ann_file, 'w') as f:
+            for item in clsdet_list:
+                f.write('%s\n' % item)
+
+    def save_segm_lists(self, subset_name, segm_list):
+        if not segm_list:
+            return
+
+        os.makedirs(self._segm_subsets_dir, exist_ok=True)
+
+        ann_file = osp.join(self._segm_subsets_dir, subset_name + '.txt')
+        with open(ann_file, 'w') as f:
+            for item in segm_list:
+                f.write('%s\n' % item)
+
+    def save_layout_lists(self, subset_name, layout_list):
+        if not layout_list:
+            return
+
+        os.makedirs(self._layout_subsets_dir, exist_ok=True)
+
+        ann_file = osp.join(self._layout_subsets_dir, subset_name + '.txt')
+        with open(ann_file, 'w') as f:
+            for item, item_layouts in layout_list.items():
+                if item_layouts:
+                    for obj_id in item_layouts:
+                        f.write('%s % d\n' % (item, 1 + obj_id))
+                else:
+                    f.write('%s\n' % (item))
+
+    def save_segm(self, path, mask, colormap=None):
+        if self._apply_colormap:
+            if colormap is None:
+                colormap = self._categories[AnnotationType.mask].colormap
+            mask = paint_mask(mask, colormap)
+        save_image(path, mask, create_dir=True)
+
+    def save_label_map(self):
+        path = osp.join(self._save_dir, VocPath.LABELMAP_FILE)
+        write_label_map(path, self._label_map)
+
+    def _load_categories(self, label_map_source):
+        if label_map_source == LabelmapType.voc.name:
+            # use the default VOC colormap
+            label_map = make_voc_label_map()
+
+        elif label_map_source == LabelmapType.source.name and \
+                AnnotationType.mask not in self._extractor.categories():
+            # generate colormap for input labels
+            labels = self._extractor.categories() \
+                .get(AnnotationType.label, LabelCategories())
+            label_map = OrderedDict((item.name, [None, [], []])
+                for item in labels.items)
+
+        elif label_map_source == LabelmapType.source.name and \
+                AnnotationType.mask in self._extractor.categories():
+            # use source colormap
+            labels = self._extractor.categories()[AnnotationType.label]
+            colors = self._extractor.categories()[AnnotationType.mask]
+            label_map = OrderedDict()
+            for idx, item in enumerate(labels.items):
+                color = colors.colormap.get(idx)
+                if color is not None:
+                    label_map[item.name] = [color, [], []]
+
+        elif isinstance(label_map_source, dict):
+            label_map = OrderedDict(
+                sorted(label_map_source.items(), key=lambda e: e[0]))
+
+        elif isinstance(label_map_source, str) and osp.isfile(label_map_source):
+            label_map = parse_label_map(label_map_source)
+
+        else:
+            raise Exception("Wrong labelmap specified, "
+                "expected one of %s or a file path" % \
+                ', '.join(t.name for t in LabelmapType))
+
+        # There must always be a label with color (0, 0, 0) at index 0
+        bg_label = find(label_map.items(), lambda x: x[1][0] == (0, 0, 0))
+        if bg_label is not None:
+            bg_label = bg_label[0]
+        else:
+            bg_label = 'background'
+            if bg_label not in label_map:
+                has_colors = any(v[0] is not None for v in label_map.values())
+                color = (0, 0, 0) if has_colors else None
+                label_map[bg_label] = [color, [], []]
+        label_map.move_to_end(bg_label, last=False)
+
+        self._categories = make_voc_categories(label_map)
+
+        # Update colors with assigned values
+        colormap = self._categories[AnnotationType.mask].colormap
+        for label_id, color in colormap.items():
+            label_desc = label_map[
+                self._categories[AnnotationType.label].items[label_id].name]
+            label_desc[0] = color
+
+        self._label_map = label_map
+        self._label_id_mapping = self._make_label_id_map()
+
+    def _is_label(self, s):
+        return self._label_map.get(s) is not None
+
+    def _is_part(self, s):
+        for label_desc in self._label_map.values():
+            if s in label_desc[1]:
+                return True
+        return False
+
+    def _is_action(self, label, s):
+        return s in self._get_actions(label)
+
+    def _get_actions(self, label):
+        label_desc = self._label_map.get(label)
+        if not label_desc:
+            return []
+        return label_desc[2]
+
+    def _make_label_id_map(self):
+        source_labels = {
+            id: label.name for id, label in
+            enumerate(self._extractor.categories().get(
+                AnnotationType.label, LabelCategories()).items)
+        }
+        target_labels = {
+            label.name: id for id, label in
+            enumerate(self._categories[AnnotationType.label].items)
+        }
+        id_mapping = {
+            src_id: target_labels.get(src_label, 0)
+            for src_id, src_label in source_labels.items()
+        }
+
+        void_labels = [src_label for src_id, src_label in source_labels.items()
+            if src_label not in target_labels]
+        if void_labels:
+            log.warning("The following labels are remapped to background: %s" %
+                ', '.join(void_labels))
+        log.debug("Saving segmentations with the following label mapping: \n%s" %
+            '\n'.join(["#%s '%s' -> #%s '%s'" %
+                (
+                    src_id, src_label, id_mapping[src_id],
+                    self._categories[AnnotationType.label] \
+                        .items[id_mapping[src_id]].name
+                )
+                for src_id, src_label in source_labels.items()
+            ])
+        )
+
+        def map_id(src_id):
+            return id_mapping.get(src_id, 0)
+        return map_id
+
+    def _remap_mask(self, mask):
+        return remap_mask(mask, self._label_id_mapping)
+
+class VocClassificationConverter(VocConverter):
+    def __init__(self, *args, **kwargs):
+        kwargs['tasks'] = VocTask.classification
+        super().__init__(*args, **kwargs)
+
+class VocDetectionConverter(VocConverter):
+    def __init__(self, *args, **kwargs):
+        kwargs['tasks'] = VocTask.detection
+        super().__init__(*args, **kwargs)
+
+class VocLayoutConverter(VocConverter):
+    def __init__(self, *args, **kwargs):
+        kwargs['tasks'] = VocTask.person_layout
+        super().__init__(*args, **kwargs)
+
+class VocActionConverter(VocConverter):
+    def __init__(self, *args, **kwargs):
+        kwargs['tasks'] = VocTask.action_classification
+        super().__init__(*args, **kwargs)
+
+class VocSegmentationConverter(VocConverter):
+    def __init__(self, *args, **kwargs):
+        kwargs['tasks'] = VocTask.segmentation
+        super().__init__(*args, **kwargs)

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

@@ -0,0 +1,206 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+from collections import OrderedDict
+from enum import Enum
+from itertools import chain
+import numpy as np
+
+from datumaro.components.extractor import (AnnotationType,
+    LabelCategories, MaskCategories
+)
+
+
+VocTask = Enum('VocTask', [
+    'classification',
+    'detection',
+    'segmentation',
+    'action_classification',
+    'person_layout',
+])
+
+VocLabel = Enum('VocLabel', [
+    ('background', 0),
+    ('aeroplane', 1),
+    ('bicycle', 2),
+    ('bird', 3),
+    ('boat', 4),
+    ('bottle', 5),
+    ('bus', 6),
+    ('car', 7),
+    ('cat', 8),
+    ('chair', 9),
+    ('cow', 10),
+    ('diningtable', 11),
+    ('dog', 12),
+    ('horse', 13),
+    ('motorbike', 14),
+    ('person', 15),
+    ('pottedplant', 16),
+    ('sheep', 17),
+    ('sofa', 18),
+    ('train', 19),
+    ('tvmonitor', 20),
+    ('ignored', 255),
+])
+
+VocPose = Enum('VocPose', [
+    'Unspecified',
+    'Left',
+    'Right',
+    'Frontal',
+    'Rear',
+])
+
+VocBodyPart = Enum('VocBodyPart', [
+    'head',
+    'hand',
+    'foot',
+])
+
+VocAction = Enum('VocAction', [
+    'other',
+    'jumping',
+    'phoning',
+    'playinginstrument',
+    'reading',
+    'ridingbike',
+    'ridinghorse',
+    'running',
+    'takingphoto',
+    'usingcomputer',
+    'walking',
+])
+
+def generate_colormap(length=256):
+    def get_bit(number, index):
+        return (number >> index) & 1
+
+    colormap = np.zeros((length, 3), dtype=int)
+    indices = np.arange(length, dtype=int)
+
+    for j in range(7, -1, -1):
+        for c in range(3):
+            colormap[:, c] |= get_bit(indices, c) << j
+        indices >>= 3
+
+    return OrderedDict(
+        (id, tuple(color)) for id, color in enumerate(colormap)
+    )
+
+VocColormap = {id: color for id, color in generate_colormap(256).items()
+    if id in [l.value for l in VocLabel]}
+VocInstColormap = generate_colormap(256)
+
+class VocPath:
+    IMAGES_DIR = 'JPEGImages'
+    ANNOTATIONS_DIR = 'Annotations'
+    SEGMENTATION_DIR = 'SegmentationClass'
+    INSTANCES_DIR = 'SegmentationObject'
+    SUBSETS_DIR = 'ImageSets'
+    IMAGE_EXT = '.jpg'
+    SEGM_EXT = '.png'
+    LABELMAP_FILE = 'labelmap.txt'
+
+    TASK_DIR = {
+        VocTask.classification: 'Main',
+        VocTask.detection: 'Main',
+        VocTask.segmentation: 'Segmentation',
+        VocTask.action_classification: 'Action',
+        VocTask.person_layout: 'Layout',
+    }
+
+
+def make_voc_label_map():
+    labels = sorted(VocLabel, key=lambda l: l.value)
+    label_map = OrderedDict(
+        (label.name, [VocColormap[label.value], [], []]) for label in labels)
+    label_map[VocLabel.person.name][1] = [p.name for p in VocBodyPart]
+    label_map[VocLabel.person.name][2] = [a.name for a in VocAction]
+    return label_map
+
+def parse_label_map(path):
+    if not path:
+        return None
+
+    label_map = OrderedDict()
+    with open(path, 'r') as f:
+        for line in f:
+            # skip empty and commented lines
+            line = line.strip()
+            if not line or line and line[0] == '#':
+                continue
+
+            # name, color, parts, actions
+            label_desc = line.strip().split(':')
+            name = label_desc[0]
+
+            if name in label_map:
+                raise ValueError("Label '%s' is already defined" % name)
+
+            if 1 < len(label_desc) and len(label_desc[1]) != 0:
+                color = label_desc[1].split(',')
+                assert len(color) == 3, \
+                    "Label '%s' has wrong color, expected 'r,g,b', got '%s'" % \
+                    (name, color)
+                color = tuple([int(c) for c in color])
+            else:
+                color = None
+
+            if 2 < len(label_desc) and len(label_desc[2]) != 0:
+                parts = label_desc[2].split(',')
+            else:
+                parts = []
+
+            if 3 < len(label_desc) and len(label_desc[3]) != 0:
+                actions = label_desc[3].split(',')
+            else:
+                actions = []
+
+            label_map[name] = [color, parts, actions]
+    return label_map
+
+def write_label_map(path, label_map):
+    with open(path, 'w') as f:
+        f.write('# label:color_rgb:parts:actions\n')
+        for label_name, label_desc in label_map.items():
+            if label_desc[0]:
+                color_rgb = ','.join(str(c) for c in label_desc[0])
+            else:
+                color_rgb = ''
+
+            parts = ','.join(str(p) for p in label_desc[1])
+            actions = ','.join(str(a) for a in label_desc[2])
+
+            f.write('%s\n' % ':'.join([label_name, color_rgb, parts, actions]))
+
+def make_voc_categories(label_map=None):
+    if label_map is None:
+        label_map = make_voc_label_map()
+
+    categories = {}
+
+    label_categories = LabelCategories()
+    label_categories.attributes.update(['difficult', 'truncated', 'occluded'])
+
+    for label, desc in label_map.items():
+        label_categories.add(label, attributes=desc[2])
+    for part in OrderedDict((k, None) for k in chain(
+            *(desc[1] for desc in label_map.values()))):
+        label_categories.add(part)
+    categories[AnnotationType.label] = label_categories
+
+    has_colors = any(v[0] is not None for v in label_map.values())
+    if not has_colors: # generate new colors
+        colormap = generate_colormap(len(label_map))
+    else: # only copy defined colors
+        label_id = lambda label: label_categories.find(label)[0]
+        colormap = { label_id(name): desc[0]
+            for name, desc in label_map.items() if desc[0] is not None }
+    mask_categories = MaskCategories(colormap)
+    mask_categories.inverse_colormap # pylint: disable=pointless-statement
+    categories[AnnotationType.mask] = mask_categories
+
+    return categories

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

@@ -0,0 +1,77 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+from glob import glob
+import os.path as osp
+
+from datumaro.components.extractor import Importer
+
+from .format import VocTask, VocPath
+
+def find_path(root_path, path, depth=4):
+    level, is_found = 0, False
+    full_path = None
+    while level < depth and not is_found:
+        full_path = osp.join(root_path, path)
+        paths = glob(full_path)
+        if paths:
+            full_path = paths[0] # ignore all after the first one
+            is_found = osp.isdir(full_path)
+        else:
+            full_path = None
+
+        level += 1
+        root_path = osp.join(root_path, '*')
+
+    return full_path
+
+class VocImporter(Importer):
+    _TASKS = [
+        (VocTask.classification, 'voc_classification', 'Main'),
+        (VocTask.detection, 'voc_detection', 'Main'),
+        (VocTask.segmentation, 'voc_segmentation', 'Segmentation'),
+        (VocTask.person_layout, 'voc_layout', 'Layout'),
+        (VocTask.action_classification, 'voc_action', 'Action'),
+    ]
+
+    def __call__(self, path, **extra_params):
+        from datumaro.components.project import Project # cyclic import
+        project = Project()
+
+        subset_paths = self.find_sources(path)
+        if len(subset_paths) == 0:
+            raise Exception("Failed to find 'voc' dataset at '%s'" % path)
+
+        for task, extractor_type, subset_path in subset_paths:
+            project.add_source('%s-%s' %
+                (task.name, osp.splitext(osp.basename(subset_path))[0]),
+            {
+                'url': subset_path,
+                'format': extractor_type,
+                'options': dict(extra_params),
+            })
+
+        return project
+
+    @classmethod
+    def find_sources(cls, path):
+        # find root path for the dataset
+        root_path = path
+        for task, extractor_type, task_dir in cls._TASKS:
+            task_path = find_path(root_path, osp.join(VocPath.SUBSETS_DIR, task_dir))
+            if task_path:
+                root_path = osp.dirname(osp.dirname(task_path))
+                break
+
+        subset_paths = []
+        for task, extractor_type, task_dir in cls._TASKS:
+            task_path = osp.join(root_path, VocPath.SUBSETS_DIR, task_dir)
+
+            if not osp.isdir(task_path):
+                continue
+            task_subsets = [p for p in glob(osp.join(task_path, '*.txt'))
+                if '_' not in osp.basename(p)]
+            subset_paths += [(task, extractor_type, p) for p in task_subsets]
+        return subset_paths

testbed/openvinotoolkit__datumaro/datumaro/plugins/widerface_format.py

@@ -0,0 +1,122 @@
+
+# Copyright (C) 2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+import os
+import os.path as osp
+import re
+
+from datumaro.components.converter import Converter
+from datumaro.components.extractor import (AnnotationType, Bbox, DatasetItem,
+    Importer, SourceExtractor)
+
+
+class WiderFacePath:
+    IMAGE_EXT = '.jpg'
+    ANNOTATIONS_DIR = 'wider_face_split'
+    IMAGES_DIR = 'images'
+    SUBSET_DIR = 'WIDER_'
+    BBOX_ATTRIBUTES = ['blur', 'expression', 'illumination',
+        'occluded', 'pose', 'invalid']
+
+class WiderFaceExtractor(SourceExtractor):
+    def __init__(self, path):
+        if not osp.isfile(path):
+            raise Exception("Can't read annotation file '%s'" % path)
+        self._path = path
+        self._dataset_dir = osp.dirname(osp.dirname(path))
+
+        subset = osp.splitext(osp.basename(path))[0]
+        match = re.fullmatch(r'wider_face_\S+_bbx_gt', subset)
+        if match:
+            subset = subset.split('_')[2]
+        super().__init__(subset=subset)
+
+        self._items = list(self._load_items(path).values())
+
+    def _load_items(self, path):
+        items = {}
+        with open(path, 'r') as f:
+            lines = f.readlines()
+
+        image_ids = [image_id for image_id, line in enumerate(lines)
+            if WiderFacePath.IMAGE_EXT in line]
+
+        for image_id in image_ids:
+            image = lines[image_id]
+            image_path = osp.join(self._dataset_dir, WiderFacePath.SUBSET_DIR
+                + self._subset, WiderFacePath.IMAGES_DIR, image[:-1])
+            item_id = image[:-(len(WiderFacePath.IMAGE_EXT) + 1)]
+
+            bbox_count = lines[image_id + 1]
+            bbox_lines = lines[image_id + 2 : image_id + int(bbox_count) + 2]
+            annotations = []
+            for bbox in bbox_lines:
+                bbox_list = bbox.split()
+                if len(bbox_list) >= 4:
+                    attributes = {}
+                    if len(bbox_list) == 10:
+                        i = 4
+                        for attr in WiderFacePath.BBOX_ATTRIBUTES:
+                            if bbox_list[i] != '-':
+                                attributes[attr] = int(bbox_list[i])
+                            i += 1
+                    annotations.append(Bbox(
+                        int(bbox_list[0]), int(bbox_list[1]),
+                        int(bbox_list[2]), int(bbox_list[3]),
+                        attributes = attributes
+                    ))
+
+            items[item_id] = DatasetItem(id=item_id, subset=self._subset,
+                image=image_path, annotations=annotations)
+        return items
+
+class WiderFaceImporter(Importer):
+    @classmethod
+    def find_sources(cls, path):
+        return cls._find_sources_recursive(osp.join(path,
+            WiderFacePath.ANNOTATIONS_DIR), '.txt', 'wider_face')
+
+class WiderFaceConverter(Converter):
+    DEFAULT_IMAGE_EXT = '.jpg'
+
+    def apply(self):
+        save_dir = self._save_dir
+
+        os.makedirs(save_dir, exist_ok=True)
+
+        for subset_name, subset in self._extractor.subsets().items():
+            subset_dir = osp.join(save_dir, WiderFacePath.SUBSET_DIR + subset_name)
+
+            wider_annotation = ''
+            for item in subset:
+                wider_annotation += '%s\n' % (item.id + WiderFacePath.IMAGE_EXT)
+                if item.has_image and self._save_images:
+                    self._save_image(item, osp.join(save_dir, subset_dir,
+                        WiderFacePath.IMAGES_DIR, item.id + WiderFacePath.IMAGE_EXT))
+
+                bboxes = [a for a in item.annotations
+                    if a.type == AnnotationType.bbox]
+
+                wider_annotation += '%s\n' % len(bboxes)
+                for bbox in bboxes:
+                    wider_bb = ' '.join('%d' % p for p in bbox.get_bbox())
+                    wider_annotation += '%s ' % wider_bb
+                    if bbox.attributes:
+                        wider_attr = ''
+                        attr_counter = 0
+                        for attr in WiderFacePath.BBOX_ATTRIBUTES:
+                            if attr in bbox.attributes:
+                                wider_attr += '%s ' % bbox.attributes[attr]
+                                attr_counter += 1
+                            else:
+                                wider_attr += '- '
+                        if attr_counter > 0:
+                            wider_annotation += wider_attr
+                    wider_annotation  += '\n'
+            annotation_path = osp.join(save_dir, WiderFacePath.ANNOTATIONS_DIR,
+                'wider_face_' + subset_name + '_bbx_gt.txt')
+            os.makedirs(osp.dirname(annotation_path), exist_ok=True)
+            with open(annotation_path, 'w') as f:
+                f.write(wider_annotation)

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

@@ -0,0 +1,197 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+from collections import OrderedDict
+import os.path as osp
+import re
+
+from datumaro.components.extractor import (SourceExtractor, Extractor,
+    DatasetItem, AnnotationType, Bbox, LabelCategories, Importer
+)
+from datumaro.util import split_path
+from datumaro.util.image import Image
+
+from .format import YoloPath
+
+
+class YoloExtractor(SourceExtractor):
+    class Subset(Extractor):
+        def __init__(self, name, parent):
+            super().__init__()
+            self._name = name
+            self._parent = parent
+            self.items = OrderedDict()
+
+        def __iter__(self):
+            for item_id in self.items:
+                yield self._parent._get(item_id, self._name)
+
+        def __len__(self):
+            return len(self.items)
+
+        def categories(self):
+            return self._parent.categories()
+
+    def __init__(self, config_path, image_info=None):
+        super().__init__()
+
+        if not osp.isfile(config_path):
+            raise Exception("Can't read dataset descriptor file '%s'" %
+                config_path)
+
+        rootpath = osp.dirname(config_path)
+        self._path = rootpath
+
+        assert image_info is None or isinstance(image_info, (str, dict))
+        if image_info is None:
+            image_info = osp.join(rootpath, YoloPath.IMAGE_META_FILE)
+            if not osp.isfile(image_info):
+                image_info = {}
+        if isinstance(image_info, str):
+            if not osp.isfile(image_info):
+                raise Exception("Can't read image meta file '%s'" % image_info)
+            with open(image_info) as f:
+                image_info = {}
+                for line in f:
+                    image_name, h, w = line.strip().split()
+                    image_info[image_name] = (int(h), int(w))
+        self._image_info = image_info
+
+        with open(config_path, 'r') as f:
+            config_lines = f.readlines()
+
+        subsets = OrderedDict()
+        names_path = None
+
+        for line in config_lines:
+            match = re.match(r'(\w+)\s*=\s*(.+)$', line)
+            if not match:
+                continue
+
+            key = match.group(1)
+            value = match.group(2)
+            if key == 'names':
+                names_path = value
+            elif key in YoloPath.SUBSET_NAMES:
+                subsets[key] = value
+            else:
+                continue
+
+        if not names_path:
+            raise Exception("Failed to parse labels path from '%s'" % \
+                config_path)
+
+        for subset_name, list_path in subsets.items():
+            list_path = osp.join(self._path, self.localize_path(list_path))
+            if not osp.isfile(list_path):
+                raise Exception("Not found '%s' subset list file" % subset_name)
+
+            subset = YoloExtractor.Subset(subset_name, self)
+            with open(list_path, 'r') as f:
+                subset.items = OrderedDict(
+                    (self.name_from_path(p), self.localize_path(p))
+                    for p in f
+                )
+            subsets[subset_name] = subset
+
+        self._subsets = subsets
+
+        self._categories = {
+            AnnotationType.label:
+                self._load_categories(
+                    osp.join(self._path, self.localize_path(names_path)))
+        }
+
+    @staticmethod
+    def localize_path(path):
+        path = path.strip()
+        default_base = osp.join('data', '')
+        if path.startswith(default_base): # default path
+            path = path[len(default_base) : ]
+        return path
+
+    @classmethod
+    def name_from_path(cls, path):
+        path = cls.localize_path(path)
+        parts = split_path(path)
+        if 1 < len(parts) and not osp.isabs(path):
+            # NOTE: when path is like [data/]<subset_obj>/<image_name>
+            # drop everything but <image name>
+            # <image name> can be <a/b/c/filename.ext>, so no just basename()
+            path = osp.join(*parts[1:])
+        return osp.splitext(path)[0]
+
+    def _get(self, item_id, subset_name):
+        subset = self._subsets[subset_name]
+        item = subset.items[item_id]
+
+        if isinstance(item, str):
+            image_size = self._image_info.get(item_id)
+            image = Image(path=osp.join(self._path, item), size=image_size)
+
+            anno_path = osp.splitext(image.path)[0] + '.txt'
+            annotations = self._parse_annotations(anno_path, image)
+
+            item = DatasetItem(id=item_id, subset=subset_name,
+                image=image, annotations=annotations)
+            subset.items[item_id] = item
+
+        return item
+
+    @staticmethod
+    def _parse_annotations(anno_path, image):
+        lines = []
+        with open(anno_path, 'r') as f:
+            for line in f:
+                line = line.strip()
+                if line:
+                    lines.append(line)
+
+        annotations = []
+        if lines:
+            size = image.size # use image info as late as possible
+            if size is None:
+                raise Exception("Can't find image info for '%s'" % image.path)
+            image_height, image_width = size
+        for line in lines:
+            label_id, xc, yc, w, h = line.split()
+            label_id = int(label_id)
+            w = float(w)
+            h = float(h)
+            x = float(xc) - w * 0.5
+            y = float(yc) - h * 0.5
+            annotations.append(Bbox(
+                round(x * image_width, 1), round(y * image_height, 1),
+                round(w * image_width, 1), round(h * image_height, 1),
+                label=label_id
+            ))
+
+        return annotations
+
+    @staticmethod
+    def _load_categories(names_path):
+        label_categories = LabelCategories()
+
+        with open(names_path, 'r') as f:
+            for label in f:
+                label_categories.add(label.strip())
+
+        return label_categories
+
+    def __iter__(self):
+        for subset in self._subsets.values():
+            for item in subset:
+                yield item
+
+    def __len__(self):
+        return sum(len(s) for s in self._subsets.values())
+
+    def get_subset(self, name):
+        return self._subsets[name]
+
+class YoloImporter(Importer):
+    @classmethod
+    def find_sources(cls, path):
+        return cls._find_sources_recursive(path, '.data', 'yolo')

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

@@ -0,0 +1,11 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+
+class YoloPath:
+    DEFAULT_SUBSET_NAME = 'train'
+    SUBSET_NAMES = ['train', 'valid']
+
+    IMAGE_META_FILE = 'images.meta'

testbed/openvinotoolkit__datumaro/datumaro/util/__init__.py

@@ -0,0 +1,93 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+import os
+import os.path as osp
+from itertools import islice
+
+
+def find(iterable, pred=lambda x: True, default=None):
+    return next((x for x in iterable if pred(x)), default)
+
+def dir_items(path, ext, truncate_ext=False):
+    items = []
+    for f in os.listdir(path):
+        ext_pos = f.rfind(ext)
+        if ext_pos != -1:
+            if truncate_ext:
+                f = f[:ext_pos]
+            items.append(f)
+    return items
+
+def split_path(path):
+    path = osp.normpath(path)
+    parts = []
+
+    while True:
+        path, part = osp.split(path)
+        if part:
+            parts.append(part)
+        else:
+            if path:
+                parts.append(path)
+            break
+    parts.reverse()
+
+    return parts
+
+def cast(value, type_conv, default=None):
+    if value is None:
+        return default
+    try:
+        return type_conv(value)
+    except Exception:
+        return default
+
+def to_snake_case(s):
+    if not s:
+        return ''
+
+    name = [s[0].lower()]
+    for idx, char in enumerate(s[1:]):
+        idx = idx + 1
+        if char.isalpha() and char.isupper():
+            prev_char = s[idx - 1]
+            if not (prev_char.isalpha() and prev_char.isupper()):
+                # avoid "HTML" -> "h_t_m_l"
+                name.append('_')
+            name.append(char.lower())
+        else:
+            name.append(char)
+    return ''.join(name)
+
+def pairs(iterable):
+    a = iter(iterable)
+    return zip(a, a)
+
+def take_by(iterable, count):
+    """
+    Returns elements from the input iterable by batches of N items.
+    ('abcdefg', 3) -> ['a', 'b', 'c'], ['d', 'e', 'f'], ['g']
+    """
+
+    it = iter(iterable)
+    while True:
+        batch = list(islice(it, count))
+        if len(batch) == 0:
+            break
+
+        yield batch
+
+def str_to_bool(s):
+    t = s.lower()
+    if t in {'true', '1', 'ok', 'yes', 'y'}:
+        return True
+    elif t in {'false', '0', 'no', 'n'}:
+        return False
+    else:
+        raise ValueError("Can't convert value '%s' to bool" % s)
+
+def filter_dict(d, exclude_keys):
+    return { k: v for k, v in d.items() if k not in exclude_keys }

testbed/openvinotoolkit__datumaro/datumaro/util/annotation_util.py

@@ -0,0 +1,212 @@
+# Copyright (C) 2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+from itertools import groupby
+
+import numpy as np
+
+from datumaro.components.extractor import _Shape, Mask, AnnotationType, RleMask
+from datumaro.util.mask_tools import mask_to_rle
+
+
+def find_instances(instance_anns):
+    instance_anns = sorted(instance_anns, key=lambda a: a.group)
+    ann_groups = []
+    for g_id, group in groupby(instance_anns, lambda a: a.group):
+        if not g_id:
+            ann_groups.extend(([a] for a in group))
+        else:
+            ann_groups.append(list(group))
+
+    return ann_groups
+
+def find_group_leader(group):
+    return max(group, key=lambda x: x.get_area())
+
+def _get_bbox(ann):
+    if isinstance(ann, (_Shape, Mask)):
+        return ann.get_bbox()
+    else:
+        return ann
+
+def max_bbox(annotations):
+    boxes = [_get_bbox(ann) for ann in annotations]
+    x0 = min((b[0] for b in boxes), default=0)
+    y0 = min((b[1] for b in boxes), default=0)
+    x1 = max((b[0] + b[2] for b in boxes), default=0)
+    y1 = max((b[1] + b[3] for b in boxes), default=0)
+    return [x0, y0, x1 - x0, y1 - y0]
+
+def mean_bbox(annotations):
+    le = len(annotations)
+    boxes = [_get_bbox(ann) for ann in annotations]
+    mlb = sum(b[0] for b in boxes) / le
+    mtb = sum(b[1] for b in boxes) / le
+    mrb = sum(b[0] + b[2] for b in boxes) / le
+    mbb = sum(b[1] + b[3] for b in boxes) / le
+    return [mlb, mtb, mrb - mlb, mbb - mtb]
+
+def softmax(x):
+    return np.exp(x) / sum(np.exp(x))
+
+def nms(segments, iou_thresh=0.5):
+    """
+    Non-maxima suppression algorithm.
+    """
+
+    indices = np.argsort([b.attributes['score'] for b in segments])
+    ious = np.array([[iou(a, b) for b in segments] for a in segments])
+
+    predictions = []
+    while len(indices) != 0:
+        i = len(indices) - 1
+        pred_idx = indices[i]
+        to_remove = [i]
+        predictions.append(segments[pred_idx])
+        for i, box_idx in enumerate(indices[:i]):
+            if iou_thresh < ious[pred_idx, box_idx]:
+                to_remove.append(i)
+        indices = np.delete(indices, to_remove)
+
+    return predictions
+
+def bbox_iou(a, b):
+    """
+    IoU computations for simple cases with bounding boxes
+    """
+    bbox_a = _get_bbox(a)
+    bbox_b = _get_bbox(b)
+
+    aX, aY, aW, aH = bbox_a
+    bX, bY, bW, bH = bbox_b
+    in_right = min(aX + aW, bX + bW)
+    in_left = max(aX, bX)
+    in_top = max(aY, bY)
+    in_bottom = min(aY + aH, bY + bH)
+
+    in_w = max(0, in_right - in_left)
+    in_h = max(0, in_bottom - in_top)
+    intersection = in_w * in_h
+    if not intersection:
+        return -1
+
+    a_area = aW * aH
+    b_area = bW * bH
+    union = a_area + b_area - intersection
+    return intersection / union
+
+def segment_iou(a, b):
+    """
+    Generic IoU computation with masks, polygons, and boxes.
+    Returns -1 if no intersection, [0; 1] otherwise
+    """
+    from pycocotools import mask as mask_utils
+
+    a_bbox = a.get_bbox()
+    b_bbox = b.get_bbox()
+
+    is_bbox = AnnotationType.bbox in [a.type, b.type]
+    if is_bbox:
+        a = [a_bbox]
+        b = [b_bbox]
+    else:
+        w = max(a_bbox[0] + a_bbox[2], b_bbox[0] + b_bbox[2])
+        h = max(a_bbox[1] + a_bbox[3], b_bbox[1] + b_bbox[3])
+
+        def _to_rle(ann):
+            if ann.type == AnnotationType.polygon:
+                return mask_utils.frPyObjects([ann.points], h, w)
+            elif isinstance(ann, RleMask):
+                return [ann.rle]
+            elif ann.type == AnnotationType.mask:
+                return mask_utils.frPyObjects([mask_to_rle(ann.image)], h, w)
+            else:
+                raise TypeError("Unexpected arguments: %s, %s" % (a, b))
+        a = _to_rle(a)
+        b = _to_rle(b)
+    return float(mask_utils.iou(a, b, [not is_bbox]))
+
+def PDJ(a, b, eps=None, ratio=0.05, bbox=None):
+    """
+    Percentage of Detected Joints metric.
+    Counts the number of matching points.
+    """
+
+    assert eps is not None or ratio is not None
+
+    p1 = np.array(a.points).reshape((-1, 2))
+    p2 = np.array(b.points).reshape((-1, 2))
+    if len(p1) != len(p2):
+        return 0
+
+    if not eps:
+        if bbox is None:
+            bbox = mean_bbox([a, b])
+
+        diag = (bbox[2] ** 2 + bbox[3] ** 2) ** 0.5
+        eps = ratio * diag
+
+    dists = np.linalg.norm(p1 - p2, axis=1)
+    return np.sum(dists < eps) / len(p1)
+
+def OKS(a, b, sigma=None, bbox=None, scale=None):
+    """
+    Object Keypoint Similarity metric.
+    https://cocodataset.org/#keypoints-eval
+    """
+
+    p1 = np.array(a.points).reshape((-1, 2))
+    p2 = np.array(b.points).reshape((-1, 2))
+    if len(p1) != len(p2):
+        return 0
+
+    if not sigma:
+        sigma = 0.1
+    else:
+        assert len(sigma) == len(p1)
+
+    if not scale:
+        if bbox is None:
+            bbox = mean_bbox([a, b])
+        scale = bbox[2] * bbox[3]
+
+    dists = np.linalg.norm(p1 - p2, axis=1)
+    return np.sum(np.exp(-(dists ** 2) / (2 * scale * (2 * sigma) ** 2)))
+
+def smooth_line(points, segments):
+    assert 2 <= len(points) // 2 and len(points) % 2 == 0
+
+    if len(points) // 2 == segments:
+        return points
+
+    points = list(points)
+    if len(points) == 2:
+        points.extend(points)
+    points = np.array(points).reshape((-1, 2))
+
+    lengths = np.linalg.norm(points[1:] - points[:-1], axis=1)
+    dists = [0]
+    for l in lengths:
+        dists.append(dists[-1] + l)
+
+    step = dists[-1] / segments
+
+    new_points = np.zeros((segments + 1, 2))
+    new_points[0] = points[0]
+
+    old_segment = 0
+    for new_segment in range(1, segments + 1):
+        pos = new_segment * step
+        while dists[old_segment + 1] < pos and old_segment + 2 < len(dists):
+            old_segment += 1
+
+        segment_start = dists[old_segment]
+        segment_len = lengths[old_segment]
+        prev_p = points[old_segment]
+        next_p = points[old_segment + 1]
+        r = (pos - segment_start) / segment_len
+
+        new_points[new_segment] = prev_p * (1 - r) + next_p * r
+
+    return new_points, step

testbed/openvinotoolkit__datumaro/datumaro/util/attrs_util.py

@@ -0,0 +1,33 @@
+# Copyright (C) 2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+import attr
+
+_NOTSET = object()
+
+def not_empty(inst, attribute, x):
+    assert len(x) != 0, x
+
+def default_if_none(conv):
+    def validator(inst, attribute, value):
+        default = attribute.default
+        if value is None:
+            if callable(default):
+                value = default()
+            elif isinstance(default, attr.Factory):
+                value = default.factory()
+            else:
+                value = default
+        elif not isinstance(value, attribute.type or conv):
+            value = conv(value)
+        setattr(inst, attribute.name, value)
+    return validator
+
+def ensure_cls(c):
+    def converter(arg):
+        if isinstance(arg, c):
+            return arg
+        else:
+            return c(**arg)
+    return converter

testbed/openvinotoolkit__datumaro/datumaro/util/command_targets.py

@@ -0,0 +1,113 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+import argparse
+from enum import Enum
+
+from datumaro.components.project import Project
+from datumaro.util.image import load_image
+
+
+TargetKinds = Enum('TargetKinds',
+    ['project', 'source', 'external_dataset', 'inference', 'image'])
+
+def is_project_name(value, project):
+    return value == project.config.project_name
+
+def is_project_path(value):
+    if value:
+        try:
+            Project.load(value)
+            return True
+        except Exception:
+            pass
+    return False
+
+def is_project(value, project=None):
+    if is_project_path(value):
+        return True
+    elif project is not None:
+        return is_project_name(value, project)
+
+    return False
+
+def is_source(value, project=None):
+    if project is not None:
+        try:
+            project.get_source(value)
+            return True
+        except KeyError:
+            pass
+
+    return False
+
+def is_external_source(value):
+    return False
+
+def is_inference_path(value):
+    return False
+
+def is_image_path(value):
+    try:
+        return load_image(value) is not None
+    except Exception:
+        return False
+
+
+class Target:
+    def __init__(self, kind, test, is_default=False, name=None):
+        self.kind = kind
+        self.test = test
+        self.is_default = is_default
+        self.name = name
+
+    def _get_fields(self):
+        return [self.kind, self.test, self.is_default, self.name]
+
+    def __str__(self):
+        return self.name or str(self.kind)
+
+    def __len__(self):
+        return len(self._get_fields())
+
+    def __iter__(self):
+        return iter(self._get_fields())
+
+def ProjectTarget(kind=TargetKinds.project, test=None,
+        is_default=False, name='project name or path',
+        project=None):
+    if test is None:
+        test = lambda v: is_project(v, project=project)
+    return Target(kind, test, is_default, name)
+
+def SourceTarget(kind=TargetKinds.source, test=None,
+        is_default=False, name='source name',
+        project=None):
+    if test is None:
+        test = lambda v: is_source(v, project=project)
+    return Target(kind, test, is_default, name)
+
+def ExternalDatasetTarget(kind=TargetKinds.external_dataset,
+        test=is_external_source,
+        is_default=False, name='external dataset path'):
+    return Target(kind, test, is_default, name)
+
+def InferenceTarget(kind=TargetKinds.inference, test=is_inference_path,
+        is_default=False, name='inference path'):
+    return Target(kind, test, is_default, name)
+
+def ImageTarget(kind=TargetKinds.image, test=is_image_path,
+            is_default=False, name='image path'):
+    return Target(kind, test, is_default, name)
+
+
+def target_selector(*targets):
+    def selector(value):
+        for (kind, test, is_default, _) in targets:
+            if (is_default and (value == '' or value is None)) or test(value):
+                return (kind, value)
+        raise argparse.ArgumentTypeError('Value should be one of: %s' \
+            % (', '.join([str(t) for t in targets])))
+    return selector

testbed/openvinotoolkit__datumaro/datumaro/util/image.py

@@ -0,0 +1,295 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+# pylint: disable=unused-import
+
+from enum import Enum
+from io import BytesIO
+import numpy as np
+import os
+import os.path as osp
+
+_IMAGE_BACKENDS = Enum('_IMAGE_BACKENDS', ['cv2', 'PIL'])
+_IMAGE_BACKEND = None
+try:
+    import cv2
+    _IMAGE_BACKEND = _IMAGE_BACKENDS.cv2
+except ImportError:
+    import PIL
+    _IMAGE_BACKEND = _IMAGE_BACKENDS.PIL
+
+from datumaro.util.image_cache import ImageCache as _ImageCache
+
+
+def load_image(path, dtype=np.float32):
+    """
+    Reads an image in the HWC Grayscale/BGR(A) float [0; 255] format.
+    """
+
+    if _IMAGE_BACKEND == _IMAGE_BACKENDS.cv2:
+        import cv2
+        image = cv2.imread(path, cv2.IMREAD_UNCHANGED)
+        image = image.astype(dtype)
+    elif _IMAGE_BACKEND == _IMAGE_BACKENDS.PIL:
+        from PIL import Image
+        image = Image.open(path)
+        image = np.asarray(image, dtype=dtype)
+        if len(image.shape) == 3 and image.shape[2] in {3, 4}:
+            image[:, :, :3] = image[:, :, 2::-1] # RGB to BGR
+    else:
+        raise NotImplementedError()
+
+    if image is None:
+        raise ValueError("Can't open image '%s'" % path)
+    assert len(image.shape) in {2, 3}
+    if len(image.shape) == 3:
+        assert image.shape[2] in {3, 4}
+    return image
+
+def save_image(path, image, create_dir=False, dtype=np.uint8, **kwargs):
+    # NOTE: Check destination path for existence
+    # OpenCV silently fails if target directory does not exist
+    dst_dir = osp.dirname(path)
+    if dst_dir:
+        if create_dir:
+            os.makedirs(dst_dir, exist_ok=True)
+        elif not osp.isdir(dst_dir):
+            raise FileNotFoundError("Directory does not exist: '%s'" % dst_dir)
+
+    if not kwargs:
+        kwargs = {}
+
+    if _IMAGE_BACKEND == _IMAGE_BACKENDS.cv2:
+        import cv2
+
+        params = []
+
+        ext = path[-4:]
+        if ext.upper() == '.JPG':
+            params = [
+                int(cv2.IMWRITE_JPEG_QUALITY), kwargs.get('jpeg_quality', 75)
+            ]
+
+        image = image.astype(dtype)
+        cv2.imwrite(path, image, params=params)
+    elif _IMAGE_BACKEND == _IMAGE_BACKENDS.PIL:
+        from PIL import Image
+
+        params = {}
+        params['quality'] = kwargs.get('jpeg_quality')
+        if kwargs.get('jpeg_quality') == 100:
+            params['subsampling'] = 0
+
+        image = image.astype(dtype)
+        if len(image.shape) == 3 and image.shape[2] in {3, 4}:
+            image[:, :, :3] = image[:, :, 2::-1] # BGR to RGB
+        image = Image.fromarray(image)
+        image.save(path, **params)
+    else:
+        raise NotImplementedError()
+
+def encode_image(image, ext, dtype=np.uint8, **kwargs):
+    if not kwargs:
+        kwargs = {}
+
+    if _IMAGE_BACKEND == _IMAGE_BACKENDS.cv2:
+        import cv2
+
+        params = []
+
+        if not ext.startswith('.'):
+            ext = '.' + ext
+
+        if ext.upper() == '.JPG':
+            params = [
+                int(cv2.IMWRITE_JPEG_QUALITY), kwargs.get('jpeg_quality', 75)
+            ]
+
+        image = image.astype(dtype)
+        success, result = cv2.imencode(ext, image, params=params)
+        if not success:
+            raise Exception("Failed to encode image to '%s' format" % (ext))
+        return result.tobytes()
+    elif _IMAGE_BACKEND == _IMAGE_BACKENDS.PIL:
+        from PIL import Image
+
+        if ext.startswith('.'):
+            ext = ext[1:]
+
+        params = {}
+        params['quality'] = kwargs.get('jpeg_quality')
+        if kwargs.get('jpeg_quality') == 100:
+            params['subsampling'] = 0
+
+        image = image.astype(dtype)
+        if len(image.shape) == 3 and image.shape[2] in {3, 4}:
+            image[:, :, :3] = image[:, :, 2::-1] # BGR to RGB
+        image = Image.fromarray(image)
+        with BytesIO() as buffer:
+            image.save(buffer, format=ext, **params)
+            return buffer.getvalue()
+    else:
+        raise NotImplementedError()
+
+def decode_image(image_bytes, dtype=np.float32):
+    if _IMAGE_BACKEND == _IMAGE_BACKENDS.cv2:
+        import cv2
+        image = np.frombuffer(image_bytes, dtype=np.uint8)
+        image = cv2.imdecode(image, cv2.IMREAD_UNCHANGED)
+        image = image.astype(dtype)
+    elif _IMAGE_BACKEND == _IMAGE_BACKENDS.PIL:
+        from PIL import Image
+        image = Image.open(BytesIO(image_bytes))
+        image = np.asarray(image, dtype=dtype)
+        if len(image.shape) == 3 and image.shape[2] in {3, 4}:
+            image[:, :, :3] = image[:, :, 2::-1] # RGB to BGR
+    else:
+        raise NotImplementedError()
+
+    assert len(image.shape) in {2, 3}
+    if len(image.shape) == 3:
+        assert image.shape[2] in {3, 4}
+    return image
+
+
+class lazy_image:
+    def __init__(self, path, loader=None, cache=None):
+        if loader is None:
+            loader = load_image
+        self.path = path
+        self.loader = loader
+
+        # Cache:
+        # - False: do not cache
+        # - None: use the global cache
+        # - object: an object to be used as cache
+        assert cache in {None, False} or isinstance(cache, object)
+        self.cache = cache
+
+    def __call__(self):
+        image = None
+        image_id = hash(self) # path is not necessary hashable or a file path
+
+        cache = self._get_cache(self.cache)
+        if cache is not None:
+            image = cache.get(image_id)
+
+        if image is None:
+            image = self.loader(self.path)
+            if cache is not None:
+                cache.push(image_id, image)
+        return image
+
+    @staticmethod
+    def _get_cache(cache):
+        if cache is None:
+            cache = _ImageCache.get_instance()
+        elif cache == False:
+            return None
+        return cache
+
+    def __hash__(self):
+        return hash((id(self), self.path, self.loader))
+
+class Image:
+    def __init__(self, data=None, path=None, loader=None, cache=None,
+            size=None):
+        assert size is None or len(size) == 2
+        if size is not None:
+            assert len(size) == 2 and 0 < size[0] and 0 < size[1], size
+            size = tuple(size)
+        self._size = size # (H, W)
+
+        assert path is None or isinstance(path, str)
+        if path is None:
+            path = ''
+        self._path = path
+
+        assert data is not None or path or loader, "Image can not be empty"
+        if data is not None:
+            assert callable(data) or isinstance(data, np.ndarray), type(data)
+        if data is None and (path or loader):
+            if osp.isfile(path) or loader:
+                data = lazy_image(path, loader=loader, cache=cache)
+        self._data = data
+
+    @property
+    def path(self):
+        return self._path
+
+    @property
+    def ext(self):
+        return osp.splitext(osp.basename(self.path))[1]
+
+    @property
+    def data(self):
+        if callable(self._data):
+            return self._data()
+        return self._data
+
+    @property
+    def has_data(self):
+        return self._data is not None
+
+    @property
+    def size(self):
+        if self._size is None:
+            data = self.data
+            if data is not None:
+                self._size = data.shape[:2]
+        return self._size
+
+    def __eq__(self, other):
+        if isinstance(other, np.ndarray):
+            return self.has_data and np.array_equal(self.data, other)
+
+        if not isinstance(other, __class__):
+            return False
+        return \
+            (np.array_equal(self.size, other.size)) and \
+            (self.has_data == other.has_data) and \
+            (self.has_data and np.array_equal(self.data, other.data) or \
+                not self.has_data)
+
+class ByteImage(Image):
+    def __init__(self, data=None, path=None, ext=None, cache=None, size=None):
+        loader = None
+        if data is not None:
+            if callable(data) and not isinstance(data, lazy_image):
+                data = lazy_image(path, loader=data, cache=cache)
+            loader = lambda _: decode_image(self.get_bytes())
+
+        super().__init__(path=path, size=size, loader=loader, cache=cache)
+        if data is None and loader is None:
+            # unset defaults for regular images
+            # to avoid random file reading to bytes
+            self._data = None
+
+        self._bytes_data = data
+        if ext:
+            ext = ext.lower()
+            if not ext.startswith('.'):
+                ext = '.' + ext
+        self._ext = ext
+
+    def get_bytes(self):
+        if callable(self._bytes_data):
+            return self._bytes_data()
+        return self._bytes_data
+
+    @property
+    def ext(self):
+        if self._ext:
+            return self._ext
+        return super().ext
+
+    def __eq__(self, other):
+        if not isinstance(other, __class__):
+            return super().__eq__(other)
+        return \
+            (np.array_equal(self.size, other.size)) and \
+            (self.has_data == other.has_data) and \
+            (self.has_data and self.get_bytes() == other.get_bytes() or \
+                not self.has_data)

testbed/openvinotoolkit__datumaro/datumaro/util/image_cache.py

@@ -0,0 +1,42 @@
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+from collections import OrderedDict
+
+
+_instance = None
+
+DEFAULT_CAPACITY = 2
+
+class ImageCache:
+    @staticmethod
+    def get_instance():
+        global _instance
+        if _instance is None:
+            _instance = ImageCache()
+        return _instance
+
+    def __init__(self, capacity=DEFAULT_CAPACITY):
+        self.capacity = int(capacity)
+        self.items = OrderedDict()
+
+    def push(self, item_id, image):
+        if self.capacity <= len(self.items):
+            self.items.popitem(last=True)
+        self.items[item_id] = image
+
+    def get(self, item_id):
+        default = object()
+        item = self.items.get(item_id, default)
+        if item is default:
+            return None
+
+        self.items.move_to_end(item_id, last=False) # naive splay tree
+        return item
+
+    def size(self):
+        return len(self.items)
+
+    def clear(self):
+        self.items.clear()

testbed/openvinotoolkit__datumaro/datumaro/util/log_utils.py

@@ -0,0 +1,16 @@
+
+# Copyright (C) 2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+from contextlib import contextmanager
+import logging
+
+@contextmanager
+def logging_disabled(max_level=logging.CRITICAL):
+    previous_level = logging.root.manager.disable
+    logging.disable(max_level)
+    try:
+        yield
+    finally:
+        logging.disable(previous_level)

testbed/openvinotoolkit__datumaro/datumaro/util/mask_tools.py

@@ -0,0 +1,288 @@
+
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+import numpy as np
+
+from datumaro.util.image import lazy_image, load_image
+
+
+def generate_colormap(length=256):
+    """
+    Generates colors using PASCAL VOC algorithm.
+
+    Returns index -> (R, G, B) mapping.
+    """
+
+    def get_bit(number, index):
+        return (number >> index) & 1
+
+    colormap = np.zeros((length, 3), dtype=int)
+    indices = np.arange(length, dtype=int)
+
+    for j in range(7, -1, -1):
+        for c in range(3):
+            colormap[:, c] |= get_bit(indices, c) << j
+        indices >>= 3
+
+    return {
+        id: tuple(color) for id, color in enumerate(colormap)
+    }
+
+def invert_colormap(colormap):
+    return {
+        tuple(a): index for index, a in colormap.items()
+    }
+
+def check_is_mask(mask):
+    assert len(mask.shape) in {2, 3}
+    if len(mask.shape) == 3:
+        assert mask.shape[2] == 1
+
+_default_colormap = generate_colormap()
+_default_unpaint_colormap = invert_colormap(_default_colormap)
+
+def unpaint_mask(painted_mask, inverse_colormap=None):
+    # Covert color mask to index mask
+
+    # mask: HWC BGR [0; 255]
+    # colormap: (R, G, B) -> index
+    assert len(painted_mask.shape) == 3
+    if inverse_colormap is None:
+        inverse_colormap = _default_unpaint_colormap
+
+    if callable(inverse_colormap):
+        map_fn = lambda a: inverse_colormap(
+                (a >> 16) & 255, (a >> 8) & 255, a & 255
+            )
+    else:
+        map_fn = lambda a: inverse_colormap[(
+                (a >> 16) & 255, (a >> 8) & 255, a & 255
+            )]
+
+    painted_mask = painted_mask.astype(int)
+    painted_mask = painted_mask[:, :, 0] + \
+                   (painted_mask[:, :, 1] << 8) + \
+                   (painted_mask[:, :, 2] << 16)
+    uvals, unpainted_mask = np.unique(painted_mask, return_inverse=True)
+    palette = np.array([map_fn(v) for v in uvals], dtype=np.float32)
+    unpainted_mask = palette[unpainted_mask].reshape(painted_mask.shape[:2])
+
+    return unpainted_mask
+
+def paint_mask(mask, colormap=None):
+    # Applies colormap to index mask
+
+    # mask: HW(C) [0; max_index] mask
+    # colormap: index -> (R, G, B)
+    check_is_mask(mask)
+
+    if colormap is None:
+        colormap = _default_colormap
+    if callable(colormap):
+        map_fn = colormap
+    else:
+        map_fn = lambda c: colormap.get(c, (-1, -1, -1))
+    palette = np.array([map_fn(c)[::-1] for c in range(256)], dtype=np.float32)
+
+    mask = mask.astype(np.uint8)
+    painted_mask = palette[mask].reshape((*mask.shape[:2], 3))
+    return painted_mask
+
+def remap_mask(mask, map_fn):
+    # Changes mask elements from one colormap to another
+
+    # mask: HW(C) [0; max_index] mask
+    check_is_mask(mask)
+
+    return np.array([map_fn(c) for c in range(256)], dtype=np.uint8)[mask]
+
+def make_index_mask(binary_mask, index):
+    return np.choose(binary_mask, np.array([0, index], dtype=np.uint8))
+
+def make_binary_mask(mask):
+    return np.nonzero(mask)
+
+
+def load_mask(path, inverse_colormap=None):
+    mask = load_image(path, dtype=np.uint8)
+    if inverse_colormap is not None:
+        if len(mask.shape) == 3 and mask.shape[2] != 1:
+            mask = unpaint_mask(mask, inverse_colormap)
+    return mask
+
+def lazy_mask(path, inverse_colormap=None):
+    return lazy_image(path, lambda path: load_mask(path, inverse_colormap))
+
+def mask_to_rle(binary_mask):
+    # walk in row-major order as COCO format specifies
+    bounded = binary_mask.ravel(order='F')
+
+    # add borders to sequence
+    # find boundary positions for sequences and compute their lengths
+    difs = np.diff(bounded, prepend=[1 - bounded[0]], append=[1 - bounded[-1]])
+    counts, = np.where(difs != 0)
+
+    # start RLE encoding from 0 as COCO format specifies
+    if bounded[0] != 0:
+        counts = np.diff(counts, prepend=[0])
+    else:
+        counts = np.diff(counts)
+
+    return {
+        'counts': counts,
+        'size': list(binary_mask.shape)
+    }
+
+def mask_to_polygons(mask, tolerance=1.0, area_threshold=1):
+    """
+    Convert an instance mask to polygons
+
+    Args:
+        mask: a 2d binary mask
+        tolerance: maximum distance from original points of
+            a polygon to the approximated ones
+        area_threshold: minimal area of generated polygons
+
+    Returns:
+        A list of polygons like [[x1,y1, x2,y2 ...], [...]]
+    """
+    from pycocotools import mask as mask_utils
+    from skimage import measure
+
+    polygons = []
+
+    # pad mask with 0 around borders
+    padded_mask = np.pad(mask, pad_width=1, mode='constant', constant_values=0)
+    contours = measure.find_contours(padded_mask, 0.5)
+    # Fix coordinates after padding
+    contours = np.subtract(contours, 1)
+
+    for contour in contours:
+        if not np.array_equal(contour[0], contour[-1]):
+            contour = np.vstack((contour, contour[0])) # make polygon closed
+
+        contour = measure.approximate_polygon(contour, tolerance)
+        if len(contour) <= 2:
+            continue
+
+        contour = np.flip(contour, axis=1).flatten().clip(0) # [x0, y0, ...]
+
+        # Check if the polygon is big enough
+        rle = mask_utils.frPyObjects([contour], mask.shape[0], mask.shape[1])
+        area = sum(mask_utils.area(rle))
+        if area_threshold <= area:
+            polygons.append(contour)
+    return polygons
+
+def crop_covered_segments(segments, width, height,
+        iou_threshold=0.0, ratio_tolerance=0.001, area_threshold=1,
+        return_masks=False):
+    """
+    Find all segments occluded by others and crop them to the visible part only.
+    Input segments are expected to be sorted from background to foreground.
+
+    Args:
+        segments: 1d list of segment RLEs (in COCO format)
+        width: width of the image
+        height: height of the image
+        iou_threshold: IoU threshold for objects to be counted as intersected
+            By default is set to 0 to process any intersected objects
+        ratio_tolerance: an IoU "handicap" value for a situation
+            when an object is (almost) fully covered by another one and we
+            don't want make a "hole" in the background object
+        area_threshold: minimal area of included segments
+
+    Returns:
+        A list of input segments' parts (in the same order as input):
+            [
+                [[x1,y1, x2,y2 ...], ...], # input segment #0 parts
+                mask1, # input segment #1 mask (if source segment is mask)
+                [], # when source segment is too small
+                ...
+            ]
+    """
+    from pycocotools import mask as mask_utils
+
+    segments = [[s] for s in segments]
+    input_rles = [mask_utils.frPyObjects(s, height, width) for s in segments]
+
+    for i, rle_bottom in enumerate(input_rles):
+        area_bottom = sum(mask_utils.area(rle_bottom))
+        if area_bottom < area_threshold:
+            segments[i] = [] if not return_masks else None
+            continue
+
+        rles_top = []
+        for j in range(i + 1, len(input_rles)):
+            rle_top = input_rles[j]
+            iou = sum(mask_utils.iou(rle_bottom, rle_top, [0, 0]))[0]
+
+            if iou <= iou_threshold:
+                continue
+
+            area_top = sum(mask_utils.area(rle_top))
+            area_ratio = area_top / area_bottom
+
+            # If a segment is fully inside another one, skip this segment
+            if abs(area_ratio - iou) < ratio_tolerance:
+                continue
+
+            # Check if the bottom segment is fully covered by the top one.
+            # There is a mistake in the annotation, keep the background one
+            if abs(1 / area_ratio - iou) < ratio_tolerance:
+                rles_top = []
+                break
+
+            rles_top += rle_top
+
+        if not rles_top and not isinstance(segments[i][0], dict) \
+                and not return_masks:
+            continue
+
+        rle_bottom = rle_bottom[0]
+        bottom_mask = mask_utils.decode(rle_bottom).astype(np.uint8)
+
+        if rles_top:
+            rle_top = mask_utils.merge(rles_top)
+            top_mask = mask_utils.decode(rle_top).astype(np.uint8)
+
+            bottom_mask -= top_mask
+            bottom_mask[bottom_mask != 1] = 0
+
+        if not return_masks and not isinstance(segments[i][0], dict):
+            segments[i] = mask_to_polygons(bottom_mask,
+                area_threshold=area_threshold)
+        else:
+            segments[i] = bottom_mask
+
+    return segments
+
+def rles_to_mask(rles, width, height):
+    from pycocotools import mask as mask_utils
+
+    rles = mask_utils.frPyObjects(rles, height, width)
+    rles = mask_utils.merge(rles)
+    mask = mask_utils.decode(rles)
+    return mask
+
+def find_mask_bbox(mask):
+    cols = np.any(mask, axis=0)
+    rows = np.any(mask, axis=1)
+    x0, x1 = np.where(cols)[0][[0, -1]]
+    y0, y1 = np.where(rows)[0][[0, -1]]
+    return [x0, y0, x1 - x0, y1 - y0]
+
+def merge_masks(masks):
+    """
+        Merges masks into one, mask order is responsible for z order.
+    """
+    if not masks:
+        return None
+
+    merged_mask = masks[0]
+    for m in masks[1:]:
+        merged_mask = np.where(m != 0, m, merged_mask)
+
+    return merged_mask

testbed/openvinotoolkit__datumaro/datumaro/util/os_util.py

@@ -0,0 +1,17 @@
+
+# Copyright (C) 2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
+import subprocess
+
+
+def check_instruction_set(instruction):
+    return instruction == str.strip(
+        # Let's ignore a warning from bandit about using shell=True.
+        # In this case it isn't a security issue and we use some
+        # shell features like pipes.
+        subprocess.check_output(
+            'lscpu | grep -o "%s" | head -1' % instruction,
+            shell=True).decode('utf-8') # nosec
+    )