├── tests
    ├── __init__.py
    ├── test_imgaug_imports.py
    ├── conftest.py
    ├── utils.py
    ├── files
    │   ├── transform_serialization_v2_without_totensor.json
    │   ├── transform_serialization_v2_with_totensor.json
    │   ├── transform_v0.4.6_without_totensor.json
    │   └── transform_v0.4.6_with_totensor.json
    ├── test_pytorch.py
    └── test_bbox.py
├── albumentations
    ├── core
    │   ├── __init__.py
    │   ├── utils.py
    │   ├── serialization.py
    │   └── transforms_interface.py
    ├── imgaug
    │   ├── __init__.py
    │   └── stubs.py
    ├── augmentations
    │   ├── crops
    │   │   ├── __init__.py
    │   │   └── functional.py
    │   ├── geometric
    │   │   ├── __init__.py
    │   │   ├── rotate.py
    │   │   └── resize.py
    │   ├── utils.py
    │   ├── __init__.py
    │   └── keypoints_utils.py
    ├── pytorch
    │   ├── __init__.py
    │   ├── functional.py
    │   └── transforms.py
    └── __init__.py
├── .gitattributes
├── conda.recipe
    ├── conda_build_config.yaml
    ├── build_upload.sh
    └── meta.yaml
├── docs
    ├── logo.png
    ├── api
    │   ├── index.rst
    │   ├── imgaug.rst
    │   ├── pytorch.rst
    │   ├── core.rst
    │   └── augmentations.rst
    ├── requirements.txt
    ├── augs_overview
    │   └── index.rst
    ├── _templates
    │   ├── searchbox.html
    │   ├── versions.html
    │   ├── search.html
    │   ├── footer.html
    │   ├── breadcrumbs.html
    │   └── layout.html
    ├── Makefile
    ├── make.bat
    ├── contributing.rst
    ├── index.rst
    ├── examples.rst
    ├── probabilities.rst
    ├── conf.py
    ├── hall_of_fame.rst
    └── citations.rst
├── MANIFEST.in
├── benchmark
    ├── requirements.txt
    ├── Dockerfile
    └── README.md
├── .readthedocs.yml
├── .deepsource.toml
├── setup.cfg
├── .github
    ├── ISSUE_TEMPLATE
    │   ├── documentation.md
    │   └── bug-report.md
    └── workflows
    │   ├── upload_to_pypi.yml
    │   └── ci.yml
├── black.toml
├── .pre-commit-config.yaml
├── LICENSE
├── .gitignore
├── setup.py
└── tools
    └── make_transforms_docs.py


/tests/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/albumentations/core/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/albumentations/imgaug/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/.gitattributes:
--------------------------------------------------------------------------------
1 | *.py linguist-language=python
2 | *.ipynb linguist-documentation
3 | 


--------------------------------------------------------------------------------
/conda.recipe/conda_build_config.yaml:
--------------------------------------------------------------------------------
1 | python:
2 |   - 3.5
3 |   - 3.6
4 |   - 3.7
5 | 


--------------------------------------------------------------------------------
/docs/logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/liaoxy169/albumentations/HEAD/docs/logo.png


--------------------------------------------------------------------------------
/albumentations/augmentations/crops/__init__.py:
--------------------------------------------------------------------------------
1 | from .functional import *
2 | from .transforms import *
3 | 


--------------------------------------------------------------------------------
/albumentations/pytorch/__init__.py:
--------------------------------------------------------------------------------
1 | from __future__ import absolute_import
2 | 
3 | from .transforms import *
4 | 


--------------------------------------------------------------------------------
/albumentations/augmentations/geometric/__init__.py:
--------------------------------------------------------------------------------
1 | from .functional import *
2 | from .resize import *
3 | from .rotate import *
4 | from .transforms import *
5 | 


--------------------------------------------------------------------------------
/docs/api/index.rst:
--------------------------------------------------------------------------------
 1 | API
 2 | ===
 3 | 
 4 | .. toctree::
 5 |    :maxdepth: 2
 6 | 
 7 |    ./core
 8 |    ./augmentations
 9 |    ./imgaug
10 |    ./pytorch
11 | 


--------------------------------------------------------------------------------
/docs/requirements.txt:
--------------------------------------------------------------------------------
1 | https://download.pytorch.org/whl/cpu/torch-1.6.0%2Bcpu-cp38-cp38-linux_x86_64.whl
2 | mock
3 | numpy==1.15.4
4 | scikit-image
5 | sphinx<2
6 | sphinx-autobuild
7 | sphinx_rtd_theme
8 | 


--------------------------------------------------------------------------------
/docs/api/imgaug.rst:
--------------------------------------------------------------------------------
1 | imgaug helpers (albumentations.imgaug)
2 | ======================================
3 | 
4 | Transforms
5 | ----------
6 | .. automodule:: albumentations.imgaug.transforms
7 |     :members:
8 | 


--------------------------------------------------------------------------------
/docs/api/pytorch.rst:
--------------------------------------------------------------------------------
1 | PyTorch helpers (albumentations.pytorch)
2 | ======================================
3 | 
4 | Transforms
5 | ----------
6 | .. automodule:: albumentations.pytorch.transforms
7 |     :members:
8 | 


--------------------------------------------------------------------------------
/docs/augs_overview/index.rst:
--------------------------------------------------------------------------------
1 | Augmentations overview
2 | ======================
3 | 
4 | You can find examples in this `repository <https://github.com/albumentations-team/albumentations_examples#augmentations-examples>`_.
5 | 


--------------------------------------------------------------------------------
/MANIFEST.in:
--------------------------------------------------------------------------------
 1 | include LICENSE
 2 | include README.md
 3 | 
 4 | graft benchmark
 5 | graft tests
 6 | graft docs
 7 | prune docs/_build
 8 | global-exclude docs/augs_overview/*/images/*.jpg
 9 | 
10 | global-exclude *.py[co] .DS_Store
11 | 


--------------------------------------------------------------------------------
/benchmark/requirements.txt:
--------------------------------------------------------------------------------
 1 | albumentations
 2 | Augmentor
 3 | imgaug
 4 | keras
 5 | numpy
 6 | opencv-python
 7 | pandas
 8 | pillow-simd
 9 | pytablewriter
10 | solt
11 | tensorflow # required for keras
12 | torchvision
13 | tqdm
14 | 


--------------------------------------------------------------------------------
/.readthedocs.yml:
--------------------------------------------------------------------------------
 1 | version: 2
 2 | 
 3 | sphinx:
 4 |   configuration: docs/conf.py
 5 | 
 6 | formats:
 7 |   - htmlzip
 8 |   - pdf
 9 |   - epub
10 | 
11 | python:
12 |   version: 3.8
13 |   system_packages: true
14 |   install:
15 |     - requirements: docs/requirements.txt
16 | 


--------------------------------------------------------------------------------
/.deepsource.toml:
--------------------------------------------------------------------------------
 1 | version = 1
 2 | 
 3 | test_patterns = [
 4 |   'tests/**'
 5 | ]
 6 | 
 7 | exclude_patterns = [
 8 | 
 9 | ]
10 | 
11 | [[analyzers]]
12 | name = 'python'
13 | enabled = true
14 | runtime_version = '3.x.x'
15 | 
16 |   [analyzers.meta]
17 |   max_line_length = 119
18 | 


--------------------------------------------------------------------------------
/setup.cfg:
--------------------------------------------------------------------------------
1 | [flake8]
2 | max-line-length = 119
3 | exclude =.git,__pycache__,docs/source/conf.py,build,dist
4 | ignore = I101,I201,F401,F403,S001,D100,D101,D102,D103,D104,D105,D106,D107,D200,D205,D400,W504,D202,E203,W503,B006
5 | inline-quotes = "
6 | 
7 | [mypy]
8 | ignore_missing_imports = True
9 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/documentation.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: "Documentation"
 3 | about: Report an issue related to https://albumentations.readthedocs.io#
 4 | 
 5 | ---
 6 | 
 7 | ## 📚 Documentation
 8 | 
 9 | <!-- A clear and concise description of what content in https://albumentations.readthedocs.io is an issue. -->
10 | 


--------------------------------------------------------------------------------
/albumentations/augmentations/utils.py:
--------------------------------------------------------------------------------
 1 | import cv2
 2 | 
 3 | __all__ = ["read_bgr_image", "read_rgb_image"]
 4 | 
 5 | 
 6 | def read_bgr_image(path):
 7 |     return cv2.imread(path, cv2.IMREAD_COLOR)
 8 | 
 9 | 
10 | def read_rgb_image(path):
11 |     image = cv2.imread(path, cv2.IMREAD_COLOR)
12 |     return cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
13 | 


--------------------------------------------------------------------------------
/docs/_templates/searchbox.html:
--------------------------------------------------------------------------------
 1 | {%- if builder != 'singlehtml' %}
 2 | <div role="search">
 3 |   <form id="rtd-search-form" class="wy-form" action="{{ pathto('search') }}" method="get">
 4 |     <input type="text" name="q" placeholder="{{ _('Search docs') }}" />
 5 |     <input type="hidden" name="check_keywords" value="yes" />
 6 |     <input type="hidden" name="area" value="default" />
 7 |   </form>
 8 | </div>
 9 | {%- endif %}
10 | 


--------------------------------------------------------------------------------
/benchmark/Dockerfile:
--------------------------------------------------------------------------------
 1 | FROM python:3.9.5
 2 | 
 3 | RUN apt-get update -y && apt install libgl1-mesa-glx -y
 4 | 
 5 | ENV DATA_DIR /images
 6 | 
 7 | WORKDIR /albumentations
 8 | COPY . .
 9 | 
10 | RUN pip install -U --no-cache-dir pip
11 | RUN pip install -U --no-cache-dir -e .
12 | RUN pip install -U --no-cache-dir -r ./benchmark/requirements.txt
13 | 
14 | WORKDIR /albumentations/benchmark
15 | 
16 | ENTRYPOINT ["python", "benchmark.py"]
17 | 


--------------------------------------------------------------------------------
/docs/api/core.rst:
--------------------------------------------------------------------------------
 1 | Core API (albumentations.core)
 2 | ==============================
 3 | 
 4 | Composition
 5 | -----------
 6 | .. automodule:: albumentations.core.composition
 7 |     :members:
 8 | 
 9 | Transforms interface
10 | --------------------
11 | .. automodule:: albumentations.core.transforms_interface
12 |     :members:
13 | 
14 | Serialization
15 | --------------------
16 | .. automodule:: albumentations.core.serialization
17 |     :members:
18 | 


--------------------------------------------------------------------------------
/albumentations/augmentations/__init__.py:
--------------------------------------------------------------------------------
 1 | # Common classes
 2 | from .bbox_utils import *
 3 | from .crops.functional import *
 4 | from .crops.transforms import *
 5 | 
 6 | # New transformations goes to individual files listed below
 7 | from .domain_adaptation import *
 8 | from .functional import *
 9 | from .geometric.functional import *
10 | from .geometric.resize import *
11 | from .geometric.rotate import *
12 | from .geometric.transforms import *
13 | from .keypoints_utils import *
14 | from .transforms import *
15 | from .utils import *
16 | 


--------------------------------------------------------------------------------
/albumentations/__init__.py:
--------------------------------------------------------------------------------
 1 | from __future__ import absolute_import
 2 | 
 3 | __version__ = "1.1.0"
 4 | 
 5 | from .augmentations import *
 6 | from .core.composition import *
 7 | from .core.serialization import *
 8 | from .core.transforms_interface import *
 9 | 
10 | try:
11 |     from .imgaug.transforms import *  # type: ignore
12 | except ImportError:
13 |     # imgaug is not installed by default, so we import stubs.
14 |     # Run `pip install -U albumentations[imgaug] if you need augmentations from imgaug.`
15 |     from .imgaug.stubs import *  # type: ignore
16 | 


--------------------------------------------------------------------------------
/black.toml:
--------------------------------------------------------------------------------
 1 | # Example configuration for Black.
 2 | 
 3 | # NOTE: you have to use single-quoted strings in TOML for regular expressions.
 4 | # It's the equivalent of r-strings in Python.  Multiline strings are treated as
 5 | # verbose regular expressions by Black.  Use [ ] to denote a significant space
 6 | # character.
 7 | 
 8 | [tool.black]
 9 | line-length = 119
10 | target-version = ['py35', 'py36', 'py37', 'py38']
11 | include = '\.pyi?$'
12 | exclude = '''
13 | /(
14 |     \.eggs
15 |   | \.git
16 |   | \.hg
17 |   | \.mypy_cache
18 |   | \.tox
19 |   | \.venv
20 |   | _build
21 |   | buck-out
22 |   | build
23 |   | dist
24 | )/
25 | '''
26 | 


--------------------------------------------------------------------------------
/docs/api/augmentations.rst:
--------------------------------------------------------------------------------
 1 | Augmentations (albumentations.augmentations)
 2 | ============================================
 3 | 
 4 | Transforms
 5 | ----------
 6 | .. automodule:: albumentations.augmentations.transforms
 7 |     :members:
 8 | 
 9 | Functional transforms
10 | ---------------------
11 | .. automodule:: albumentations.augmentations.functional
12 |     :members:
13 | 
14 | Helper functions for working with bounding boxes
15 | ------------------------------------------------
16 | .. automodule:: albumentations.augmentations.bbox_utils
17 |     :members:
18 | 
19 | Helper functions for working with keypoints
20 | ------------------------------------------------
21 | .. automodule:: albumentations.augmentations.keypoints_utils
22 |     :members:
23 | 


--------------------------------------------------------------------------------
/.github/workflows/upload_to_pypi.yml:
--------------------------------------------------------------------------------
 1 | name: Upload release to PyPI
 2 | 
 3 | on:
 4 |   release:
 5 |     types: [published]
 6 | 
 7 | jobs:
 8 |   upload:
 9 |     runs-on: ubuntu-latest
10 |     steps:
11 |     - uses: actions/checkout@v2
12 |     - name: Set up Python
13 |       uses: actions/setup-python@v2
14 |       with:
15 |         python-version: '3.8'
16 |     - name: Install dependencies
17 |       run: |
18 |         python -m pip install --upgrade pip
19 |         pip install setuptools wheel twine
20 |     - name: Build and publish
21 |       env:
22 |         TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }}
23 |         TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }}
24 |       run: |
25 |         python setup.py sdist bdist_wheel
26 |         twine upload dist/*
27 | 


--------------------------------------------------------------------------------
/docs/Makefile:
--------------------------------------------------------------------------------
 1 | # Minimal makefile for Sphinx documentation
 2 | #
 3 | 
 4 | # You can set these variables from the command line.
 5 | SPHINXOPTS    =
 6 | SPHINXBUILD   = sphinx-build
 7 | SPHINXPROJ    = albumentations
 8 | SOURCEDIR     = .
 9 | BUILDDIR      = _build
10 | 
11 | # Put it first so that "make" without argument is like "make help".
12 | help:
13 | 	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
14 | 
15 | .PHONY: help Makefile
16 | 
17 | livehtml:
18 | 	sphinx-autobuild -b html --ignore "*.text" "$(SOURCEDIR)" "$(BUILDDIR)"
19 | 
20 | # Catch-all target: route all unknown targets to Sphinx using the new
21 | # "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
22 | %: Makefile
23 | 	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
24 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/bug-report.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: "Bug Report"
 3 | about: Submit a bug report to help us improve albumentations
 4 | 
 5 | ---
 6 | 
 7 | ## 🐛 Bug
 8 | 
 9 | <!-- A clear and concise description of what the bug is. -->
10 | 
11 | ## To Reproduce
12 | 
13 | Steps to reproduce the behavior:
14 | 
15 | 1.
16 | 1.
17 | 1.
18 | 
19 | <!-- If you have a code sample, error messages, stack traces, please provide it here as well -->
20 | 
21 | ## Expected behavior
22 | 
23 | <!-- A clear and concise description of what you expected to happen. -->
24 | 
25 | ## Environment
26 | 
27 |  - Albumentations version (e.g., 0.1.8):
28 |  - Python version (e.g., 3.7):
29 |  - OS (e.g., Linux):
30 |  - How you installed albumentations (`conda`, `pip`, source):
31 |  - Any other relevant information:
32 | 
33 | ## Additional context
34 | 
35 | <!-- Add any other context about the problem here. -->
36 | 


--------------------------------------------------------------------------------
/conda.recipe/build_upload.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | # How to generate ANACONDA_TOKEN: https://docs.anaconda.com/anaconda-cloud/user-guide/tasks/work-with-accounts#creating-access-tokens
 4 | if [ -z "$ANACONDA_TOKEN" ]; then
 5 |     echo "ANACONDA_TOKEN is unset. Please set it in your environment before running this script";
 6 |     exit 1
 7 | fi
 8 | 
 9 | conda install -y conda-build conda-verify anaconda-client
10 | conda config --set anaconda_upload no
11 | conda build --quiet --no-test --output-folder conda_build conda.recipe
12 | 
13 | # Convert to other platforms: OSX, WIN
14 | conda convert --platform win-64 conda_build/linux-64/*.tar.bz2 -o conda_build/
15 | conda convert --platform osx-64 conda_build/linux-64/*.tar.bz2 -o conda_build/
16 | 
17 | # Upload to Anaconda
18 | # We could use --all but too much platforms to upload
19 | ls conda_build/*/*.tar.bz2 | xargs -I {} anaconda -v -t $ANACONDA_TOKEN upload -u albumentations {}
20 | 


--------------------------------------------------------------------------------
/conda.recipe/meta.yaml:
--------------------------------------------------------------------------------
 1 | {% set data = load_setup_py_data() %}
 2 | 
 3 | package:
 4 |   name: albumentations
 5 |   version: {{ data['version'] }}
 6 | 
 7 | source:
 8 |   path: ..
 9 | 
10 | build:
11 |   number: 0
12 |   script: python setup.py install --single-version-externally-managed --record=record.txt
13 | 
14 | # https://conda.io/docs/user-guide/tasks/build-packages/define-metadata.html#export-runtime-requirements
15 | requirements:
16 |   build:
17 |     - python
18 |     - numpy>=1.11.1,<1.16.0
19 |     - scipy
20 |     - opencv
21 | 
22 |   run:
23 |     - python
24 |     - numpy>=1.11.1,<1.16.0
25 |     - scipy
26 |     - opencv
27 |     # ImgAug is not at Conda and should be installed via pip install 'imgaug>=0.2.5,<0.2.7'
28 |     # - imgaug>=0.2.5,<0.2.7
29 | 
30 | test:
31 |   imports:
32 |     - albumentations
33 | 
34 | about:
35 |   home: {{ data['url'] }}
36 |   license: {{ data['license'] }}
37 | summary: {{ data['description'] }}
38 | 


--------------------------------------------------------------------------------
/docs/make.bat:
--------------------------------------------------------------------------------
 1 | @ECHO OFF
 2 | 
 3 | pushd %~dp0
 4 | 
 5 | REM Command file for Sphinx documentation
 6 | 
 7 | if "%SPHINXBUILD%" == "" (
 8 | 	set SPHINXBUILD=sphinx-build
 9 | )
10 | set SOURCEDIR=.
11 | set BUILDDIR=_build
12 | set SPHINXPROJ=albumentations
13 | 
14 | if "%1" == "" goto help
15 | 
16 | %SPHINXBUILD% >NUL 2>NUL
17 | if errorlevel 9009 (
18 | 	echo.
19 | 	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
20 | 	echo.installed, then set the SPHINXBUILD environment variable to point
21 | 	echo.to the full path of the 'sphinx-build' executable. Alternatively you
22 | 	echo.may add the Sphinx directory to PATH.
23 | 	echo.
24 | 	echo.If you don't have Sphinx installed, grab it from
25 | 	echo.http://sphinx-doc.org/
26 | 	exit /b 1
27 | )
28 | 
29 | %SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
30 | goto end
31 | 
32 | :help
33 | %SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
34 | 
35 | :end
36 | popd
37 | 


--------------------------------------------------------------------------------
/docs/contributing.rst:
--------------------------------------------------------------------------------
 1 | Contributing
 2 | ============
 3 | All development is done on GitHub: https://github.com/albumentations-team/albumentations
 4 | 
 5 | If you find a bug or have a feature request file an issue at https://github.com/albumentations-team/albumentations/issues
 6 | 
 7 | To create a pull request:
 8 | =======================
 9 | 
10 | 1. Fork the repository.
11 | 2. Clone it.
12 | 3. Install pre-commit hook:
13 | 
14 | .. code-block:: bash
15 | 
16 |     pip install pre-commit black flake8 isort mypy
17 | 
18 | 4. Initialize it from the folder with the repo:
19 | 
20 | .. code-block:: bash
21 | 
22 |     pre-commit install
23 | 
24 | 
25 | 4. Make desired changes to the code.
26 | 5. Install the library in development mode:
27 | 
28 | 
29 | .. code-block:: bash
30 | 
31 |     pip install -e .[tests]
32 | 
33 | 
34 | 6. Run tests:
35 | 
36 | .. code-block:: bash
37 | 
38 |     pytest
39 | 
40 | 
41 | 7. Push code to your forked repo.
42 | 8. Create pull request.
43 | 


--------------------------------------------------------------------------------
/.pre-commit-config.yaml:
--------------------------------------------------------------------------------
 1 | repos:
 2 |   - repo: https://github.com/pre-commit/pre-commit-hooks
 3 |     rev: v3.4.0
 4 |     hooks:
 5 |       - id: trailing-whitespace
 6 |       - id: end-of-file-fixer
 7 |       - id: requirements-txt-fixer
 8 |       - id: check-json
 9 |       - id: check-yaml
10 |   - repo: https://github.com/pre-commit/mirrors-isort
11 |     rev: 1ba6bfc # Use the revision sha / tag you want to point at
12 |     hooks:
13 |       - id: isort
14 |         args: [ "--profile", "black" ]
15 |   - repo: https://github.com/psf/black
16 |     rev: 21.9b0
17 |     hooks:
18 |       - id: black
19 |         args: [ --config=black.toml ]
20 |   - repo: https://github.com/pre-commit/mirrors-mypy
21 |     rev: v0.910
22 |     hooks:
23 |       - id: mypy
24 |         additional_dependencies: [ types-PyYAML ]
25 |   - repo: https://gitlab.com/pycqa/flake8
26 |     rev: 3.9.2
27 |     hooks:
28 |       - id: flake8
29 |         additional_dependencies: [ flake8-docstrings==1.6.0 ]
30 | 


--------------------------------------------------------------------------------
/benchmark/README.md:
--------------------------------------------------------------------------------
 1 | ## Running the benchmark
 2 | 
 3 | ### Running the benchmark as a Python script
 4 | 
 5 | 1. Install requirements
 6 | ```
 7 | pip install -r requirements.txt
 8 | ```
 9 | 2. Prepare a directory with images
10 | 3. Run the benchmark
11 | ```
12 | python benchmark.py --data-dir <path to directory with images> --images <number of images> --runs <number of runs> --print-package-versions
13 | ```
14 | for example
15 | ```
16 | python benchmark.py --data-dir '/hdd/ILSVRC2012_img_val' --images 2000 --runs 5 --print-package-versions
17 | ```
18 | 
19 | ### Running the benchmark in a Docker container
20 | 
21 | 1. Build the image, from the root project directory run:
22 | ```
23 | docker build -t albumentations-benchmark -f ./benchmark/Dockerfile .
24 | ```
25 | 
26 | 2. Run the benchmark:
27 | ```
28 | docker run -v <path to a directory with images on the host machine>:/images albumentations-benchmark <args>
29 | ```
30 | 
31 | [Benchmarking results in README.md](../README.md#benchmarking-results) were obtained by running the following command:
32 | ```
33 | docker run -v /hdd/ILSVRC2012_img_val:/images albumentations-benchmark --runs 10 --markdown
34 | ```
35 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2017 Buslaev Alexander, Alexander Parinov, Vladimir Iglovikov
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/albumentations/pytorch/functional.py:
--------------------------------------------------------------------------------
 1 | from __future__ import division
 2 | 
 3 | import numpy as np
 4 | import torch
 5 | import torchvision.transforms.functional as F
 6 | 
 7 | 
 8 | def img_to_tensor(im, normalize=None):
 9 |     tensor = torch.from_numpy(np.moveaxis(im / (255.0 if im.dtype == np.uint8 else 1), -1, 0).astype(np.float32))
10 |     if normalize is not None:
11 |         return F.normalize(tensor, **normalize)
12 |     return tensor
13 | 
14 | 
15 | def mask_to_tensor(mask, num_classes, sigmoid):
16 |     if num_classes > 1:
17 |         if not sigmoid:
18 |             # softmax
19 |             long_mask = np.zeros((mask.shape[:2]), dtype=np.int64)
20 |             if len(mask.shape) == 3:
21 |                 for c in range(mask.shape[2]):
22 |                     long_mask[mask[..., c] > 0] = c
23 |             else:
24 |                 long_mask[mask > 127] = 1
25 |                 long_mask[mask == 0] = 0
26 |             mask = long_mask
27 |         else:
28 |             mask = np.moveaxis(mask / (255.0 if mask.dtype == np.uint8 else 1), -1, 0).astype(np.float32)
29 |     else:
30 |         mask = np.expand_dims(mask / (255.0 if mask.dtype == np.uint8 else 1), 0).astype(np.float32)
31 |     return torch.from_numpy(mask)
32 | 


--------------------------------------------------------------------------------
/docs/_templates/versions.html:
--------------------------------------------------------------------------------
 1 | {% if READTHEDOCS %}
 2 | {# Add rst-badge after rst-versions for small badge style. #}
 3 |   <div class="rst-versions" data-toggle="rst-versions" role="note" aria-label="versions">
 4 |     <span class="rst-current-version" data-toggle="rst-current-version">
 5 |       <span class="fa fa-book"> Read the Docs</span>
 6 |       v: {{ current_version }}
 7 |       <span class="fa fa-caret-down"></span>
 8 |     </span>
 9 |     <div class="rst-other-versions">
10 |       <dl>
11 |         <dt>{{ _('Versions') }}</dt>
12 |         {% for slug, url in versions %}
13 |           <dd><a href="{{ url }}">{{ slug }}</a></dd>
14 |         {% endfor %}
15 |       </dl>
16 |       <dl>
17 |         <dt>{{ _('Downloads') }}</dt>
18 |         {% for type, url in downloads %}
19 |           <dd><a href="{{ url }}">{{ type }}</a></dd>
20 |         {% endfor %}
21 |       </dl>
22 |       <dl>
23 |         {# Translators: The phrase "Read the Docs" is not translated #}
24 |         <dt>{{ _('On Read the Docs') }}</dt>
25 |           <dd>
26 |             <a href="//{{ PRODUCTION_DOMAIN }}/projects/{{ slug }}/?fromdocs={{ slug }}">{{ _('Project Home') }}</a>
27 |           </dd>
28 |           <dd>
29 |             <a href="//{{ PRODUCTION_DOMAIN }}/builds/{{ slug }}/?fromdocs={{ slug }}">{{ _('Builds') }}</a>
30 |           </dd>
31 |       </dl>
32 |     </div>
33 |   </div>
34 | {% endif %}
35 | 


--------------------------------------------------------------------------------
/docs/index.rst:
--------------------------------------------------------------------------------
 1 | albumentations
 2 | ==============
 3 | 
 4 | albumentations is a fast image augmentation library and easy to use wrapper around other libraries.
 5 | 
 6 | Features
 7 | --------
 8 | * Great fast augmentations based on highly-optimized OpenCV library.
 9 | * Super simple yet powerful interface for different tasks like (segmentation, detection, etc).
10 | * Easy to customize.
11 | * Easy to add other frameworks.
12 | 
13 | Project info
14 | ------------
15 | * GitHub repository: https://github.com/albumentations-team/albumentations
16 | * GitHub repository with examples: https://github.com/albumentations-team/albumentations_examples
17 | * License: MIT
18 | 
19 | Installation
20 | ------------
21 | You can use pip to install albumentations:
22 | 
23 | ::
24 | 
25 |     pip install albumentations
26 | 
27 | If you want to get the latest version of the code before it is released on PyPI you can install the library from GitHub:
28 | 
29 | ::
30 | 
31 |     pip install -U git+https://github.com/albumentations-team/albumentations
32 | 
33 | 
34 | Demo
35 | ----
36 | You can use this `Google Colaboratory notebook <https://colab.research.google.com/drive/1JuZ23u0C0gx93kV0oJ8Mq0B6CBYhPLXy#scrollTo=GwFN-In3iagp&forceEdit=true&offline=true&sandboxMode=true>`_
37 | to adjust image augmentation parameters and see the resulting images.
38 | 
39 | 
40 | .. toctree::
41 |    :hidden:
42 | 
43 |    self
44 | 
45 | .. toctree::
46 |    :maxdepth: 2
47 |    :caption: Contents:
48 | 
49 |    examples
50 |    contributing
51 |    augs_overview/index
52 |    api/index
53 |    probabilities
54 |    writing_tests
55 |    hall_of_fame
56 |    citations
57 | 


--------------------------------------------------------------------------------
/docs/_templates/search.html:
--------------------------------------------------------------------------------
 1 | {#
 2 |     basic/search.html
 3 |     ~~~~~~~~~~~~~~~~~
 4 | 
 5 |     Template for the search page.
 6 | 
 7 |     :copyright: Copyright 2007-2013 by the Sphinx team, see AUTHORS.
 8 |     :license: BSD, see LICENSE for details.
 9 | #}
10 | {%- extends "layout.html" %}
11 | {% set title = _('Search') %}
12 | {%- block scripts %}
13 |     {{ super() }}
14 |     <script type="text/javascript" src="{{ pathto('_static/searchtools.js', 1) }}"></script>
15 | {%- endblock %}
16 | {% block footer %}
17 |   <script type="text/javascript">
18 |     jQuery(function() { Search.loadIndex("{{ pathto('searchindex.js', 1) }}"); });
19 |   </script>
20 |   {# this is used when loading the search index using $.ajax fails,
21 |      such as on Chrome for documents on localhost #}
22 |   <script type="text/javascript" id="searchindexloader"></script>
23 |   {{ super() }}
24 | {% endblock %}
25 | {% block body %}
26 |   <noscript>
27 |   <div id="fallback" class="admonition warning">
28 |     <p class="last">
29 |       {% trans trimmed %}Please activate JavaScript to enable the search
30 |       functionality.{% endtrans %}
31 |     </p>
32 |   </div>
33 |   </noscript>
34 | 
35 |   {% if search_performed %}
36 |     {# Translators: Search is a noun, not a verb #}
37 |     <h2>{{ _('Search Results') }}</h2>
38 |     {% if not search_results %}
39 |       <p>{{ _('Your search did not match any documents. Please make sure that all words are spelled correctly and that you\'ve selected enough categories.') }}</p>
40 |     {% endif %}
41 |   {% endif %}
42 |   <div id="search-results">
43 |   {% if search_results %}
44 |     <ul>
45 |     {% for href, caption, context in search_results %}
46 |       <li>
47 |         <a href="{{ pathto(item.href) }}">{{ caption }}</a>
48 |         <p class="context">{{ context|e }}</p>
49 |       </li>
50 |     {% endfor %}
51 |     </ul>
52 |   {% endif %}
53 |   </div>
54 | {% endblock %}
55 | 


--------------------------------------------------------------------------------
/docs/examples.rst:
--------------------------------------------------------------------------------
 1 | Examples
 2 | ========
 3 | 
 4 | .. toctree::
 5 |    :maxdepth: 2
 6 | 
 7 | .. code-block:: python
 8 | 
 9 |    from albumentations import (
10 |        HorizontalFlip, IAAPerspective, ShiftScaleRotate, CLAHE, RandomRotate90,
11 |        Transpose, ShiftScaleRotate, Blur, OpticalDistortion, GridDistortion, HueSaturationValue,
12 |        IAAAdditiveGaussianNoise, GaussNoise, MotionBlur, MedianBlur, IAAPiecewiseAffine,
13 |        IAASharpen, IAAEmboss, RandomBrightnessContrast, Flip, OneOf, Compose
14 |    )
15 |    import numpy as np
16 | 
17 |    def strong_aug(p=0.5):
18 |        return Compose([
19 |            RandomRotate90(),
20 |            Flip(),
21 |            Transpose(),
22 |            OneOf([
23 |                IAAAdditiveGaussianNoise(),
24 |                GaussNoise(),
25 |            ], p=0.2),
26 |            OneOf([
27 |                MotionBlur(p=0.2),
28 |                MedianBlur(blur_limit=3, p=0.1),
29 |                Blur(blur_limit=3, p=0.1),
30 |            ], p=0.2),
31 |            ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.2),
32 |            OneOf([
33 |                OpticalDistortion(p=0.3),
34 |                GridDistortion(p=0.1),
35 |                IAAPiecewiseAffine(p=0.3),
36 |            ], p=0.2),
37 |            OneOf([
38 |                CLAHE(clip_limit=2),
39 |                IAASharpen(),
40 |                IAAEmboss(),
41 |                RandomBrightnessContrast(),
42 |            ], p=0.3),
43 |            HueSaturationValue(p=0.3),
44 |        ], p=p)
45 | 
46 |    image = np.ones((300, 300, 3), dtype=np.uint8)
47 |    mask = np.ones((300, 300), dtype=np.uint8)
48 |    whatever_data = "my name"
49 |    augmentation = strong_aug(p=0.9)
50 |    data = {"image": image, "mask": mask, "whatever_data": whatever_data, "additional": "hello"}
51 |    augmented = augmentation(**data)
52 |    image, mask, whatever_data, additional = augmented["image"], augmented["mask"], augmented["whatever_data"], augmented["additional"]
53 | 
54 | 
55 | For more examples see `repository with examples <https://github.com/albumentations-team/albumentations_examples>`_
56 | and `example.ipynb <https://github.com/albumentations-team/albumentations_examples/blob/master/notebooks/example.ipynb>`_
57 | and `example_16_bit_tiff.ipynb <https://github.com/albumentations-team/albumentations_examples/blob/master/notebooks/example_16_bit_tiff.ipynb>`_
58 | 


--------------------------------------------------------------------------------
/docs/_templates/footer.html:
--------------------------------------------------------------------------------
 1 | <footer>
 2 |   {% if (theme_prev_next_buttons_location == 'bottom' or theme_prev_next_buttons_location == 'both') and (next or prev) %}
 3 |     <div class="rst-footer-buttons" role="navigation" aria-label="footer navigation">
 4 |       {% if next %}
 5 |         <a href="{{ next.link|e }}" class="btn btn-neutral float-right" title="{{ next.title|striptags|e }}" accesskey="n" rel="next">{{ _('Next') }} <span class="fa fa-arrow-circle-right"></span></a>
 6 |       {% endif %}
 7 |       {% if prev %}
 8 |         <a href="{{ prev.link|e }}" class="btn btn-neutral float-left" title="{{ prev.title|striptags|e }}" accesskey="p" rel="prev"><span class="fa fa-arrow-circle-left"></span> {{ _('Previous') }}</a>
 9 |       {% endif %}
10 |     </div>
11 |   {% endif %}
12 | 
13 |   <hr/>
14 | 
15 |   <div role="contentinfo">
16 |     <p>
17 |     {%- if show_copyright %}
18 |       {%- if hasdoc('copyright') %}
19 |         {% set path = pathto('copyright') %}
20 |         {% set copyright = copyright|e %}
21 |         &copy; <a href="{{ path }}">{% trans %}Copyright{% endtrans %}</a> {{ copyright }}
22 |       {%- else %}
23 |         {% set copyright = copyright|e %}
24 |         &copy; {% trans %}Copyright{% endtrans %} {{ copyright }}
25 |       {%- endif %}
26 |     {%- endif %}
27 | 
28 |     {%- if build_id and build_url %}
29 |       <span class="build">
30 |         {# Translators: Build is a noun, not a verb #}
31 |         {% trans %}Build{% endtrans %}
32 |         <a href="{{ build_url }}">{{ build_id }}</a>.
33 |       </span>
34 |     {%- elif commit %}
35 |       <span class="commit">
36 |         {% trans %}Revision{% endtrans %} <code>{{ commit }}</code>.
37 |       </span>
38 |     {%- elif last_updated %}
39 |       <span class="lastupdated">
40 |         {% trans last_updated=last_updated|e %}Last updated on {{ last_updated }}.{% endtrans %}
41 |       </span>
42 |     {%- endif %}
43 | 
44 |     </p>
45 |   </div>
46 | 
47 |   {%- if show_sphinx %}
48 |     {% set sphinx_web = '<a href="http://sphinx-doc.org/">Sphinx</a>' %}
49 |     {% set readthedocs_web = '<a href="https://readthedocs.org">Read the Docs</a>'  %}
50 |       {% trans sphinx_web=sphinx_web, readthedocs_web=readthedocs_web %}Built with {{ sphinx_web }} using a{% endtrans %} <a href="https://github.com/rtfd/sphinx_rtd_theme">{% trans %}theme{% endtrans %}</a> {% trans %}provided by {{ readthedocs_web }}{% endtrans %}.
51 |   {%- endif %}
52 | 
53 |   {%- block extrafooter %} {% endblock %}
54 | 
55 | </footer>
56 | 


--------------------------------------------------------------------------------
/tests/test_imgaug_imports.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | 
 3 | import albumentations as A
 4 | from albumentations.imgaug.stubs import IAAStub
 5 | from tests.conftest import skipif_no_imgaug, skipif_imgaug
 6 | 
 7 | 
 8 | @skipif_no_imgaug
 9 | @pytest.mark.parametrize(
10 |     "aug_name",
11 |     [
12 |         "IAAEmboss",
13 |         "IAASuperpixels",
14 |         "IAASharpen",
15 |         "IAAAdditiveGaussianNoise",
16 |         "IAACropAndPad",
17 |         "IAAFliplr",
18 |         "IAAFlipud",
19 |         "IAAAffine",
20 |         "IAAPiecewiseAffine",
21 |     ],
22 | )
23 | def test_imgaug_augmentations_imported_when_imgaug_is_installed(aug_name):
24 |     aug_cls = getattr(A, aug_name)
25 |     t = aug_cls()
26 |     assert isinstance(t, A.BasicIAATransform)
27 | 
28 | 
29 | @skipif_no_imgaug
30 | def test_iaaperpective_augmentation_imported_when_imgaug_is_installed():
31 |     from albumentations.imgaug.transforms import IAAPerspective
32 | 
33 |     t = IAAPerspective()
34 |     assert isinstance(t, A.DualTransform)
35 | 
36 | 
37 | @skipif_imgaug
38 | @pytest.mark.parametrize(
39 |     "aug_name",
40 |     [
41 |         "IAAEmboss",
42 |         "IAASuperpixels",
43 |         "IAASharpen",
44 |         "IAAAdditiveGaussianNoise",
45 |         "IAACropAndPad",
46 |         "IAAFliplr",
47 |         "IAAFlipud",
48 |         "IAAAffine",
49 |         "IAAPiecewiseAffine",
50 |         "IAAPerspective",
51 |     ],
52 | )
53 | def test_imgaug_stubs_imported_when_imgaug_is_not_installed(aug_name):
54 |     aug_cls = getattr(A, aug_name)
55 |     assert issubclass(aug_cls, IAAStub)
56 |     with pytest.raises(RuntimeError) as exc_info:
57 |         aug_cls()
58 |         message = (
59 |             f"You are trying to use a deprecated augmentation '{aug_name}' which depends on the imgaug library, "
60 |             f"but imgaug is not installed."
61 |         )
62 |         assert message in str(exc_info.value)
63 | 
64 | 
65 | @skipif_no_imgaug
66 | def test_imports_from_imgaug_module_dont_raise_import_error():
67 |     from albumentations.imgaug.transforms import IAAFlipud
68 | 
69 |     IAAFlipud()
70 | 
71 | 
72 | @skipif_imgaug
73 | def test_imports_from_imgaug_module_raise_import_error():
74 |     with pytest.raises(ImportError) as exc_info:
75 |         from albumentations.imgaug.transforms import IAAFlipud
76 | 
77 |         message = (
78 |             "You are trying to import an augmentation that depends on the imgaug library, but imgaug is not "
79 |             "installed. To install a version of Albumentations that contains imgaug please run "
80 |             "'pip install -U albumentations[imgaug]'"
81 |         )
82 |         assert message in str(exc_info.value)
83 | 


--------------------------------------------------------------------------------
/albumentations/imgaug/stubs.py:
--------------------------------------------------------------------------------
 1 | __all__ = [
 2 |     "IAAEmboss",
 3 |     "IAASuperpixels",
 4 |     "IAASharpen",
 5 |     "IAAAdditiveGaussianNoise",
 6 |     "IAACropAndPad",
 7 |     "IAAFliplr",
 8 |     "IAAFlipud",
 9 |     "IAAAffine",
10 |     "IAAPiecewiseAffine",
11 |     "IAAPerspective",
12 | ]
13 | 
14 | 
15 | class IAAStub:
16 |     def __init__(self, *args, **kwargs):
17 |         cls_name = self.__class__.__name__
18 |         doc_link = "https://albumentations.ai/docs/api_reference/augmentations" + self.doc_link
19 |         raise RuntimeError(
20 |             f"You are trying to use a deprecated augmentation '{cls_name}' which depends on the imgaug library, "
21 |             f"but imgaug is not installed.\n\n"
22 |             "There are two options to fix this error:\n"
23 |             "1. [Recommended]. Switch to the Albumentations' implementation of the augmentation with the same API: "
24 |             f"{self.alternative} - {doc_link}\n"
25 |             "2. Install a version of Albumentations that contains imgaug by running "
26 |             "'pip install -U albumentations[imgaug]'."
27 |         )
28 | 
29 | 
30 | class IAACropAndPad(IAAStub):
31 |     alternative = "CropAndPad"
32 |     doc_link = "/crops/transforms/#albumentations.augmentations.crops.transforms.CropAndPad"
33 | 
34 | 
35 | class IAAFliplr(IAAStub):
36 |     alternative = "HorizontalFlip"
37 |     doc_link = "/transforms/#albumentations.augmentations.transforms.HorizontalFlip"
38 | 
39 | 
40 | class IAAFlipud(IAAStub):
41 |     alternative = "VerticalFlip"
42 |     doc_link = "/transforms/#albumentations.augmentations.transforms.VerticalFlip"
43 | 
44 | 
45 | class IAAEmboss(IAAStub):
46 |     alternative = "Emboss"
47 |     doc_link = "/transforms/#albumentations.augmentations.transforms.Emboss"
48 | 
49 | 
50 | class IAASuperpixels(IAAStub):
51 |     alternative = "Superpixels"
52 |     doc_link = "/transforms/#albumentations.augmentations.transforms.Superpixels"
53 | 
54 | 
55 | class IAASharpen(IAAStub):
56 |     alternative = "Sharpen"
57 |     doc_link = "/transforms/#albumentations.augmentations.transforms.Sharpen"
58 | 
59 | 
60 | class IAAAdditiveGaussianNoise(IAAStub):
61 |     alternative = "GaussNoise"
62 |     doc_link = "/transforms/#albumentations.augmentations.transforms.GaussNoise"
63 | 
64 | 
65 | class IAAPiecewiseAffine(IAAStub):
66 |     alternative = "PiecewiseAffine"
67 |     doc_link = "/geometric/transforms/#albumentations.augmentations.geometric.transforms.PiecewiseAffine"
68 | 
69 | 
70 | class IAAAffine(IAAStub):
71 |     alternative = "Affine"
72 |     doc_link = "/geometric/transforms/#albumentations.augmentations.geometric.transforms.Affine"
73 | 
74 | 
75 | class IAAPerspective(IAAStub):
76 |     alternative = "Perspective"
77 |     doc_link = "/geometric/transforms/#albumentations.augmentations.geometric.transforms.Perspective"
78 | 


--------------------------------------------------------------------------------
/docs/probabilities.rst:
--------------------------------------------------------------------------------
 1 | About probabilities.
 2 | =====================
 3 | 
 4 | .. toctree::
 5 |    :maxdepth: 2
 6 | 
 7 | 
 8 | Default probability values
 9 | **************************
10 | 
11 | All pre / post processing transforms: **Compose**, **PadIfNeeded**, **CenterCrop**, **RandomCrop**, **Crop**, **RandomCropNearBBox**, **RandomSizedCrop**, **RandomResizedCrop**, **RandomSizedBBoxSafeCrop**, **CropNonEmptyMaskIfExists**, **Lambda**,  **Normalize**, **ToFloat**, **FromFloat**, **ToTensor**, **LongestMaxSize** have default
12 | probability values equal to **1**. All others are equal to **0.5**
13 | 
14 | 
15 | .. code-block:: python
16 | 
17 |     from albumentations import (
18 |        RandomRotate90, IAAAdditiveGaussianNoise, GaussNoise, Compose, OneOf
19 |     )
20 |     import numpy as np
21 | 
22 |     def aug(p1, p2, p3):
23 |        return Compose([
24 |            RandomRotate90(p=p2),
25 |            OneOf([
26 |                IAAAdditiveGaussianNoise(p=0.9),
27 |                GaussNoise(p=0.6),
28 |            ], p=p3)
29 |        ], p=p1)
30 | 
31 |     image = np.ones((300, 300, 3), dtype=np.uint8)
32 |     mask = np.ones((300, 300), dtype=np.uint8)
33 |     whatever_data = "my name"
34 |     augmentation = aug(p1=0.9, p2=0.7, p3=0.3)
35 |     data = {"image": image, "mask": mask, "whatever_data": whatever_data, "additional": "hello"}
36 |     augmented = augmentation(**data)
37 |     image, mask, whatever_data, additional = augmented["image"], augmented["mask"], augmented["whatever_data"], augmented["additional"]
38 | 
39 | 
40 | 
41 | 
42 | In the above augmentation pipeline, we have three types of probabilities. Combination of them is the primary factor that
43 | decides how often each of them will be applied.
44 | 
45 |  1. **p1**: decides if this augmentation will be applied. The most common case is **p1=1** means that we always apply the transformations from above. **p1=0** will mean that the transformation block will be ignored.
46 |  2. **p2**: every augmentation has an option to be applied with some probability.
47 |  3. **p3**: decide if **OneOf** will be applied.
48 | 
49 | OneOf Block
50 | *************
51 | 
52 | To decide which augmentation within **OneOf** block is used the following rule is applied.
53 | 
54 |  1. We normalize all probabilities within a block to one.
55 |  After this we pick augmentation based on the normalized probabilities.
56 |  In the example above **IAAAdditiveGaussianNoise** has probability **0.9** and **GaussNoise** probability **0.6**.
57 |  After normalization, they become **0.6** and **0.4**.
58 |  Which means that we decide if we should use **IAAAdditiveGaussianNoise** with probability **0.6** and **GaussNoise** otherwise.
59 |  2. If we picked to consider **GaussNoise** the next step we call **GaussNoise** with flag **force_apply=True**.
60 | 
61 | Example calculations
62 | ********************
63 | Thus, each augmentation in the example above will be applied with the probability:
64 | 
65 |  1. **RandomRotate90**: `p1 * p2`
66 |  2. **IAAAdditiveGaussianNoise**: `p1 * p3 * (0.9 / (0.9 + 0.6))`
67 |  3. **GaussianNoise**: `p1 * p3 * (0.6 / (0.9 + 0.6))`
68 | 


--------------------------------------------------------------------------------
/tests/conftest.py:
--------------------------------------------------------------------------------
  1 | import sys
  2 | import warnings
  3 | import multiprocessing
  4 | 
  5 | import numpy as np
  6 | import pytest
  7 | 
  8 | 
  9 | try:
 10 |     import torch  # skipcq: PYL-W0611
 11 |     import torchvision  # skipcq: PYL-W0611
 12 | 
 13 |     torch_available = True
 14 | except ImportError:
 15 |     torch_available = False
 16 | 
 17 | 
 18 | try:
 19 |     import imgaug
 20 | 
 21 |     imgaug_available = True
 22 | except ImportError:
 23 |     imgaug_available = False
 24 | 
 25 | 
 26 | skipif_imgaug = pytest.mark.skipif(imgaug_available, reason="The test was skipped because imgaug is installed")
 27 | skipif_no_imgaug = pytest.mark.skipif(
 28 |     not imgaug_available, reason="The test was skipped because imgaug is not installed"
 29 | )
 30 | skipif_no_torch = pytest.mark.skipif(
 31 |     not torch_available, reason="The test was skipped because PyTorch and torchvision are not installed"
 32 | )
 33 | 
 34 | 
 35 | def pytest_ignore_collect(path):
 36 |     if not torch_available and path.fnmatch("test_pytorch.py"):
 37 |         warnings.warn(
 38 |             UserWarning(
 39 |                 "Tests that require PyTorch and torchvision were skipped because those libraries are not installed."
 40 |             )
 41 |         )
 42 |         return True
 43 | 
 44 |     if not imgaug_available and path.fnmatch("test_imgaug.py"):
 45 |         warnings.warn(UserWarning("Tests that require imgaug were skipped because this library is not installed."))
 46 |         return True
 47 | 
 48 |     return False
 49 | 
 50 | 
 51 | @pytest.fixture
 52 | def image():
 53 |     return np.random.randint(low=0, high=256, size=(100, 100, 3), dtype=np.uint8)
 54 | 
 55 | 
 56 | @pytest.fixture
 57 | def mask():
 58 |     return np.random.randint(low=0, high=2, size=(100, 100), dtype=np.uint8)
 59 | 
 60 | 
 61 | @pytest.fixture
 62 | def bboxes():
 63 |     return [[15, 12, 75, 30, 1], [55, 25, 90, 90, 2]]
 64 | 
 65 | 
 66 | @pytest.fixture
 67 | def albumentations_bboxes():
 68 |     return [[0.15, 0.12, 0.75, 0.30, 1], [0.55, 0.25, 0.90, 0.90, 2]]
 69 | 
 70 | 
 71 | @pytest.fixture
 72 | def keypoints():
 73 |     return [[20, 30, 40, 50, 1], [20, 30, 60, 80, 2]]
 74 | 
 75 | 
 76 | @pytest.fixture
 77 | def float_image():
 78 |     return np.random.uniform(low=0.0, high=1.0, size=(100, 100, 3)).astype("float32")
 79 | 
 80 | 
 81 | @pytest.fixture
 82 | def template():
 83 |     return np.random.randint(low=0, high=256, size=(100, 100, 3), dtype=np.uint8)
 84 | 
 85 | 
 86 | @pytest.fixture
 87 | def float_template():
 88 |     return np.random.uniform(low=0.0, high=1.0, size=(100, 100, 3)).astype("float32")
 89 | 
 90 | 
 91 | @pytest.fixture
 92 | def multiprocessing_context():
 93 |     # Usage of `fork` as a start method for multiprocessing could lead to deadlocks on macOS.
 94 |     # Because `fork` was the default start method for macOS until Python 3.8
 95 |     # we had to manually set the start method to `spawn` to avoid those issues.
 96 |     if sys.platform == "darwin":
 97 |         method = "spawn"
 98 |     else:
 99 |         method = None
100 |     return multiprocessing.get_context(method)
101 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | # Created by .ignore support plugin (hsz.mobi)
  2 | ### Python template
  3 | # Byte-compiled / optimized / DLL files
  4 | __pycache__/
  5 | *.py[cod]
  6 | *$py.class
  7 | 
  8 | # C extensions
  9 | *.so
 10 | 
 11 | # Distribution / packaging
 12 | .Python
 13 | build/
 14 | develop-eggs/
 15 | dist/
 16 | downloads/
 17 | eggs/
 18 | .eggs/
 19 | lib/
 20 | lib64/
 21 | parts/
 22 | sdist/
 23 | var/
 24 | wheels/
 25 | *.egg-info/
 26 | .installed.cfg
 27 | *.egg
 28 | MANIFEST
 29 | 
 30 | # PyInstaller
 31 | #  Usually these files are written by a python script from a template
 32 | #  before PyInstaller builds the exe, so as to inject date/other infos into it.
 33 | *.manifest
 34 | *.spec
 35 | 
 36 | # Installer logs
 37 | pip-log.txt
 38 | pip-delete-this-directory.txt
 39 | 
 40 | # Unit test / coverage reports
 41 | htmlcov/
 42 | .tox/
 43 | .coverage
 44 | .coverage.*
 45 | .cache
 46 | nosetests.xml
 47 | coverage.xml
 48 | *.cover
 49 | .hypothesis/
 50 | .pytest_cache/
 51 | 
 52 | # Translations
 53 | *.mo
 54 | *.pot
 55 | 
 56 | # Django stuff:
 57 | *.log
 58 | local_settings.py
 59 | db.sqlite3
 60 | 
 61 | # Flask stuff:
 62 | instance/
 63 | .webassets-cache
 64 | 
 65 | # Scrapy stuff:
 66 | .scrapy
 67 | 
 68 | # Sphinx documentation
 69 | docs/_build/
 70 | 
 71 | # PyBuilder
 72 | target/
 73 | 
 74 | # Jupyter Notebook
 75 | .ipynb_checkpoints
 76 | 
 77 | # pyenv
 78 | .python-version
 79 | 
 80 | # celery beat schedule file
 81 | celerybeat-schedule
 82 | 
 83 | # SageMath parsed files
 84 | *.sage.py
 85 | 
 86 | # Environments
 87 | .env
 88 | .venv
 89 | env/
 90 | venv/
 91 | ENV/
 92 | env.bak/
 93 | venv.bak/
 94 | 
 95 | # Spyder project settings
 96 | .spyderproject
 97 | .spyproject
 98 | 
 99 | # Rope project settings
100 | .ropeproject
101 | 
102 | # mkdocs documentation
103 | /site
104 | 
105 | # mypy
106 | .mypy_cache/
107 | ### JetBrains template
108 | # Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and WebStorm
109 | # Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
110 | 
111 | # User-specific stuff:
112 | .idea/**/workspace.xml
113 | .idea/**/tasks.xml
114 | .idea/dictionaries
115 | 
116 | # Sensitive or high-churn files:
117 | .idea/**/dataSources/
118 | .idea/**/dataSources.ids
119 | .idea/**/dataSources.local.xml
120 | .idea/**/sqlDataSources.xml
121 | .idea/**/dynamic.xml
122 | .idea/**/uiDesigner.xml
123 | 
124 | # Gradle:
125 | .idea/**/gradle.xml
126 | .idea/**/libraries
127 | 
128 | # CMake
129 | cmake-build-debug/
130 | cmake-build-release/
131 | 
132 | # Mongo Explorer plugin:
133 | .idea/**/mongoSettings.xml
134 | 
135 | ## File-based project format:
136 | *.iws
137 | 
138 | ## Plugin-specific files:
139 | 
140 | # IntelliJ
141 | out/
142 | 
143 | # mpeltonen/sbt-idea plugin
144 | .idea_modules/
145 | 
146 | # JIRA plugin
147 | atlassian-ide-plugin.xml
148 | 
149 | # Cursive Clojure plugin
150 | .idea/replstate.xml
151 | 
152 | # Crashlytics plugin (for Android Studio and IntelliJ)
153 | com_crashlytics_export_strings.xml
154 | crashlytics.properties
155 | crashlytics-build.properties
156 | fabric.properties
157 | 
158 | .idea
159 | 
160 | conda_build/
161 | 


--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
 1 | import io
 2 | import os
 3 | import re
 4 | from setuptools import setup, find_packages
 5 | from pkg_resources import DistributionNotFound, get_distribution
 6 | 
 7 | 
 8 | INSTALL_REQUIRES = ["numpy>=1.11.1", "scipy", "scikit-image>=0.16.1", "PyYAML", "qudida>=0.0.4"]
 9 | 
10 | # If none of packages in first installed, install second package
11 | CHOOSE_INSTALL_REQUIRES = [
12 |     (
13 |         ("opencv-python>=4.1.1", "opencv-contrib-python>=4.1.1", "opencv-contrib-python-headless>=4.1.1"),
14 |         "opencv-python-headless>=4.1.1",
15 |     )
16 | ]
17 | 
18 | 
19 | def get_version():
20 |     current_dir = os.path.abspath(os.path.dirname(__file__))
21 |     version_file = os.path.join(current_dir, "albumentations", "__init__.py")
22 |     with io.open(version_file, encoding="utf-8") as f:
23 |         return re.search(r'^__version__ = [\'"]([^\'"]*)[\'"]', f.read(), re.M).group(1)
24 | 
25 | 
26 | def get_long_description():
27 |     base_dir = os.path.abspath(os.path.dirname(__file__))
28 |     with io.open(os.path.join(base_dir, "README.md"), encoding="utf-8") as f:
29 |         return f.read()
30 | 
31 | 
32 | def choose_requirement(mains, secondary):
33 |     """If some version version of main requirement installed, return main,
34 |     else return secondary.
35 | 
36 |     """
37 |     chosen = secondary
38 |     for main in mains:
39 |         try:
40 |             name = re.split(r"[!<>=]", main)[0]
41 |             get_distribution(name)
42 |             chosen = main
43 |             break
44 |         except DistributionNotFound:
45 |             pass
46 | 
47 |     return str(chosen)
48 | 
49 | 
50 | def get_install_requirements(install_requires, choose_install_requires):
51 |     for mains, secondary in choose_install_requires:
52 |         install_requires.append(choose_requirement(mains, secondary))
53 | 
54 |     return install_requires
55 | 
56 | 
57 | setup(
58 |     name="albumentations",
59 |     version=get_version(),
60 |     description="Fast image augmentation library and easy to use wrapper around other libraries",
61 |     long_description=get_long_description(),
62 |     long_description_content_type="text/markdown",
63 |     author="Buslaev Alexander, Alexander Parinov, Vladimir Iglovikov, Eugene Khvedchenya, Druzhinin Mikhail",
64 |     license="MIT",
65 |     url="https://github.com/albumentations-team/albumentations",
66 |     packages=find_packages(exclude=["tests"]),
67 |     python_requires=">=3.6",
68 |     install_requires=get_install_requirements(INSTALL_REQUIRES, CHOOSE_INSTALL_REQUIRES),
69 |     extras_require={"tests": ["pytest"], "imgaug": ["imgaug>=0.4.0"], "develop": ["pytest", "imgaug>=0.4.0"]},
70 |     classifiers=[
71 |         "Development Status :: 4 - Beta",
72 |         "License :: OSI Approved :: MIT License",
73 |         "Intended Audience :: Developers",
74 |         "Intended Audience :: Science/Research",
75 |         "Operating System :: OS Independent",
76 |         "Programming Language :: Python",
77 |         "Programming Language :: Python :: 3",
78 |         "Programming Language :: Python :: 3.6",
79 |         "Programming Language :: Python :: 3.7",
80 |         "Programming Language :: Python :: 3.8",
81 |         "Programming Language :: Python :: 3.9",
82 |         "Topic :: Software Development :: Libraries",
83 |         "Topic :: Software Development :: Libraries :: Python Modules",
84 |     ],
85 | )
86 | 


--------------------------------------------------------------------------------
/.github/workflows/ci.yml:
--------------------------------------------------------------------------------
  1 | name: CI
  2 | on: [push, pull_request]
  3 | 
  4 | jobs:
  5 |   test_and_lint:
  6 |     name: Test and lint
  7 |     runs-on: ${{ matrix.operating-system }}
  8 |     strategy:
  9 |       matrix:
 10 |         operating-system: [ubuntu-latest, windows-latest, macos-11]
 11 |         python-version: [3.6, 3.7, 3.8, 3.9]
 12 |         albumentations-version: [tests, develop]
 13 |       fail-fast: false
 14 |     steps:
 15 |     - name: Checkout
 16 |       uses: actions/checkout@v2
 17 |     - name: Set up Python
 18 |       uses: actions/setup-python@v2
 19 |       with:
 20 |         python-version: ${{ matrix.python-version }}
 21 |     - name: Update pip
 22 |       run: python -m pip install --upgrade pip
 23 |     - name: Install wheel
 24 |       run: python -m pip install --upgrade wheel
 25 |     - name: Install PyTorch on Linux and Windows
 26 |       if: >
 27 |         matrix.operating-system == 'ubuntu-latest' ||
 28 |         matrix.operating-system == 'windows-latest'
 29 |       run: >
 30 |         pip install torch==1.8.1+cpu torchvision==0.9.1+cpu
 31 |         -f https://download.pytorch.org/whl/torch_stable.html
 32 |     - name: Install PyTorch on MacOS
 33 |       if: matrix.operating-system == 'macos-latest'
 34 |       run: pip install torch==1.8.1 torchvision==0.9.1
 35 |     - name: Install dependencies
 36 |       run: pip install .[${{ matrix.albumentations-version }}]
 37 |     - name: Install linters
 38 |       run: pip install flake8==3.9.2 flake8-docstrings==1.6.0 mypy==0.910 isort==5.9.3 types-PyYAML==5.4.10 types-setuptools
 39 |     - name: Cleanup the build directory
 40 |       uses: JesseTG/rm@v1.0.2
 41 |       with:
 42 |         path: build
 43 |     - name: Run PyTest
 44 |       run: pytest
 45 |     - name: Run Flake8
 46 |       run: flake8
 47 |     - name: Run mypy
 48 |       run: mypy .
 49 |     - name: Run isort
 50 |       run: isort --profile black albumentations
 51 | 
 52 |   check_code_formatting:
 53 |     name: Check code formatting with Black
 54 |     runs-on: ubuntu-latest
 55 |     strategy:
 56 |       matrix:
 57 |         python-version: [3.8]
 58 |     steps:
 59 |     - name: Checkout
 60 |       uses: actions/checkout@v2
 61 |     - name: Set up Python
 62 |       uses: actions/setup-python@v2
 63 |       with:
 64 |         python-version: ${{ matrix.python-version }}
 65 |     - name: Update pip
 66 |       run: python -m pip install --upgrade pip
 67 |     - name: Install Black
 68 |       run: pip install black==21.9b0
 69 |     - name: Run Black
 70 |       run: black --config=black.toml --check .
 71 | 
 72 |   check_sphinx_build:
 73 |     name: Check Sphinx build for docs
 74 |     runs-on: ubuntu-latest
 75 |     strategy:
 76 |       matrix:
 77 |         python-version: [3.8]
 78 |     steps:
 79 |     - name: Checkout
 80 |       uses: actions/checkout@v2
 81 |     - name: Set up Python
 82 |       uses: actions/setup-python@v2
 83 |       with:
 84 |         python-version: ${{ matrix.python-version }}
 85 |     - name: Update pip
 86 |       run: python -m pip install --upgrade pip
 87 |     - name: Install dependencies
 88 |       run: pip install -r docs/requirements.txt
 89 |     - name: Run Sphinx
 90 |       run: sphinx-build -b html docs /tmp/_docs_build
 91 | 
 92 |   check_transforms_docs:
 93 |     name: Check that transforms docs are not outdated
 94 |     runs-on: ubuntu-latest
 95 |     strategy:
 96 |       matrix:
 97 |         python-version: [3.8]
 98 |     steps:
 99 |     - name: Checkout
100 |       uses: actions/checkout@v2
101 |     - name: Set up Python
102 |       uses: actions/setup-python@v2
103 |       with:
104 |         python-version: ${{ matrix.python-version }}
105 |     - name: Update pip
106 |       run: python -m pip install --upgrade pip
107 |     - name: Install dependencies
108 |       run: pip install .[develop]
109 |     - name: Run checks
110 |       run: python tools/make_transforms_docs.py check README.md
111 | 


--------------------------------------------------------------------------------
/docs/_templates/breadcrumbs.html:
--------------------------------------------------------------------------------
 1 | {# Support for Sphinx 1.3+ page_source_suffix, but don't break old builds. #}
 2 | 
 3 | {% if page_source_suffix %}
 4 | {% set suffix = page_source_suffix %}
 5 | {% else %}
 6 | {% set suffix = source_suffix %}
 7 | {% endif %}
 8 | 
 9 | {% if meta is defined and meta is not none %}
10 | {% set check_meta = True %}
11 | {% else %}
12 | {% set check_meta = False %}
13 | {% endif %}
14 | 
15 | {% if check_meta and 'github_url' in meta %}
16 | {% set display_github = True %}
17 | {% endif %}
18 | 
19 | {% if check_meta and 'bitbucket_url' in meta %}
20 | {% set display_bitbucket = True %}
21 | {% endif %}
22 | 
23 | {% if check_meta and 'gitlab_url' in meta %}
24 | {% set display_gitlab = True %}
25 | {% endif %}
26 | 
27 | <div role="navigation" aria-label="breadcrumbs navigation">
28 | 
29 |   <ul class="wy-breadcrumbs">
30 |     {% block breadcrumbs %}
31 |       <li><a href="{{ pathto(master_doc) }}" class="icon icon-home"></a> &raquo;</li>
32 |         {% for doc in parents %}
33 |           <li><a href="{{ doc.link|e }}">{{ doc.title }}</a> &raquo;</li>
34 |         {% endfor %}
35 |       <li>{{ title }}</li>
36 |     {% endblock %}
37 |     {% block breadcrumbs_aside %}
38 |       <li class="wy-breadcrumbs-aside">
39 |         {% if hasdoc(pagename) %}
40 |             {% if display_github %}
41 |             {% if check_meta and 'github_url' in meta %}
42 |               <!-- User defined GitHub URL -->
43 |               <a href="{{ meta['github_url'] }}" class="fa fa-github"> {{ _('Edit on GitHub') }}</a>
44 |             {% else %}
45 |               <a href="https://{{ github_host|default("github.com") }}/{{ github_user }}/{{ github_repo }}/{{ theme_vcs_pageview_mode|default("blob") }}/{{ github_version }}{{ conf_py_path }}{{ pagename }}{{ suffix }}" class="fa fa-github"> {{ _('Edit on GitHub') }}</a>
46 |             {% endif %}
47 |           {% elif display_bitbucket %}
48 |             {% if check_meta and 'bitbucket_url' in meta %}
49 |               <!-- User defined Bitbucket URL -->
50 |               <a href="{{ meta['bitbucket_url'] }}" class="fa fa-bitbucket"> {{ _('Edit on Bitbucket') }}</a>
51 |             {% else %}
52 |               <a href="https://bitbucket.org/{{ bitbucket_user }}/{{ bitbucket_repo }}/src/{{ bitbucket_version}}{{ conf_py_path }}{{ pagename }}{{ suffix }}?mode={{ theme_vcs_pageview_mode|default("view") }}" class="fa fa-bitbucket"> {{ _('Edit on Bitbucket') }}</a>
53 |             {% endif %}
54 |           {% elif display_gitlab %}
55 |             {% if check_meta and 'gitlab_url' in meta %}
56 |               <!-- User defined GitLab URL -->
57 |               <a href="{{ meta['gitlab_url'] }}" class="fa fa-gitlab"> {{ _('Edit on GitLab') }}</a>
58 |             {% else %}
59 |               <a href="https://{{ gitlab_host|default("gitlab.com") }}/{{ gitlab_user }}/{{ gitlab_repo }}/{{ theme_vcs_pageview_mode|default("blob") }}/{{ gitlab_version }}{{ conf_py_path }}{{ pagename }}{{ suffix }}" class="fa fa-gitlab"> {{ _('Edit on GitLab') }}</a>
60 |             {% endif %}
61 |           {% elif show_source and source_url_prefix %}
62 |             <a href="{{ source_url_prefix }}{{ pagename }}{{ suffix }}">{{ _('View page source') }}</a>
63 |           {% elif show_source and has_source and sourcename %}
64 |             <a href="{{ pathto('_sources/' + sourcename, true)|e }}" rel="nofollow"> {{ _('View page source') }}</a>
65 |           {% endif %}
66 |         {% endif %}
67 |       </li>
68 |     {% endblock %}
69 |   </ul>
70 | 
71 |   {% if (theme_prev_next_buttons_location == 'top' or theme_prev_next_buttons_location == 'both') and (next or prev) %}
72 |   <div class="rst-breadcrumbs-buttons" role="navigation" aria-label="breadcrumb navigation">
73 |       {% if next %}
74 |         <a href="{{ next.link|e }}" class="btn btn-neutral float-right" title="{{ next.title|striptags|e }}" accesskey="n">{{ _('Next') }} <span class="fa fa-arrow-circle-right"></span></a>
75 |       {% endif %}
76 |       {% if prev %}
77 |         <a href="{{ prev.link|e }}" class="btn btn-neutral float-left" title="{{ prev.title|striptags|e }}" accesskey="p"><span class="fa fa-arrow-circle-left"></span> {{ _('Previous') }}</a>
78 |       {% endif %}
79 |   </div>
80 |   {% endif %}
81 |   <hr/>
82 | </div>
83 | 


--------------------------------------------------------------------------------
/albumentations/pytorch/transforms.py:
--------------------------------------------------------------------------------
  1 | from __future__ import absolute_import
  2 | 
  3 | import warnings
  4 | 
  5 | import numpy as np
  6 | import torch
  7 | from torchvision.transforms import functional as F
  8 | 
  9 | from ..core.transforms_interface import BasicTransform
 10 | 
 11 | __all__ = ["ToTensorV2"]
 12 | 
 13 | 
 14 | def img_to_tensor(im, normalize=None):
 15 |     tensor = torch.from_numpy(np.moveaxis(im / (255.0 if im.dtype == np.uint8 else 1), -1, 0).astype(np.float32))
 16 |     if normalize is not None:
 17 |         return F.normalize(tensor, **normalize)
 18 |     return tensor
 19 | 
 20 | 
 21 | def mask_to_tensor(mask, num_classes, sigmoid):
 22 |     if num_classes > 1:
 23 |         if not sigmoid:
 24 |             # softmax
 25 |             long_mask = np.zeros((mask.shape[:2]), dtype=np.int64)
 26 |             if len(mask.shape) == 3:
 27 |                 for c in range(mask.shape[2]):
 28 |                     long_mask[mask[..., c] > 0] = c
 29 |             else:
 30 |                 long_mask[mask > 127] = 1
 31 |                 long_mask[mask == 0] = 0
 32 |             mask = long_mask
 33 |         else:
 34 |             mask = np.moveaxis(mask / (255.0 if mask.dtype == np.uint8 else 1), -1, 0).astype(np.float32)
 35 |     else:
 36 |         mask = np.expand_dims(mask / (255.0 if mask.dtype == np.uint8 else 1), 0).astype(np.float32)
 37 |     return torch.from_numpy(mask)
 38 | 
 39 | 
 40 | class ToTensor(BasicTransform):
 41 |     """Convert image and mask to `torch.Tensor` and divide by 255 if image or mask are `uint8` type.
 42 |     This transform is now removed from Albumentations. If you need it downgrade the library to version 0.5.2.
 43 | 
 44 |     Args:
 45 |         num_classes (int): only for segmentation
 46 |         sigmoid (bool, optional): only for segmentation, transform mask to LongTensor or not.
 47 |         normalize (dict, optional): dict with keys [mean, std] to pass it into torchvision.normalize
 48 | 
 49 |     """
 50 | 
 51 |     def __init__(self, num_classes=1, sigmoid=True, normalize=None):
 52 |         raise RuntimeError(
 53 |             "`ToTensor` is obsolete and it was removed from Albumentations. Please use `ToTensorV2` instead - "
 54 |             "https://albumentations.ai/docs/api_reference/pytorch/transforms/"
 55 |             "#albumentations.pytorch.transforms.ToTensorV2. "
 56 |             "\n\nIf you need `ToTensor` downgrade Albumentations to version 0.5.2."
 57 |         )
 58 | 
 59 | 
 60 | class ToTensorV2(BasicTransform):
 61 |     """Convert image and mask to `torch.Tensor`. The numpy `HWC` image is converted to pytorch `CHW` tensor.
 62 |     If the image is in `HW` format (grayscale image), it will be converted to pytorch `HW` tensor.
 63 |     This is a simplified and improved version of the old `ToTensor`
 64 |     transform (`ToTensor` was deprecated, and now it is not present in Albumentations. You should use `ToTensorV2`
 65 |     instead).
 66 | 
 67 |     Args:
 68 |         transpose_mask (bool): if True and an input mask has three dimensions, this transform will transpose dimensions
 69 |         so the shape `[height, width, num_channels]` becomes `[num_channels, height, width]`. The latter format is a
 70 |         standard format for PyTorch Tensors. Default: False.
 71 |     """
 72 | 
 73 |     def __init__(self, transpose_mask=False, always_apply=True, p=1.0):
 74 |         super(ToTensorV2, self).__init__(always_apply=always_apply, p=p)
 75 |         self.transpose_mask = transpose_mask
 76 | 
 77 |     @property
 78 |     def targets(self):
 79 |         return {"image": self.apply, "mask": self.apply_to_mask}
 80 | 
 81 |     def apply(self, img, **params):  # skipcq: PYL-W0613
 82 |         if len(img.shape) not in [2, 3]:
 83 |             raise ValueError("Albumentations only supports images in HW or HWC format")
 84 | 
 85 |         if len(img.shape) == 2:
 86 |             img = np.expand_dims(img, 2)
 87 | 
 88 |         return torch.from_numpy(img.transpose(2, 0, 1))
 89 | 
 90 |     def apply_to_mask(self, mask, **params):  # skipcq: PYL-W0613
 91 |         if self.transpose_mask and mask.ndim == 3:
 92 |             mask = mask.transpose(2, 0, 1)
 93 |         return torch.from_numpy(mask)
 94 | 
 95 |     def get_transform_init_args_names(self):
 96 |         return ("transpose_mask",)
 97 | 
 98 |     def get_params_dependent_on_targets(self, params):
 99 |         return {}
100 | 


--------------------------------------------------------------------------------
/albumentations/core/utils.py:
--------------------------------------------------------------------------------
  1 | from __future__ import absolute_import
  2 | 
  3 | from abc import ABCMeta, abstractmethod
  4 | from typing import Any, Tuple
  5 | 
  6 | import numpy as np
  7 | 
  8 | 
  9 | def get_shape(img: Any) -> Tuple[int, int]:
 10 |     if isinstance(img, np.ndarray):
 11 |         rows, cols = img.shape[:2]
 12 |         return rows, cols
 13 | 
 14 |     try:
 15 |         import torch
 16 | 
 17 |         if torch.is_tensor(img):
 18 |             rows, cols = img.shape[-2:]
 19 |             return rows, cols
 20 |     except ImportError:
 21 |         pass
 22 | 
 23 |     raise RuntimeError(
 24 |         f"Albumentations supports only numpy.ndarray and torch.Tensor data type for image. Got: {type(img)}"
 25 |     )
 26 | 
 27 | 
 28 | def format_args(args_dict):
 29 |     formatted_args = []
 30 |     for k, v in args_dict.items():
 31 |         if isinstance(v, str):
 32 |             v = "'{}'".format(v)
 33 |         formatted_args.append("{}={}".format(k, v))
 34 |     return ", ".join(formatted_args)
 35 | 
 36 | 
 37 | class Params(metaclass=ABCMeta):
 38 |     def __init__(self, format, label_fields=None):
 39 |         self.format = format
 40 |         self.label_fields = label_fields
 41 | 
 42 |     def _to_dict(self):
 43 |         return {"format": self.format, "label_fields": self.label_fields}
 44 | 
 45 | 
 46 | class DataProcessor(metaclass=ABCMeta):
 47 |     def __init__(self, params, additional_targets=None):
 48 |         self.params = params
 49 |         self.data_fields = [self.default_data_name]
 50 |         if additional_targets is not None:
 51 |             for k, v in additional_targets.items():
 52 |                 if v == self.default_data_name:
 53 |                     self.data_fields.append(k)
 54 | 
 55 |     @property
 56 |     @abstractmethod
 57 |     def default_data_name(self):
 58 |         raise NotImplementedError
 59 | 
 60 |     def ensure_data_valid(self, data):
 61 |         pass
 62 | 
 63 |     def ensure_transforms_valid(self, transforms):
 64 |         pass
 65 | 
 66 |     def postprocess(self, data):
 67 |         rows, cols = get_shape(data["image"])
 68 | 
 69 |         for data_name in self.data_fields:
 70 |             data[data_name] = self.filter(data[data_name], rows, cols)
 71 |             data[data_name] = self.check_and_convert(data[data_name], rows, cols, direction="from")
 72 | 
 73 |         data = self.remove_label_fields_from_data(data)
 74 |         return data
 75 | 
 76 |     def preprocess(self, data):
 77 |         data = self.add_label_fields_to_data(data)
 78 | 
 79 |         rows, cols = data["image"].shape[:2]
 80 |         for data_name in self.data_fields:
 81 |             data[data_name] = self.check_and_convert(data[data_name], rows, cols, direction="to")
 82 | 
 83 |     def check_and_convert(self, data, rows, cols, direction="to"):
 84 |         if self.params.format == "albumentations":
 85 |             self.check(data, rows, cols)
 86 |             return data
 87 | 
 88 |         if direction == "to":
 89 |             return self.convert_to_albumentations(data, rows, cols)
 90 | 
 91 |         return self.convert_from_albumentations(data, rows, cols)
 92 | 
 93 |     @abstractmethod
 94 |     def filter(self, data, rows, cols):
 95 |         pass
 96 | 
 97 |     @abstractmethod
 98 |     def check(self, data, rows, cols):
 99 |         pass
100 | 
101 |     @abstractmethod
102 |     def convert_to_albumentations(self, data, rows, cols):
103 |         pass
104 | 
105 |     @abstractmethod
106 |     def convert_from_albumentations(self, data, rows, cols):
107 |         pass
108 | 
109 |     def add_label_fields_to_data(self, data):
110 |         if self.params.label_fields is None:
111 |             return data
112 |         for data_name in self.data_fields:
113 |             for field in self.params.label_fields:
114 |                 assert len(data[data_name]) == len(data[field])
115 |                 data_with_added_field = []
116 |                 for d, field_value in zip(data[data_name], data[field]):
117 |                     data_with_added_field.append(list(d) + [field_value])
118 |                 data[data_name] = data_with_added_field
119 |         return data
120 | 
121 |     def remove_label_fields_from_data(self, data):
122 |         if self.params.label_fields is None:
123 |             return data
124 |         for data_name in self.data_fields:
125 |             label_fields_len = len(self.params.label_fields)
126 |             for idx, field in enumerate(self.params.label_fields):
127 |                 field_values = []
128 |                 for bbox in data[data_name]:
129 |                     field_values.append(bbox[-label_fields_len + idx])
130 |                 data[field] = field_values
131 |             if label_fields_len:
132 |                 data[data_name] = [d[:-label_fields_len] for d in data[data_name]]
133 |         return data
134 | 


--------------------------------------------------------------------------------
/tests/utils.py:
--------------------------------------------------------------------------------
  1 | import inspect
  2 | import random
  3 | import typing
  4 | import numpy as np
  5 | 
  6 | from io import StringIO
  7 | 
  8 | import albumentations
  9 | 
 10 | 
 11 | def convert_2d_to_3d(arrays, num_channels=3):
 12 |     # Converts a 2D numpy array with shape (H, W) into a 3D array with shape (H, W, num_channels)
 13 |     # by repeating the existing values along the new axis.
 14 |     arrays = tuple(np.repeat(array[:, :, np.newaxis], repeats=num_channels, axis=2) for array in arrays)
 15 |     if len(arrays) == 1:
 16 |         return arrays[0]
 17 |     return arrays
 18 | 
 19 | 
 20 | def convert_2d_to_target_format(arrays, target):
 21 |     if target == "mask":
 22 |         return arrays[0] if len(arrays) == 1 else arrays
 23 |     if target == "image":
 24 |         return convert_2d_to_3d(arrays, num_channels=3)
 25 |     if target == "image_4_channels":
 26 |         return convert_2d_to_3d(arrays, num_channels=4)
 27 | 
 28 |     raise ValueError("Unknown target {}".format(target))
 29 | 
 30 | 
 31 | class InMemoryFile(StringIO):
 32 |     def __init__(self, value, save_value, file):
 33 |         super().__init__(value)
 34 |         self.save_value = save_value
 35 |         self.file = file
 36 | 
 37 |     def close(self):
 38 |         self.save_value(self.getvalue(), self.file)
 39 |         super().close()
 40 | 
 41 | 
 42 | class OpenMock:
 43 |     """
 44 |     Mocks the `open` built-in function. A call to the instance of OpenMock returns an in-memory file which is
 45 |     readable and writable. The actual in-memory file implementation should call the passed `save_value` method
 46 |     to save the file content in the cache when the file is being closed to preserve the file content.
 47 |     """
 48 | 
 49 |     def __init__(self):
 50 |         self.values = {}
 51 | 
 52 |     def __call__(self, file, *args, **kwargs):
 53 |         value = self.values.get(file)
 54 |         return InMemoryFile(value, self.save_value, file)
 55 | 
 56 |     def save_value(self, value, file):
 57 |         self.values[file] = value
 58 | 
 59 | 
 60 | def set_seed(seed):
 61 |     random.seed(seed)
 62 |     np.random.seed(seed)
 63 | 
 64 | 
 65 | def get_filtered_transforms(
 66 |     base_classes: typing.Tuple[typing.Type, ...],
 67 |     custom_arguments: typing.Optional[typing.Dict[typing.Type, dict]] = None,
 68 |     except_augmentations: typing.Optional[typing.Set[typing.Type]] = None,
 69 | ) -> typing.List[typing.Tuple[typing.Type, dict]]:
 70 |     custom_arguments = custom_arguments or {}
 71 |     except_augmentations = except_augmentations or set()
 72 | 
 73 |     result = []
 74 | 
 75 |     for name, cls in inspect.getmembers(albumentations):
 76 |         if not inspect.isclass(cls) or not issubclass(
 77 |             cls, (albumentations.BasicTransform, albumentations.BaseCompose)
 78 |         ):
 79 |             continue
 80 | 
 81 |         if "DeprecationWarning" in inspect.getsource(cls) or "FutureWarning" in inspect.getsource(cls):
 82 |             continue
 83 | 
 84 |         if not issubclass(cls, base_classes) or any(cls == i for i in base_classes) or cls in except_augmentations:
 85 |             continue
 86 | 
 87 |         try:
 88 |             if issubclass(cls, albumentations.BasicIAATransform):
 89 |                 continue
 90 |         except AttributeError:
 91 |             pass
 92 | 
 93 |         result.append((cls, custom_arguments.get(cls, {})))
 94 | 
 95 |     return result
 96 | 
 97 | 
 98 | def get_image_only_transforms(
 99 |     custom_arguments: typing.Optional[typing.Dict[typing.Type[albumentations.ImageOnlyTransform], dict]] = None,
100 |     except_augmentations: typing.Optional[typing.Set[typing.Type[albumentations.ImageOnlyTransform]]] = None,
101 | ) -> typing.List[typing.Tuple[typing.Type, dict]]:
102 |     return get_filtered_transforms((albumentations.ImageOnlyTransform,), custom_arguments, except_augmentations)
103 | 
104 | 
105 | def get_dual_transforms(
106 |     custom_arguments: typing.Optional[typing.Dict[typing.Type[albumentations.DualTransform], dict]] = None,
107 |     except_augmentations: typing.Optional[typing.Set[typing.Type[albumentations.DualTransform]]] = None,
108 | ) -> typing.List[typing.Tuple[typing.Type, dict]]:
109 |     return get_filtered_transforms((albumentations.DualTransform,), custom_arguments, except_augmentations)
110 | 
111 | 
112 | def get_transforms(
113 |     custom_arguments: typing.Optional[typing.Dict[typing.Type[albumentations.BasicTransform], dict]] = None,
114 |     except_augmentations: typing.Optional[typing.Set[typing.Type[albumentations.BasicTransform]]] = None,
115 | ) -> typing.List[typing.Tuple[typing.Type, dict]]:
116 |     return get_filtered_transforms(
117 |         (albumentations.ImageOnlyTransform, albumentations.DualTransform), custom_arguments, except_augmentations
118 |     )
119 | 
120 | 
121 | def check_all_augs_exists(
122 |     augmentations: typing.List[typing.List],
123 |     except_augmentations: typing.Optional[typing.Set[typing.Type[albumentations.BasicTransform]]] = None,
124 | ) -> typing.List[typing.List]:
125 |     existed_augs = {i[0] for i in augmentations}
126 |     except_augmentations = except_augmentations or set()
127 | 
128 |     not_existed = []
129 | 
130 |     for cls, _ in get_transforms(except_augmentations=except_augmentations):
131 |         if cls not in existed_augs:
132 |             not_existed.append(cls.__name__)
133 | 
134 |     if not_existed:
135 |         raise ValueError(f"These augmentations do not exist in augmentations and except_augmentations: {not_existed}")
136 | 
137 |     return augmentations
138 | 


--------------------------------------------------------------------------------
/docs/conf.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python3
  2 | # -*- coding: utf-8 -*-
  3 | import datetime
  4 | from typing import Dict, Any
  5 | from unittest.mock import MagicMock
  6 | 
  7 | import re
  8 | import os
  9 | import sys
 10 | 
 11 | sys.path.insert(0, os.path.abspath("../"))
 12 | 
 13 | 
 14 | class Mock(MagicMock):
 15 |     @classmethod
 16 |     def __getattr__(cls, name):
 17 |         return MagicMock()
 18 | 
 19 | 
 20 | MOCK_MODULES = ["pytorch", "torchvision.transforms", "torchvision.transforms.functional"]
 21 | for module_name in MOCK_MODULES:
 22 |     sys.modules[module_name] = Mock()
 23 | 
 24 | 
 25 | def get_version():
 26 |     current_dir = os.path.abspath(os.path.dirname(__file__))
 27 |     root = os.path.dirname(current_dir)
 28 |     version_file = os.path.join(root, "albumentations", "__init__.py")
 29 |     with open(version_file) as f:
 30 |         return re.search(r'^__version__ = [\'"]([^\'"]*)[\'"]', f.read(), re.M).group(1)
 31 | 
 32 | 
 33 | # -- General configuration ------------------------------------------------
 34 | 
 35 | # If your documentation needs a minimal Sphinx version, state it here.
 36 | #
 37 | # needs_sphinx = '1.0'
 38 | 
 39 | # Add any Sphinx extension module names here, as strings. They can be
 40 | # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
 41 | # ones.
 42 | extensions = ["sphinx.ext.autodoc", "sphinx.ext.viewcode", "sphinx.ext.mathjax", "sphinx.ext.napoleon"]
 43 | 
 44 | # Add any paths that contain templates here, relative to this directory.
 45 | templates_path = ["_templates"]
 46 | 
 47 | # The suffix(es) of source filenames.
 48 | # You can specify multiple suffix as a list of string:
 49 | #
 50 | # source_suffix = ['.rst', '.md']
 51 | source_suffix = ".rst"
 52 | 
 53 | # The master toctree document.
 54 | master_doc = "index"
 55 | 
 56 | # General information about the project.
 57 | project = "albumentations"
 58 | 
 59 | authors = "Alexander Buslaev, Alex Parinov, Vladimir Iglovikov, Evegene Khvedchenya, Mikhail Druzhinin"
 60 | 
 61 | copyright = "{}, {}".format(datetime.datetime.now().year, authors)
 62 | 
 63 | # The version info for the project you're documenting, acts as replacement for
 64 | # |version| and |release|, also used in various other places throughout the
 65 | # built documents.
 66 | #
 67 | # The short X.Y version.
 68 | version = get_version()
 69 | # The full version, including alpha/beta/rc tags.
 70 | release = version
 71 | 
 72 | # The language for content autogenerated by Sphinx. Refer to documentation
 73 | # for a list of supported languages.
 74 | #
 75 | # This is also used if you do content translation via gettext catalogs.
 76 | # Usually you set "language" from the command line for these cases.
 77 | language = None
 78 | 
 79 | # List of patterns, relative to source directory, that match files and
 80 | # directories to ignore when looking for source files.
 81 | # This patterns also effect to html_static_path and html_extra_path
 82 | exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"]
 83 | 
 84 | # The name of the Pygments (syntax highlighting) style to use.
 85 | pygments_style = "sphinx"
 86 | 
 87 | # If true, `todo` and `todoList` produce output, else they produce nothing.
 88 | todo_include_todos = False
 89 | 
 90 | 
 91 | # -- Options for HTML output ----------------------------------------------
 92 | 
 93 | # The theme to use for HTML and HTML Help pages.  See the documentation for
 94 | # a list of builtin themes.
 95 | #
 96 | html_theme = "sphinx_rtd_theme"
 97 | 
 98 | # Theme options are theme-specific and customize the look and feel of a theme
 99 | # further.  For a list of options available for each theme, see the
100 | # documentation.
101 | #
102 | html_theme_options = {"collapse_navigation": True}
103 | 
104 | # Add any paths that contain custom static files (such as style sheets) here,
105 | # relative to this directory. They are copied after the builtin static files,
106 | # so a file named "default.css" will overwrite the builtin "default.css".
107 | html_static_path = ["_static"]
108 | 
109 | html_logo = "logo.png"
110 | 
111 | 
112 | # -- Options for HTMLHelp output ------------------------------------------
113 | 
114 | # Output file base name for HTML help builder.
115 | htmlhelp_basename = "albumentationsdoc"
116 | 
117 | 
118 | # -- Options for LaTeX output ---------------------------------------------
119 | 
120 | latex_elements = {
121 |     # The paper size ('letterpaper' or 'a4paper').
122 |     #
123 |     # 'papersize': 'letterpaper',
124 |     # The font size ('10pt', '11pt' or '12pt').
125 |     #
126 |     # 'pointsize': '10pt',
127 |     # Additional stuff for the LaTeX preamble.
128 |     #
129 |     # 'preamble': '',
130 |     # Latex figure (float) alignment
131 |     #
132 |     # 'figure_align': 'htbp',
133 | }  # type: Dict[str, Any]
134 | 
135 | # Grouping the document tree into LaTeX files. List of tuples
136 | # (source start file, target name, title,
137 | #  author, documentclass [howto, manual, or own class]).
138 | latex_documents = [(master_doc, "albumentations.tex", "albumentations Documentation", authors, "manual")]
139 | 
140 | 
141 | # -- Options for manual page output ---------------------------------------
142 | 
143 | # One entry per manual page. List of tuples
144 | # (source start file, name, description, authors, manual section).
145 | man_pages = [(master_doc, "albumentations", "albumentations Documentation", [authors], 1)]
146 | 
147 | 
148 | # -- Options for Texinfo output -------------------------------------------
149 | 
150 | # Grouping the document tree into Texinfo files. List of tuples
151 | # (source start file, target name, title, author,
152 | #  dir menu entry, description, category)
153 | texinfo_documents = [
154 |     (
155 |         master_doc,
156 |         "albumentations",
157 |         "albumentations Documentation",
158 |         authors,
159 |         "albumentations",
160 |         "One line description of project.",
161 |         "Miscellaneous",
162 |     )
163 | ]
164 | 


--------------------------------------------------------------------------------
/tests/files/transform_serialization_v2_without_totensor.json:
--------------------------------------------------------------------------------
1 | {"__version__": "0.5.2", "transform": {"__class_fullname__": "Compose", "p": 1.0, "transforms": [{"__class_fullname__": "Blur", "always_apply": false, "p": 0.5, "blur_limit": [3, 7]}, {"__class_fullname__": "CLAHE", "always_apply": false, "p": 0.5, "clip_limit": [1, 4.0], "tile_grid_size": [8, 8]}, {"__class_fullname__": "ChannelDropout", "always_apply": false, "p": 0.5, "channel_drop_range": [1, 1], "fill_value": 0}, {"__class_fullname__": "ChannelShuffle", "always_apply": false, "p": 0.5}, {"__class_fullname__": "CoarseDropout", "always_apply": false, "p": 0.5, "max_holes": 8, "max_height": 8, "max_width": 8, "min_holes": 8, "min_height": 8, "min_width": 8, "fill_value": 0, "mask_fill_value": null}, {"__class_fullname__": "Downscale", "always_apply": false, "p": 0.5, "scale_min": 0.25, "scale_max": 0.25, "interpolation": 0}, {"__class_fullname__": "ElasticTransform", "always_apply": false, "p": 0.5, "alpha": 1, "sigma": 50, "alpha_affine": 50, "interpolation": 1, "border_mode": 4, "value": null, "mask_value": null, "approximate": false}, {"__class_fullname__": "Equalize", "always_apply": false, "p": 0.5, "mode": "cv", "by_channels": true}, {"__class_fullname__": "FancyPCA", "always_apply": false, "p": 0.5, "alpha": 0.1}, {"__class_fullname__": "Flip", "always_apply": false, "p": 0.5}, {"__class_fullname__": "GaussNoise", "always_apply": false, "p": 0.5, "var_limit": [10.0, 50.0], "per_channel": true, "mean": 0}, {"__class_fullname__": "GaussianBlur", "always_apply": false, "p": 0.5, "blur_limit": [3, 7], "sigma_limit": [0, 0]}, {"__class_fullname__": "GlassBlur", "always_apply": false, "p": 0.5, "sigma": 0.7, "max_delta": 4, "iterations": 2}, {"__class_fullname__": "GridDistortion", "always_apply": false, "p": 0.5, "num_steps": 5, "distort_limit": [-0.3, 0.3], "interpolation": 1, "border_mode": 4, "value": null, "mask_value": null}, {"__class_fullname__": "HorizontalFlip", "always_apply": false, "p": 0.5}, {"__class_fullname__": "HueSaturationValue", "always_apply": false, "p": 0.5, "hue_shift_limit": [-20, 20], "sat_shift_limit": [-30, 30], "val_shift_limit": [-20, 20]}, {"__class_fullname__": "ISONoise", "always_apply": false, "p": 0.5, "intensity": [0.1, 0.5], "color_shift": [0.01, 0.05]}, {"__class_fullname__": "ImageCompression", "always_apply": false, "p": 0.5, "quality_lower": 99, "quality_upper": 100, "compression_type": 0}, {"__class_fullname__": "InvertImg", "always_apply": false, "p": 0.5}, {"__class_fullname__": "LongestMaxSize", "always_apply": false, "p": 1, "max_size": 1024, "interpolation": 1}, {"__class_fullname__": "MedianBlur", "always_apply": false, "p": 0.5, "blur_limit": [3, 7]}, {"__class_fullname__": "MotionBlur", "always_apply": false, "p": 0.5, "blur_limit": [3, 7]}, {"__class_fullname__": "MultiplicativeNoise", "always_apply": false, "p": 0.5, "multiplier": [0.9, 1.1], "per_channel": false, "elementwise": false}, {"__class_fullname__": "NoOp", "always_apply": false, "p": 0.5}, {"__class_fullname__": "OpticalDistortion", "always_apply": false, "p": 0.5, "distort_limit": [-0.05, 0.05], "shift_limit": [-0.05, 0.05], "interpolation": 1, "border_mode": 4, "value": null, "mask_value": null}, {"__class_fullname__": "PadIfNeeded", "always_apply": false, "p": 1.0, "min_height": 1024, "min_width": 1024, "pad_height_divisor": null, "pad_width_divisor": null, "border_mode": 4, "value": null, "mask_value": null}, {"__class_fullname__": "Posterize", "always_apply": false, "p": 0.5, "num_bits": [4, 4]}, {"__class_fullname__": "RGBShift", "always_apply": false, "p": 0.5, "r_shift_limit": [-20, 20], "g_shift_limit": [-20, 20], "b_shift_limit": [-20, 20]}, {"__class_fullname__": "RandomBrightnessContrast", "always_apply": false, "p": 0.5, "brightness_limit": [-0.2, 0.2], "contrast_limit": [-0.2, 0.2], "brightness_by_max": true}, {"__class_fullname__": "RandomFog", "always_apply": false, "p": 0.5, "fog_coef_lower": 0.3, "fog_coef_upper": 1, "alpha_coef": 0.08}, {"__class_fullname__": "RandomGamma", "always_apply": false, "p": 0.5, "gamma_limit": [80, 120], "eps": null}, {"__class_fullname__": "RandomGridShuffle", "always_apply": false, "p": 0.5, "grid": [3, 3]}, {"__class_fullname__": "RandomRain", "always_apply": false, "p": 0.5, "slant_lower": -10, "slant_upper": 10, "drop_length": 20, "drop_width": 1, "drop_color": [200, 200, 200], "blur_value": 7, "brightness_coefficient": 0.7, "rain_type": null}, {"__class_fullname__": "RandomRotate90", "always_apply": false, "p": 0.5}, {"__class_fullname__": "RandomScale", "always_apply": false, "p": 0.5, "interpolation": 1, "scale_limit": [-0.09999999999999998, 0.10000000000000009]}, {"__class_fullname__": "RandomShadow", "always_apply": false, "p": 0.5, "shadow_roi": [0, 0.5, 1, 1], "num_shadows_lower": 1, "num_shadows_upper": 2, "shadow_dimension": 5}, {"__class_fullname__": "RandomSnow", "always_apply": false, "p": 0.5, "snow_point_lower": 0.1, "snow_point_upper": 0.3, "brightness_coeff": 2.5}, {"__class_fullname__": "RandomSunFlare", "always_apply": false, "p": 0.5, "flare_roi": [0, 0, 1, 0.5], "angle_lower": 0, "angle_upper": 1, "num_flare_circles_lower": 6, "num_flare_circles_upper": 10, "src_radius": 400, "src_color": [255, 255, 255]}, {"__class_fullname__": "Rotate", "always_apply": false, "p": 0.5, "limit": [-90, 90], "interpolation": 1, "border_mode": 4, "value": null, "mask_value": null}, {"__class_fullname__": "ShiftScaleRotate", "always_apply": false, "p": 0.5, "shift_limit_x": [-0.0625, 0.0625], "shift_limit_y": [-0.0625, 0.0625], "scale_limit": [-0.09999999999999998, 0.10000000000000009], "rotate_limit": [-45, 45], "interpolation": 1, "border_mode": 4, "value": null, "mask_value": null}, {"__class_fullname__": "SmallestMaxSize", "always_apply": false, "p": 1, "max_size": 1024, "interpolation": 1}, {"__class_fullname__": "Solarize", "always_apply": false, "p": 0.5, "threshold": [128, 128]}, {"__class_fullname__": "ToGray", "always_apply": false, "p": 0.5}, {"__class_fullname__": "ToSepia", "always_apply": false, "p": 0.5}, {"__class_fullname__": "Transpose", "always_apply": false, "p": 0.5}, {"__class_fullname__": "VerticalFlip", "always_apply": false, "p": 0.5}, {"__class_fullname__": "RandomCrop", "always_apply": false, "p": 1.0, "height": 32, "width": 32}, {"__class_fullname__": "Normalize", "always_apply": false, "p": 1.0, "mean": [0.485, 0.456, 0.406], "std": [0.229, 0.224, 0.225], "max_pixel_value": 255.0}], "bbox_params": null, "keypoint_params": null, "additional_targets": {}}}
2 | 


--------------------------------------------------------------------------------
/tests/files/transform_serialization_v2_with_totensor.json:
--------------------------------------------------------------------------------
1 | {"__version__": "0.5.2", "transform": {"__class_fullname__": "Compose", "p": 1.0, "transforms": [{"__class_fullname__": "Blur", "always_apply": false, "p": 0.5, "blur_limit": [3, 7]}, {"__class_fullname__": "CLAHE", "always_apply": false, "p": 0.5, "clip_limit": [1, 4.0], "tile_grid_size": [8, 8]}, {"__class_fullname__": "ChannelDropout", "always_apply": false, "p": 0.5, "channel_drop_range": [1, 1], "fill_value": 0}, {"__class_fullname__": "ChannelShuffle", "always_apply": false, "p": 0.5}, {"__class_fullname__": "CoarseDropout", "always_apply": false, "p": 0.5, "max_holes": 8, "max_height": 8, "max_width": 8, "min_holes": 8, "min_height": 8, "min_width": 8, "fill_value": 0, "mask_fill_value": null}, {"__class_fullname__": "Downscale", "always_apply": false, "p": 0.5, "scale_min": 0.25, "scale_max": 0.25, "interpolation": 0}, {"__class_fullname__": "ElasticTransform", "always_apply": false, "p": 0.5, "alpha": 1, "sigma": 50, "alpha_affine": 50, "interpolation": 1, "border_mode": 4, "value": null, "mask_value": null, "approximate": false}, {"__class_fullname__": "Equalize", "always_apply": false, "p": 0.5, "mode": "cv", "by_channels": true}, {"__class_fullname__": "FancyPCA", "always_apply": false, "p": 0.5, "alpha": 0.1}, {"__class_fullname__": "Flip", "always_apply": false, "p": 0.5}, {"__class_fullname__": "GaussNoise", "always_apply": false, "p": 0.5, "var_limit": [10.0, 50.0]}, {"__class_fullname__": "GaussianBlur", "always_apply": false, "p": 0.5, "blur_limit": [3, 7], "sigma_limit": [0, 0]}, {"__class_fullname__": "GlassBlur", "always_apply": false, "p": 0.5, "sigma": 0.7, "max_delta": 4, "iterations": 2}, {"__class_fullname__": "GridDistortion", "always_apply": false, "p": 0.5, "num_steps": 5, "distort_limit": [-0.3, 0.3], "interpolation": 1, "border_mode": 4, "value": null, "mask_value": null}, {"__class_fullname__": "HorizontalFlip", "always_apply": false, "p": 0.5}, {"__class_fullname__": "HueSaturationValue", "always_apply": false, "p": 0.5, "hue_shift_limit": [-20, 20], "sat_shift_limit": [-30, 30], "val_shift_limit": [-20, 20]}, {"__class_fullname__": "ISONoise", "always_apply": false, "p": 0.5, "intensity": [0.1, 0.5], "color_shift": [0.01, 0.05]}, {"__class_fullname__": "ImageCompression", "always_apply": false, "p": 0.5, "quality_lower": 99, "quality_upper": 100, "compression_type": 0}, {"__class_fullname__": "InvertImg", "always_apply": false, "p": 0.5}, {"__class_fullname__": "LongestMaxSize", "always_apply": false, "p": 1, "max_size": 1024, "interpolation": 1}, {"__class_fullname__": "MedianBlur", "always_apply": false, "p": 0.5, "blur_limit": [3, 7]}, {"__class_fullname__": "MotionBlur", "always_apply": false, "p": 0.5, "blur_limit": [3, 7]}, {"__class_fullname__": "MultiplicativeNoise", "always_apply": false, "p": 0.5, "multiplier": [0.9, 1.1], "per_channel": false, "elementwise": false}, {"__class_fullname__": "NoOp", "always_apply": false, "p": 0.5}, {"__class_fullname__": "OpticalDistortion", "always_apply": false, "p": 0.5, "distort_limit": [-0.05, 0.05], "shift_limit": [-0.05, 0.05], "interpolation": 1, "border_mode": 4, "value": null, "mask_value": null}, {"__class_fullname__": "PadIfNeeded", "always_apply": false, "p": 1.0, "min_height": 1024, "min_width": 1024, "pad_height_divisor": null, "pad_width_divisor": null, "border_mode": 4, "value": null, "mask_value": null}, {"__class_fullname__": "Posterize", "always_apply": false, "p": 0.5, "num_bits": [4, 4]}, {"__class_fullname__": "RGBShift", "always_apply": false, "p": 0.5, "r_shift_limit": [-20, 20], "g_shift_limit": [-20, 20], "b_shift_limit": [-20, 20]}, {"__class_fullname__": "RandomBrightnessContrast", "always_apply": false, "p": 0.5, "brightness_limit": [-0.2, 0.2], "contrast_limit": [-0.2, 0.2], "brightness_by_max": true}, {"__class_fullname__": "RandomFog", "always_apply": false, "p": 0.5, "fog_coef_lower": 0.3, "fog_coef_upper": 1, "alpha_coef": 0.08}, {"__class_fullname__": "RandomGamma", "always_apply": false, "p": 0.5, "gamma_limit": [80, 120], "eps": null}, {"__class_fullname__": "RandomGridShuffle", "always_apply": false, "p": 0.5, "grid": [3, 3]}, {"__class_fullname__": "RandomRain", "always_apply": false, "p": 0.5, "slant_lower": -10, "slant_upper": 10, "drop_length": 20, "drop_width": 1, "drop_color": [200, 200, 200], "blur_value": 7, "brightness_coefficient": 0.7, "rain_type": null}, {"__class_fullname__": "RandomRotate90", "always_apply": false, "p": 0.5}, {"__class_fullname__": "RandomScale", "always_apply": false, "p": 0.5, "interpolation": 1, "scale_limit": [-0.09999999999999998, 0.10000000000000009]}, {"__class_fullname__": "RandomShadow", "always_apply": false, "p": 0.5, "shadow_roi": [0, 0.5, 1, 1], "num_shadows_lower": 1, "num_shadows_upper": 2, "shadow_dimension": 5}, {"__class_fullname__": "RandomSnow", "always_apply": false, "p": 0.5, "snow_point_lower": 0.1, "snow_point_upper": 0.3, "brightness_coeff": 2.5}, {"__class_fullname__": "RandomSunFlare", "always_apply": false, "p": 0.5, "flare_roi": [0, 0, 1, 0.5], "angle_lower": 0, "angle_upper": 1, "num_flare_circles_lower": 6, "num_flare_circles_upper": 10, "src_radius": 400, "src_color": [255, 255, 255]}, {"__class_fullname__": "Rotate", "always_apply": false, "p": 0.5, "limit": [-90, 90], "interpolation": 1, "border_mode": 4, "value": null, "mask_value": null}, {"__class_fullname__": "ShiftScaleRotate", "always_apply": false, "p": 0.5, "shift_limit_x": [-0.0625, 0.0625], "shift_limit_y": [-0.0625, 0.0625], "scale_limit": [-0.09999999999999998, 0.10000000000000009], "rotate_limit": [-45, 45], "interpolation": 1, "border_mode": 4, "value": null, "mask_value": null}, {"__class_fullname__": "SmallestMaxSize", "always_apply": false, "p": 1, "max_size": 1024, "interpolation": 1}, {"__class_fullname__": "Solarize", "always_apply": false, "p": 0.5, "threshold": [128, 128]}, {"__class_fullname__": "ToGray", "always_apply": false, "p": 0.5}, {"__class_fullname__": "ToSepia", "always_apply": false, "p": 0.5}, {"__class_fullname__": "Transpose", "always_apply": false, "p": 0.5}, {"__class_fullname__": "VerticalFlip", "always_apply": false, "p": 0.5}, {"__class_fullname__": "RandomCrop", "always_apply": false, "p": 1.0, "height": 32, "width": 32}, {"__class_fullname__": "Normalize", "always_apply": false, "p": 1.0, "mean": [0.485, 0.456, 0.406], "std": [0.229, 0.224, 0.225], "max_pixel_value": 255.0}, {"__class_fullname__": "ToTensorV2", "always_apply": true, "p": 1.0, "transpose_mask": false}], "bbox_params": null, "keypoint_params": null, "additional_targets": {}}}
2 | 


--------------------------------------------------------------------------------
/tools/make_transforms_docs.py:
--------------------------------------------------------------------------------
  1 | import inspect
  2 | import os
  3 | import sys
  4 | from enum import Enum
  5 | import argparse
  6 | 
  7 | sys.path.append("..")
  8 | import albumentations  # noqa: E402
  9 | 
 10 | 
 11 | IGNORED_CLASSES = {
 12 |     "BasicTransform",
 13 |     "BasicIAATransform",
 14 |     "DualIAATransform",
 15 |     "DualTransform",
 16 |     "ImageOnlyIAATransform",
 17 |     "ImageOnlyTransform",
 18 | }
 19 | 
 20 | 
 21 | def make_augmentation_docs_link(cls):
 22 |     module_parts = cls.__module__.split(".")
 23 |     module_page = "/".join(module_parts[1:])
 24 |     return (
 25 |         "[{cls.__name__}](https://albumentations.ai/docs/api_reference/{module_page}/#{cls.__module__}.{cls.__name__})"
 26 |     ).format(module_page=module_page, cls=cls)
 27 | 
 28 | 
 29 | class Targets(Enum):
 30 |     IMAGE = "Image"
 31 |     MASKS = "Masks"
 32 |     BBOXES = "BBoxes"
 33 |     KEYPOINTS = "Keypoints"
 34 | 
 35 | 
 36 | def parse_args():
 37 |     parser = argparse.ArgumentParser()
 38 |     subparsers = parser.add_subparsers(help="Commands", dest="command")
 39 |     subparsers.add_parser("make")
 40 |     check_parser = subparsers.add_parser("check")
 41 |     check_parser.add_argument("filepath", type=str, help="Path to a file that should be checked")
 42 |     return parser.parse_args()
 43 | 
 44 | 
 45 | def make_separator(width, align_center):
 46 |     if align_center:
 47 |         return ":" + "-" * (width - 2) + ":"
 48 |     return "-" * width
 49 | 
 50 | 
 51 | def get_transforms_info():
 52 |     transforms_info = {}
 53 |     for name, cls in inspect.getmembers(albumentations):
 54 |         if inspect.isclass(cls) and issubclass(cls, albumentations.BasicTransform) and name not in IGNORED_CLASSES:
 55 |             if "DeprecationWarning" in inspect.getsource(cls) or "FutureWarning" in inspect.getsource(cls):
 56 |                 continue
 57 | 
 58 |             targets = {Targets.IMAGE}
 59 |             if issubclass(cls, albumentations.DualTransform):
 60 |                 targets.add(Targets.MASKS)
 61 | 
 62 |             if hasattr(cls, "apply_to_bbox") and cls.apply_to_bbox is not albumentations.DualTransform.apply_to_bbox:
 63 |                 targets.add(Targets.BBOXES)
 64 | 
 65 |             if (
 66 |                 hasattr(cls, "apply_to_keypoint")
 67 |                 and cls.apply_to_keypoint is not albumentations.DualTransform.apply_to_keypoint
 68 |             ):
 69 |                 targets.add(Targets.KEYPOINTS)
 70 | 
 71 |             if issubclass(cls, albumentations.DualIAATransform):
 72 |                 targets.update({Targets.BBOXES, Targets.KEYPOINTS})
 73 | 
 74 |             if issubclass(cls, albumentations.Lambda):
 75 |                 targets.add(Targets.MASKS)
 76 |                 targets.add(Targets.BBOXES)
 77 |                 targets.add(Targets.KEYPOINTS)
 78 | 
 79 |             transforms_info[name] = {
 80 |                 "targets": targets,
 81 |                 "docs_link": make_augmentation_docs_link(cls),
 82 |                 "image_only": issubclass(cls, albumentations.ImageOnlyTransform),
 83 |             }
 84 |     return transforms_info
 85 | 
 86 | 
 87 | def make_transforms_targets_table(transforms_info, header):
 88 |     rows = [header]
 89 |     for transform, info in sorted(transforms_info.items(), key=lambda kv: kv[0]):
 90 |         transform_targets = []
 91 |         for target in Targets:
 92 |             mark = "✓" if target in info["targets"] else ""
 93 |             transform_targets.append(mark)
 94 |         row = [info["docs_link"] or transform] + transform_targets
 95 |         rows.append(row)
 96 | 
 97 |     column_widths = [max(len(r) for r in column) for column in zip(*rows)]
 98 |     lines = [
 99 |         " | ".join(
100 |             "{title: <{width}}".format(width=width, title=title) for width, title in zip(column_widths, rows[0])
101 |         ),
102 |         " | ".join(
103 |             make_separator(width, align_center=column_index > 0) for column_index, width in enumerate(column_widths)
104 |         ),
105 |     ]
106 |     for row in rows[1:]:
107 |         lines.append(
108 |             " | ".join(
109 |                 "{column: <{width}}".format(width=width, column=column) for width, column in zip(column_widths, row)
110 |             )
111 |         )
112 |     return "\n".join("| {line} |".format(line=line) for line in lines)
113 | 
114 | 
115 | def make_transforms_targets_links(transforms_info):
116 |     return "\n".join(
117 |         "- " + info["docs_link"] for transform, info in sorted(transforms_info.items(), key=lambda kv: kv[0])
118 |     )
119 | 
120 | 
121 | def check_docs(filepath, image_only_transforms_links, dual_transforms_table):
122 |     with open(filepath, "r", encoding="utf8") as f:
123 |         text = f.read()
124 |     outdated_docs = set()
125 |     image_only_lines_not_in_text = []
126 |     dual_lines_not_in_text = []
127 |     for line in image_only_transforms_links.split("\n"):
128 |         if line not in text:
129 |             outdated_docs.update(["Pixel-level"])
130 |             image_only_lines_not_in_text.append(line)
131 |     for line in dual_transforms_table.split("\n"):
132 |         if line not in text:
133 |             dual_lines_not_in_text.append(line)
134 |             outdated_docs.update(["Spatial-level"])
135 |     if outdated_docs:
136 |         raise ValueError(
137 |             "Docs for the following transform types are outdated: {outdated_docs_headers}. "
138 |             "Generate new docs by executing the `python tools/{py_file} make` command "
139 |             "and paste them to {filename}.\n"
140 |             "# Pixel-level transforms lines not in file:\n"
141 |             "{image_only_lines}\n"
142 |             "# Spatial-level transforms lines not in file:\n"
143 |             "{dual_lines}".format(
144 |                 outdated_docs_headers=", ".join(outdated_docs),
145 |                 py_file=os.path.basename(os.path.realpath(__file__)),
146 |                 filename=os.path.basename(filepath),
147 |                 image_only_lines="\n".join(image_only_lines_not_in_text),
148 |                 dual_lines="\n".join(dual_lines_not_in_text),
149 |             )
150 |         )
151 | 
152 |     if image_only_transforms_links not in text:
153 |         raise ValueError("Image only transforms links are outdated.")
154 |     if dual_transforms_table not in text:
155 |         raise ValueError("Dual transforms table are outdated.")
156 | 
157 | 
158 | def main():
159 |     args = parse_args()
160 |     command = args.command
161 |     if command not in {"make", "check"}:
162 |         raise ValueError(
163 |             "You should provide a valid command: {{make|check}}. Got {command} instead.".format(command=command)
164 |         )
165 |     transforms_info = get_transforms_info()
166 |     image_only_transforms = {transform: info for transform, info in transforms_info.items() if info["image_only"]}
167 |     dual_transforms = {transform: info for transform, info in transforms_info.items() if not info["image_only"]}
168 |     image_only_transforms_links = make_transforms_targets_links(image_only_transforms)
169 |     dual_transforms_table = make_transforms_targets_table(
170 |         dual_transforms, header=["Transform"] + [target.value for target in Targets]
171 |     )
172 |     if command == "make":
173 |         print(image_only_transforms_links)
174 |         print(dual_transforms_table)
175 |     else:
176 |         check_docs(args.filepath, image_only_transforms_links, dual_transforms_table)
177 | 
178 | 
179 | if __name__ == "__main__":
180 |     main()
181 | 


--------------------------------------------------------------------------------
/albumentations/augmentations/geometric/rotate.py:
--------------------------------------------------------------------------------
  1 | import random
  2 | 
  3 | import cv2
  4 | import numpy as np
  5 | 
  6 | from ...core.transforms_interface import DualTransform, to_tuple
  7 | from . import functional as F
  8 | 
  9 | __all__ = ["Rotate", "RandomRotate90", "SafeRotate"]
 10 | 
 11 | 
 12 | class RandomRotate90(DualTransform):
 13 |     """Randomly rotate the input by 90 degrees zero or more times.
 14 | 
 15 |     Args:
 16 |         p (float): probability of applying the transform. Default: 0.5.
 17 | 
 18 |     Targets:
 19 |         image, mask, bboxes, keypoints
 20 | 
 21 |     Image types:
 22 |         uint8, float32
 23 |     """
 24 | 
 25 |     def apply(self, img, factor=0, **params):
 26 |         """
 27 |         Args:
 28 |             factor (int): number of times the input will be rotated by 90 degrees.
 29 |         """
 30 |         return np.ascontiguousarray(np.rot90(img, factor))
 31 | 
 32 |     def get_params(self):
 33 |         # Random int in the range [0, 3]
 34 |         return {"factor": random.randint(0, 3)}
 35 | 
 36 |     def apply_to_bbox(self, bbox, factor=0, **params):
 37 |         return F.bbox_rot90(bbox, factor, **params)
 38 | 
 39 |     def apply_to_keypoint(self, keypoint, factor=0, **params):
 40 |         return F.keypoint_rot90(keypoint, factor, **params)
 41 | 
 42 |     def get_transform_init_args_names(self):
 43 |         return ()
 44 | 
 45 | 
 46 | class Rotate(DualTransform):
 47 |     """Rotate the input by an angle selected randomly from the uniform distribution.
 48 | 
 49 |     Args:
 50 |         limit ((int, int) or int): range from which a random angle is picked. If limit is a single int
 51 |             an angle is picked from (-limit, limit). Default: (-90, 90)
 52 |         interpolation (OpenCV flag): flag that is used to specify the interpolation algorithm. Should be one of:
 53 |             cv2.INTER_NEAREST, cv2.INTER_LINEAR, cv2.INTER_CUBIC, cv2.INTER_AREA, cv2.INTER_LANCZOS4.
 54 |             Default: cv2.INTER_LINEAR.
 55 |         border_mode (OpenCV flag): flag that is used to specify the pixel extrapolation method. Should be one of:
 56 |             cv2.BORDER_CONSTANT, cv2.BORDER_REPLICATE, cv2.BORDER_REFLECT, cv2.BORDER_WRAP, cv2.BORDER_REFLECT_101.
 57 |             Default: cv2.BORDER_REFLECT_101
 58 |         value (int, float, list of ints, list of float): padding value if border_mode is cv2.BORDER_CONSTANT.
 59 |         mask_value (int, float,
 60 |                     list of ints,
 61 |                     list of float): padding value if border_mode is cv2.BORDER_CONSTANT applied for masks.
 62 |         p (float): probability of applying the transform. Default: 0.5.
 63 | 
 64 |     Targets:
 65 |         image, mask, bboxes, keypoints
 66 | 
 67 |     Image types:
 68 |         uint8, float32
 69 |     """
 70 | 
 71 |     def __init__(
 72 |         self,
 73 |         limit=90,
 74 |         interpolation=cv2.INTER_LINEAR,
 75 |         border_mode=cv2.BORDER_REFLECT_101,
 76 |         value=None,
 77 |         mask_value=None,
 78 |         always_apply=False,
 79 |         p=0.5,
 80 |     ):
 81 |         super(Rotate, self).__init__(always_apply, p)
 82 |         self.limit = to_tuple(limit)
 83 |         self.interpolation = interpolation
 84 |         self.border_mode = border_mode
 85 |         self.value = value
 86 |         self.mask_value = mask_value
 87 | 
 88 |     def apply(self, img, angle=0, interpolation=cv2.INTER_LINEAR, **params):
 89 |         return F.rotate(img, angle, interpolation, self.border_mode, self.value)
 90 | 
 91 |     def apply_to_mask(self, img, angle=0, **params):
 92 |         return F.rotate(img, angle, cv2.INTER_NEAREST, self.border_mode, self.mask_value)
 93 | 
 94 |     def get_params(self):
 95 |         return {"angle": random.uniform(self.limit[0], self.limit[1])}
 96 | 
 97 |     def apply_to_bbox(self, bbox, angle=0, **params):
 98 |         return F.bbox_rotate(bbox, angle, params["rows"], params["cols"])
 99 | 
100 |     def apply_to_keypoint(self, keypoint, angle=0, **params):
101 |         return F.keypoint_rotate(keypoint, angle, **params)
102 | 
103 |     def get_transform_init_args_names(self):
104 |         return ("limit", "interpolation", "border_mode", "value", "mask_value")
105 | 
106 | 
107 | class SafeRotate(DualTransform):
108 |     """Rotate the input inside the input's frame by an angle selected randomly from the uniform distribution.
109 | 
110 |     The resulting image may have artifacts in it. After rotation, the image may have a different aspect ratio, and
111 |     after resizing, it returns to its original shape with the original aspect ratio of the image. For these reason we
112 |     may see some artifacts.
113 | 
114 |     Args:
115 |         limit ((int, int) or int): range from which a random angle is picked. If limit is a single int
116 |             an angle is picked from (-limit, limit). Default: (-90, 90)
117 |         interpolation (OpenCV flag): flag that is used to specify the interpolation algorithm. Should be one of:
118 |             cv2.INTER_NEAREST, cv2.INTER_LINEAR, cv2.INTER_CUBIC, cv2.INTER_AREA, cv2.INTER_LANCZOS4.
119 |             Default: cv2.INTER_LINEAR.
120 |         border_mode (OpenCV flag): flag that is used to specify the pixel extrapolation method. Should be one of:
121 |             cv2.BORDER_CONSTANT, cv2.BORDER_REPLICATE, cv2.BORDER_REFLECT, cv2.BORDER_WRAP, cv2.BORDER_REFLECT_101.
122 |             Default: cv2.BORDER_REFLECT_101
123 |         value (int, float, list of ints, list of float): padding value if border_mode is cv2.BORDER_CONSTANT.
124 |         mask_value (int, float,
125 |                     list of ints,
126 |                     list of float): padding value if border_mode is cv2.BORDER_CONSTANT applied for masks.
127 |         p (float): probability of applying the transform. Default: 0.5.
128 | 
129 |     Targets:
130 |         image, mask, bboxes, keypoints
131 | 
132 |     Image types:
133 |         uint8, float32
134 |     """
135 | 
136 |     def __init__(
137 |         self,
138 |         limit=90,
139 |         interpolation=cv2.INTER_LINEAR,
140 |         border_mode=cv2.BORDER_REFLECT_101,
141 |         value=None,
142 |         mask_value=None,
143 |         always_apply=False,
144 |         p=0.5,
145 |     ):
146 |         super(SafeRotate, self).__init__(always_apply, p)
147 |         self.limit = to_tuple(limit)
148 |         self.interpolation = interpolation
149 |         self.border_mode = border_mode
150 |         self.value = value
151 |         self.mask_value = mask_value
152 | 
153 |     def apply(self, img, angle=0, interpolation=cv2.INTER_LINEAR, **params):
154 |         return F.safe_rotate(
155 |             img=img, value=self.value, angle=angle, interpolation=interpolation, border_mode=self.border_mode
156 |         )
157 | 
158 |     def apply_to_mask(self, img, angle=0, **params):
159 |         return F.safe_rotate(
160 |             img=img, value=self.mask_value, angle=angle, interpolation=cv2.INTER_NEAREST, border_mode=self.border_mode
161 |         )
162 | 
163 |     def get_params(self):
164 |         return {"angle": random.uniform(self.limit[0], self.limit[1])}
165 | 
166 |     def apply_to_bbox(self, bbox, angle=0, **params):
167 |         return F.bbox_safe_rotate(bbox=bbox, angle=angle, rows=params["rows"], cols=params["cols"])
168 | 
169 |     def apply_to_keypoint(self, keypoint, angle=0, **params):
170 |         return F.keypoint_safe_rotate(keypoint, angle=angle, rows=params["rows"], cols=params["cols"])
171 | 
172 |     def get_transform_init_args_names(self):
173 |         return ("limit", "interpolation", "border_mode", "value", "mask_value")
174 | 


--------------------------------------------------------------------------------
/tests/test_pytorch.py:
--------------------------------------------------------------------------------
  1 | import pytest
  2 | 
  3 | import numpy as np
  4 | import torch
  5 | from PIL import Image
  6 | from torchvision.transforms import ColorJitter
  7 | 
  8 | import albumentations as A
  9 | from albumentations.pytorch.transforms import ToTensor, ToTensorV2
 10 | 
 11 | 
 12 | def test_torch_to_tensor_v2_augmentations(image, mask):
 13 |     aug = ToTensorV2()
 14 |     data = aug(image=image, mask=mask, force_apply=True)
 15 |     height, width, num_channels = image.shape
 16 |     assert isinstance(data["image"], torch.Tensor) and data["image"].shape == (num_channels, height, width)
 17 |     assert isinstance(data["mask"], torch.Tensor) and data["mask"].shape == mask.shape
 18 |     assert data["image"].dtype == torch.uint8
 19 |     assert data["mask"].dtype == torch.uint8
 20 | 
 21 | 
 22 | def test_torch_to_tensor_v2_augmentations_with_transpose_2d_mask(image, mask):
 23 |     aug = ToTensorV2(transpose_mask=True)
 24 |     data = aug(image=image, mask=mask, force_apply=True)
 25 |     image_height, image_width, image_num_channels = image.shape
 26 |     mask_height, mask_width = mask.shape
 27 |     assert isinstance(data["image"], torch.Tensor) and data["image"].shape == (
 28 |         image_num_channels,
 29 |         image_height,
 30 |         image_width,
 31 |     )
 32 |     assert isinstance(data["mask"], torch.Tensor) and data["mask"].shape == (mask_height, mask_width)
 33 |     assert data["image"].dtype == torch.uint8
 34 |     assert data["mask"].dtype == torch.uint8
 35 | 
 36 | 
 37 | def test_torch_to_tensor_v2_augmentations_with_transpose_3d_mask(image):
 38 |     aug = ToTensorV2(transpose_mask=True)
 39 |     mask = np.random.randint(low=0, high=256, size=(100, 100, 4), dtype=np.uint8)
 40 |     data = aug(image=image, mask=mask, force_apply=True)
 41 |     image_height, image_width, image_num_channels = image.shape
 42 |     mask_height, mask_width, mask_num_channels = mask.shape
 43 |     assert isinstance(data["image"], torch.Tensor) and data["image"].shape == (
 44 |         image_num_channels,
 45 |         image_height,
 46 |         image_width,
 47 |     )
 48 |     assert isinstance(data["mask"], torch.Tensor) and data["mask"].shape == (
 49 |         mask_num_channels,
 50 |         mask_height,
 51 |         mask_width,
 52 |     )
 53 |     assert data["image"].dtype == torch.uint8
 54 |     assert data["mask"].dtype == torch.uint8
 55 | 
 56 | 
 57 | def test_additional_targets_for_totensorv2():
 58 |     aug = A.Compose([ToTensorV2()], additional_targets={"image2": "image", "mask2": "mask"})
 59 |     for _i in range(10):
 60 |         image1 = np.random.randint(low=0, high=256, size=(100, 100, 3), dtype=np.uint8)
 61 |         image2 = image1.copy()
 62 |         mask1 = np.random.randint(low=0, high=256, size=(100, 100, 4), dtype=np.uint8)
 63 |         mask2 = mask1.copy()
 64 |         res = aug(image=image1, image2=image2, mask=mask1, mask2=mask2)
 65 | 
 66 |         image1_height, image1_width, image1_num_channels = image1.shape
 67 |         image2_height, image2_width, image2_num_channels = image2.shape
 68 |         assert isinstance(res["image"], torch.Tensor) and res["image"].shape == (
 69 |             image1_num_channels,
 70 |             image1_height,
 71 |             image1_width,
 72 |         )
 73 |         assert isinstance(res["image2"], torch.Tensor) and res["image2"].shape == (
 74 |             image2_num_channels,
 75 |             image2_height,
 76 |             image2_width,
 77 |         )
 78 |         assert isinstance(res["mask"], torch.Tensor) and res["mask"].shape == mask1.shape
 79 |         assert isinstance(res["mask2"], torch.Tensor) and res["mask2"].shape == mask2.shape
 80 |         assert np.array_equal(res["image"], res["image2"])
 81 |         assert np.array_equal(res["mask"], res["mask2"])
 82 | 
 83 | 
 84 | def test_torch_to_tensor_v2_on_gray_scale_images():
 85 |     aug = ToTensorV2()
 86 |     grayscale_image = np.random.randint(low=0, high=256, size=(100, 100), dtype=np.uint8)
 87 |     data = aug(image=grayscale_image)
 88 |     assert isinstance(data["image"], torch.Tensor)
 89 |     assert len(data["image"].shape) == 3
 90 |     assert data["image"].shape[1:] == grayscale_image.shape
 91 |     assert data["image"].dtype == torch.uint8
 92 | 
 93 | 
 94 | def test_torch_to_tensor_raises_runtime_error():
 95 |     with pytest.raises(RuntimeError) as exc_info:
 96 |         aug = ToTensor()  # noqa F841
 97 |     message = (
 98 |         "`ToTensor` is obsolete and it was removed from Albumentations. Please use `ToTensorV2` instead - "
 99 |         "https://albumentations.ai/docs/api_reference/pytorch/transforms/"
100 |         "#albumentations.pytorch.transforms.ToTensorV2. "
101 |         "\n\nIf you need `ToTensor` downgrade Albumentations to version 0.5.2."
102 |     )
103 |     assert str(exc_info.value) == message
104 | 
105 | 
106 | def test_with_replaycompose():
107 |     aug = A.ReplayCompose([ToTensorV2()])
108 |     kwargs = {
109 |         "image": np.random.randint(low=0, high=256, size=(100, 100, 3), dtype=np.uint8),
110 |         "mask": np.random.randint(low=0, high=256, size=(100, 100, 3), dtype=np.uint8),
111 |     }
112 |     res = aug(**kwargs)
113 |     res2 = A.ReplayCompose.replay(res["replay"], **kwargs)
114 |     assert np.array_equal(res["image"], res2["image"])
115 |     assert np.array_equal(res["mask"], res2["mask"])
116 |     assert res["image"].dtype == torch.uint8
117 |     assert res["mask"].dtype == torch.uint8
118 |     assert res2["image"].dtype == torch.uint8
119 |     assert res2["mask"].dtype == torch.uint8
120 | 
121 | 
122 | @pytest.mark.parametrize(
123 |     ["brightness", "contrast", "saturation", "hue"],
124 |     [
125 |         [1, 1, 1, 0],
126 |         [0.123, 1, 1, 0],
127 |         [1.321, 1, 1, 0],
128 |         [1, 0.234, 1, 0],
129 |         [1, 1.432, 1, 0],
130 |         [1, 1, 0.345, 0],
131 |         [1, 1, 1.543, 0],
132 |     ],
133 | )
134 | def test_color_jitter(brightness, contrast, saturation, hue):
135 |     np.random.seed(0)
136 |     img = np.random.randint(0, 256, [100, 100, 3], dtype=np.uint8)
137 |     pil_image = Image.fromarray(img)
138 | 
139 |     transform = A.Compose(
140 |         [
141 |             A.ColorJitter(
142 |                 brightness=[brightness, brightness],
143 |                 contrast=[contrast, contrast],
144 |                 saturation=[saturation, saturation],
145 |                 hue=[hue, hue],
146 |                 p=1,
147 |             )
148 |         ]
149 |     )
150 | 
151 |     pil_transform = ColorJitter(
152 |         brightness=[brightness, brightness],
153 |         contrast=[contrast, contrast],
154 |         saturation=[saturation, saturation],
155 |         hue=[hue, hue],
156 |     )
157 | 
158 |     res1 = transform(image=img)["image"]
159 |     res2 = np.array(pil_transform(pil_image))
160 | 
161 |     _max = np.abs(res1.astype(np.int16) - res2.astype(np.int16)).max()
162 |     assert _max <= 2, "Max: {}".format(_max)
163 | 
164 | 
165 | def test_post_data_check():
166 |     img = np.empty([100, 100, 3], dtype=np.uint8)
167 |     bboxes = [
168 |         [0, 0, 90, 90, 0],
169 |     ]
170 |     keypoints = [
171 |         [90, 90],
172 |         [50, 50],
173 |     ]
174 | 
175 |     transform = A.Compose(
176 |         [
177 |             A.Resize(50, 50),
178 |             A.Normalize(),
179 |             ToTensorV2(),
180 |         ],
181 |         keypoint_params=A.KeypointParams("xy"),
182 |         bbox_params=A.BboxParams("pascal_voc"),
183 |     )
184 | 
185 |     res = transform(image=img, keypoints=keypoints, bboxes=bboxes)
186 |     assert len(res["keypoints"]) != 0 and len(res["bboxes"]) != 0
187 |     assert res["keypoints"] == [(45, 45), (25, 25)]
188 |     assert res["bboxes"] == [(0, 0, 45, 45, 0)]
189 | 


--------------------------------------------------------------------------------
/albumentations/augmentations/keypoints_utils.py:
--------------------------------------------------------------------------------
  1 | from __future__ import division
  2 | 
  3 | import math
  4 | import warnings
  5 | 
  6 | from albumentations.core.utils import DataProcessor
  7 | 
  8 | __all__ = [
  9 |     "angle_to_2pi_range",
 10 |     "check_keypoints",
 11 |     "convert_keypoints_from_albumentations",
 12 |     "convert_keypoints_to_albumentations",
 13 |     "filter_keypoints",
 14 |     "KeypointsProcessor",
 15 | ]
 16 | 
 17 | keypoint_formats = {"xy", "yx", "xya", "xys", "xyas", "xysa"}
 18 | 
 19 | 
 20 | def angle_to_2pi_range(angle):
 21 |     two_pi = 2 * math.pi
 22 |     return angle % two_pi
 23 | 
 24 | 
 25 | class KeypointsProcessor(DataProcessor):
 26 |     @property
 27 |     def default_data_name(self):
 28 |         return "keypoints"
 29 | 
 30 |     def ensure_data_valid(self, data):
 31 |         if self.params.label_fields:
 32 |             if not all(i in data.keys() for i in self.params.label_fields):
 33 |                 raise ValueError(
 34 |                     "Your 'label_fields' are not valid - them must have same names as params in "
 35 |                     "'keypoint_params' dict"
 36 |                 )
 37 | 
 38 |     def ensure_transforms_valid(self, transforms):
 39 |         # IAA-based augmentations supports only transformation of xy keypoints.
 40 |         # If your keypoints formats is other than 'xy' we emit warning to let user
 41 |         # be aware that angle and size will not be modified.
 42 | 
 43 |         try:
 44 |             from albumentations.imgaug.transforms import DualIAATransform
 45 |         except ImportError:
 46 |             # imgaug is not installed so we skip imgaug checks.
 47 |             return
 48 | 
 49 |         if self.params.format is not None and self.params.format != "xy":
 50 |             for transform in transforms:
 51 |                 if isinstance(transform, DualIAATransform):
 52 |                     warnings.warn(
 53 |                         "{} transformation supports only 'xy' keypoints "
 54 |                         "augmentation. You have '{}' keypoints format. Scale "
 55 |                         "and angle WILL NOT BE transformed.".format(transform.__class__.__name__, self.params.format)
 56 |                     )
 57 |                     break
 58 | 
 59 |     def filter(self, data, rows, cols):
 60 |         return filter_keypoints(data, rows, cols, remove_invisible=self.params.remove_invisible)
 61 | 
 62 |     def check(self, data, rows, cols):
 63 |         return check_keypoints(data, rows, cols)
 64 | 
 65 |     def convert_from_albumentations(self, data, rows, cols):
 66 |         return convert_keypoints_from_albumentations(
 67 |             data,
 68 |             self.params.format,
 69 |             rows,
 70 |             cols,
 71 |             check_validity=self.params.remove_invisible,
 72 |             angle_in_degrees=self.params.angle_in_degrees,
 73 |         )
 74 | 
 75 |     def convert_to_albumentations(self, data, rows, cols):
 76 |         return convert_keypoints_to_albumentations(
 77 |             data,
 78 |             self.params.format,
 79 |             rows,
 80 |             cols,
 81 |             check_validity=self.params.remove_invisible,
 82 |             angle_in_degrees=self.params.angle_in_degrees,
 83 |         )
 84 | 
 85 | 
 86 | def check_keypoint(kp, rows, cols):
 87 |     """Check if keypoint coordinates are less than image shapes"""
 88 |     for name, value, size in zip(["x", "y"], kp[:2], [cols, rows]):
 89 |         if not 0 <= value < size:
 90 |             raise ValueError(
 91 |                 "Expected {name} for keypoint {kp} "
 92 |                 "to be in the range [0.0, {size}], got {value}.".format(kp=kp, name=name, value=value, size=size)
 93 |             )
 94 | 
 95 |     angle = kp[2]
 96 |     if not (0 <= angle < 2 * math.pi):
 97 |         raise ValueError("Keypoint angle must be in range [0, 2 * PI). Got: {angle}".format(angle=angle))
 98 | 
 99 | 
100 | def check_keypoints(keypoints, rows, cols):
101 |     """Check if keypoints boundaries are less than image shapes"""
102 |     for kp in keypoints:
103 |         check_keypoint(kp, rows, cols)
104 | 
105 | 
106 | def filter_keypoints(keypoints, rows, cols, remove_invisible):
107 |     if not remove_invisible:
108 |         return keypoints
109 | 
110 |     resulting_keypoints = []
111 |     for kp in keypoints:
112 |         x, y = kp[:2]
113 |         if x < 0 or x >= cols:
114 |             continue
115 |         if y < 0 or y >= rows:
116 |             continue
117 |         resulting_keypoints.append(kp)
118 |     return resulting_keypoints
119 | 
120 | 
121 | def keypoint_has_extra_data(kp, format):
122 |     return len(kp) > len(format)
123 | 
124 | 
125 | def convert_keypoint_to_albumentations(
126 |     keypoint, source_format, rows, cols, check_validity=False, angle_in_degrees=True
127 | ):
128 |     if source_format not in keypoint_formats:
129 |         raise ValueError("Unknown target_format {}. Supported formats are: {}".format(source_format, keypoint_formats))
130 | 
131 |     if source_format == "xy":
132 |         (x, y), tail = keypoint[:2], tuple(keypoint[2:])
133 |         a, s = 0, 0
134 |     elif source_format == "yx":
135 |         (y, x), tail = keypoint[:2], tuple(keypoint[2:])
136 |         a, s = 0, 0
137 |     elif source_format == "xya":
138 |         (x, y, a), tail = keypoint[:3], tuple(keypoint[3:])
139 |         s = 0
140 |     elif source_format == "xys":
141 |         (x, y, s), tail = keypoint[:3], tuple(keypoint[3:])
142 |         a = 0
143 |     elif source_format == "xyas":
144 |         (x, y, a, s), tail = keypoint[:4], tuple(keypoint[4:])
145 |     elif source_format == "xysa":
146 |         (x, y, s, a), tail = keypoint[:4], tuple(keypoint[4:])
147 | 
148 |     if angle_in_degrees:
149 |         a = math.radians(a)
150 | 
151 |     keypoint = (x, y, angle_to_2pi_range(a), s) + tail
152 |     if check_validity:
153 |         check_keypoint(keypoint, rows, cols)
154 |     return keypoint
155 | 
156 | 
157 | def convert_keypoint_from_albumentations(
158 |     keypoint, target_format, rows, cols, check_validity=False, angle_in_degrees=True
159 | ):
160 |     # type (tuple, str, int, int, bool, bool) -> tuple
161 |     if target_format not in keypoint_formats:
162 |         raise ValueError("Unknown target_format {}. Supported formats are: {}".format(target_format, keypoint_formats))
163 |     if check_validity:
164 |         check_keypoint(keypoint, rows, cols)
165 | 
166 |     (x, y, angle, scale), tail = keypoint[:4], tuple(keypoint[4:])
167 |     angle = angle_to_2pi_range(angle)
168 |     if angle_in_degrees:
169 |         angle = math.degrees(angle)
170 | 
171 |     if target_format == "xy":
172 |         kp = (x, y)
173 |     elif target_format == "yx":
174 |         kp = (y, x)
175 |     elif target_format == "xya":
176 |         kp = (x, y, angle)
177 |     elif target_format == "xys":
178 |         kp = (x, y, scale)
179 |     elif target_format == "xyas":
180 |         kp = (x, y, angle, scale)
181 |     elif target_format == "xysa":
182 |         kp = (x, y, scale, angle)
183 | 
184 |     return kp + tail
185 | 
186 | 
187 | def convert_keypoints_to_albumentations(
188 |     keypoints, source_format, rows, cols, check_validity=False, angle_in_degrees=True
189 | ):
190 |     return [
191 |         convert_keypoint_to_albumentations(kp, source_format, rows, cols, check_validity, angle_in_degrees)
192 |         for kp in keypoints
193 |     ]
194 | 
195 | 
196 | def convert_keypoints_from_albumentations(
197 |     keypoints, target_format, rows, cols, check_validity=False, angle_in_degrees=True
198 | ):
199 |     return [
200 |         convert_keypoint_from_albumentations(kp, target_format, rows, cols, check_validity, angle_in_degrees)
201 |         for kp in keypoints
202 |     ]
203 | 


--------------------------------------------------------------------------------
/tests/files/transform_v0.4.6_without_totensor.json:
--------------------------------------------------------------------------------
1 | {"__version__": "0.4.6", "transform": {"__class_fullname__": "albumentations.core.composition.Compose", "p": 1.0, "transforms": [{"__class_fullname__": "albumentations.augmentations.transforms.Blur", "always_apply": false, "p": 0.5, "blur_limit": [3, 7]}, {"__class_fullname__": "albumentations.augmentations.transforms.CLAHE", "always_apply": false, "p": 0.5, "clip_limit": [1, 4.0], "tile_grid_size": [8, 8]}, {"__class_fullname__": "albumentations.augmentations.transforms.ChannelDropout", "always_apply": false, "p": 0.5, "channel_drop_range": [1, 1], "fill_value": 0}, {"__class_fullname__": "albumentations.augmentations.transforms.ChannelShuffle", "always_apply": false, "p": 0.5}, {"__class_fullname__": "albumentations.augmentations.transforms.CoarseDropout", "always_apply": false, "p": 0.5, "max_holes": 8, "max_height": 8, "max_width": 8, "min_holes": 8, "min_height": 8, "min_width": 8}, {"__class_fullname__": "albumentations.augmentations.transforms.Downscale", "always_apply": false, "p": 0.5, "scale_min": 0.25, "scale_max": 0.25, "interpolation": 0}, {"__class_fullname__": "albumentations.augmentations.transforms.ElasticTransform", "always_apply": false, "p": 0.5, "alpha": 1, "sigma": 50, "alpha_affine": 50, "interpolation": 1, "border_mode": 4, "value": null, "mask_value": null, "approximate": false}, {"__class_fullname__": "albumentations.augmentations.transforms.Equalize", "always_apply": false, "p": 0.5, "mode": "cv", "by_channels": true}, {"__class_fullname__": "albumentations.augmentations.transforms.FancyPCA", "always_apply": false, "p": 0.5, "alpha": 0.1}, {"__class_fullname__": "albumentations.augmentations.transforms.Flip", "always_apply": false, "p": 0.5}, {"__class_fullname__": "albumentations.augmentations.transforms.GaussNoise", "always_apply": false, "p": 0.5, "var_limit": [10.0, 50.0]}, {"__class_fullname__": "albumentations.augmentations.transforms.GaussianBlur", "always_apply": false, "p": 0.5, "blur_limit": [3, 7]}, {"__class_fullname__": "albumentations.augmentations.transforms.GlassBlur", "always_apply": false, "p": 0.5, "sigma": 0.7, "max_delta": 4, "iterations": 2}, {"__class_fullname__": "albumentations.augmentations.transforms.GridDistortion", "always_apply": false, "p": 0.5, "num_steps": 5, "distort_limit": [-0.3, 0.3], "interpolation": 1, "border_mode": 4, "value": null, "mask_value": null}, {"__class_fullname__": "albumentations.augmentations.transforms.HorizontalFlip", "always_apply": false, "p": 0.5}, {"__class_fullname__": "albumentations.augmentations.transforms.HueSaturationValue", "always_apply": false, "p": 0.5, "hue_shift_limit": [-20, 20], "sat_shift_limit": [-30, 30], "val_shift_limit": [-20, 20]}, {"__class_fullname__": "albumentations.augmentations.transforms.ISONoise", "always_apply": false, "p": 0.5, "intensity": [0.1, 0.5], "color_shift": [0.01, 0.05]}, {"__class_fullname__": "albumentations.augmentations.transforms.ImageCompression", "always_apply": false, "p": 0.5, "quality_lower": 99, "quality_upper": 100, "compression_type": 0}, {"__class_fullname__": "albumentations.augmentations.transforms.InvertImg", "always_apply": false, "p": 0.5}, {"__class_fullname__": "albumentations.augmentations.transforms.LongestMaxSize", "always_apply": false, "p": 1, "max_size": 1024, "interpolation": 1}, {"__class_fullname__": "albumentations.augmentations.transforms.MedianBlur", "always_apply": false, "p": 0.5, "blur_limit": [3, 7]}, {"__class_fullname__": "albumentations.augmentations.transforms.MotionBlur", "always_apply": false, "p": 0.5, "blur_limit": [3, 7]}, {"__class_fullname__": "albumentations.augmentations.transforms.MultiplicativeNoise", "always_apply": false, "p": 0.5, "multiplier": [0.9, 1.1], "per_channel": false, "elementwise": false}, {"__class_fullname__": "albumentations.core.transforms_interface.NoOp", "always_apply": false, "p": 0.5}, {"__class_fullname__": "albumentations.augmentations.transforms.OpticalDistortion", "always_apply": false, "p": 0.5, "distort_limit": [-0.05, 0.05], "shift_limit": [-0.05, 0.05], "interpolation": 1, "border_mode": 4, "value": null, "mask_value": null}, {"__class_fullname__": "albumentations.augmentations.transforms.PadIfNeeded", "always_apply": false, "p": 1.0, "min_height": 1024, "min_width": 1024, "border_mode": 4, "value": null, "mask_value": null}, {"__class_fullname__": "albumentations.augmentations.transforms.Posterize", "always_apply": false, "p": 0.5, "num_bits": [4, 4]}, {"__class_fullname__": "albumentations.augmentations.transforms.RGBShift", "always_apply": false, "p": 0.5, "r_shift_limit": [-20, 20], "g_shift_limit": [-20, 20], "b_shift_limit": [-20, 20]}, {"__class_fullname__": "albumentations.augmentations.transforms.RandomBrightnessContrast", "always_apply": false, "p": 0.5, "brightness_limit": [-0.2, 0.2], "contrast_limit": [-0.2, 0.2], "brightness_by_max": true}, {"__class_fullname__": "albumentations.augmentations.transforms.RandomFog", "always_apply": false, "p": 0.5, "fog_coef_lower": 0.3, "fog_coef_upper": 1, "alpha_coef": 0.08}, {"__class_fullname__": "albumentations.augmentations.transforms.RandomGamma", "always_apply": false, "p": 0.5, "gamma_limit": [80, 120], "eps": null}, {"__class_fullname__": "albumentations.augmentations.transforms.RandomGridShuffle", "always_apply": false, "p": 0.5, "grid": [3, 3]}, {"__class_fullname__": "albumentations.augmentations.transforms.RandomRain", "always_apply": false, "p": 0.5, "slant_lower": -10, "slant_upper": 10, "drop_length": 20, "drop_width": 1, "drop_color": [200, 200, 200], "blur_value": 7, "brightness_coefficient": 0.7, "rain_type": null}, {"__class_fullname__": "albumentations.augmentations.transforms.RandomRotate90", "always_apply": false, "p": 0.5}, {"__class_fullname__": "albumentations.augmentations.transforms.RandomScale", "always_apply": false, "p": 0.5, "interpolation": 1, "scale_limit": [-0.09999999999999998, 0.10000000000000009]}, {"__class_fullname__": "albumentations.augmentations.transforms.RandomShadow", "always_apply": false, "p": 0.5, "shadow_roi": [0, 0.5, 1, 1], "num_shadows_lower": 1, "num_shadows_upper": 2, "shadow_dimension": 5}, {"__class_fullname__": "albumentations.augmentations.transforms.RandomSnow", "always_apply": false, "p": 0.5, "snow_point_lower": 0.1, "snow_point_upper": 0.3, "brightness_coeff": 2.5}, {"__class_fullname__": "albumentations.augmentations.transforms.RandomSunFlare", "always_apply": false, "p": 0.5, "flare_roi": [0, 0, 1, 0.5], "angle_lower": 0, "angle_upper": 1, "num_flare_circles_lower": 6, "num_flare_circles_upper": 10, "src_radius": 400, "src_color": [255, 255, 255]}, {"__class_fullname__": "albumentations.augmentations.transforms.Rotate", "always_apply": false, "p": 0.5, "limit": [-90, 90], "interpolation": 1, "border_mode": 4, "value": null, "mask_value": null}, {"__class_fullname__": "albumentations.augmentations.transforms.ShiftScaleRotate", "always_apply": false, "p": 0.5, "shift_limit": [-0.0625, 0.0625], "scale_limit": [-0.09999999999999998, 0.10000000000000009], "rotate_limit": [-45, 45], "interpolation": 1, "border_mode": 4, "value": null, "mask_value": null}, {"__class_fullname__": "albumentations.augmentations.transforms.SmallestMaxSize", "always_apply": false, "p": 1, "max_size": 1024, "interpolation": 1}, {"__class_fullname__": "albumentations.augmentations.transforms.Solarize", "always_apply": false, "p": 0.5, "threshold": [128, 128]}, {"__class_fullname__": "albumentations.augmentations.transforms.ToGray", "always_apply": false, "p": 0.5}, {"__class_fullname__": "albumentations.augmentations.transforms.ToSepia", "always_apply": false, "p": 0.5}, {"__class_fullname__": "albumentations.augmentations.transforms.Transpose", "always_apply": false, "p": 0.5}, {"__class_fullname__": "albumentations.augmentations.transforms.VerticalFlip", "always_apply": false, "p": 0.5}, {"__class_fullname__": "albumentations.augmentations.transforms.RandomCrop", "always_apply": false, "p": 1.0, "height": 32, "width": 32}, {"__class_fullname__": "albumentations.augmentations.transforms.Normalize", "always_apply": false, "p": 1.0, "mean": [0.485, 0.456, 0.406], "std": [0.229, 0.224, 0.225], "max_pixel_value": 255.0}], "bbox_params": null, "keypoint_params": null, "additional_targets": {}}}
2 | 


--------------------------------------------------------------------------------
/albumentations/augmentations/geometric/resize.py:
--------------------------------------------------------------------------------
  1 | import random
  2 | from typing import Dict, Sequence, Tuple, Union
  3 | 
  4 | import cv2
  5 | import numpy as np
  6 | 
  7 | from ...core.transforms_interface import DualTransform, to_tuple
  8 | from . import functional as F
  9 | 
 10 | __all__ = ["RandomScale", "LongestMaxSize", "SmallestMaxSize", "Resize"]
 11 | 
 12 | 
 13 | class RandomScale(DualTransform):
 14 |     """Randomly resize the input. Output image size is different from the input image size.
 15 | 
 16 |     Args:
 17 |         scale_limit ((float, float) or float): scaling factor range. If scale_limit is a single float value, the
 18 |             range will be (1 - scale_limit, 1 + scale_limit). Default: (0.9, 1.1).
 19 |         interpolation (OpenCV flag): flag that is used to specify the interpolation algorithm. Should be one of:
 20 |             cv2.INTER_NEAREST, cv2.INTER_LINEAR, cv2.INTER_CUBIC, cv2.INTER_AREA, cv2.INTER_LANCZOS4.
 21 |             Default: cv2.INTER_LINEAR.
 22 |         p (float): probability of applying the transform. Default: 0.5.
 23 | 
 24 |     Targets:
 25 |         image, mask, bboxes, keypoints
 26 | 
 27 |     Image types:
 28 |         uint8, float32
 29 |     """
 30 | 
 31 |     def __init__(self, scale_limit=0.1, interpolation=cv2.INTER_LINEAR, always_apply=False, p=0.5):
 32 |         super(RandomScale, self).__init__(always_apply, p)
 33 |         self.scale_limit = to_tuple(scale_limit, bias=1.0)
 34 |         self.interpolation = interpolation
 35 | 
 36 |     def get_params(self):
 37 |         return {"scale": random.uniform(self.scale_limit[0], self.scale_limit[1])}
 38 | 
 39 |     def apply(self, img, scale=0, interpolation=cv2.INTER_LINEAR, **params):
 40 |         return F.scale(img, scale, interpolation)
 41 | 
 42 |     def apply_to_bbox(self, bbox, **params):
 43 |         # Bounding box coordinates are scale invariant
 44 |         return bbox
 45 | 
 46 |     def apply_to_keypoint(self, keypoint, scale=0, **params):
 47 |         return F.keypoint_scale(keypoint, scale, scale)
 48 | 
 49 |     def get_transform_init_args(self):
 50 |         return {"interpolation": self.interpolation, "scale_limit": to_tuple(self.scale_limit, bias=-1.0)}
 51 | 
 52 | 
 53 | class LongestMaxSize(DualTransform):
 54 |     """Rescale an image so that maximum side is equal to max_size, keeping the aspect ratio of the initial image.
 55 | 
 56 |     Args:
 57 |         max_size (int, list of int): maximum size of the image after the transformation. When using a list, max size
 58 |             will be randomly selected from the values in the list.
 59 |         interpolation (OpenCV flag): interpolation method. Default: cv2.INTER_LINEAR.
 60 |         p (float): probability of applying the transform. Default: 1.
 61 | 
 62 |     Targets:
 63 |         image, mask, bboxes, keypoints
 64 | 
 65 |     Image types:
 66 |         uint8, float32
 67 |     """
 68 | 
 69 |     def __init__(
 70 |         self,
 71 |         max_size: Union[int, Sequence[int]] = 1024,
 72 |         interpolation: int = cv2.INTER_LINEAR,
 73 |         always_apply: bool = False,
 74 |         p: float = 1,
 75 |     ):
 76 |         super(LongestMaxSize, self).__init__(always_apply, p)
 77 |         self.interpolation = interpolation
 78 |         self.max_size = max_size
 79 | 
 80 |     def apply(
 81 |         self, img: np.ndarray, max_size: int = 1024, interpolation: int = cv2.INTER_LINEAR, **params
 82 |     ) -> np.ndarray:
 83 |         return F.longest_max_size(img, max_size=max_size, interpolation=interpolation)
 84 | 
 85 |     def apply_to_bbox(self, bbox: Sequence[float], **params) -> Sequence[float]:
 86 |         # Bounding box coordinates are scale invariant
 87 |         return bbox
 88 | 
 89 |     def apply_to_keypoint(self, keypoint: Sequence[float], max_size: int = 1024, **params) -> Sequence[float]:
 90 |         height = params["rows"]
 91 |         width = params["cols"]
 92 | 
 93 |         scale = max_size / max([height, width])
 94 |         return F.keypoint_scale(keypoint, scale, scale)
 95 | 
 96 |     def get_params(self) -> Dict[str, int]:
 97 |         return {"max_size": self.max_size if isinstance(self.max_size, int) else random.choice(self.max_size)}
 98 | 
 99 |     def get_transform_init_args_names(self) -> Tuple[str, ...]:
100 |         return ("max_size", "interpolation")
101 | 
102 | 
103 | class SmallestMaxSize(DualTransform):
104 |     """Rescale an image so that minimum side is equal to max_size, keeping the aspect ratio of the initial image.
105 | 
106 |     Args:
107 |         max_size (int, list of int): maximum size of smallest side of the image after the transformation. When using a
108 |             list, max size will be randomly selected from the values in the list.
109 |         interpolation (OpenCV flag): interpolation method. Default: cv2.INTER_LINEAR.
110 |         p (float): probability of applying the transform. Default: 1.
111 | 
112 |     Targets:
113 |         image, mask, bboxes, keypoints
114 | 
115 |     Image types:
116 |         uint8, float32
117 |     """
118 | 
119 |     def __init__(
120 |         self,
121 |         max_size: Union[int, Sequence[int]] = 1024,
122 |         interpolation: int = cv2.INTER_LINEAR,
123 |         always_apply: bool = False,
124 |         p: float = 1,
125 |     ):
126 |         super(SmallestMaxSize, self).__init__(always_apply, p)
127 |         self.interpolation = interpolation
128 |         self.max_size = max_size
129 | 
130 |     def apply(
131 |         self, img: np.ndarray, max_size: int = 1024, interpolation: int = cv2.INTER_LINEAR, **params
132 |     ) -> np.ndarray:
133 |         return F.smallest_max_size(img, max_size=max_size, interpolation=interpolation)
134 | 
135 |     def apply_to_bbox(self, bbox: Sequence[float], **params) -> Sequence[float]:
136 |         return bbox
137 | 
138 |     def apply_to_keypoint(self, keypoint: Sequence[float], max_size: int = 1024, **params) -> Sequence[float]:
139 |         height = params["rows"]
140 |         width = params["cols"]
141 | 
142 |         scale = max_size / min([height, width])
143 |         return F.keypoint_scale(keypoint, scale, scale)
144 | 
145 |     def get_params(self) -> Dict[str, int]:
146 |         return {"max_size": self.max_size if isinstance(self.max_size, int) else random.choice(self.max_size)}
147 | 
148 |     def get_transform_init_args_names(self) -> Tuple[str, ...]:
149 |         return ("max_size", "interpolation")
150 | 
151 | 
152 | class Resize(DualTransform):
153 |     """Resize the input to the given height and width.
154 | 
155 |     Args:
156 |         height (int): desired height of the output.
157 |         width (int): desired width of the output.
158 |         interpolation (OpenCV flag): flag that is used to specify the interpolation algorithm. Should be one of:
159 |             cv2.INTER_NEAREST, cv2.INTER_LINEAR, cv2.INTER_CUBIC, cv2.INTER_AREA, cv2.INTER_LANCZOS4.
160 |             Default: cv2.INTER_LINEAR.
161 |         p (float): probability of applying the transform. Default: 1.
162 | 
163 |     Targets:
164 |         image, mask, bboxes, keypoints
165 | 
166 |     Image types:
167 |         uint8, float32
168 |     """
169 | 
170 |     def __init__(self, height, width, interpolation=cv2.INTER_LINEAR, always_apply=False, p=1):
171 |         super(Resize, self).__init__(always_apply, p)
172 |         self.height = height
173 |         self.width = width
174 |         self.interpolation = interpolation
175 | 
176 |     def apply(self, img, interpolation=cv2.INTER_LINEAR, **params):
177 |         return F.resize(img, height=self.height, width=self.width, interpolation=interpolation)
178 | 
179 |     def apply_to_bbox(self, bbox, **params):
180 |         # Bounding box coordinates are scale invariant
181 |         return bbox
182 | 
183 |     def apply_to_keypoint(self, keypoint, **params):
184 |         height = params["rows"]
185 |         width = params["cols"]
186 |         scale_x = self.width / width
187 |         scale_y = self.height / height
188 |         return F.keypoint_scale(keypoint, scale_x, scale_y)
189 | 
190 |     def get_transform_init_args_names(self):
191 |         return ("height", "width", "interpolation")
192 | 


--------------------------------------------------------------------------------
/tests/files/transform_v0.4.6_with_totensor.json:
--------------------------------------------------------------------------------
1 | {"__version__": "0.4.6", "transform": {"__class_fullname__": "albumentations.core.composition.Compose", "p": 1.0, "transforms": [{"__class_fullname__": "albumentations.augmentations.transforms.Blur", "always_apply": false, "p": 0.5, "blur_limit": [3, 7]}, {"__class_fullname__": "albumentations.augmentations.transforms.CLAHE", "always_apply": false, "p": 0.5, "clip_limit": [1, 4.0], "tile_grid_size": [8, 8]}, {"__class_fullname__": "albumentations.augmentations.transforms.ChannelDropout", "always_apply": false, "p": 0.5, "channel_drop_range": [1, 1], "fill_value": 0}, {"__class_fullname__": "albumentations.augmentations.transforms.ChannelShuffle", "always_apply": false, "p": 0.5}, {"__class_fullname__": "albumentations.augmentations.transforms.CoarseDropout", "always_apply": false, "p": 0.5, "max_holes": 8, "max_height": 8, "max_width": 8, "min_holes": 8, "min_height": 8, "min_width": 8}, {"__class_fullname__": "albumentations.augmentations.transforms.Downscale", "always_apply": false, "p": 0.5, "scale_min": 0.25, "scale_max": 0.25, "interpolation": 0}, {"__class_fullname__": "albumentations.augmentations.transforms.ElasticTransform", "always_apply": false, "p": 0.5, "alpha": 1, "sigma": 50, "alpha_affine": 50, "interpolation": 1, "border_mode": 4, "value": null, "mask_value": null, "approximate": false}, {"__class_fullname__": "albumentations.augmentations.transforms.Equalize", "always_apply": false, "p": 0.5, "mode": "cv", "by_channels": true}, {"__class_fullname__": "albumentations.augmentations.transforms.FancyPCA", "always_apply": false, "p": 0.5, "alpha": 0.1}, {"__class_fullname__": "albumentations.augmentations.transforms.Flip", "always_apply": false, "p": 0.5}, {"__class_fullname__": "albumentations.augmentations.transforms.GaussNoise", "always_apply": false, "p": 0.5, "var_limit": [10.0, 50.0]}, {"__class_fullname__": "albumentations.augmentations.transforms.GaussianBlur", "always_apply": false, "p": 0.5, "blur_limit": [3, 7]}, {"__class_fullname__": "albumentations.augmentations.transforms.GlassBlur", "always_apply": false, "p": 0.5, "sigma": 0.7, "max_delta": 4, "iterations": 2}, {"__class_fullname__": "albumentations.augmentations.transforms.GridDistortion", "always_apply": false, "p": 0.5, "num_steps": 5, "distort_limit": [-0.3, 0.3], "interpolation": 1, "border_mode": 4, "value": null, "mask_value": null}, {"__class_fullname__": "albumentations.augmentations.transforms.HorizontalFlip", "always_apply": false, "p": 0.5}, {"__class_fullname__": "albumentations.augmentations.transforms.HueSaturationValue", "always_apply": false, "p": 0.5, "hue_shift_limit": [-20, 20], "sat_shift_limit": [-30, 30], "val_shift_limit": [-20, 20]}, {"__class_fullname__": "albumentations.augmentations.transforms.ISONoise", "always_apply": false, "p": 0.5, "intensity": [0.1, 0.5], "color_shift": [0.01, 0.05]}, {"__class_fullname__": "albumentations.augmentations.transforms.ImageCompression", "always_apply": false, "p": 0.5, "quality_lower": 99, "quality_upper": 100, "compression_type": 0}, {"__class_fullname__": "albumentations.augmentations.transforms.InvertImg", "always_apply": false, "p": 0.5}, {"__class_fullname__": "albumentations.augmentations.transforms.LongestMaxSize", "always_apply": false, "p": 1, "max_size": 1024, "interpolation": 1}, {"__class_fullname__": "albumentations.augmentations.transforms.MedianBlur", "always_apply": false, "p": 0.5, "blur_limit": [3, 7]}, {"__class_fullname__": "albumentations.augmentations.transforms.MotionBlur", "always_apply": false, "p": 0.5, "blur_limit": [3, 7]}, {"__class_fullname__": "albumentations.augmentations.transforms.MultiplicativeNoise", "always_apply": false, "p": 0.5, "multiplier": [0.9, 1.1], "per_channel": false, "elementwise": false}, {"__class_fullname__": "albumentations.core.transforms_interface.NoOp", "always_apply": false, "p": 0.5}, {"__class_fullname__": "albumentations.augmentations.transforms.OpticalDistortion", "always_apply": false, "p": 0.5, "distort_limit": [-0.05, 0.05], "shift_limit": [-0.05, 0.05], "interpolation": 1, "border_mode": 4, "value": null, "mask_value": null}, {"__class_fullname__": "albumentations.augmentations.transforms.PadIfNeeded", "always_apply": false, "p": 1.0, "min_height": 1024, "min_width": 1024, "border_mode": 4, "value": null, "mask_value": null}, {"__class_fullname__": "albumentations.augmentations.transforms.Posterize", "always_apply": false, "p": 0.5, "num_bits": [4, 4]}, {"__class_fullname__": "albumentations.augmentations.transforms.RGBShift", "always_apply": false, "p": 0.5, "r_shift_limit": [-20, 20], "g_shift_limit": [-20, 20], "b_shift_limit": [-20, 20]}, {"__class_fullname__": "albumentations.augmentations.transforms.RandomBrightnessContrast", "always_apply": false, "p": 0.5, "brightness_limit": [-0.2, 0.2], "contrast_limit": [-0.2, 0.2], "brightness_by_max": true}, {"__class_fullname__": "albumentations.augmentations.transforms.RandomFog", "always_apply": false, "p": 0.5, "fog_coef_lower": 0.3, "fog_coef_upper": 1, "alpha_coef": 0.08}, {"__class_fullname__": "albumentations.augmentations.transforms.RandomGamma", "always_apply": false, "p": 0.5, "gamma_limit": [80, 120], "eps": null}, {"__class_fullname__": "albumentations.augmentations.transforms.RandomGridShuffle", "always_apply": false, "p": 0.5, "grid": [3, 3]}, {"__class_fullname__": "albumentations.augmentations.transforms.RandomRain", "always_apply": false, "p": 0.5, "slant_lower": -10, "slant_upper": 10, "drop_length": 20, "drop_width": 1, "drop_color": [200, 200, 200], "blur_value": 7, "brightness_coefficient": 0.7, "rain_type": null}, {"__class_fullname__": "albumentations.augmentations.transforms.RandomRotate90", "always_apply": false, "p": 0.5}, {"__class_fullname__": "albumentations.augmentations.transforms.RandomScale", "always_apply": false, "p": 0.5, "interpolation": 1, "scale_limit": [-0.09999999999999998, 0.10000000000000009]}, {"__class_fullname__": "albumentations.augmentations.transforms.RandomShadow", "always_apply": false, "p": 0.5, "shadow_roi": [0, 0.5, 1, 1], "num_shadows_lower": 1, "num_shadows_upper": 2, "shadow_dimension": 5}, {"__class_fullname__": "albumentations.augmentations.transforms.RandomSnow", "always_apply": false, "p": 0.5, "snow_point_lower": 0.1, "snow_point_upper": 0.3, "brightness_coeff": 2.5}, {"__class_fullname__": "albumentations.augmentations.transforms.RandomSunFlare", "always_apply": false, "p": 0.5, "flare_roi": [0, 0, 1, 0.5], "angle_lower": 0, "angle_upper": 1, "num_flare_circles_lower": 6, "num_flare_circles_upper": 10, "src_radius": 400, "src_color": [255, 255, 255]}, {"__class_fullname__": "albumentations.augmentations.transforms.Rotate", "always_apply": false, "p": 0.5, "limit": [-90, 90], "interpolation": 1, "border_mode": 4, "value": null, "mask_value": null}, {"__class_fullname__": "albumentations.augmentations.transforms.ShiftScaleRotate", "always_apply": false, "p": 0.5, "shift_limit": [-0.0625, 0.0625], "scale_limit": [-0.09999999999999998, 0.10000000000000009], "rotate_limit": [-45, 45], "interpolation": 1, "border_mode": 4, "value": null, "mask_value": null}, {"__class_fullname__": "albumentations.augmentations.transforms.SmallestMaxSize", "always_apply": false, "p": 1, "max_size": 1024, "interpolation": 1}, {"__class_fullname__": "albumentations.augmentations.transforms.Solarize", "always_apply": false, "p": 0.5, "threshold": [128, 128]}, {"__class_fullname__": "albumentations.augmentations.transforms.ToGray", "always_apply": false, "p": 0.5}, {"__class_fullname__": "albumentations.augmentations.transforms.ToSepia", "always_apply": false, "p": 0.5}, {"__class_fullname__": "albumentations.augmentations.transforms.Transpose", "always_apply": false, "p": 0.5}, {"__class_fullname__": "albumentations.augmentations.transforms.VerticalFlip", "always_apply": false, "p": 0.5}, {"__class_fullname__": "albumentations.augmentations.transforms.RandomCrop", "always_apply": false, "p": 1.0, "height": 32, "width": 32}, {"__class_fullname__": "albumentations.augmentations.transforms.Normalize", "always_apply": false, "p": 1.0, "mean": [0.485, 0.456, 0.406], "std": [0.229, 0.224, 0.225], "max_pixel_value": 255.0}, {"__class_fullname__": "albumentations.pytorch.transforms.ToTensorV2", "always_apply": true, "p": 1.0}], "bbox_params": null, "keypoint_params": null, "additional_targets": {}}}
2 | 


--------------------------------------------------------------------------------
/albumentations/core/serialization.py:
--------------------------------------------------------------------------------
  1 | from __future__ import absolute_import
  2 | 
  3 | import abc
  4 | import json
  5 | import warnings
  6 | 
  7 | try:
  8 |     import yaml
  9 | 
 10 |     yaml_available = True
 11 | except ImportError:
 12 |     yaml_available = False
 13 | 
 14 | 
 15 | from albumentations import __version__
 16 | 
 17 | __all__ = ["to_dict", "from_dict", "save", "load"]
 18 | 
 19 | 
 20 | SERIALIZABLE_REGISTRY = {}
 21 | NON_SERIALIZABLE_REGISTRY = {}
 22 | 
 23 | 
 24 | def shorten_class_name(class_fullname):
 25 |     splitted = class_fullname.split(".")
 26 |     if len(splitted) == 1:
 27 |         return class_fullname
 28 |     top_module, *_, class_name = splitted
 29 |     if top_module == "albumentations":
 30 |         return class_name
 31 |     return class_fullname
 32 | 
 33 | 
 34 | def get_shortest_class_fullname(cls):
 35 |     class_fullname = "{cls.__module__}.{cls.__name__}".format(cls=cls)
 36 |     return shorten_class_name(class_fullname)
 37 | 
 38 | 
 39 | class SerializableMeta(type):
 40 |     """
 41 |     A metaclass that is used to register classes in `SERIALIZABLE_REGISTRY` or `NON_SERIALIZABLE_REGISTRY`
 42 |     so they can be found later while deserializing transformation pipeline using classes full names.
 43 |     """
 44 | 
 45 |     def __new__(cls, name, bases, class_dict):
 46 |         cls_obj = super().__new__(cls, name, bases, class_dict)
 47 |         if cls_obj.is_serializable():
 48 |             SERIALIZABLE_REGISTRY[cls_obj.get_class_fullname()] = cls_obj
 49 |         else:
 50 |             NON_SERIALIZABLE_REGISTRY[cls_obj.get_class_fullname()] = cls_obj
 51 |         return cls_obj
 52 | 
 53 | 
 54 | def to_dict(transform, on_not_implemented_error="raise"):
 55 |     """
 56 |     Take a transform pipeline and convert it to a serializable representation that uses only standard
 57 |     python data types: dictionaries, lists, strings, integers, and floats.
 58 | 
 59 |     Args:
 60 |         transform (object): A transform that should be serialized. If the transform doesn't implement the `to_dict`
 61 |             method and `on_not_implemented_error` equals to 'raise' then `NotImplementedError` is raised.
 62 |             If `on_not_implemented_error` equals to 'warn' then `NotImplementedError` will be ignored
 63 |             but no transform parameters will be serialized.
 64 |     """
 65 |     if on_not_implemented_error not in {"raise", "warn"}:
 66 |         raise ValueError(
 67 |             "Unknown on_not_implemented_error value: {}. Supported values are: 'raise' and 'warn'".format(
 68 |                 on_not_implemented_error
 69 |             )
 70 |         )
 71 |     try:
 72 |         transform_dict = transform._to_dict()  # skipcq: PYL-W0212
 73 |     except NotImplementedError as e:
 74 |         if on_not_implemented_error == "raise":
 75 |             raise e
 76 | 
 77 |         transform_dict = {}
 78 |         warnings.warn(
 79 |             "Got NotImplementedError while trying to serialize {obj}. Object arguments are not preserved. "
 80 |             "Implement either '{cls_name}.get_transform_init_args_names' or '{cls_name}.get_transform_init_args' "
 81 |             "method to make the transform serializable".format(obj=transform, cls_name=transform.__class__.__name__)
 82 |         )
 83 |     return {"__version__": __version__, "transform": transform_dict}
 84 | 
 85 | 
 86 | def instantiate_nonserializable(transform, nonserializable=None):
 87 |     if transform.get("__class_fullname__") in NON_SERIALIZABLE_REGISTRY:
 88 |         name = transform["__name__"]
 89 |         if nonserializable is None:
 90 |             raise ValueError(
 91 |                 "To deserialize a non-serializable transform with name {name} you need to pass a dict with"
 92 |                 "this transform as the `lambda_transforms` argument".format(name=name)
 93 |             )
 94 |         transform = nonserializable.get(name)
 95 |         if transform is None:
 96 |             raise ValueError(
 97 |                 "Non-serializable transform with {name} was not found in `nonserializable`".format(name=name)
 98 |             )
 99 |         return transform
100 |     return None
101 | 
102 | 
103 | def from_dict(transform_dict, nonserializable=None, lambda_transforms="deprecated"):
104 |     """
105 |     Args:
106 |         transform_dict (dict): A dictionary with serialized transform pipeline.
107 |         nonserializable (dict): A dictionary that contains non-serializable transforms.
108 |             This dictionary is required when you are restoring a pipeline that contains non-serializable transforms.
109 |             Keys in that dictionary should be named same as `name` arguments in respective transforms from
110 |             a serialized pipeline.
111 |         lambda_transforms (dict): Deprecated. Use 'nonserizalizable' instead.
112 |     """
113 |     if lambda_transforms != "deprecated":
114 |         warnings.warn("lambda_transforms argument is deprecated, please use 'nonserializable'", DeprecationWarning)
115 |         nonserializable = lambda_transforms
116 | 
117 |     register_additional_transforms()
118 |     transform = transform_dict["transform"]
119 |     lmbd = instantiate_nonserializable(transform, nonserializable)
120 |     if lmbd:
121 |         return lmbd
122 |     name = transform["__class_fullname__"]
123 |     args = {k: v for k, v in transform.items() if k != "__class_fullname__"}
124 |     cls = SERIALIZABLE_REGISTRY[shorten_class_name(name)]
125 |     if "transforms" in args:
126 |         args["transforms"] = [from_dict({"transform": t}, nonserializable=nonserializable) for t in args["transforms"]]
127 |     return cls(**args)
128 | 
129 | 
130 | def check_data_format(data_format):
131 |     if data_format not in {"json", "yaml"}:
132 |         raise ValueError("Unknown data_format {}. Supported formats are: 'json' and 'yaml'".format(data_format))
133 | 
134 | 
135 | def save(transform, filepath, data_format="json", on_not_implemented_error="raise"):
136 |     """
137 |     Take a transform pipeline, serialize it and save a serialized version to a file
138 |     using either json or yaml format.
139 | 
140 |     Args:
141 |         transform (obj): Transform to serialize.
142 |         filepath (str): Filepath to write to.
143 |         data_format (str): Serialization format. Should be either `json` or 'yaml'.
144 |         on_not_implemented_error (str): Parameter that describes what to do if a transform doesn't implement
145 |             the `to_dict` method. If 'raise' then `NotImplementedError` is raised, if `warn` then the exception will be
146 |             ignored and no transform arguments will be saved.
147 |     """
148 |     check_data_format(data_format)
149 |     transform_dict = to_dict(transform, on_not_implemented_error=on_not_implemented_error)
150 |     dump_fn = json.dump if data_format == "json" else yaml.safe_dump
151 |     with open(filepath, "w") as f:
152 |         dump_fn(transform_dict, f)
153 | 
154 | 
155 | def load(filepath, data_format="json", nonserializable=None, lambda_transforms="deprecated"):
156 |     """
157 |     Load a serialized pipeline from a json or yaml file and construct a transform pipeline.
158 | 
159 |     Args:
160 |         filepath (str): Filepath to read from.
161 |         data_format (str): Serialization format. Should be either `json` or 'yaml'.
162 |         nonserializable (dict): A dictionary that contains non-serializable transforms.
163 |             This dictionary is required when you are restoring a pipeline that contains non-serializable transforms.
164 |             Keys in that dictionary should be named same as `name` arguments in respective transforms from
165 |             a serialized pipeline.
166 |         lambda_transforms (dict): Deprecated. Use 'nonserizalizable' instead.
167 |     """
168 |     if lambda_transforms != "deprecated":
169 |         warnings.warn("lambda_transforms argument is deprecated, please use 'nonserializable'", DeprecationWarning)
170 |         nonserializable = lambda_transforms
171 | 
172 |     check_data_format(data_format)
173 |     load_fn = json.load if data_format == "json" else yaml.safe_load
174 |     with open(filepath) as f:
175 |         transform_dict = load_fn(f)
176 | 
177 |     return from_dict(transform_dict, nonserializable=nonserializable)
178 | 
179 | 
180 | def register_additional_transforms():
181 |     """
182 |     Register transforms that are not imported directly into the `albumentations` module.
183 |     """
184 |     try:
185 |         # This import will result in ImportError if `torch` is not installed
186 |         import albumentations.pytorch
187 |     except ImportError:
188 |         pass
189 | 


--------------------------------------------------------------------------------
/albumentations/core/transforms_interface.py:
--------------------------------------------------------------------------------
  1 | from __future__ import absolute_import
  2 | 
  3 | import random
  4 | from copy import deepcopy
  5 | from typing import Any, Callable, Dict, List, Sequence, Tuple
  6 | from warnings import warn
  7 | 
  8 | import cv2
  9 | import numpy as np
 10 | 
 11 | from albumentations.core.serialization import (
 12 |     SerializableMeta,
 13 |     get_shortest_class_fullname,
 14 | )
 15 | from albumentations.core.utils import format_args
 16 | 
 17 | __all__ = ["to_tuple", "BasicTransform", "DualTransform", "ImageOnlyTransform", "NoOp"]
 18 | 
 19 | 
 20 | def to_tuple(param, low=None, bias=None):
 21 |     """Convert input argument to min-max tuple
 22 |     Args:
 23 |         param (scalar, tuple or list of 2+ elements): Input value.
 24 |             If value is scalar, return value would be (offset - value, offset + value).
 25 |             If value is tuple, return value would be value + offset (broadcasted).
 26 |         low:  Second element of tuple can be passed as optional argument
 27 |         bias: An offset factor added to each element
 28 |     """
 29 |     if low is not None and bias is not None:
 30 |         raise ValueError("Arguments low and bias are mutually exclusive")
 31 | 
 32 |     if param is None:
 33 |         return param
 34 | 
 35 |     if isinstance(param, (int, float)):
 36 |         if low is None:
 37 |             param = -param, +param
 38 |         else:
 39 |             param = (low, param) if low < param else (param, low)
 40 |     elif isinstance(param, Sequence):
 41 |         param = tuple(param)
 42 |     else:
 43 |         raise ValueError("Argument param must be either scalar (int, float) or tuple")
 44 | 
 45 |     if bias is not None:
 46 |         return tuple(bias + x for x in param)
 47 | 
 48 |     return tuple(param)
 49 | 
 50 | 
 51 | class BasicTransform(metaclass=SerializableMeta):
 52 |     call_backup = None
 53 |     interpolation: Any
 54 |     fill_value: Any
 55 |     mask_fill_value: Any
 56 | 
 57 |     def __init__(self, always_apply: bool = False, p: float = 0.5):
 58 |         self.p = p
 59 |         self.always_apply = always_apply
 60 |         self._additional_targets: Dict[str, str] = {}
 61 | 
 62 |         # replay mode params
 63 |         self.deterministic = False
 64 |         self.save_key = "replay"
 65 |         self.params: Dict[Any, Any] = {}
 66 |         self.replay_mode = False
 67 |         self.applied_in_replay = False
 68 | 
 69 |     def __call__(self, *args, force_apply: bool = False, **kwargs) -> Dict[str, Any]:
 70 |         if args:
 71 |             raise KeyError("You have to pass data to augmentations as named arguments, for example: aug(image=image)")
 72 |         if self.replay_mode:
 73 |             if self.applied_in_replay:
 74 |                 return self.apply_with_params(self.params, **kwargs)
 75 | 
 76 |             return kwargs
 77 | 
 78 |         if (random.random() < self.p) or self.always_apply or force_apply:
 79 |             params = self.get_params()
 80 | 
 81 |             if self.targets_as_params:
 82 |                 assert all(key in kwargs for key in self.targets_as_params), "{} requires {}".format(
 83 |                     self.__class__.__name__, self.targets_as_params
 84 |                 )
 85 |                 targets_as_params = {k: kwargs[k] for k in self.targets_as_params}
 86 |                 params_dependent_on_targets = self.get_params_dependent_on_targets(targets_as_params)
 87 |                 params.update(params_dependent_on_targets)
 88 |             if self.deterministic:
 89 |                 if self.targets_as_params:
 90 |                     warn(
 91 |                         self.get_class_fullname() + " could work incorrectly in ReplayMode for other input data"
 92 |                         " because its' params depend on targets."
 93 |                     )
 94 |                 kwargs[self.save_key][id(self)] = deepcopy(params)
 95 |             return self.apply_with_params(params, **kwargs)
 96 | 
 97 |         return kwargs
 98 | 
 99 |     def apply_with_params(
100 |         self, params: Dict[str, Any], force_apply: bool = False, **kwargs
101 |     ) -> Dict[str, Any]:  # skipcq: PYL-W0613
102 |         if params is None:
103 |             return kwargs
104 |         params = self.update_params(params, **kwargs)
105 |         res = {}
106 |         for key, arg in kwargs.items():
107 |             if arg is not None:
108 |                 target_function = self._get_target_function(key)
109 |                 target_dependencies = {k: kwargs[k] for k in self.target_dependence.get(key, [])}
110 |                 res[key] = target_function(arg, **dict(params, **target_dependencies))
111 |             else:
112 |                 res[key] = None
113 |         return res
114 | 
115 |     def set_deterministic(self, flag: bool, save_key: str = "replay") -> "BasicTransform":
116 |         assert save_key != "params", "params save_key is reserved"
117 |         self.deterministic = flag
118 |         self.save_key = save_key
119 |         return self
120 | 
121 |     def __repr__(self) -> str:
122 |         state = self.get_base_init_args()
123 |         state.update(self.get_transform_init_args())
124 |         return "{name}({args})".format(name=self.__class__.__name__, args=format_args(state))
125 | 
126 |     def _get_target_function(self, key: str) -> Callable:
127 |         transform_key = key
128 |         if key in self._additional_targets:
129 |             transform_key = self._additional_targets.get(key, key)
130 | 
131 |         target_function = self.targets.get(transform_key, lambda x, **p: x)
132 |         return target_function
133 | 
134 |     def apply(self, img, **params) -> np.ndarray:
135 |         raise NotImplementedError
136 | 
137 |     def get_params(self) -> Dict:
138 |         return {}
139 | 
140 |     @property
141 |     def targets(self) -> Dict[str, Callable]:
142 |         # you must specify targets in subclass
143 |         # for example: ('image', 'mask')
144 |         #              ('image', 'boxes')
145 |         raise NotImplementedError
146 | 
147 |     def update_params(self, params: Dict[str, Any], **kwargs) -> Dict[str, Any]:
148 |         if hasattr(self, "interpolation"):
149 |             params["interpolation"] = self.interpolation
150 |         if hasattr(self, "fill_value"):
151 |             params["fill_value"] = self.fill_value
152 |         if hasattr(self, "mask_fill_value"):
153 |             params["mask_fill_value"] = self.mask_fill_value
154 |         params.update({"cols": kwargs["image"].shape[1], "rows": kwargs["image"].shape[0]})
155 |         return params
156 | 
157 |     @property
158 |     def target_dependence(self) -> Dict:
159 |         return {}
160 | 
161 |     def add_targets(self, additional_targets: Dict[str, str]):
162 |         """Add targets to transform them the same way as one of existing targets
163 |         ex: {'target_image': 'image'}
164 |         ex: {'obj1_mask': 'mask', 'obj2_mask': 'mask'}
165 |         by the way you must have at least one object with key 'image'
166 | 
167 |         Args:
168 |             additional_targets (dict): keys - new target name, values - old target name. ex: {'image2': 'image'}
169 |         """
170 |         self._additional_targets = additional_targets
171 | 
172 |     @property
173 |     def targets_as_params(self) -> List[str]:
174 |         return []
175 | 
176 |     def get_params_dependent_on_targets(self, params: Dict[str, Any]) -> Dict[str, Any]:
177 |         raise NotImplementedError(
178 |             "Method get_params_dependent_on_targets is not implemented in class " + self.__class__.__name__
179 |         )
180 | 
181 |     @classmethod
182 |     def get_class_fullname(cls) -> str:
183 |         return get_shortest_class_fullname(cls)
184 | 
185 |     @classmethod
186 |     def is_serializable(cls):
187 |         return True
188 | 
189 |     def get_transform_init_args_names(self) -> Tuple[str, ...]:
190 |         raise NotImplementedError(
191 |             "Class {name} is not serializable because the `get_transform_init_args_names` method is not "
192 |             "implemented".format(name=self.get_class_fullname())
193 |         )
194 | 
195 |     def get_base_init_args(self) -> Dict[str, Any]:
196 |         return {"always_apply": self.always_apply, "p": self.p}
197 | 
198 |     def get_transform_init_args(self) -> Dict[str, Any]:
199 |         return {k: getattr(self, k) for k in self.get_transform_init_args_names()}
200 | 
201 |     def _to_dict(self) -> Dict[str, Any]:
202 |         state = {"__class_fullname__": self.get_class_fullname()}
203 |         state.update(self.get_base_init_args())
204 |         state.update(self.get_transform_init_args())
205 |         return state
206 | 
207 |     def get_dict_with_id(self) -> Dict[str, Any]:
208 |         d = self._to_dict()
209 |         d["id"] = id(self)
210 |         return d
211 | 
212 | 
213 | class DualTransform(BasicTransform):
214 |     """Transform for segmentation task."""
215 | 
216 |     @property
217 |     def targets(self) -> Dict[str, Callable]:
218 |         return {
219 |             "image": self.apply,
220 |             "mask": self.apply_to_mask,
221 |             "masks": self.apply_to_masks,
222 |             "bboxes": self.apply_to_bboxes,
223 |             "keypoints": self.apply_to_keypoints,
224 |         }
225 | 
226 |     def apply_to_bbox(self, bbox, **params):
227 |         raise NotImplementedError("Method apply_to_bbox is not implemented in class " + self.__class__.__name__)
228 | 
229 |     def apply_to_keypoint(self, keypoint, **params):
230 |         raise NotImplementedError("Method apply_to_keypoint is not implemented in class " + self.__class__.__name__)
231 | 
232 |     def apply_to_bboxes(self, bboxes, **params):
233 |         return [self.apply_to_bbox(tuple(bbox[:4]), **params) + tuple(bbox[4:]) for bbox in bboxes]
234 | 
235 |     def apply_to_keypoints(self, keypoints, **params):
236 |         return [self.apply_to_keypoint(tuple(keypoint[:4]), **params) + tuple(keypoint[4:]) for keypoint in keypoints]
237 | 
238 |     def apply_to_mask(self, img, **params):
239 |         return self.apply(img, **{k: cv2.INTER_NEAREST if k == "interpolation" else v for k, v in params.items()})
240 | 
241 |     def apply_to_masks(self, masks, **params):
242 |         return [self.apply_to_mask(mask, **params) for mask in masks]
243 | 
244 | 
245 | class ImageOnlyTransform(BasicTransform):
246 |     """Transform applied to image only."""
247 | 
248 |     @property
249 |     def targets(self):
250 |         return {"image": self.apply}
251 | 
252 | 
253 | class NoOp(DualTransform):
254 |     """Does nothing"""
255 | 
256 |     def apply_to_keypoint(self, keypoint, **params):
257 |         return keypoint
258 | 
259 |     def apply_to_bbox(self, bbox, **params):
260 |         return bbox
261 | 
262 |     def apply(self, img, **params):
263 |         return img
264 | 
265 |     def apply_to_mask(self, img, **params):
266 |         return img
267 | 
268 |     def get_transform_init_args_names(self):
269 |         return ()
270 | 


--------------------------------------------------------------------------------
/albumentations/augmentations/crops/functional.py:
--------------------------------------------------------------------------------
  1 | from typing import List, Optional, Sequence, Tuple, Union
  2 | 
  3 | import cv2
  4 | import numpy as np
  5 | 
  6 | from ..bbox_utils import denormalize_bbox, normalize_bbox
  7 | from ..functional import _maybe_process_in_chunks, pad_with_params, preserve_channel_dim
  8 | from ..geometric import functional as FGeometric
  9 | 
 10 | BboxType = Union[List[int], List[float], Tuple[int, ...], Tuple[float, ...], np.ndarray]
 11 | KeypointType = Union[List[int], List[float], Tuple[int, ...], Tuple[float, ...], np.ndarray]
 12 | 
 13 | 
 14 | def get_random_crop_coords(height: int, width: int, crop_height: int, crop_width: int, h_start: float, w_start: float):
 15 |     y1 = int((height - crop_height) * h_start)
 16 |     y2 = y1 + crop_height
 17 |     x1 = int((width - crop_width) * w_start)
 18 |     x2 = x1 + crop_width
 19 |     return x1, y1, x2, y2
 20 | 
 21 | 
 22 | def random_crop(img: np.ndarray, crop_height: int, crop_width: int, h_start: float, w_start: float):
 23 |     height, width = img.shape[:2]
 24 |     if height < crop_height or width < crop_width:
 25 |         raise ValueError(
 26 |             "Requested crop size ({crop_height}, {crop_width}) is "
 27 |             "larger than the image size ({height}, {width})".format(
 28 |                 crop_height=crop_height, crop_width=crop_width, height=height, width=width
 29 |             )
 30 |         )
 31 |     x1, y1, x2, y2 = get_random_crop_coords(height, width, crop_height, crop_width, h_start, w_start)
 32 |     img = img[y1:y2, x1:x2]
 33 |     return img
 34 | 
 35 | 
 36 | def crop_bbox_by_coords(
 37 |     bbox: BboxType, crop_coords: Tuple[int, int, int, int], crop_height: int, crop_width: int, rows: int, cols: int
 38 | ):
 39 |     """Crop a bounding box using the provided coordinates of bottom-left and top-right corners in pixels and the
 40 |     required height and width of the crop.
 41 | 
 42 |     Args:
 43 |         bbox (tuple): A cropped box `(x_min, y_min, x_max, y_max)`.
 44 |         crop_coords (tuple): Crop coordinates `(x1, y1, x2, y2)`.
 45 |         crop_height (int):
 46 |         crop_width (int):
 47 |         rows (int): Image rows.
 48 |         cols (int): Image cols.
 49 | 
 50 |     Returns:
 51 |         tuple: A cropped bounding box `(x_min, y_min, x_max, y_max)`.
 52 | 
 53 |     """
 54 |     bbox = denormalize_bbox(bbox, rows, cols)
 55 |     x_min, y_min, x_max, y_max = bbox[:4]
 56 |     x1, y1, _, _ = crop_coords
 57 |     cropped_bbox = x_min - x1, y_min - y1, x_max - x1, y_max - y1
 58 |     return normalize_bbox(cropped_bbox, crop_height, crop_width)
 59 | 
 60 | 
 61 | def bbox_random_crop(
 62 |     bbox: BboxType, crop_height: int, crop_width: int, h_start: float, w_start: float, rows: int, cols: int
 63 | ):
 64 |     crop_coords = get_random_crop_coords(rows, cols, crop_height, crop_width, h_start, w_start)
 65 |     return crop_bbox_by_coords(bbox, crop_coords, crop_height, crop_width, rows, cols)
 66 | 
 67 | 
 68 | def crop_keypoint_by_coords(keypoint: KeypointType, crop_coords: Tuple[int, int, int, int]):  # skipcq: PYL-W0613
 69 |     """Crop a keypoint using the provided coordinates of bottom-left and top-right corners in pixels and the
 70 |     required height and width of the crop.
 71 | 
 72 |     Args:
 73 |         keypoint (tuple): A keypoint `(x, y, angle, scale)`.
 74 |         crop_coords (tuple): Crop box coords `(x1, x2, y1, y2)`.
 75 | 
 76 |     Returns:
 77 |         A keypoint `(x, y, angle, scale)`.
 78 | 
 79 |     """
 80 |     x, y, angle, scale = keypoint[:4]
 81 |     x1, y1, _, _ = crop_coords
 82 |     return x - x1, y - y1, angle, scale
 83 | 
 84 | 
 85 | def keypoint_random_crop(
 86 |     keypoint: KeypointType, crop_height: int, crop_width: int, h_start: float, w_start: float, rows: int, cols: int
 87 | ):
 88 |     """Keypoint random crop.
 89 | 
 90 |     Args:
 91 |         keypoint: (tuple): A keypoint `(x, y, angle, scale)`.
 92 |         crop_height (int): Crop height.
 93 |         crop_width (int): Crop width.
 94 |         h_start (int): Crop height start.
 95 |         w_start (int): Crop width start.
 96 |         rows (int): Image height.
 97 |         cols (int): Image width.
 98 | 
 99 |     Returns:
100 |         A keypoint `(x, y, angle, scale)`.
101 | 
102 |     """
103 |     crop_coords = get_random_crop_coords(rows, cols, crop_height, crop_width, h_start, w_start)
104 |     return crop_keypoint_by_coords(keypoint, crop_coords)
105 | 
106 | 
107 | def get_center_crop_coords(height: int, width: int, crop_height: int, crop_width: int):
108 |     y1 = (height - crop_height) // 2
109 |     y2 = y1 + crop_height
110 |     x1 = (width - crop_width) // 2
111 |     x2 = x1 + crop_width
112 |     return x1, y1, x2, y2
113 | 
114 | 
115 | def center_crop(img: np.ndarray, crop_height: int, crop_width: int):
116 |     height, width = img.shape[:2]
117 |     if height < crop_height or width < crop_width:
118 |         raise ValueError(
119 |             "Requested crop size ({crop_height}, {crop_width}) is "
120 |             "larger than the image size ({height}, {width})".format(
121 |                 crop_height=crop_height, crop_width=crop_width, height=height, width=width
122 |             )
123 |         )
124 |     x1, y1, x2, y2 = get_center_crop_coords(height, width, crop_height, crop_width)
125 |     img = img[y1:y2, x1:x2]
126 |     return img
127 | 
128 | 
129 | def bbox_center_crop(bbox: BboxType, crop_height: int, crop_width: int, rows: int, cols: int):
130 |     crop_coords = get_center_crop_coords(rows, cols, crop_height, crop_width)
131 |     return crop_bbox_by_coords(bbox, crop_coords, crop_height, crop_width, rows, cols)
132 | 
133 | 
134 | def keypoint_center_crop(keypoint: KeypointType, crop_height: int, crop_width: int, rows: int, cols: int):
135 |     """Keypoint center crop.
136 | 
137 |     Args:
138 |         keypoint (tuple): A keypoint `(x, y, angle, scale)`.
139 |         crop_height (int): Crop height.
140 |         crop_width (int): Crop width.
141 |         rows (int): Image height.
142 |         cols (int): Image width.
143 | 
144 |     Returns:
145 |         tuple: A keypoint `(x, y, angle, scale)`.
146 | 
147 |     """
148 |     crop_coords = get_center_crop_coords(rows, cols, crop_height, crop_width)
149 |     return crop_keypoint_by_coords(keypoint, crop_coords)
150 | 
151 | 
152 | def crop(img: np.ndarray, x_min: int, y_min: int, x_max: int, y_max: int):
153 |     height, width = img.shape[:2]
154 |     if x_max <= x_min or y_max <= y_min:
155 |         raise ValueError(
156 |             "We should have x_min < x_max and y_min < y_max. But we got"
157 |             " (x_min = {x_min}, y_min = {y_min}, x_max = {x_max}, y_max = {y_max})".format(
158 |                 x_min=x_min, x_max=x_max, y_min=y_min, y_max=y_max
159 |             )
160 |         )
161 | 
162 |     if x_min < 0 or x_max > width or y_min < 0 or y_max > height:
163 |         raise ValueError(
164 |             "Values for crop should be non negative and equal or smaller than image sizes"
165 |             "(x_min = {x_min}, y_min = {y_min}, x_max = {x_max}, y_max = {y_max}, "
166 |             "height = {height}, width = {width})".format(
167 |                 x_min=x_min, x_max=x_max, y_min=y_min, y_max=y_max, height=height, width=width
168 |             )
169 |         )
170 | 
171 |     return img[y_min:y_max, x_min:x_max]
172 | 
173 | 
174 | def bbox_crop(bbox: BboxType, x_min: int, y_min: int, x_max: int, y_max: int, rows: int, cols: int):
175 |     """Crop a bounding box.
176 | 
177 |     Args:
178 |         bbox (tuple): A bounding box `(x_min, y_min, x_max, y_max)`.
179 |         x_min (int):
180 |         y_min (int):
181 |         x_max (int):
182 |         y_max (int):
183 |         rows (int): Image rows.
184 |         cols (int): Image cols.
185 | 
186 |     Returns:
187 |         tuple: A cropped bounding box `(x_min, y_min, x_max, y_max)`.
188 | 
189 |     """
190 |     crop_coords = x_min, y_min, x_max, y_max
191 |     crop_height = y_max - y_min
192 |     crop_width = x_max - x_min
193 |     return crop_bbox_by_coords(bbox, crop_coords, crop_height, crop_width, rows, cols)
194 | 
195 | 
196 | def clamping_crop(img: np.ndarray, x_min: int, y_min: int, x_max: int, y_max: int):
197 |     h, w = img.shape[:2]
198 |     if x_min < 0:
199 |         x_min = 0
200 |     if y_min < 0:
201 |         y_min = 0
202 |     if y_max >= h:
203 |         y_max = h - 1
204 |     if x_max >= w:
205 |         x_max = w - 1
206 |     return img[int(y_min) : int(y_max), int(x_min) : int(x_max)]
207 | 
208 | 
209 | @preserve_channel_dim
210 | def crop_and_pad(
211 |     img: np.ndarray,
212 |     crop_params: Sequence[int],
213 |     pad_params: Sequence[int],
214 |     pad_value: Union[int, float],
215 |     rows: int,
216 |     cols: int,
217 |     interpolation: int,
218 |     pad_mode: int,
219 |     keep_size: bool,
220 | ) -> np.ndarray:
221 |     if crop_params is not None and any(i != 0 for i in crop_params):
222 |         img = crop(img, *crop_params)
223 |     if pad_params is not None and any(i != 0 for i in pad_params):
224 |         img = pad_with_params(img, *pad_params, border_mode=pad_mode, value=pad_value)
225 | 
226 |     if keep_size:
227 |         resize_fn = _maybe_process_in_chunks(cv2.resize, dsize=(cols, rows), interpolation=interpolation)
228 |         img = resize_fn(img)
229 | 
230 |     return img
231 | 
232 | 
233 | def crop_and_pad_bbox(
234 |     bbox: Sequence[float],
235 |     crop_params: Optional[Sequence[int]],
236 |     pad_params: Optional[Sequence[int]],
237 |     rows,
238 |     cols,
239 |     result_rows,
240 |     result_cols,
241 |     keep_size: bool,
242 | ) -> Sequence[float]:
243 |     x1, y1, x2, y2 = denormalize_bbox(bbox, rows, cols)
244 | 
245 |     if crop_params is not None:
246 |         crop_x, crop_y = crop_params[:2]
247 |         x1, y1, x2, y2 = x1 - crop_x, y1 - crop_y, x2 - crop_x, y2 - crop_y
248 |     if pad_params is not None:
249 |         top, bottom, left, right = pad_params
250 |         x1, y1, x2, y2 = x1 + left, y1 + top, x2 + left, y2 + top
251 | 
252 |     if keep_size:
253 |         bbox = normalize_bbox((x1, y1, x2, y2), result_rows, result_cols)
254 |     else:
255 |         bbox = normalize_bbox((x1, y1, x2, y2), rows, cols)
256 | 
257 |     return bbox
258 | 
259 | 
260 | def crop_and_pad_keypoint(
261 |     keypoint: Sequence[float],
262 |     crop_params: Optional[Sequence[int]],
263 |     pad_params: Optional[Sequence[int]],
264 |     rows: int,
265 |     cols: int,
266 |     result_rows: int,
267 |     result_cols: int,
268 |     keep_size: bool,
269 | ) -> Sequence[float]:
270 |     x, y, angle, scale = keypoint
271 | 
272 |     if crop_params is not None:
273 |         crop_x1, crop_y1, crop_x2, crop_y2 = crop_params
274 |         x, y = x - crop_x1, y - crop_y1
275 |     if pad_params is not None:
276 |         top, bottom, left, right = pad_params
277 |         x, y = x + left, y + top
278 | 
279 |     if keep_size and (result_cols != cols or result_rows != rows):
280 |         scale_x = cols / result_cols
281 |         scale_y = rows / result_rows
282 |         return FGeometric.keypoint_scale((x, y, angle, scale), scale_x, scale_y)
283 | 
284 |     return x, y, angle, scale
285 | 


--------------------------------------------------------------------------------
/docs/hall_of_fame.rst:
--------------------------------------------------------------------------------
  1 | Hall of Fame
  2 | ============
  3 | Albumentations are widely used in Computer Vision Competitions at Kaggle an other platforms.
  4 | 
  5 | Here are the links to the competitions, names of the winners and to their solutions.
  6 | 
  7 | We follow these rules, when adding a solution to the "Hall of Fame":
  8 | 
  9 | 1. There should be a description of the solution: post at the forum / code / blog post / paper / pre-print.
 10 | 
 11 | 2. Solution should have some value:
 12 | 
 13 | * For Kaggle: gold or silver medal solutions.
 14 | * For Topcoder and other platforms: in money.
 15 | * For competitions held as a part of the academic conferences: there is a paper or pre-print describing the solution.
 16 | 
 17 | 
 18 | Kaggle
 19 | ------
 20 | 
 21 | `Carvana Image Masking Challenge <https://www.kaggle.com/c/carvana-image-masking-challenge>`_
 22 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 23 | 1. `Vladimir Iglovikov <https://www.linkedin.com/in/iglovikov/>`__, `Alexander Buslaev <https://www.kaggle.com/albuslaev>`__, `Artem Sanakoev <https://www.kaggle.com/asanakoev>`__
 24 |     `solution <http://blog.kaggle.com/2017/12/22/carvana-image-masking-first-place-interview/>`_
 25 | 
 26 | `Data Science Bowl 2018 <https://www.kaggle.com/c/data-science-bowl-2018>`__
 27 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 28 | 1. `Alexander Buslaev <https://www.kaggle.com/albuslaev>`__, `Selim Seferbekov <https://www.kaggle.com/selimsef>`__, `Victor Durnov <https://www.kaggle.com/victorsd>`__
 29 |     `solution <https://www.kaggle.com/c/data-science-bowl-2018/discussion/5474>`__
 30 | 
 31 | `Humpback Whale Identification <https://www.kaggle.com/c/humpback-whale-identification>`_
 32 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 33 | 5. `Roman Solovyev <https://www.kaggle.com/zfturbo>`__, `Weimin Wang <https://www.kaggle.com/weimin>`__
 34 |     `blog post <https://weiminwang.blog/2019/03/01/whale-identification-5th-place-approach-using-siamese-networks-with-adversarial-training/>`__,
 35 |     `code <https://github.com/aaxwaz/Humpback-whale-identification-challenge>`__
 36 | 
 37 | `TGS Salt Identification Challenge <https://www.kaggle.com/c/tgs-salt-identification-challeng>`_
 38 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 39 | 1. `b.e.s. <https://www.kaggle.com/ybabakhin>`__, `phalanx <https://www.kaggle.com/phalanx>`__
 40 |     `solution <https://www.kaggle.com/c/tgs-salt-identification-challenge/discussion/69291>`__,
 41 |     `code <https://github.com/ybabakhin/kaggle_salt_bes_phalanx>`__,
 42 |     `pre-print <https://arxiv.org/abs/1904.04445>`__
 43 | 
 44 | 27. `Insaf Ashrapov <https://www.linkedin.com/in/iashrapov/>`__, `Mikhail Karchevskiy <https://www.linkedin.com/in/mikhail-karchevskiy-aa46245a/>`__, `Leonid Kozinkin <https://www.linkedin.com/in/lkozinkin/>`__
 45 |      `blog post <https://towardsdatascience.com/kaggle-salt-identification-challenge-7fc502d1c3c3>`__,
 46 |      `code <https://github.com/K-Mike/Automatic-salt-deposits-segmentation>`__,
 47 |      `pre-print <https://arxiv.org/abs/1812.01429>`__
 48 | 
 49 | `APTOS 2019 Blindness Detection <https://www.kaggle.com/c/aptos2019-blindness-detection>`_
 50 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 51 | 7. `Eugene Khvedchenya <https://www.kaggle.com/bloodaxe>`__
 52 |     `solution <https://www.kaggle.com/c/aptos2019-blindness-detection/discussion/108058>`__,
 53 |     `code <https://github.com/BloodAxe/Kaggle-2019-Cellular-Image-Classification>`__
 54 | 
 55 | 76. `Insaf Ashrapov <https://www.linkedin.com/in/iashrapov/>`__, `Mamat Shamshiev <https://www.kaggle.com/mamatml/>`__, `Mishunyayev Nikita <https://www.kaggle.com/mnikita/>`__
 56 |      `solution <https://www.kaggle.com/c/aptos2019-blindness-detection/discussion/108057>`__,
 57 |      `code <https://github.com/MamatShamshiev/Kaggle-APTOS-2019-Blindness-Detection>`__
 58 | 
 59 | `SIIM-ACR Pneumothorax Segmentation <https://www.kaggle.com/c/siim-acr-pneumothorax-segmentation>`_
 60 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 61 | 1. `Anuar Aimoldin <https://www.linkedin.com/in/anuar-aimoldin/>`__
 62 |      `solution <https://www.kaggle.com/c/siim-acr-pneumothorax-segmentation/discussion/107824>`__,
 63 |      `code <https://github.com/sneddy/pneumothorax-segmentation>`__,
 64 |      `video <https://youtu.be/Wuf0wE3Mrxg>`__,
 65 |      `presentation <https://yadi.sk/i/oDYnpvMhqi8a7w>`__
 66 | 
 67 | 4. `Miras Amir <https://www.linkedin.com/in/amirassov/>`__
 68 |      `solution <https://www.kaggle.com/c/siim-acr-pneumothorax-segmentation/discussion/108397#latest-626947>`__,
 69 |      `code <https://github.com/amirassov/kaggle-pneumothorax>`__
 70 | 
 71 | 33. `Renat Alimbekov <https://www.linkedin.com/in/alimbekovkz/>`__, `Ivan Vassilenko <https://www.linkedin.com/in/ivannvassilenko/>`__
 72 |      `solution <https://github.com/jovenwayfarer/kaggle-pneumothorax>`__
 73 | 
 74 | 50. `AlexeyK <https://www.kaggle.com/akuritsyn>`__, `wayfarer <https://www.kaggle.com/joven1997>`__, `Kudaibergen R <https://www.kaggle.com/kudaibergenu>`__
 75 |      `code and solution <https://github.com/jovenwayfarer/kaggle-pneumothorax>`__
 76 | 
 77 | `iMaterialist (Fashion) 2019 at FGVC6 <https://www.kaggle.com/c/imaterialist-fashion-2019-FGVC6>`_
 78 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 79 | 1. `Miras Amir <https://www.linkedin.com/in/amirassov/>`__
 80 |      `solution <https://www.kaggle.com/c/imaterialist-fashion-2019-FGVC6/discussion/95247#latest-626701>`__,
 81 |      `code <https://github.com/amirassov/kaggle-imaterialist>`__
 82 | 
 83 | `Google Landmark Recognition 2019 <https://www.kaggle.com/c/landmark-recognition-2019>`_
 84 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 85 | 20. `Artyom Palvelev <https://www.linkedin.com/in/artyompp/>`__
 86 |      `solution <https://www.kaggle.com/c/landmark-recognition-2019/discussion/94645#latest-549974>`__,
 87 |      `code <https://github.com/artyompal/google_landmark_2019>`__
 88 | 
 89 | `Inclusive Images Challenge <https://www.kaggle.com/c/inclusive-images-challenge/>`_
 90 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 91 | 3. `Roman Solovyev <https://www.kaggle.com/zfturbo>`_, `Weimin Wang <https://www.kaggle.com/weimin>`__
 92 |     `solution <https://www.kaggle.com/c/inclusive-images-challenge/discussion/71433>`__
 93 | 
 94 | `Airbus Ship Detection Challenge <https://www.kaggle.com/c/airbus-ship-detection/>`_
 95 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 96 | 30. `Konstantin Maksimov <https://www.kaggle.com/maksimovka>`__
 97 |      `paper <https://ieeexplore.ieee.org/document/8783822/authors#authors>`__
 98 | 
 99 | `Severstal: Steel Defect Detection Challenge <https://www.kaggle.com/c/severstal-steel-defect-detection/>`_
100 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
101 | 27. `Ilia Larchenko <https://www.kaggle.com/ilialar>`__
102 |      `solution <https://www.kaggle.com/c/severstal-steel-defect-detection/discussion/115876>`_
103 | 
104 | Topcoder
105 | --------
106 | 2019
107 | ^^^^
108 | `Neptune - Facial Detection Marathon Match <https://www.topcoder.com/challenges/30086997>`__
109 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
110 | 2. `Miras Amir <https://www.linkedin.com/in/amirassov/>`__
111 |      `solution <https://github.com/amirassov/topcoder-facial-marathon>`__
112 | 
113 | `Neptune - Facial Re-Identification Marathon Match <https://www.topcoder.com/challenges/30086998>`__
114 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
115 | 2. `Miras Amir <https://www.linkedin.com/in/amirassov/>`__
116 |      `solution <https://github.com/amirassov/topcoder-facial-marathon>`__
117 | 
118 | 2018
119 | ^^^^
120 | `SpaceNet Challenge Round 4: Off-Nadir Buildings <https://spacenet.ai/off-nadir-building-detection/>`__
121 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
122 | 3. `Konstantin Maksimov <https://www.linkedin.com/in/konstantin-maksimov/>`__
123 |      `solution <https://github.com/SpaceNetChallenge/SpaceNet_Off_Nadir_Solutions/tree/master/MaksimovKA_solution>`__
124 | 
125 | CVPR
126 | ----
127 | 2018
128 | ^^^^
129 | 
130 | `DeepGlobe: Road Extraction <https://competitions.codalab.org/competitions/18467>`__
131 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
132 | 2. `Vladimir Iglovikov <https://www.linkedin.com/in/iglovikov/>`__, `Alexander Buslaev <https://www.kaggle.com/albuslaev>`__, `Selim Seferbekov <https://www.kaggle.com/selimsef>`__, `Alexey Shvets <https://www.linkedin.com/in/shvetsiya/>`__
133 |     `paper <http://openaccess.thecvf.com/content_cvpr_2018_workshops/papers/w4/Buslaev_Fully_Convolutional_Network_CVPR_2018_paper.pdf>`__
134 | 
135 | `Deepglobe: Building detection <https://competitions.codalab.org/competitions/18544>`__
136 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
137 | 2. `Vladimir Iglovikov <https://www.linkedin.com/in/iglovikov/>`__, `Alexander Buslaev <https://www.kaggle.com/albuslaev>`__, `Selim Seferbekov <https://www.kaggle.com/selimsef>`__, `Alexey Shvets <https://www.linkedin.com/in/shvetsiya/>`__
138 |     `paper <http://openaccess.thecvf.com/content_cvpr_2018_workshops/papers/w4/Iglovikov_TernausNetV2_Fully_Convolutional_CVPR_2018_paper.pdf>`__
139 | 
140 | `Deepglobe: Land Cover Classification <https://competitions.codalab.org/competitions/18468>`__
141 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
142 | 3. `Vladimir Iglovikov <https://www.linkedin.com/in/iglovikov/>`__, `Alexander Buslaev <https://www.kaggle.com/albuslaev>`__, `Selim Seferbekov <https://www.kaggle.com/selimsef>`__, `Alexey Shvets <https://www.linkedin.com/in/shvetsiya/>`__
143 |     `paper <http://openaccess.thecvf.com/content_cvpr_2018_workshops/papers/w4/Seferbekov_Feature_Pyramid_Network_CVPR_2018_paper.pdf>`__
144 | 
145 | MICCAI
146 | ------
147 | 2017
148 | ^^^^
149 | `Robotic Instrument Segmentation <https://endovissub2017-roboticinstrumentsegmentation.grand-challenge.org/>`__
150 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
151 | 1. `Vladimir Iglovikov <https://www.linkedin.com/in/iglovikov/>`__, `Alexey Shvets <https://www.linkedin.com/in/shvetsiya/>`__
152 |     `paper <https://ieeexplore.ieee.org/abstract/document/8614125>`__,
153 |     `pre-print from organizers <https://arxiv.org/abs/1902.06426>`__
154 | 
155 | `GIANA: Angiodysplasia localization <https://endovissub2017-giana.grand-challenge.org/Tasks/>`__
156 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
157 | 1. `Vladimir Iglovikov <https://www.linkedin.com/in/iglovikov/>`__, `Alexey Shvets <https://www.linkedin.com/in/shvetsiya/>`__
158 |     `paper <https://ieeexplore.ieee.org/abstract/document/8614123>`__
159 | 


--------------------------------------------------------------------------------
/docs/citations.rst:
--------------------------------------------------------------------------------
  1 | Citations
  2 | =========
  3 | Albumentations is widely used in research areas related to computer vision and deep learning.
  4 | If you find this library useful for your research, please consider citing:
  5 | 
  6 | ::
  7 | 
  8 |   @article{2018arXiv180906839B,
  9 |     author = {A. Buslaev, A. Parinov, E. Khvedchenya, V.~I. Iglovikov and A.~A. Kalinin},
 10 |     title = "{Albumentations: fast and flexible image augmentations}",
 11 |     journal = {ArXiv e-prints},
 12 |     eprint = {1809.06839},
 13 |     year = 2018
 14 |   }
 15 | 
 16 | List of papers that cite Albumentations
 17 | ----------------------------------------
 18 | 1. `Camera Model Identification Using Convolutional Neural Networks <https://ieeexplore.ieee.org/abstract/document/8622031/>`_.
 19 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 20 | October 2018 - `A Kuzin <https://scholar.google.com/citations?user=lHjLPBsAAAAJ&hl=en&oi=sra>`_, A Fattakhov, I Kibardin.
 21 | 
 22 | 2. `Automatic lesion boundary detection in dermoscopy <https://arxiv.org/abs/1812.00877>`_.
 23 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 24 | December 2018 - G Kechyn.
 25 | 
 26 | 3. `Automatic salt deposits segmentation: A deep learning approach <https://arxiv.org/abs/1812.01429>`_.
 27 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 28 | December 2018 - M Karchevskiy, `I Ashrapov <https://scholar.google.com/citations?user=eTn5PTIAAAAJ&hl=en&oi=sra>`_, L Kozinkin.
 29 | 
 30 | 4. `Adapting Convolutional Neural Networks for Geographical Domain Shift <https://arxiv.org/abs/1901.06345>`_.
 31 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 32 | January 2019 - `P Ostyakov <https://scholar.google.com/citations?user=mREcLI8AAAAJ&hl=en&oi=sra>`_, `SI Nikolenko <https://scholar.google.com/citations?user=_lk95cEAAAAJ&hl=en&oi=sra>`_.
 33 | 
 34 | 5. `Cell Nuclear Morphology Analysis Using 3D Shape Modeling, Machine Learning and Visual Analytics <https://deepblue.lib.umich.edu/handle/2027.42/147598>`_.
 35 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 36 | February 2019 - `A Kalinin <https://scholar.google.com/citations?user=oEHDAgMAAAAJ&hl=en&oi=sra>`_.
 37 | 
 38 | 6. `Safe Augmentation: Learning Task-Specific Transformations from Data <https://arxiv.org/abs/1907.12896>`_.
 39 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 40 | February 2019 - I Baran, `O Kupyn <https://scholar.google.com/citations?user=Yl1Lu2YAAAAJ&hl=en&oi=sra>`_, A Kravchenko.
 41 | 
 42 | 7. `Self-supervised Learning for Dense Depth Estimation in Monocular Endoscopy <https://arxiv.org/abs/1902.07766>`_.
 43 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 44 | February 2019 - `X Liu <https://scholar.google.com/citations?user=qMxRGQkAAAAJ&hl=en&oi=sra>`_, `A Sinha <https://scholar.google.com/citations?user=RrhxYCAAAAAJ&hl=en&oi=sra>`_, M Ishii, `GD Hager <https://scholar.google.com/citations?user=ivApfKcAAAAJ&hl=en&oi=sra>`_, `A Reiter <https://scholar.google.com/citations?user=CxKgqz0AAAAJ&hl=en&oi=sra>`_.
 45 | 
 46 | 8. `U-NetPlus: A Modified Encoder-Decoder U-Net Architecture for Semantic and Instance Segmentation of Surgical Instrument <https://arxiv.org/abs/1902.08994>`_.
 47 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 48 | February 2019 - `SM Hasan <https://scholar.google.com/citations?user=1-n7bwMAAAAJ&hl=en&oi=sra>`_, `CA Linte <https://scholar.google.com/citations?user=Gv4gGVsAAAAJ&hl=en&oi=sra>`_.
 49 | 
 50 | 9. `General Purpose (GenP) Bioimage Ensemble of Handcrafted and Learned Features with Data Augmentation <https://arxiv.org/abs/1904.08084>`_.
 51 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 52 | March 2019 - `L Nanni <https://scholar.google.com/citations?user=5NSGzcQAAAAJ&hl=en&oi=sra>`_, `S Brahnam <https://scholar.google.com/citations?user=sYF3eJkAAAAJ&hl=en&oi=sra>`_, `S Ghidoni <https://scholar.google.com/citations?user=s5PIk-4AAAAJ&hl=en&oi=sra>`_, `G Maguolo <https://scholar.google.com/citations?user=Df9a1YkAAAAJ&hl=en&oi=sra>`_.
 53 | 
 54 | 10. `Breast Tumor Cellularity Assessment using Deep Neural Networks <https://arxiv.org/abs/1905.01743>`_.
 55 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 56 | May 2019 - `A Rakhlin <https://scholar.google.com/citations?user=TIAJg3IAAAAJ&hl=en&oi=sra>`_, `AA Shvets <https://scholar.google.com/citations?user=_eJ5xysAAAAJ&hl=en&oi=sra>`_, `AA Kalinin <https://scholar.google.com/citations?user=oEHDAgMAAAAJ&hl=en&oi=sra>`_, `A Tiulpin <https://scholar.google.com/citations?user=EFE2gpQAAAAJ&hl=en&oi=sra>`_.
 57 | 
 58 | 11. `A Deep 3D Object Pose Estimation Framework for Robots with RGB-D Sensors <https://digitalcommons.wpi.edu/etd-theses/1287/>`_.
 59 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 60 | June 2019 - AY Wagh.
 61 | 
 62 | 12. `Data Augmentation From RGB to Chlorophyll Fluorescence Imaging Application to Leaf Segmentation of Arabidopsis thaliana From Top View Images <http://openaccess.thecvf.com/content_CVPRW_2019/html/CVPPP/Sapoukhina_Data_Augmentation_From_RGB_to_Chlorophyll_Fluorescence_Imaging_Application_to_CVPRW_2019_paper.html>`_.
 63 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 64 | June 2019 - N Sapoukhina, `S Samiei <https://scholar.google.com/citations?user=64L4ImgAAAAJ&hl=en&oi=sra>`_, `P Rasti <https://scholar.google.com/citations?user=hl8Jyr4AAAAJ&hl=en&oi=sra>`_.
 65 | 
 66 | 13. `CLoDSA: a tool for augmentation in classification, localization, detection, semantic segmentation and instance segmentation tasks <https://bmcbioinformatics.biomedcentral.com/articles/10.1186/s12859-019-2931-1>`_.
 67 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 68 | June 2019 - Á Casado-García, C Domínguez.
 69 | 
 70 | 14. `Urban Sound Tagging using Convolutional Neural Networks <https://arxiv.org/abs/1909.12699>`_.
 71 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 72 | July 2019 - `S Adapa <https://scholar.google.com/citations?user=SJUsAwsAAAAJ&hl=en&oi=sra>`_.
 73 | 
 74 | 15. `A Framework for Knowing Who is Doing What in Aerial Surveillance Videos <https://ieeexplore.ieee.org/abstract/document/8753491/>`_.
 75 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 76 | July 2019 - `F Yang <https://scholar.google.com/citations?user=LndV87gAAAAJ&hl=en&oi=sra>`_, `S Sakti <https://scholar.google.com/citations?user=E0uhtlkAAAAJ&hl=en&oi=sra>`_, Y Wu, S Nakamura.
 77 | 
 78 | 16. `Visual Anomaly Detection For Automatic Quality Control <https://boa.unimib.it/handle/10281/241219>`_.
 79 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 80 | July 2019 - `F Piccoli <https://scholar.google.com/citations?user=qBoFeZoAAAAJ&hl=en&oi=sra>`_.
 81 | 
 82 | 17. `Physical Cue based Depth-Sensing by Color Coding with Deaberration Network <https://arxiv.org/abs/1908.00329>`_.
 83 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 84 | August 2019 - N Mishima, T Kozakaya, A Moriya, R Okada.
 85 | 
 86 | 18. `Bayesian Feature Pyramid Networks for Automatic Multi-Label Segmentation of Chest X-rays and Assessment of Cardio-Thoratic Ratio <https://arxiv.org/abs/1908.02924>`_.
 87 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 88 | August 2019 - R Solovyev, `I Melekhov <https://scholar.google.com/citations?user=BXNprrsAAAAJ&hl=en&oi=sra>`_, T Lesonen.
 89 | 
 90 | 19. `DeblurGAN-v2: Deblurring (Orders-of-Magnitude) Faster and Better <https://arxiv.org/abs/1908.03826>`_.
 91 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 92 | August 2019 - `O Kupyn <https://scholar.google.com/citations?user=Yl1Lu2YAAAAJ&hl=en&oi=sra>`_, `T Martyniuk <https://scholar.google.com/citations?user=Ur0vgfMAAAAJ&hl=en&oi=sra>`_, `J Wu <https://scholar.google.com/citations?user=nBbGvyEAAAAJ&hl=en&oi=sra>`_, `Z Wang <https://scholar.google.com/citations?user=pxFyKAIAAAAJ&hl=en&oi=sra>`_.
 93 | 
 94 | 20. `The Impact of Padding on Image Classification by Using Pre-trained Convolutional Neural Networks <https://link.springer.com/chapter/10.1007/978-3-030-30645-8_31>`_.
 95 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 96 | September 2019 - H Tang, `A Ortis <https://scholar.google.com/citations?user=gcztqXgAAAAJ&hl=en&oi=sra>`_, `S Battiato <https://scholar.google.com/citations?user=OplbtHgAAAAJ&hl=en&oi=sra>`_.
 97 | 
 98 | 21. `A load frame for in situ tomography at PETRA III <https://www.spiedigitallibrary.org/conference-proceedings-of-spie/11113/1111318/A-load-frame-for-in-situ-tomography-at-PETRA-III/10.1117/12.2530445.short>`_.
 99 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
100 | September 2019 - J Moosmann, DCF Wieland.
101 | 
102 | 22. `Deep convolutions for in-depth automated rock typing <https://www.sciencedirect.com/science/article/pii/S0098300419304686>`_.
103 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
104 | September 2019 - EE Baraboshkin, `LS Ismailova <https://scholar.google.com/citations?user=-ZP9a8YAAAAJ&hl=en&oi=sra>`_, `DM Orlov <https://scholar.google.com/citations?user=jP69FIgAAAAJ&hl=en&oi=sra>`_.
105 | 
106 | 23. `残差密集相对平均 CGAN 的图像配准方法 <http://www.cjig.cn/jig/ch/reader/download_new_edit_content.aspx?edit_id=20190926091554001&file_no=201903270000001&journal_id=jig>`_.
107 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
108 | September 2019 - 王丽芳， 张程程， 秦品乐， 蔺素珍， 高媛， 窦杰亮.
109 | 
110 | 24. `Cloud Recognition and Masking of Earth Observation Imagery-An Optimized approach for Automatic Labeling of Sentinel-2 Imagery for Object Detection <https://ntnuopen.ntnu.no/ntnu-xmlui/handle/11250/2619036>`_.
111 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
112 | September 2019 - LM Ellefsen.
113 | 


--------------------------------------------------------------------------------
/tests/test_bbox.py:
--------------------------------------------------------------------------------
  1 | import numpy as np
  2 | import pytest
  3 | 
  4 | from albumentations.augmentations.bbox_utils import (
  5 |     normalize_bbox,
  6 |     denormalize_bbox,
  7 |     normalize_bboxes,
  8 |     denormalize_bboxes,
  9 |     calculate_bbox_area,
 10 |     convert_bbox_to_albumentations,
 11 |     convert_bbox_from_albumentations,
 12 |     convert_bboxes_to_albumentations,
 13 | )
 14 | from albumentations.core.composition import Compose, ReplayCompose, BboxParams
 15 | from albumentations.core.transforms_interface import NoOp
 16 | from albumentations import RandomSizedCrop, RandomResizedCrop, Rotate, RandomCrop
 17 | 
 18 | 
 19 | @pytest.mark.parametrize(
 20 |     ["bbox", "expected"],
 21 |     [((15, 25, 100, 200), (0.0375, 0.125, 0.25, 1.0)), ((15, 25, 100, 200, 99), (0.0375, 0.125, 0.25, 1.0, 99))],
 22 | )
 23 | def test_normalize_bbox(bbox, expected):
 24 |     normalized_bbox = normalize_bbox(bbox, 200, 400)
 25 |     assert normalized_bbox == expected
 26 | 
 27 | 
 28 | @pytest.mark.parametrize(
 29 |     ["bbox", "expected"],
 30 |     [((0.0375, 0.125, 0.25, 1.0), (15, 25, 100, 200)), ((0.0375, 0.125, 0.25, 1.0, 99), (15, 25, 100, 200, 99))],
 31 | )
 32 | def test_denormalize_bbox(bbox, expected):
 33 |     denormalized_bbox = denormalize_bbox(bbox, 200, 400)
 34 |     assert denormalized_bbox == expected
 35 | 
 36 | 
 37 | @pytest.mark.parametrize("bbox", [(15, 25, 100, 200), (15, 25, 100, 200, 99)])
 38 | def test_normalize_denormalize_bbox(bbox):
 39 |     normalized_bbox = normalize_bbox(bbox, 200, 400)
 40 |     denormalized_bbox = denormalize_bbox(normalized_bbox, 200, 400)
 41 |     assert denormalized_bbox == bbox
 42 | 
 43 | 
 44 | @pytest.mark.parametrize("bbox", [(0.0375, 0.125, 0.25, 1.0), (0.0375, 0.125, 0.25, 1.0, 99)])
 45 | def test_denormalize_normalize_bbox(bbox):
 46 |     denormalized_bbox = denormalize_bbox(bbox, 200, 400)
 47 |     normalized_bbox = normalize_bbox(denormalized_bbox, 200, 400)
 48 |     assert normalized_bbox == bbox
 49 | 
 50 | 
 51 | def test_normalize_bboxes():
 52 |     bboxes = [(15, 25, 100, 200), (15, 25, 100, 200, 99)]
 53 |     normalized_bboxes_1 = normalize_bboxes(bboxes, 200, 400)
 54 |     normalized_bboxes_2 = [normalize_bbox(bboxes[0], 200, 400), normalize_bbox(bboxes[1], 200, 400)]
 55 |     assert normalized_bboxes_1 == normalized_bboxes_2
 56 | 
 57 | 
 58 | def test_denormalize_bboxes():
 59 |     bboxes = [(0.0375, 0.125, 0.25, 1.0), (0.0375, 0.125, 0.25, 1.0, 99)]
 60 |     denormalized_bboxes_1 = denormalize_bboxes(bboxes, 200, 400)
 61 |     denormalized_bboxes_2 = [denormalize_bbox(bboxes[0], 200, 400), denormalize_bbox(bboxes[1], 200, 400)]
 62 |     assert denormalized_bboxes_1 == denormalized_bboxes_2
 63 | 
 64 | 
 65 | @pytest.mark.parametrize(
 66 |     ["bbox", "rows", "cols", "expected"], [((0, 0, 1, 1), 50, 100, 5000), ((0.2, 0.2, 1, 1, 99), 50, 50, 1600)]
 67 | )
 68 | def test_calculate_bbox_area(bbox, rows, cols, expected):
 69 |     area = calculate_bbox_area(bbox, rows, cols)
 70 |     assert area == expected
 71 | 
 72 | 
 73 | @pytest.mark.parametrize(
 74 |     ["bbox", "source_format", "expected"],
 75 |     [
 76 |         ((20, 30, 40, 50), "coco", (0.2, 0.3, 0.6, 0.8)),
 77 |         ((20, 30, 40, 50, 99), "coco", (0.2, 0.3, 0.6, 0.8, 99)),
 78 |         ((20, 30, 60, 80), "pascal_voc", (0.2, 0.3, 0.6, 0.8)),
 79 |         ((20, 30, 60, 80, 99), "pascal_voc", (0.2, 0.3, 0.6, 0.8, 99)),
 80 |         ((0.2, 0.3, 0.4, 0.5), "yolo", (0.00, 0.05, 0.40, 0.55)),
 81 |         ((0.2, 0.3, 0.4, 0.5, 99), "yolo", (0.00, 0.05, 0.40, 0.55, 99)),
 82 |         ((0.1, 0.1, 0.2, 0.2), "yolo", (0.0, 0.0, 0.2, 0.2)),
 83 |         ((0.99662423, 0.7520255, 0.00675154, 0.01446759), "yolo", (0.99324846, 0.744791705, 1.0, 0.759259295)),
 84 |         ((0.9375, 0.510416, 0.1234375, 0.97638), "yolo", (0.87578125, 0.022226, 0.999218749, 0.998606)),
 85 |     ],
 86 | )
 87 | def test_convert_bbox_to_albumentations(bbox, source_format, expected):
 88 |     image = np.ones((100, 100, 3))
 89 | 
 90 |     converted_bbox = convert_bbox_to_albumentations(
 91 |         bbox, rows=image.shape[0], cols=image.shape[1], source_format=source_format
 92 |     )
 93 |     assert np.all(np.isclose(converted_bbox, expected))
 94 | 
 95 | 
 96 | @pytest.mark.parametrize(
 97 |     ["bbox", "target_format", "expected"],
 98 |     [
 99 |         ((0.2, 0.3, 0.6, 0.8), "coco", (20, 30, 40, 50)),
100 |         ((0.2, 0.3, 0.6, 0.8, 99), "coco", (20, 30, 40, 50, 99)),
101 |         ((0.2, 0.3, 0.6, 0.8), "pascal_voc", (20, 30, 60, 80)),
102 |         ((0.2, 0.3, 0.6, 0.8, 99), "pascal_voc", (20, 30, 60, 80, 99)),
103 |         ((0.00, 0.05, 0.40, 0.55), "yolo", (0.2, 0.3, 0.4, 0.5)),
104 |         ((0.00, 0.05, 0.40, 0.55, 99), "yolo", (0.2, 0.3, 0.4, 0.5, 99)),
105 |     ],
106 | )
107 | def test_convert_bbox_from_albumentations(bbox, target_format, expected):
108 |     image = np.ones((100, 100, 3))
109 |     converted_bbox = convert_bbox_from_albumentations(
110 |         bbox, rows=image.shape[0], cols=image.shape[1], target_format=target_format
111 |     )
112 |     assert np.all(np.isclose(converted_bbox, expected))
113 | 
114 | 
115 | @pytest.mark.parametrize(
116 |     ["bbox", "bbox_format"],
117 |     [
118 |         ((20, 30, 40, 50), "coco"),
119 |         ((20, 30, 40, 50, 99), "coco"),
120 |         ((20, 30, 41, 51, 99), "coco"),
121 |         ((21, 31, 40, 50, 99), "coco"),
122 |         ((21, 31, 41, 51, 99), "coco"),
123 |         ((20, 30, 60, 80), "pascal_voc"),
124 |         ((20, 30, 60, 80, 99), "pascal_voc"),
125 |         ((20, 30, 61, 81, 99), "pascal_voc"),
126 |         ((21, 31, 60, 80, 99), "pascal_voc"),
127 |         ((21, 31, 61, 81, 99), "pascal_voc"),
128 |         ((0.01, 0.06, 0.41, 0.56), "yolo"),
129 |         ((0.01, 0.06, 0.41, 0.56, 99), "yolo"),
130 |         ((0.02, 0.06, 0.42, 0.56, 99), "yolo"),
131 |         ((0.01, 0.05, 0.41, 0.55, 99), "yolo"),
132 |         ((0.02, 0.06, 0.41, 0.55, 99), "yolo"),
133 |     ],
134 | )
135 | def test_convert_bbox_to_albumentations_and_back(bbox, bbox_format):
136 |     image = np.ones((100, 100, 3))
137 |     converted_bbox = convert_bbox_to_albumentations(
138 |         bbox, rows=image.shape[0], cols=image.shape[1], source_format=bbox_format
139 |     )
140 |     converted_back_bbox = convert_bbox_from_albumentations(
141 |         converted_bbox, rows=image.shape[0], cols=image.shape[1], target_format=bbox_format
142 |     )
143 |     assert np.all(np.isclose(converted_back_bbox, bbox))
144 | 
145 | 
146 | def test_convert_bboxes_to_albumentations():
147 |     bboxes = [(20, 30, 40, 50), (30, 40, 50, 60, 99)]
148 |     image = np.ones((100, 100, 3))
149 |     converted_bboxes = convert_bboxes_to_albumentations(
150 |         bboxes, rows=image.shape[0], cols=image.shape[1], source_format="coco"
151 |     )
152 |     converted_bbox_1 = convert_bbox_to_albumentations(
153 |         bboxes[0], rows=image.shape[0], cols=image.shape[1], source_format="coco"
154 |     )
155 |     converted_bbox_2 = convert_bbox_to_albumentations(
156 |         bboxes[1], rows=image.shape[0], cols=image.shape[1], source_format="coco"
157 |     )
158 |     assert converted_bboxes == [converted_bbox_1, converted_bbox_2]
159 | 
160 | 
161 | def test_convert_bboxes_from_albumentations():
162 |     bboxes = [(0.2, 0.3, 0.6, 0.8), (0.3, 0.4, 0.7, 0.9, 99)]
163 |     image = np.ones((100, 100, 3))
164 |     converted_bboxes = convert_bboxes_to_albumentations(
165 |         bboxes, rows=image.shape[0], cols=image.shape[1], source_format="coco"
166 |     )
167 |     converted_bbox_1 = convert_bbox_to_albumentations(
168 |         bboxes[0], rows=image.shape[0], cols=image.shape[1], source_format="coco"
169 |     )
170 |     converted_bbox_2 = convert_bbox_to_albumentations(
171 |         bboxes[1], rows=image.shape[0], cols=image.shape[1], source_format="coco"
172 |     )
173 |     assert converted_bboxes == [converted_bbox_1, converted_bbox_2]
174 | 
175 | 
176 | @pytest.mark.parametrize(
177 |     ["bboxes", "bbox_format", "labels"],
178 |     [
179 |         ([(20, 30, 40, 50)], "coco", [1]),
180 |         ([(20, 30, 40, 50, 99), (10, 40, 30, 20, 9)], "coco", None),
181 |         ([(20, 30, 60, 80)], "pascal_voc", [2]),
182 |         ([(20, 30, 60, 80, 99)], "pascal_voc", None),
183 |         ([(0.1, 0.2, 0.1, 0.2)], "yolo", [2]),
184 |         ([(0.1, 0.2, 0.1, 0.2, 99)], "yolo", None),
185 |     ],
186 | )
187 | def test_compose_with_bbox_noop(bboxes, bbox_format, labels):
188 |     image = np.ones((100, 100, 3))
189 |     if labels is not None:
190 |         aug = Compose([NoOp(p=1.0)], bbox_params={"format": bbox_format, "label_fields": ["labels"]})
191 |         transformed = aug(image=image, bboxes=bboxes, labels=labels)
192 |     else:
193 |         aug = Compose([NoOp(p=1.0)], bbox_params={"format": bbox_format})
194 |         transformed = aug(image=image, bboxes=bboxes)
195 |     assert np.array_equal(transformed["image"], image)
196 |     assert np.all(np.isclose(transformed["bboxes"], bboxes))
197 | 
198 | 
199 | @pytest.mark.parametrize(["bboxes", "bbox_format"], [[[[20, 30, 40, 50]], "coco"]])
200 | def test_compose_with_bbox_noop_error_label_fields(bboxes, bbox_format):
201 |     image = np.ones((100, 100, 3))
202 |     aug = Compose([NoOp(p=1.0)], bbox_params={"format": bbox_format})
203 |     with pytest.raises(Exception):
204 |         aug(image=image, bboxes=bboxes)
205 | 
206 | 
207 | @pytest.mark.parametrize(
208 |     ["bboxes", "bbox_format", "labels"],
209 |     [
210 |         [[(20, 30, 60, 80)], "pascal_voc", {"label": [1]}],
211 |         [[], "pascal_voc", {}],
212 |         [[], "pascal_voc", {"label": []}],
213 |         [[(20, 30, 60, 80)], "pascal_voc", {"id": [3]}],
214 |         [[(20, 30, 60, 80), (30, 40, 40, 50)], "pascal_voc", {"id": [3, 1]}],
215 |         [[(20, 30, 60, 80, 1, 11), (30, 40, 40, 50, 2, 22)], "pascal_voc", {"id": [3, 1]}],
216 |         [[(20, 30, 60, 80, 1, 11), (30, 40, 40, 50, 2, 22)], "pascal_voc", {}],
217 |         [[(20, 30, 60, 80, 1, 11), (30, 40, 40, 50, 2, 21)], "pascal_voc", {"id": [31, 32], "subclass": [311, 321]}],
218 |     ],
219 | )
220 | def test_compose_with_bbox_noop_label_outside(bboxes, bbox_format, labels):
221 |     image = np.ones((100, 100, 3))
222 |     aug = Compose([NoOp(p=1.0)], bbox_params={"format": bbox_format, "label_fields": list(labels.keys())})
223 |     transformed = aug(image=image, bboxes=bboxes, **labels)
224 |     assert np.array_equal(transformed["image"], image)
225 |     assert transformed["bboxes"] == bboxes
226 |     for k, v in labels.items():
227 |         assert transformed[k] == v
228 | 
229 | 
230 | def test_random_sized_crop_size():
231 |     image = np.ones((100, 100, 3))
232 |     bboxes = [(0.2, 0.3, 0.6, 0.8), (0.3, 0.4, 0.7, 0.9, 99)]
233 |     aug = RandomSizedCrop(min_max_height=(70, 90), height=50, width=50, p=1.0)
234 |     transformed = aug(image=image, bboxes=bboxes)
235 |     assert transformed["image"].shape == (50, 50, 3)
236 |     assert len(bboxes) == len(transformed["bboxes"])
237 | 
238 | 
239 | def test_random_resized_crop_size():
240 |     image = np.ones((100, 100, 3))
241 |     bboxes = [(0.2, 0.3, 0.6, 0.8), (0.3, 0.4, 0.7, 0.9, 99)]
242 |     aug = RandomResizedCrop(height=50, width=50, p=1.0)
243 |     transformed = aug(image=image, bboxes=bboxes)
244 |     assert transformed["image"].shape == (50, 50, 3)
245 |     assert len(bboxes) == len(transformed["bboxes"])
246 | 
247 | 
248 | def test_random_rotate():
249 |     image = np.ones((192, 192, 3))
250 |     bboxes = [(78, 42, 142, 80)]
251 |     aug = Rotate(limit=15, p=1.0)
252 |     transformed = aug(image=image, bboxes=bboxes)
253 |     assert len(bboxes) == len(transformed["bboxes"])
254 | 
255 | 
256 | def test_crop_boxes_replay_compose():
257 |     image = np.ones((512, 384, 3))
258 |     bboxes = [(78, 42, 142, 80), (32, 12, 42, 72), (200, 100, 300, 200)]
259 |     labels = [0, 1, 2]
260 |     transform = ReplayCompose(
261 |         [RandomCrop(256, 256, p=1.0)],
262 |         bbox_params=BboxParams(format="pascal_voc", min_area=16, label_fields=["labels"]),
263 |     )
264 | 
265 |     input_data = dict(image=image, bboxes=bboxes, labels=labels)
266 |     transformed = transform(**input_data)
267 |     transformed2 = ReplayCompose.replay(transformed["replay"], **input_data)
268 | 
269 |     np.testing.assert_almost_equal(transformed["bboxes"], transformed2["bboxes"])
270 | 


--------------------------------------------------------------------------------
/docs/_templates/layout.html:
--------------------------------------------------------------------------------
  1 | {# TEMPLATE VAR SETTINGS #}
  2 | {%- set url_root = pathto('', 1) %}
  3 | {%- if url_root == '#' %}{% set url_root = '' %}{% endif %}
  4 | {%- if not embedded and docstitle %}
  5 |   {%- set titlesuffix = " &mdash; "|safe + docstitle|e %}
  6 | {%- else %}
  7 |   {%- set titlesuffix = "" %}
  8 | {%- endif %}
  9 | {%- set lang_attr = 'en' if language == None else (language | replace('_', '-')) %}
 10 | 
 11 | <!DOCTYPE html>
 12 | <!--[if IE 8]><html class="no-js lt-ie9" lang="{{ lang_attr }}" > <![endif]-->
 13 | <!--[if gt IE 8]><!--> <html class="no-js" lang="{{ lang_attr }}" > <!--<![endif]-->
 14 | <head>
 15 |   <meta charset="utf-8">
 16 |   {{ metatags }}
 17 |   <meta name="viewport" content="width=device-width, initial-scale=1.0">
 18 |   {% block htmltitle %}
 19 |   <title>{{ title|striptags|e }}{{ titlesuffix }}</title>
 20 |   {% endblock %}
 21 | 
 22 |   {# FAVICON #}
 23 |   {% if favicon %}
 24 |     <link rel="shortcut icon" href="{{ pathto('_static/' + favicon, 1) }}"/>
 25 |   {% endif %}
 26 |   {# CANONICAL URL #}
 27 |   {% if theme_canonical_url %}
 28 |     <link rel="canonical" href="{{ theme_canonical_url }}{{ pagename }}.html"/>
 29 |   {% endif %}
 30 | 
 31 |   {# JAVASCRIPTS #}
 32 |   {%- block scripts %}
 33 |   <script type="text/javascript" src="{{ pathto('_static/js/modernizr.min.js', 1) }}"></script>
 34 |   {%- if not embedded %}
 35 |   {# XXX Sphinx 1.8.0 made this an external js-file, quick fix until we refactor the template to inherert more blocks directly from sphinx #}
 36 |     {% if sphinx_version >= "1.8.0" %}
 37 |       <script type="text/javascript" id="documentation_options" data-url_root="{{ pathto('', 1) }}" src="{{ pathto('_static/documentation_options.js', 1) }}"></script>
 38 |       {%- for scriptfile in script_files %}
 39 |         {{ js_tag(scriptfile) }}
 40 |       {%- endfor %}
 41 |     {% else %}
 42 |       <script type="text/javascript">
 43 |           var DOCUMENTATION_OPTIONS = {
 44 |               URL_ROOT:'{{ url_root }}',
 45 |               VERSION:'{{ release|e }}',
 46 |               LANGUAGE:'{{ language }}',
 47 |               COLLAPSE_INDEX:false,
 48 |               FILE_SUFFIX:'{{ '' if no_search_suffix else file_suffix }}',
 49 |               HAS_SOURCE:  {{ has_source|lower }},
 50 |               SOURCELINK_SUFFIX: '{{ sourcelink_suffix }}'
 51 |           };
 52 |       </script>
 53 |       {%- for scriptfile in script_files %}
 54 |         <script type="text/javascript" src="{{ pathto(scriptfile, 1) }}"></script>
 55 |       {%- endfor %}
 56 |     {% endif %}
 57 |     <script type="text/javascript" src="{{ pathto('_static/js/theme.js', 1) }}"></script>
 58 | 
 59 |     {# OPENSEARCH #}
 60 |     {%- if use_opensearch %}
 61 |     <link rel="search" type="application/opensearchdescription+xml"
 62 |           title="{% trans docstitle=docstitle|e %}Search within {{ docstitle }}{% endtrans %}"
 63 |           href="{{ pathto('_static/opensearch.xml', 1) }}"/>
 64 |     {%- endif %}
 65 |   {%- endif %}
 66 |   {%- endblock %}
 67 | 
 68 |   {# CSS #}
 69 |   <link rel="stylesheet" href="{{ pathto('_static/' + style, 1) }}" type="text/css" />
 70 |   <link rel="stylesheet" href="{{ pathto('_static/pygments.css', 1) }}" type="text/css" />
 71 |   {%- for css in css_files %}
 72 |     {%- if css|attr("rel") %}
 73 |   <link rel="{{ css.rel }}" href="{{ pathto(css.filename, 1) }}" type="text/css"{% if css.title is not none %} title="{{ css.title }}"{% endif %} />
 74 |     {%- else %}
 75 |   <link rel="stylesheet" href="{{ pathto(css, 1) }}" type="text/css" />
 76 |     {%- endif %}
 77 |   {%- endfor %}
 78 | 
 79 |   {%- for cssfile in extra_css_files %}
 80 |     <link rel="stylesheet" href="{{ pathto(cssfile, 1) }}" type="text/css" />
 81 |   {%- endfor %}
 82 |   <style>
 83 |     .wy-side-nav-search {
 84 |       background-color: #ffffff;
 85 |     }
 86 |     .wy-side-nav-search>a, .wy-side-nav-search .wy-dropdown>a {
 87 |       color: #222;
 88 |     }
 89 |     .wy-side-nav-search>div.version {
 90 |       color: #222;
 91 |     }
 92 |   </style>
 93 | 
 94 |   {%- block linktags %}
 95 |     {%- if hasdoc('about') %}
 96 |     <link rel="author" title="{{ _('About these documents') }}" href="{{ pathto('about') }}" />
 97 |     {%- endif %}
 98 |     {%- if hasdoc('genindex') %}
 99 |     <link rel="index" title="{{ _('Index') }}" href="{{ pathto('genindex') }}" />
100 |     {%- endif %}
101 |     {%- if hasdoc('search') %}
102 |     <link rel="search" title="{{ _('Search') }}" href="{{ pathto('search') }}" />
103 |     {%- endif %}
104 |     {%- if hasdoc('copyright') %}
105 |     <link rel="copyright" title="{{ _('Copyright') }}" href="{{ pathto('copyright') }}" />
106 |     {%- endif %}
107 |     {%- if next %}
108 |     <link rel="next" title="{{ next.title|striptags|e }}" href="{{ next.link|e }}" />
109 |     {%- endif %}
110 |     {%- if prev %}
111 |     <link rel="prev" title="{{ prev.title|striptags|e }}" href="{{ prev.link|e }}" />
112 |     {%- endif %}
113 |   {%- endblock %}
114 |   {%- block extrahead %} {% endblock %}
115 | </head>
116 | 
117 | <body class="wy-body-for-nav">
118 |   <style>
119 |     #documentation-link-header {
120 |       position: static;
121 |       top: 0;
122 |       left: 0;
123 |       width: 100%;
124 |       color: white;
125 |       font-size: 24px;
126 |       text-align: center;
127 |       padding: 10px 0;
128 |       height: 50px;
129 |       background: #448aff;
130 |       z-index: 999999
131 |     }
132 | 
133 |     .wy-nav-side {
134 |         top: 50px
135 |     }
136 | 
137 |     #documentation-link-header a {
138 |       color: white;
139 |       text-decoration: underline;
140 |     }
141 | 
142 |     #documentation-link-header a:hover {
143 |       text-decoration: none;
144 |     }
145 | 
146 |     @media only screen and (max-width: 600px) {
147 |       #documentation-link-header {
148 |         font-size: 18px;
149 |         height: 90px;
150 |       }
151 |       .wy-nav-side {
152 |         top: 90px;
153 |       }
154 | 
155 |     }
156 | 
157 |     @media only screen and (min-width: 600px) {
158 |       #documentation-link-header {
159 |         font-size: 20px;
160 |         height: 75px;
161 |       }
162 |       .wy-nav-side {
163 |         top: 75px;
164 |       }
165 |     }
166 | 
167 |     @media only screen and (min-width: 768px) {
168 |       #documentation-link-header {
169 |         height: 70px;
170 |       }
171 | 
172 |       .wy-nav-side {
173 |         top: 70px;
174 |       }
175 |     }
176 | 
177 |     @media only screen and (min-width: 992px) {
178 |       #documentation-link-header {
179 |         height: 50px;
180 |       }
181 | 
182 |       .wy-nav-side {
183 |         top: 50px
184 |     }
185 | 
186 |     }
187 |   </style>
188 | 
189 |   <div id="documentation-link-header">The updated and extended version of the documentation is available at <a
190 |       href="https://albumentations.ai/docs/">https://albumentations.ai/docs/</a>
191 |   </div>
192 | 
193 |   {% block extrabody %}{% endblock %}
194 |   <div class="wy-grid-for-nav">
195 |     {# SIDE NAV, TOGGLES ON MOBILE #}
196 |     <nav data-toggle="wy-nav-shift" class="wy-nav-side">
197 |       <div class="wy-side-scroll">
198 |         <div class="wy-side-nav-search" {% if theme_style_nav_header_background %} style="background: {{theme_style_nav_header_background}}" {% endif %}>
199 |           {% block sidebartitle %}
200 | 
201 |           {% if logo and theme_logo_only %}
202 |             <a href="{{ pathto(master_doc) }}">
203 |           {% else %}
204 |             <a href="{{ pathto(master_doc) }}" class="icon icon-home" alt="{{ _("Documentation Home") }}"> {{ project }}
205 |           {% endif %}
206 | 
207 |           {% if logo %}
208 |             {# Not strictly valid HTML, but it's the only way to display/scale
209 |                it properly, without weird scripting or heaps of work
210 |             #}
211 |             <img src="{{ pathto('_static/' + logo, 1) }}" class="logo" alt="{{ _('Logo') }}"/>
212 |           {% endif %}
213 |           </a>
214 | 
215 |           {% if theme_display_version %}
216 |             {%- set nav_version = version %}
217 |             {% if READTHEDOCS and current_version %}
218 |               {%- set nav_version = current_version %}
219 |             {% endif %}
220 |             {% if nav_version %}
221 |               <div class="version">
222 |                 {{ nav_version }}
223 |               </div>
224 |             {% endif %}
225 |           {% endif %}
226 | 
227 |           {% include "searchbox.html" %}
228 |           {% endblock %}
229 |         </div>
230 | 
231 |         {% block navigation %}
232 |         <div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="main navigation">
233 |           <div style="padding: 5px 10px 10px 10px; text-align: center; width: 100%">
234 |             <iframe
235 |               src="https://ghbtns.com/github-btn.html?user=albumentations-team&repo=albumentations&type=star&count=true&size=large"
236 |               frameborder="0" scrolling="0" width="170" height="30" title="GitHub"></iframe>
237 |           </div>
238 |           {% block menu %}
239 |             {#
240 |               The singlehtml builder doesn't handle this toctree call when the
241 |               toctree is empty. Skip building this for now.
242 |             #}
243 |             {% if 'singlehtml' not in builder %}
244 |               {% set global_toc = toctree(maxdepth=4,
245 |                                           collapse=True,
246 |                                           includehidden=True,
247 |                                           titles_only=False) %}
248 |             {% endif %}
249 |             {% if global_toc %}
250 |               {{ global_toc }}
251 |             {% else %}
252 |               <!-- Local TOC -->
253 |               <div class="local-toc">{{ toc }}</div>
254 |             {% endif %}
255 |           {% endblock %}
256 |         </div>
257 |         {% endblock %}
258 |       </div>
259 |     </nav>
260 | 
261 |     <section data-toggle="wy-nav-shift" class="wy-nav-content-wrap">
262 | 
263 |       {# MOBILE NAV, TRIGGLES SIDE NAV ON TOGGLE #}
264 |       <nav class="wy-nav-top" aria-label="top navigation">
265 |         {% block mobile_nav %}
266 |           <i data-toggle="wy-nav-top" class="fa fa-bars"></i>
267 |           <a href="{{ pathto(master_doc) }}">{{ project }}</a>
268 |         {% endblock %}
269 |       </nav>
270 | 
271 | 
272 |       <div class="wy-nav-content">
273 |       {%- block content %}
274 |         {% if theme_style_external_links|tobool %}
275 |         <div class="rst-content style-external-links">
276 |         {% else %}
277 |         <div class="rst-content">
278 |         {% endif %}
279 |           {% include "breadcrumbs.html" %}
280 |           <div role="main" class="document" itemscope="itemscope" itemtype="http://schema.org/Article">
281 |           {%- block document %}
282 |            <div itemprop="articleBody">
283 |             {% block body %}{% endblock %}
284 |            </div>
285 |            {% if self.comments()|trim %}
286 |            <div class="articleComments">
287 |             {% block comments %}{% endblock %}
288 |            </div>
289 |            {% endif%}
290 |           </div>
291 |           {%- endblock %}
292 |           {% include "footer.html" %}
293 |         </div>
294 |       {%- endblock %}
295 |       </div>
296 | 
297 |     </section>
298 | 
299 |   </div>
300 |   {% include "versions.html" %}
301 | 
302 |   <script type="text/javascript">
303 |       jQuery(function () {
304 |           SphinxRtdTheme.Navigation.enable({{ 'true' if theme_sticky_navigation|tobool else 'false' }});
305 |       });
306 |   </script>
307 | 
308 |   {# Do not conflict with RTD insertion of analytics script #}
309 |   {% if not READTHEDOCS %}
310 |     {% if theme_analytics_id %}
311 |     <!-- Theme Analytics -->
312 |     <script>
313 |     (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
314 |       (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
315 |       m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
316 |     })(window,document,'script','https://www.google-analytics.com/analytics.js','ga');
317 |     ga('create', '{{ theme_analytics_id }}', 'auto');
318 |     ga('send', 'pageview');
319 |     </script>
320 | 
321 |     {% endif %}
322 |   {% endif %}
323 | 
324 |   {%- block footer %} {% endblock %}
325 | 
326 | </body>
327 | </html>
328 | 


--------------------------------------------------------------------------------