+
+
+
+
+
+*Kornia* is a differentiable computer vision library for [PyTorch](https://pytorch.org).
+
+It consists of a set of routines and differentiable modules to solve generic computer vision problems. At its core, the package uses *PyTorch* as its main backend both for efficiency and to take advantage of the reverse-mode auto-differentiation to define and compute the gradient of complex functions.
+
+
+ 
+
+
+
+
+ 
+
+
+
+
+## Overview
+
+Inspired by existing packages, this library is composed by a subset of packages containing operators that can be inserted within neural networks to train models to perform image transformations, epipolar geometry, depth estimation, and low-level image processing such as filtering and edge detection that operate directly on tensors.
+
+At a granular level, Kornia is a library that consists of the following components:
+
+| **Component** | **Description** |
+|----------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------|
+| [kornia](https://kornia.readthedocs.io/en/latest/index.html) | a Differentiable Computer Vision library, with strong GPU support |
+| [kornia.augmentation](https://kornia.readthedocs.io/en/latest/augmentation.html) | a module to perform data augmentation in the GPU |
+| [kornia.color](https://kornia.readthedocs.io/en/latest/color.html) | a set of routines to perform color space conversions |
+| [kornia.contrib](https://kornia.readthedocs.io/en/latest/contrib.html) | a compilation of user contrib and experimental operators |
+| [kornia.enhance](https://kornia.readthedocs.io/en/latest/enhance.html) | a module to perform normalization and intensity transformation |
+| [kornia.feature](https://kornia.readthedocs.io/en/latest/feature.html) | a module to perform feature detection |
+| [kornia.filters](https://kornia.readthedocs.io/en/latest/filters.html) | a module to perform image filtering and edge detection |
+| [kornia.geometry](https://kornia.readthedocs.io/en/latest/geometry.html) | a geometric computer vision library to perform image transformations, 3D linear algebra and conversions using different camera models |
+| [kornia.losses](https://kornia.readthedocs.io/en/latest/losses.html) | a stack of loss functions to solve different vision tasks |
+| [kornia.morphology](https://kornia.readthedocs.io/en/latest/morphology.html) | a module to perform morphological operations |
+| [kornia.utils](https://kornia.readthedocs.io/en/latest/utils.html) | image to tensor utilities and metrics for vision problems |
+
+## Installation
+
+### From pip:
+
+ ```bash
+ pip install kornia
+ pip install kornia[x] # to get the training API !
+ ```
+
+
+
+
+
+
+## Examples
+
+Run our Jupyter notebooks [tutorials](https://kornia-tutorials.readthedocs.io/en/latest/) to learn to use the library.
+
+Other installation options
+ + #### From source: + + ```bash + python setup.py install + ``` + + #### From source with symbolic links: + + ```bash + pip install -e . + ``` + + #### From source using pip: + + ```bash + pip install git+https://github.com/kornia/kornia + ``` + +
+
+ 
+
+
+
+:triangular_flag_on_post: **Updates**
+- :white_check_mark: Integrated to [Huggingface Spaces](https://huggingface.co/spaces) with [Gradio](https://github.com/gradio-app/gradio). See [Gradio Web Demo](https://huggingface.co/spaces/akhaliq/Kornia-LoFTR).
+
+## Cite
+
+If you are using kornia in your research-related documents, it is recommended that you cite the paper. See more in [CITATION](https://github.com/kornia/kornia/blob/master/CITATION.md).
+
+ ```bash
+ @inproceedings{eriba2019kornia,
+ author = {E. Riba, D. Mishkin, D. Ponsa, E. Rublee and G. Bradski},
+ title = {Kornia: an Open Source Differentiable Computer Vision Library for PyTorch},
+ booktitle = {Winter Conference on Applications of Computer Vision},
+ year = {2020},
+ url = {https://arxiv.org/pdf/1910.02190.pdf}
+ }
+ ```
+
+## Contributing
+We appreciate all contributions. If you are planning to contribute back bug-fixes, please do so without any further discussion. If you plan to contribute new features, utility functions or extensions, please first open an issue and discuss the feature with us. Please, consider reading the [CONTRIBUTING](https://github.com/kornia/kornia/blob/master/CONTRIBUTING.rst) notes. The participation in this open source project is subject to [Code of Conduct](https://github.com/kornia/kornia/blob/master/CODE_OF_CONDUCT.md).
+
+
+## Community
+- **Forums:** discuss implementations, research, etc. [GitHub Forums](https://github.com/kornia/kornia/discussions)
+- **GitHub Issues:** bug reports, feature requests, install issues, RFCs, thoughts, etc. [OPEN](https://github.com/kornia/kornia/issues/new/choose)
+- **Slack:** Join our workspace to keep in touch with our core contributors and be part of our community. [JOIN HERE](https://join.slack.com/t/kornia/shared_invite/zt-csobk21g-CnydWe5fmvkcktIeRFGCEQ)
+- For general information, please visit our website at www.kornia.org
diff --git a/README_zh-CN.md b/README_zh-CN.md
new file mode 100644
index 0000000000000000000000000000000000000000..563c0f08f0c89eacd554662d81a8a2fbd5c446ac
--- /dev/null
+++ b/README_zh-CN.md
@@ -0,0 +1,145 @@
+
+
+
+
+
+*Kornia* ๆฏไธๆฌพๅบไบ [PyTorch](https://pytorch.org) ็ๅฏๅพฎๅ็่ฎก็ฎๆบ่ง่งๅบใ
+
+ๅฎ็ฑไธ็ป็จไบ่งฃๅณ้็จ่ฎก็ฎๆบ่ง่ง้ฎ้ข็ๆไฝๆจกๅๅๅฏๅพฎๅๆจกๅ็ปๆใๅ
ถๆ ธๅฟไฝฟ็จ *PyTorch* ไฝไธบไธป่ฆๅ็ซฏ๏ผไปฅๆ้ซๆ็ๅนถๅฉ็จๅๅๆจกๅผ่ชๅจๅพฎๅๆฅๅฎไนๅ่ฎก็ฎๅคๆๅฝๆฐ็ๆขฏๅบฆใ
+
+
+ 
+
+
+
+
+
+
+## ๆฆ่ง
+
+ๅ็ฐๆๅผๆบๅบ็ๅฏๅ๏ผKorniaๅฏไปฅ็ฑๅ
ๅซๅ็งๅฏไปฅๅตๅ
ฅ็ฅ็ป็ฝ็ป็ๆไฝ็ฌฆ็ปๆ๏ผๅนถๅฏไปฅ่ฎญ็ปๆจกๅๆฅๆง่กๅพๅๅๆขใๅฏนๆๅ ไฝใๆทฑๅบฆไผฐ่ฎกๅไฝ็บงๅพๅๅค็๏ผไพๅฆ่ฟๆปคๅ่พน็ผๆฃๆตใๆญคๅค๏ผๆดไธชๅบ้ฝๅฏไปฅ็ดๆฅๅฏนๅผ ้่ฟ่กๆไฝใ
+
+่ฏฆ็ปๆฅ่ฏด๏ผKornia ๆฏไธไธชๅ
ๅซไปฅไธ็ปไปถ็ๅบ๏ผ
+
+| **Component** | **Description** |
+|----------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------|
+| [kornia](https://kornia.readthedocs.io/en/latest/index.html) | ๅ
ทๆๅผบๅคง GPU ๆฏๆ็ๅฏๅพฎ่ฎก็ฎๆบ่ง่งๅบ |
+| [kornia.augmentation](https://kornia.readthedocs.io/en/latest/augmentation.html) | ๅจ GPU ไธญๆง่กๆฐๆฎๅขๅผบ็ๆจกๅ |
+| [kornia.color](https://kornia.readthedocs.io/en/latest/color.html) | ๆง่ก่ฒๅฝฉ็ฉบ้ด่ฝฌๆข็ๆจกๅ |
+| [kornia.contrib](https://kornia.readthedocs.io/en/latest/contrib.html) | ๆช่ฟๅ
ฅ็จณๅฎ็ๆฌ็ๅฎ้ชๆงๆจกๅ |
+| [kornia.enhance](https://kornia.readthedocs.io/en/latest/enhance.html) | ๆง่กๅฝไธๅๅๅ็ด ๅผบๅบฆๅๆข็ๆจกๅ |
+| [kornia.feature](https://kornia.readthedocs.io/en/latest/feature.html) | ๆง่ก็นๅพๆฃๆต็ๆจกๅ |
+| [kornia.filters](https://kornia.readthedocs.io/en/latest/filters.html) | ๆง่กๅพๅๆปคๆณขๅ่พน็ผๆฃๆต็ๆจกๅ |
+| [kornia.geometry](https://kornia.readthedocs.io/en/latest/geometry.html) | ๆง่กๅ ไฝ่ฎก็ฎ็ๆจกๅ๏ผ็จไบไฝฟ็จไธๅ็็ธๆบๆจกๅๆง่กๅพๅๅๆขใ3D็บฟๆงไปฃๆฐๅ่ฝฌๆข |
+| [kornia.losses](https://kornia.readthedocs.io/en/latest/losses.html) | ๆๅคฑๅฝๆฐๆจกๅ |
+| [kornia.morphology](https://kornia.readthedocs.io/en/latest/morphology.html) | ๆง่กๅฝขๆๅญฆๆไฝ็ๆจกๅ |
+| [kornia.utils](https://kornia.readthedocs.io/en/latest/utils.html) | ๅพๅ/ๅผ ้ๅธธ็จๅทฅๅ
ทไปฅๅmetrics |
+
+## ๅฎ่ฃ
่ฏดๆ
+
+### ้่ฟ pip ๅฎ่ฃ
:
+
+ ```bash
+ pip install kornia
+ ```
+
+
+
+
+
+
+## ไพๅญ
+
+ๅฏไปฅๅฐ่ฏ้่ฟ่ฟไบ [ๆ็จ](https://kornia-tutorials.readthedocs.io/en/latest/) ๆฅๅญฆไน ๅไฝฟ็จ่ฟไธชๅบใ
+
+ๅ ถไปๅฎ่ฃ ๆนๆณ
+ + #### ้่ฟๆบ็ ๅฎ่ฃ : + + ```bash + python setup.py install + ``` + + #### ้่ฟๆบ็ ๅฎ่ฃ ๏ผ่ฝฏ้พๆฅ่ณๅฝๅ่ทฏๅพ๏ผ: + + ```bash + pip install -e . + ``` + + #### ้่ฟๆบ็ ๅฎ่ฃ ๏ผไปGIT่ชๅจไธ่ฝฝๆๆฐไปฃ็ ๏ผ: + + ```bash + pip install git+https://github.com/kornia/kornia + ``` + +
+
+
+
+
+
+## ๅผ็จ
+
+ๅฆๆๆจๅจไธ็ ็ฉถ็ธๅ
ณ็ๆๆกฃไธญไฝฟ็จ Kornia๏ผๆจๅฏไปฅๅผ็จๆไปฌ็่ฎบๆใๆดๅคไฟกๆฏๅฏไปฅๅจ [CITATION](https://github.com/kornia/kornia/blob/master/CITATION.md) ็ๅฐใ
+
+ ```bash
+ @inproceedings{eriba2019kornia,
+ author = {E. Riba, D. Mishkin, D. Ponsa, E. Rublee and G. Bradski},
+ title = {Kornia: an Open Source Differentiable Computer Vision Library for PyTorch},
+ booktitle = {Winter Conference on Applications of Computer Vision},
+ year = {2020},
+ url = {https://arxiv.org/pdf/1910.02190.pdf}
+ }
+ ```
+
+## ่ดก็ฎ
+ๆไปฌๆ่ฐขๆๆ็่ดก็ฎ่
ไธบๆน่ฟๅๆๅ Kornia ๆไฝๅบ็ๅชๅใๆจๅฏไปฅ็ดๆฅไฟฎๅคไธไธชๅทฒ็ฅ็BUG่ๆ ้่ฟไธๆญฅ่ฎจ่ฎบ๏ผๅฆๆๆจๆณ่ฆๆทปๅ ไธไธชไปปไฝๆฐ็ๆ่
ๆฉๅฑๅ่ฝ๏ผ่ฏทๅกๅฟ
ๅ
้่ฟๆไบคไธไธชIssueๆฅไธๆไปฌ่ฎจ่ฎบใ่ฏฆๆ
่ฏท้
่ฏป [่ดก็ฎๆๅ](https://github.com/kornia/kornia/blob/master/CONTRIBUTING.rst)ใๅผๆบ้กน็ฎ็ๅไธ่
่ฏทๅกๅฟ
ไบ่งฃๅฆไธ [่ง่](https://github.com/kornia/kornia/blob/master/CODE_OF_CONDUCT.md)ใ
+
+## ็คพๅบ
+- **่ฎบๅ:** ่ฎจ่ฎบไปฃ็ ๅฎ็ฐ๏ผๅญฆๆฏ็ ็ฉถ็ญใ[GitHub Forums](https://github.com/kornia/kornia/discussions)
+- **GitHub Issues:** bug reports, feature requests, install issues, RFCs, thoughts, etc. [OPEN](https://github.com/kornia/kornia/issues/new/choose)
+- **Slack:** ๅ ๅ
ฅๆไปฌ็Slack็คพๅบ๏ผไธๆไปฌ็ๆ ธๅฟ่ดก็ฎ่
ไฟๆ่็ณปใ [JOIN HERE](https://join.slack.com/t/kornia/shared_invite/zt-csobk21g-CnydWe5fmvkcktIeRFGCEQ)
+- ๅธธ่งไฟกๆฏ่ฏท่ฎฟ้ฎๆไปฌ็็ฝ็ซ www.kornia.org
+
+## ไธญๆ็คพๅบ
+ๆซๆไธๆน็ไบ็ปด็ ๅฏๅ
ณๆณจ Kornia ็ๅฎๆนไบคๆตQQ็พค๏ผ679683070๏ผใ
+
+
+
+
+ 
+
+
+ๆไปฌไผๅจ Kornia ไบคๆต็คพๅบไธบๅคงๅฎถ
+
+- ๐ข ๆดๆฐ Kornia ็ๆๆฐๅจๆ
+- ๐ ่ฟ่กๆด้ซๆ็็ญ็่งฃๆไปฅๅๆ่งๅ้ฆ
+- ๐ป ๆไพไธ่กไธๅคง็็ๅ
ๅไบคๆต็ๅนณๅฐ
diff --git a/conftest.py b/conftest.py
new file mode 100644
index 0000000000000000000000000000000000000000..7d84642ebb456b4be138a620730841a8b97573c4
--- /dev/null
+++ b/conftest.py
@@ -0,0 +1,108 @@
+from itertools import product
+from typing import Dict
+
+import numpy
+import pytest
+import torch
+
+import kornia
+
+
+def get_test_devices() -> Dict[str, torch.device]:
+ """Create a dictionary with the devices to test the source code. CUDA devices will be test only in case the
+ current hardware supports it.
+
+ Return:
+ dict(str, torch.device): list with devices names.
+ """
+ devices: Dict[str, torch.device] = {}
+ devices["cpu"] = torch.device("cpu")
+ if torch.cuda.is_available():
+ devices["cuda"] = torch.device("cuda:0")
+ if kornia.xla_is_available():
+ import torch_xla.core.xla_model as xm
+
+ devices["tpu"] = xm.xla_device()
+ return devices
+
+
+def get_test_dtypes() -> Dict[str, torch.dtype]:
+ """Create a dictionary with the dtypes the source code.
+
+ Return:
+ dict(str, torch.dtype): list with dtype names.
+ """
+ dtypes: Dict[str, torch.dtype] = {}
+ dtypes["float16"] = torch.float16
+ dtypes["float32"] = torch.float32
+ dtypes["float64"] = torch.float64
+ return dtypes
+
+
+# setup the devices to test the source code
+
+TEST_DEVICES: Dict[str, torch.device] = get_test_devices()
+TEST_DTYPES: Dict[str, torch.dtype] = get_test_dtypes()
+
+# Combinations of device and dtype to be excluded from testing.
+DEVICE_DTYPE_BLACKLIST = {('cpu', 'float16')}
+
+
+@pytest.fixture()
+def device(device_name) -> torch.device:
+ return TEST_DEVICES[device_name]
+
+
+@pytest.fixture()
+def dtype(dtype_name) -> torch.dtype:
+ return TEST_DTYPES[dtype_name]
+
+
+def pytest_generate_tests(metafunc):
+ device_names = None
+ dtype_names = None
+ if 'device_name' in metafunc.fixturenames:
+ raw_value = metafunc.config.getoption('--device')
+ if raw_value == 'all':
+ device_names = list(TEST_DEVICES.keys())
+ else:
+ device_names = raw_value.split(',')
+ if 'dtype_name' in metafunc.fixturenames:
+ raw_value = metafunc.config.getoption('--dtype')
+ if raw_value == 'all':
+ dtype_names = list(TEST_DTYPES.keys())
+ else:
+ dtype_names = raw_value.split(',')
+ if device_names is not None and dtype_names is not None:
+ # Exclude any blacklisted device/dtype combinations.
+ params = [combo for combo in product(device_names, dtype_names) if combo not in DEVICE_DTYPE_BLACKLIST]
+ metafunc.parametrize('device_name,dtype_name', params)
+ elif device_names is not None:
+ metafunc.parametrize('device_name', device_names)
+ elif dtype_names is not None:
+ metafunc.parametrize('dtype_name', dtype_names)
+
+
+def pytest_addoption(parser):
+ parser.addoption('--device', action="store", default="cpu")
+ parser.addoption('--dtype', action="store", default="float32")
+
+
+@pytest.fixture(autouse=True)
+def add_np(doctest_namespace):
+ doctest_namespace["np"] = numpy
+ doctest_namespace["torch"] = torch
+ doctest_namespace["kornia"] = kornia
+
+
+# the commit hash for the data version
+sha: str = 'cb8f42bf28b9f347df6afba5558738f62a11f28a'
+
+
+@pytest.fixture(scope='session')
+def data(request):
+ url = {
+ 'loftr_homo': f'https://github.com/kornia/data_test/blob/{sha}/loftr_outdoor_and_homography_data.pt?raw=true',
+ 'loftr_fund': f'https://github.com/kornia/data_test/blob/{sha}/loftr_indoor_and_fundamental_data.pt?raw=true',
+ }
+ return torch.hub.load_state_dict_from_url(url[request.param])
diff --git a/docker/Dockerfile b/docker/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..1622a9ef474d16020352a2103949fb2b0a0ac4d2
--- /dev/null
+++ b/docker/Dockerfile
@@ -0,0 +1,18 @@
+FROM nvidia/cuda:9.1-cudnn7-devel-ubuntu16.04
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+ curl \
+ vim \
+ ca-certificates &&\
+rm -rf /var/lib/apt/lists/*
+
+RUN curl -o ~/miniconda.sh -O https://repo.continuum.io/miniconda/Miniconda3-latest-Linux-x86_64.sh && \
+ chmod +x ~/miniconda.sh && \
+ ~/miniconda.sh -b -p /opt/conda && \
+ rm ~/miniconda.sh && \
+ /opt/conda/bin/conda install -y python=$PYTHON_VERSION numpy pyyaml scipy ipython mkl mkl-include cython typing && \
+ /opt/conda/bin/conda install -y -c pytorch magma-cuda90 && \
+ /opt/conda/bin/conda clean -ya
+ENV PATH /opt/conda/bin:$PATH
+
+RUN conda install pytorch torchvision cuda91 -c pytorch
diff --git a/docker/Dockerfile.travis b/docker/Dockerfile.travis
new file mode 100644
index 0000000000000000000000000000000000000000..78018b2205aca5c8ed7482c98eec00ffdf0aae22
--- /dev/null
+++ b/docker/Dockerfile.travis
@@ -0,0 +1,13 @@
+FROM ubuntu:16.04
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+ curl \
+ bzip2 \
+ build-essential \
+ ca-certificates &&\
+rm -rf /var/lib/apt/lists/*
+
+COPY . /torchgeometry
+WORKDIR /torchgeometry
+
+RUN ./setup_travis_env.sh
diff --git a/docker/build.sh b/docker/build.sh
new file mode 100644
index 0000000000000000000000000000000000000000..7bf418d0439965f56a43bad775ffcd320332af86
--- /dev/null
+++ b/docker/build.sh
@@ -0,0 +1,13 @@
+#!/bin/bash -ex
+# This script is useful to build the dev_env container.
+script_link="$( readlink "$BASH_SOURCE" )" || script_link="$BASH_SOURCE"
+apparent_sdk_dir="${script_link%/*}"
+if [ "$apparent_sdk_dir" == "$script_link" ]; then
+ apparent_sdk_dir=.
+fi
+
+sdk_dir="$( command cd -P "$apparent_sdk_dir/../" > /dev/null && pwd -P )"
+
+# This builds the docker file, from the root of the workspace
+# docker build -t arraiy/torchgeometry -f Dockerfile $sdk_dir
+docker build -t arraiy/torchgeometry -f Dockerfile.travis $sdk_dir
diff --git a/docker/tpu-tests/Dockerfile b/docker/tpu-tests/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..5b245e07cc680d8615f63a3711a8719755c485a6
--- /dev/null
+++ b/docker/tpu-tests/Dockerfile
@@ -0,0 +1,64 @@
+FROM google/cloud-sdk:slim
+
+# Build args.
+ARG GITHUB_REF=refs/heads/master
+
+# TODO: This Dockerfile installs pytorch/xla 3.6 wheels. There are also 3.7
+# wheels available; see below.
+ARG PYTHON_VERSION=3.6
+
+ARG PYTORCH_VERSION=1.7
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+ build-essential \
+ cmake \
+ git \
+ curl \
+ ca-certificates
+
+# Install conda and python.
+# NOTE new Conda does not forward the exit status... https://github.com/conda/conda/issues/8385
+RUN curl -o ~/miniconda.sh https://repo.anaconda.com/miniconda/Miniconda3-4.7.12-Linux-x86_64.sh && \
+ chmod +x ~/miniconda.sh && \
+ ~/miniconda.sh -b && \
+ rm ~/miniconda.sh
+
+ENV PATH=/root/miniconda3/bin:$PATH
+
+RUN conda create -y --name container python=$PYTHON_VERSION
+
+# Run the rest of commands within the new conda env.
+# Use absolute path to appease Codefactor.
+SHELL ["/root/miniconda3/bin/conda", "run", "-n", "container", "/bin/bash", "-c"]
+RUN conda install -y python=$PYTHON_VERSION mkl
+
+RUN pip uninstall -y torch && \
+ # Python 3.7 wheels are available. Replace cp36-cp36m with cp37-cp37m
+ gsutil cp 'gs://tpu-pytorch/wheels/torch-${PYTORCH_VERSION}-cp${PYTHON_VERSION/./}-cp${PYTHON_VERSION/./}m-linux_x86_64.whl' . && \
+ gsutil cp 'gs://tpu-pytorch/wheels/torch_xla-${PYTORCH_VERSION}-cp${PYTHON_VERSION/./}-cp${PYTHON_VERSION/./}m-linux_x86_64.whl' . && \
+ pip install 'torch-${PYTORCH_VERSION}-cp${PYTHON_VERSION/./}-cp${PYTHON_VERSION/./}m-linux_x86_64.whl' && \
+ pip install 'torch_xla-${PYTORCH_VERSION}-cp${PYTHON_VERSION/./}-cp${PYTHON_VERSION/./}m-linux_x86_64.whl' && \
+ rm 'torch-${PYTORCH_VERSION}-cp${PYTHON_VERSION/./}-cp${PYTHON_VERSION/./}m-linux_x86_64.whl' && \
+ rm 'torch_xla-${PYTORCH_VERSION}-cp${PYTHON_VERSION/./}-cp${PYTHON_VERSION/./}m-linux_x86_64.whl' && \
+ apt-get install -y libomp5
+
+ENV LD_LIBRARY_PATH=root/miniconda3/envs/container/lib
+
+# Install kornia/kornia at the current PR, plus dependencies.
+RUN git clone https://github.com/kornia/kornia.git && \
+ cd kornia && \
+ git fetch origin $GITHUB_REF:CI && \
+ git checkout CI && \
+ python setup.py install && \
+ pip install pytest
+
+RUN conda init bash
+
+RUN python -c "import torch; print(torch.__version__)"
+RUN python -c "import torch_xla; print(torch_xla.__version__)"
+RUN python -c "import kornia as K; print(K.__version__)"
+COPY docker-entrypoint.sh /usr/local/bin/
+RUN chmod +x /usr/local/bin/docker-entrypoint.sh
+
+ENTRYPOINT ["/usr/local/bin/docker-entrypoint.sh"]
+CMD ["bash"]
diff --git a/docker/tpu-tests/docker-entrypoint.sh b/docker/tpu-tests/docker-entrypoint.sh
new file mode 100644
index 0000000000000000000000000000000000000000..fbe59566fdcdfd2e61d23288d8da6273003ff9ab
--- /dev/null
+++ b/docker/tpu-tests/docker-entrypoint.sh
@@ -0,0 +1,8 @@
+#!/bin/bash
+source ~/.bashrc
+echo "running docker-entrypoint.sh"
+conda activate container
+echo $KUBE_GOOGLE_CLOUD_TPU_ENDPOINTS
+echo "printed TPU info"
+export XRT_TPU_CONFIG="tpu_worker;0;${KUBE_GOOGLE_CLOUD_TPU_ENDPOINTS:7}"
+exec "$@"#!/bin/bash
diff --git a/docker/tpu-tests/tpu_test_cases.jsonnet b/docker/tpu-tests/tpu_test_cases.jsonnet
new file mode 100644
index 0000000000000000000000000000000000000000..b7bd817e3b4c49f13bf1469e6b43ea2764a837ca
--- /dev/null
+++ b/docker/tpu-tests/tpu_test_cases.jsonnet
@@ -0,0 +1,34 @@
+local base = import 'templates/base.libsonnet';
+local tpus = import 'templates/tpus.libsonnet';
+local utils = import "templates/utils.libsonnet";
+
+local tputests = base.BaseTest {
+ frameworkPrefix: 'kornia',
+ modelName: 'tpu-tests',
+ mode: 'postsubmit',
+ configMaps: [],
+
+ timeout: 900, # 15 minutes, in seconds.
+
+ image: std.extVar('image'),
+ imageTag: std.extVar('image-tag'),
+
+ tpuSettings+: {
+ softwareVersion: 'pytorch-VERSION',
+ },
+ accelerator: tpus.v3_8,
+
+ command: utils.scriptCommand(
+ |||
+ python -c "import torch; print(torch.__version__)"
+ python -c "import torch_xla; print(torch_xla.__version__)"
+ python -c "import kornia; print(kornia.__version__)"
+ pytest -v kornia/test/color kornia/test/enhance kornia/test/filters kornia/test/test_losses.py --device tpu --dtype float32 -k "not grad"
+ test_exit_code=$?
+ echo "\nFinished running commands.\n"
+ test $test_exit_code -eq 0
+ |||
+ ),
+};
+
+tputests.oneshotJob
diff --git a/docs/.gitignore b/docs/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..98a840bf411ec0e8e72dd81dbf95cc4f4d87742a
--- /dev/null
+++ b/docs/.gitignore
@@ -0,0 +1,5 @@
+build/doctest
+build/html/.buildinfo
+build/html/objects.inv
+source/tutorials/*
+source/_static/img/*.png
diff --git a/docs/Makefile b/docs/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..d85a34c268a4b6eeba6912d31ce97f9955e372d5
--- /dev/null
+++ b/docs/Makefile
@@ -0,0 +1,27 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line.
+SPHINXOPTS =
+SPHINXBUILD = sphinx-build
+SPHINXPROJ = kornia
+SOURCEDIR = source
+BUILDDIR = build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+ @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+ @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+clean:
+ @echo "Removing everything under 'build'.."
+ @rm -rf $(BUILDDIR)/html/ $(BUILDDIR)/doctrees
+
+images:
+ python3 generate_example_images.py
diff --git a/docs/generate_example_images.py b/docs/generate_example_images.py
new file mode 100644
index 0000000000000000000000000000000000000000..3a66e4c74ad38f91049de3d61a3c65e5d3b22ea8
--- /dev/null
+++ b/docs/generate_example_images.py
@@ -0,0 +1,348 @@
+import importlib
+import math
+import os
+from pathlib import Path
+from typing import Optional, Tuple
+
+import cv2
+import numpy as np
+import requests
+import torch
+
+import kornia as K
+
+
+def read_img_from_url(url: str, resize_to: Optional[Tuple[int, int]] = None) -> torch.Tensor:
+ # perform request
+ response = requests.get(url).content
+ # convert to array of ints
+ nparr = np.frombuffer(response, np.uint8)
+ # convert to image array and resize
+ img: np.ndarray = cv2.imdecode(nparr, cv2.IMREAD_UNCHANGED)[..., :3]
+ # convert the image to a tensor
+ img_t: torch.Tensor = K.utils.image_to_tensor(img, keepdim=False) # 1xCxHXW
+ img_t = img_t.float() / 255.0
+ if resize_to is None:
+ img_t = K.geometry.resize(img_t, 184)
+ else:
+ img_t = K.geometry.resize(img_t, resize_to)
+ return img_t
+
+
+def main():
+ # load the images
+ BASE_IMAGE_URL1: str = "https://raw.githubusercontent.com/kornia/data/main/panda.jpg" # augmentation
+ BASE_IMAGE_URL2: str = "https://raw.githubusercontent.com/kornia/data/main/simba.png" # color
+ BASE_IMAGE_URL3: str = "https://raw.githubusercontent.com/kornia/data/main/girona.png" # enhance
+ BASE_IMAGE_URL4: str = "https://raw.githubusercontent.com/kornia/data/main/baby_giraffe.png" # morphology
+ BASE_IMAGE_URL5: str = "https://raw.githubusercontent.com/kornia/data/main/persistencia_memoria.jpg" # filters
+ BASE_IMAGE_URL6: str = "https://raw.githubusercontent.com/kornia/data/main/delorean.png" # geometry
+ OUTPUT_PATH = Path(__file__).absolute().parent / "source/_static/img"
+
+ os.makedirs(OUTPUT_PATH, exist_ok=True)
+ print(f"Pointing images to path {OUTPUT_PATH}.")
+ img1 = read_img_from_url(BASE_IMAGE_URL1)
+ img2 = read_img_from_url(BASE_IMAGE_URL2, img1.shape[-2:])
+ img3 = read_img_from_url(BASE_IMAGE_URL3, img1.shape[-2:])
+ img4 = read_img_from_url(BASE_IMAGE_URL4)
+ img5 = read_img_from_url(BASE_IMAGE_URL5, (234, 320))
+ img6 = read_img_from_url(BASE_IMAGE_URL6)
+
+ # TODO: make this more generic for modules out of kornia.augmentation
+ # Dictionary containing the transforms to generate the sample images:
+ # Key: Name of the transform class.
+ # Value: (parameters, num_samples, seed)
+ mod = importlib.import_module("kornia.augmentation")
+ augmentations_list: dict = {
+ "CenterCrop": ((184, 184), 1, 2018),
+ "ColorJitter": ((0.3, 0.3, 0.3, 0.3), 2, 2018),
+ "RandomAffine": (((-15.0, 20.0), (0.1, 0.1), (0.7, 1.3), 20), 2, 2019),
+ "RandomBoxBlur": (((7, 7),), 1, 2020),
+ "RandomCrop": ((img1.shape[-2:], (50, 50)), 2, 2020),
+ "RandomChannelShuffle": ((), 1, 2020),
+ "RandomElasticTransform": (((63, 63), (32, 32), (2.0, 2.0)), 2, 2018),
+ "RandomEqualize": ((), 1, 2020),
+ "RandomErasing": (((0.2, 0.4), (0.3, 1 / 0.3)), 2, 2017),
+ "RandomFisheye": ((torch.tensor([-0.3, 0.3]), torch.tensor([-0.3, 0.3]), torch.tensor([0.9, 1.0])), 2, 2020),
+ "RandomGaussianBlur": (((3, 3), (0.1, 2.0)), 1, 2020),
+ "RandomGaussianNoise": ((0.0, 0.05), 1, 2020),
+ "RandomGrayscale": ((), 1, 2020),
+ "RandomHorizontalFlip": ((), 1, 2020),
+ "RandomInvert": ((), 1, 2020),
+ "RandomMotionBlur": ((7, 35.0, 0.5), 2, 2020),
+ "RandomPerspective": ((0.2,), 2, 2020),
+ "RandomPosterize": (((1, 4),), 2, 2016),
+ "RandomResizedCrop": ((img1.shape[-2:], (1.0, 2.0), (1.0, 2.0)), 2, 2020),
+ "RandomRotation": ((45.0,), 2, 2019),
+ "RandomSharpness": ((16.0,), 1, 2019),
+ "RandomSolarize": ((0.2, 0.2), 2, 2019),
+ "RandomVerticalFlip": ((), 1, 2020),
+ "RandomThinPlateSpline": ((), 1, 2020),
+ }
+
+ # ITERATE OVER THE TRANSFORMS
+ for aug_name, (args, num_samples, seed) in augmentations_list.items():
+ img_in = img1.repeat(num_samples, 1, 1, 1)
+ # dynamically create the class instance
+ cls = getattr(mod, aug_name)
+ aug = cls(*args, p=1.0)
+ # set seed
+ torch.manual_seed(seed)
+ # apply the augmentaiton to the image and concat
+ out = aug(img_in)
+
+ if aug_name == "CenterCrop":
+ h, w = img1.shape[-2:]
+ h_new, w_new = out.shape[-2:]
+ h_dif, w_dif = int(h - h_new), int(w - w_new)
+ out = torch.nn.functional.pad(out, (w_dif // 2, w_dif // 2, 0, h_dif))
+
+ out = torch.cat([img_in[0], *(out[i] for i in range(out.size(0)))], dim=-1)
+ # save the output image
+ out_np = K.utils.tensor_to_image((out * 255.0).byte())
+ cv2.imwrite(str(OUTPUT_PATH / f"{aug_name}.png"), out_np)
+ sig = f"{aug_name}({', '.join([str(a) for a in args])}, p=1.0)"
+ print(f"Generated image example for {aug_name}. {sig}")
+
+ mod = importlib.import_module("kornia.augmentation")
+ mix_augmentations_list: dict = {
+ "RandomMixUp": (((0.3, 0.4),), 2, 20),
+ "RandomCutMix": ((img1.shape[-2], img1.shape[-1]), 2, 2019),
+ }
+ # ITERATE OVER THE TRANSFORMS
+ for aug_name, (args, num_samples, seed) in mix_augmentations_list.items():
+ img_in = torch.cat([img1, img2])
+ # dynamically create the class instance
+ cls = getattr(mod, aug_name)
+ aug = cls(*args, p=1.0)
+ # set seed
+ torch.manual_seed(seed)
+ # apply the augmentaiton to the image and concat
+ out, _ = aug(img_in, torch.tensor([0, 1]))
+ out = torch.cat([img_in[0], img_in[1], *(out[i] for i in range(out.size(0)))], dim=-1)
+ # save the output image
+ out_np = K.utils.tensor_to_image((out * 255.0).byte())
+ cv2.imwrite(str(OUTPUT_PATH / f"{aug_name}.png"), out_np)
+ sig = f"{aug_name}({', '.join([str(a) for a in args])}, p=1.0)"
+ print(f"Generated image example for {aug_name}. {sig}")
+
+ mod = importlib.import_module("kornia.color")
+ color_transforms_list: dict = {
+ "grayscale_to_rgb": ((), 3),
+ "rgb_to_bgr": ((), 1),
+ "rgb_to_grayscale": ((), 1),
+ "rgb_to_hsv": ((), 1),
+ "rgb_to_hls": ((), 1),
+ "rgb_to_luv": ((), 1),
+ "rgb_to_lab": ((), 1),
+ # "rgb_to_rgba": ((1.,), 1),
+ "rgb_to_xyz": ((), 1),
+ "rgb_to_ycbcr": ((), 1),
+ "rgb_to_yuv": ((), 1),
+ "rgb_to_linear_rgb": ((), 1),
+ }
+ # ITERATE OVER THE TRANSFORMS
+ for fn_name, (args, num_samples) in color_transforms_list.items():
+ # import function and apply
+ fn = getattr(mod, fn_name)
+ if fn_name == "grayscale_to_rgb":
+ out = fn(K.color.rgb_to_grayscale(img2), *args)
+ else:
+ out = fn(img2, *args)
+ # perform normalization to visualize
+ if fn_name == "rgb_to_lab":
+ out = out[:, :1] / 100.0
+ elif fn_name == "rgb_to_hsv":
+ out[:, :1] = out[:, :1] / 2 * math.pi
+ elif fn_name == "rgb_to_luv":
+ out = out[:, :1] / 116.0
+ # repeat channels for grayscale
+ if out.shape[1] != 3:
+ out = out.repeat(1, 3, 1, 1)
+ # save the output image
+ if fn_name == "grayscale_to_rgb":
+ out = torch.cat(
+ [K.color.rgb_to_grayscale(img2[0]).repeat(3, 1, 1), *(out[i] for i in range(out.size(0)))], dim=-1
+ )
+ else:
+ out = torch.cat([img2[0], *(out[i] for i in range(out.size(0)))], dim=-1)
+ out_np = K.utils.tensor_to_image((out * 255.0).byte())
+ cv2.imwrite(str(OUTPUT_PATH / f"{fn_name}.png"), out_np)
+ sig = f"{fn_name}({', '.join([str(a) for a in args])})"
+ print(f"Generated image example for {fn_name}. {sig}")
+
+ # korna.enhance module
+ mod = importlib.import_module("kornia.enhance")
+ transforms: dict = {
+ "adjust_brightness": ((torch.tensor([0.25, 0.5]),), 2),
+ "adjust_contrast": ((torch.tensor([0.65, 0.5]),), 2),
+ "adjust_gamma": ((torch.tensor([0.85, 0.75]), 2.0), 2),
+ "adjust_hue": ((torch.tensor([-math.pi / 4, math.pi / 4]),), 2),
+ "adjust_saturation": ((torch.tensor([1.0, 2.0]),), 2),
+ "solarize": ((torch.tensor([0.8, 0.5]), torch.tensor([-0.25, 0.25])), 2),
+ "posterize": ((torch.tensor([4, 2]),), 2),
+ "sharpness": ((torch.tensor([1.0, 2.5]),), 2),
+ "equalize": ((), 1),
+ "invert": ((), 1),
+ "equalize_clahe": ((), 1),
+ "add_weighted": ((0.75, 0.25, 2.0), 1),
+ }
+ # ITERATE OVER THE TRANSFORMS
+ for fn_name, (args, num_samples) in transforms.items():
+ img_in = img3.repeat(num_samples, 1, 1, 1)
+ if fn_name == "add_weighted":
+ args_in = (img_in, args[0], img2, args[1], args[2])
+ else:
+ args_in = (img_in, *args)
+ # import function and apply
+ fn = getattr(mod, fn_name)
+ out = fn(*args_in)
+ # save the output image
+ out = torch.cat([img_in[0], *(out[i] for i in range(out.size(0)))], dim=-1)
+ out_np = K.utils.tensor_to_image((out * 255.0).byte())
+ cv2.imwrite(str(OUTPUT_PATH / f"{fn_name}.png"), out_np)
+ sig = f"{fn_name}({', '.join([str(a) for a in args])})"
+ print(f"Generated image example for {fn_name}. {sig}")
+
+ # korna.morphology module
+ mod = importlib.import_module("kornia.morphology")
+ kernel = torch.tensor([[0, 1, 0], [1, 1, 1], [0, 1, 0]])
+ transforms: dict = {
+ "dilation": ((kernel,), 1),
+ "erosion": ((kernel,), 1),
+ "opening": ((kernel,), 1),
+ "closing": ((kernel,), 1),
+ "gradient": ((kernel,), 1),
+ "top_hat": ((kernel,), 1),
+ "bottom_hat": ((kernel,), 1),
+ }
+ # ITERATE OVER THE TRANSFORMS
+ for fn_name, (args, num_samples) in transforms.items():
+ img_in = img4.repeat(num_samples, 1, 1, 1)
+ args_in = (img_in, *args)
+ # import function and apply
+ # import pdb;pdb.set_trace()
+ fn = getattr(mod, fn_name)
+ out = fn(*args_in)
+ # save the output image
+ out = torch.cat([img_in[0], *(out[i] for i in range(out.size(0)))], dim=-1)
+ out_np = K.utils.tensor_to_image((out * 255.0).byte())
+ cv2.imwrite(str(OUTPUT_PATH / f"{fn_name}.png"), out_np)
+ sig = f"{fn_name}({', '.join([str(a) for a in args])})"
+ print(f"Generated image example for {fn_name}. {sig}")
+
+ # korna.filters module
+ mod = importlib.import_module("kornia.filters")
+ kernel = torch.tensor([[0, 1, 0], [1, 1, 1], [0, 1, 0]])
+ transforms: dict = {
+ "box_blur": (((5, 5),), 1),
+ "median_blur": (((5, 5),), 1),
+ "gaussian_blur2d": (((5, 5), (1.5, 1.5)), 1),
+ "motion_blur": ((5, 90.0, 1.0), 1),
+ "max_blur_pool2d": ((5,), 1),
+ "blur_pool2d": ((5,), 1),
+ "unsharp_mask": (((5, 5), (1.5, 1.5)), 1),
+ "laplacian": ((5,), 1),
+ "sobel": ((), 1),
+ "spatial_gradient": ((), 1),
+ "canny": ((), 1),
+ }
+ # ITERATE OVER THE TRANSFORMS
+ for fn_name, (args, num_samples) in transforms.items():
+ img_in = img5.repeat(num_samples, 1, 1, 1)
+ args_in = (img_in, *args)
+ # import function and apply
+ fn = getattr(mod, fn_name)
+ out = fn(*args_in)
+ if fn_name in ("max_blur_pool2d", "blur_pool2d"):
+ out = K.geometry.resize(out, img_in.shape[-2:])
+ if fn_name == "canny":
+ out = out[1].repeat(1, 3, 1, 1)
+ if isinstance(out, torch.Tensor):
+ out = out.clamp(min=0.0, max=1.0)
+ if fn_name in ("laplacian", "sobel", "spatial_gradient", "canny"):
+ out = K.enhance.normalize_min_max(out)
+ if fn_name == "spatial_gradient":
+ out = out.permute(2, 1, 0, 3, 4).squeeze()
+ # save the output image
+ out = torch.cat([img_in[0], *(out[i] for i in range(out.size(0)))], dim=-1)
+ out_np = K.utils.tensor_to_image((out * 255.0).byte())
+ cv2.imwrite(str(OUTPUT_PATH / f"{fn_name}.png"), out_np)
+ sig = f"{fn_name}({', '.join([str(a) for a in args])})"
+ print(f"Generated image example for {fn_name}. {sig}")
+
+ # korna.geometry.transform module
+ mod = importlib.import_module("kornia.geometry.transform")
+ h, w = img6.shape[-2:]
+
+ def _get_tps_args():
+ src = torch.tensor([[[-1.0, -1.0], [-1.0, 1.0], [1.0, -1.0], [1.0, -1.0], [0.0, 0.0]]]).repeat(2, 1, 1) # Bx5x2
+ dst = src + torch.distributions.Uniform(-0.2, 0.2).rsample((2, 5, 2))
+ kernel, affine = K.geometry.transform.get_tps_transform(dst, src)
+ return src, kernel, affine
+
+ transforms: dict = {
+ "warp_affine": (
+ (
+ K.geometry.transform.get_affine_matrix2d(
+ translations=torch.zeros(2, 2),
+ center=(torch.tensor([w, h]) / 2).repeat(2, 1),
+ scale=torch.distributions.Uniform(0.5, 1.5).rsample((2, 2)),
+ angle=torch.tensor([-25.0, 25.0]),
+ )[:, :2, :3],
+ (h, w),
+ ),
+ 2,
+ ),
+ "remap": (
+ (
+ *(K.utils.create_meshgrid(h, w, normalized_coordinates=True) - 0.25).unbind(-1),
+ 'bilinear',
+ 'zeros',
+ True,
+ True,
+ ),
+ 1,
+ ),
+ "warp_image_tps": ((_get_tps_args()), 2),
+ "rotate": ((torch.tensor([-15.0, 25.0]),), 2),
+ "translate": ((torch.tensor([[10.0, -15], [50.0, -25.0]]),), 2),
+ "scale": ((torch.tensor([[0.5, 1.25], [1.0, 1.5]]),), 2),
+ "shear": ((torch.tensor([[0.1, -0.2], [-0.2, 0.1]]),), 2),
+ "rot180": ((), 1),
+ "hflip": ((), 1),
+ "vflip": ((), 1),
+ "resize": (((120, 220),), 1),
+ "rescale": ((0.5,), 1),
+ "elastic_transform2d": ((torch.rand(1, 2, h, w) * 2 - 1, (63, 63), (32, 32), (4.0, 4.0)), 1),
+ "pyrdown": ((), 1),
+ "pyrup": ((), 1),
+ "build_pyramid": ((3,), 1),
+ }
+ # ITERATE OVER THE TRANSFORMS
+ for fn_name, (args, num_samples) in transforms.items():
+ img_in = img6.repeat(num_samples, 1, 1, 1)
+ args_in = (img_in, *args)
+ # import function and apply
+ fn = getattr(mod, fn_name)
+ out = fn(*args_in)
+ if fn_name in ("resize", "rescale", "pyrdown", "pyrup"):
+ h_new, w_new = out.shape[-2:]
+ out = torch.nn.functional.pad(out, (0, (w - w_new), 0, (h - h_new)))
+ if fn_name == "build_pyramid":
+ _out = []
+ for pyr in out[1:]:
+ h_new, w_new = pyr.shape[-2:]
+ out_tmp = torch.nn.functional.pad(pyr, (0, (w - w_new), 0, (h - h_new)))
+ _out.append(out_tmp)
+ out = torch.cat(_out)
+ # save the output image
+ out = torch.cat([img_in[0], *(out[i] for i in range(out.size(0)))], dim=-1)
+ out_np = K.utils.tensor_to_image((out * 255.0).byte())
+ cv2.imwrite(str(OUTPUT_PATH / f"{fn_name}.png"), out_np)
+ sig = f"{fn_name}({', '.join([str(a) for a in args])})"
+ print(f"Generated image example for {fn_name}. {sig}")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/docs/requirements.txt b/docs/requirements.txt
new file mode 100644
index 0000000000000000000000000000000000000000..185ba5ecc6dccf6ce25065661e7d45b260c1c42b
--- /dev/null
+++ b/docs/requirements.txt
@@ -0,0 +1,16 @@
+# docs requirements
+torch
+torchvision
+opencv-python
+matplotlib
+# sphinx
+sphinx>=4.0
+sphinx_rtd_theme>0.5
+sphinxcontrib-bibtex
+sphinxcontrib-youtube
+sphinx-autodoc-typehints>=1.0
+sphinx-copybutton>=0.3
+sphinx-autodoc-defaultargs
+PyYAML>=5.1,<6.1.0
+furo
+sphinx-design
diff --git a/docs/source/_extra/googlef1b16a85a18694bd.html b/docs/source/_extra/googlef1b16a85a18694bd.html
new file mode 100644
index 0000000000000000000000000000000000000000..8b7d1d6ede7052cbdb127bedd35d4623e6906d44
--- /dev/null
+++ b/docs/source/_extra/googlef1b16a85a18694bd.html
@@ -0,0 +1 @@
+google-site-verification: googlef1b16a85a18694bd.html
diff --git a/docs/source/_static/css/main.css b/docs/source/_static/css/main.css
new file mode 100644
index 0000000000000000000000000000000000000000..92dc2a0cb48b87e9bdcd6517d80bd2ceb9aa6589
--- /dev/null
+++ b/docs/source/_static/css/main.css
@@ -0,0 +1,13 @@
+.sidebar-logo {
+ max-width: 30%;
+}
+
+/* TODO: make sure it works for all the browsers */
+body{
+ font-family: 'Montserrat', sans-serif;
+}
+
+/* The section headers in the toc tree */
+.sidebar-scroll p.caption{
+ background-color: #4d59ff;
+}
diff --git a/docs/source/_static/image_registration.py b/docs/source/_static/image_registration.py
new file mode 100644
index 0000000000000000000000000000000000000000..0345f6ffca648dcbe91b01696906096760e74b24
--- /dev/null
+++ b/docs/source/_static/image_registration.py
@@ -0,0 +1,38 @@
+import os
+
+import cv2
+import imageio
+import torch
+
+import kornia as K
+import kornia.geometry as KG
+
+
+def load_timg(file_name):
+ """Loads the image with OpenCV and converts to torch.Tensor."""
+ assert os.path.isfile(file_name), f"Invalid file {file_name}" # nosec
+ # load image with OpenCV
+ img = cv2.imread(file_name, cv2.IMREAD_COLOR)
+ # convert image to torch tensor
+ tensor = K.image_to_tensor(img, None).float() / 255.
+ return K.color.bgr_to_rgb(tensor)
+
+
+registrator = KG.ImageRegistrator('similarity')
+
+img1 = K.resize(load_timg('/Users/oldufo/datasets/stewart/MR-CT/CT.png'), (400, 600))
+img2 = K.resize(load_timg('/Users/oldufo/datasets/stewart/MR-CT/MR.png'), (400, 600))
+model, intermediate = registrator.register(img1, img2, output_intermediate_models=True)
+
+video_writer = imageio.get_writer('medical_registration.gif', fps=2)
+
+timg_dst_first = img1.clone()
+timg_dst_first[0, 0, :, :] = img2[0, 0, :, :]
+video_writer.append_data(K.tensor_to_image((timg_dst_first * 255.).byte()))
+
+with torch.no_grad():
+ for m in intermediate:
+ timg_dst = KG.homography_warp(img1, m, img2.shape[-2:])
+ timg_dst[0, 0, :, :] = img2[0, 0, :, :]
+ video_writer.append_data(K.tensor_to_image((timg_dst_first * 255.).byte()))
+video_writer.close()
diff --git a/docs/source/_static/img/cn_community_qq.jpg b/docs/source/_static/img/cn_community_qq.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..380d257e7473f709046b611ae92e9c2d8f46f0f7
--- /dev/null
+++ b/docs/source/_static/img/cn_community_qq.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:53dd37a42c33bc44f368a1e96acb42bee486fc3ac3f7fe94cbed4fae98b16e55
+size 210646
diff --git a/docs/source/_static/img/hakuna_matata.gif b/docs/source/_static/img/hakuna_matata.gif
new file mode 100644
index 0000000000000000000000000000000000000000..4a0f71e4a6f456a112027d8d72ee43aae58e5399
--- /dev/null
+++ b/docs/source/_static/img/hakuna_matata.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:45aed33611ec960f6a0af3e1c2ee973a10227cf4716f3bb794465f30249ed53c
+size 445231
diff --git a/docs/source/_static/img/kornia_logo.png b/docs/source/_static/img/kornia_logo.png
new file mode 100644
index 0000000000000000000000000000000000000000..fc0cd9cbcaaa620637610f371ba249489b99acb1
Binary files /dev/null and b/docs/source/_static/img/kornia_logo.png differ
diff --git a/docs/source/_static/img/kornia_logo.svg b/docs/source/_static/img/kornia_logo.svg
new file mode 100644
index 0000000000000000000000000000000000000000..a4613ba2fe7d2cc7ab72324a741a80533485a341
--- /dev/null
+++ b/docs/source/_static/img/kornia_logo.svg
@@ -0,0 +1,108 @@
+
+
+
diff --git a/docs/source/_static/img/kornia_logo_favicon.png b/docs/source/_static/img/kornia_logo_favicon.png
new file mode 100644
index 0000000000000000000000000000000000000000..0c526293897cfe304035c9958108f3278b4ccd3e
Binary files /dev/null and b/docs/source/_static/img/kornia_logo_favicon.png differ
diff --git a/docs/source/_static/img/kornia_logo_only.png b/docs/source/_static/img/kornia_logo_only.png
new file mode 100644
index 0000000000000000000000000000000000000000..5ebb08c2b30a4bc74945f64e34e7e27412ec730b
Binary files /dev/null and b/docs/source/_static/img/kornia_logo_only.png differ
diff --git a/docs/source/_static/img/kornia_logo_only_dark.svg b/docs/source/_static/img/kornia_logo_only_dark.svg
new file mode 100644
index 0000000000000000000000000000000000000000..1a7c8f8c8b51edfd5bd3774d8c2abb5a1bad15bb
--- /dev/null
+++ b/docs/source/_static/img/kornia_logo_only_dark.svg
@@ -0,0 +1 @@
+
diff --git a/docs/source/_static/img/kornia_logo_only_light.svg b/docs/source/_static/img/kornia_logo_only_light.svg
new file mode 100644
index 0000000000000000000000000000000000000000..f80aa37ba81c843626bbde28b0e07a9baa6a39fc
--- /dev/null
+++ b/docs/source/_static/img/kornia_logo_only_light.svg
@@ -0,0 +1 @@
+
diff --git a/docs/source/_static/img/registration.gif b/docs/source/_static/img/registration.gif
new file mode 100644
index 0000000000000000000000000000000000000000..7f61c2163fef396be4d7e2917ba5e0b63113b560
--- /dev/null
+++ b/docs/source/_static/img/registration.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7f26ca293fa6e0cfbbd5d4a7e691f17839f706a8f6bac5cf153cf06caff1e24a
+size 2237000
diff --git a/docs/source/_static/js/custom.js b/docs/source/_static/js/custom.js
new file mode 100644
index 0000000000000000000000000000000000000000..c714701d7eec648148206e6a7388df62926bd7a0
--- /dev/null
+++ b/docs/source/_static/js/custom.js
@@ -0,0 +1,33 @@
+// Based on https://github.com/huggingface/transformers/blob/master/docs/source/_static/js/custom.js
+// TODO (Jian): probably update this by the latest https://buttons.github.io/, which added dark and light mode to align furo theme.
+
+
+function addGithubButton() {
+ const div = `
+
+
+
+ Star
+
+
+ `;
+ document.querySelector(".sidebar-brand").insertAdjacentHTML('afterend', div);
+}
+
+/*!
+ * github-buttons v2.2.10
+ * (c) 2019 ใชใคใ
+ * @license BSD-2-Clause
+ */
+/**
+ * modified to run programmatically
+ */
+function parseGithubButtons (){"use strict";var e=window.document,t=e.location,o=window.encodeURIComponent,r=window.decodeURIComponent,n=window.Math,a=window.HTMLElement,i=window.XMLHttpRequest,l="https://unpkg.com/github-buttons@2.2.10/dist/buttons.html",c=i&&i.prototype&&"withCredentials"in i.prototype,d=c&&a&&a.prototype.attachShadow&&!a.prototype.attachShadow.prototype,s=function(e,t,o){e.addEventListener?e.addEventListener(t,o):e.attachEvent("on"+t,o)},u=function(e,t,o){e.removeEventListener?e.removeEventListener(t,o):e.detachEvent("on"+t,o)},h=function(e,t,o){var r=function(n){return u(e,t,r),o(n)};s(e,t,r)},f=function(e,t,o){var r=function(n){if(t.test(e.readyState))return u(e,"readystatechange",r),o(n)};s(e,"readystatechange",r)},p=function(e){return function(t,o,r){var n=e.createElement(t);if(o)for(var a in o){var i=o[a];null!=i&&(null!=n[a]?n[a]=i:n.setAttribute(a,i))}if(r)for(var l=0,c=r.length;l![](\"https://github.com/kornia/data/raw/main/GitHub-Mark-Light-32px.png\"){kind=small}
+ # Star Kornia on GitHub
+ #
+ # """,
+}
+
+# html_logo = '_static/img/kornia_logo.svg'
+# html_logo = '_static/img/kornia_logo_only.png'
+html_favicon = '_static/img/kornia_logo_favicon.png'
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ['_static']
+html_extra_path = ['_extra']
+
+# Output file base name for HTML help builder.
+htmlhelp_basename = 'Kornia'
+html_css_files = ['css/main.css']
+html_js_files = ['js/custom.js']
+
+
+# -- Options for LaTeX output ---------------------------------------------
+
+latex_elements = {
+ # The paper size ('letterpaper' or 'a4paper').
+ #
+ # 'papersize': 'letterpaper',
+ # The font size ('10pt', '11pt' or '12pt').
+ #
+ # 'pointsize': '10pt',
+ # Additional stuff for the LaTeX preamble.
+ #
+ # 'preamble': '',
+ # Latex figure (float) alignment
+ #
+ # 'figure_align': 'htbp',
+}
+
+# Grouping the document tree into LaTeX files. List of tuples
+# (source start file, target name, title,
+# author, documentclass [howto, manual, or own class]).
+latex_documents = [(master_doc, 'kornia.tex', 'Kornia', 'manual')]
+
+
+# -- Options for manual page output ---------------------------------------
+
+# One entry per manual page. List of tuples
+# (source start file, name, description, authors, manual section).
+man_pages = [(master_doc, 'Kornia', 'Kornia Documentation', [author], 1)]
+
+
+# -- Options for Texinfo output -------------------------------------------
+
+# Grouping the document tree into Texinfo files. List of tuples
+# (source start file, target name, title, author,
+# dir menu entry, description, category)
+texinfo_documents = [
+ (
+ master_doc,
+ 'kornia',
+ 'Kornia Documentation',
+ author,
+ 'Kornia',
+ 'Differentiable Computer Vision in Pytorch.',
+ 'Miscellaneous',
+ )
+]
+
+
+# Example configuration for intersphinx: refer to the Python standard library.
+intersphinx_mapping = {
+ 'python': ('https://docs.python.org/3/', None),
+ 'numpy': ('http://numpy.org/doc/stable/', None),
+ 'torch': ('http://pytorch.org/docs/stable/', None),
+}
diff --git a/docs/source/contrib.rst b/docs/source/contrib.rst
new file mode 100644
index 0000000000000000000000000000000000000000..f3966d37ba11ca77d98576dfcd3e16c172400ed4
--- /dev/null
+++ b/docs/source/contrib.rst
@@ -0,0 +1,35 @@
+kornia.contrib
+==============
+
+.. currentmodule:: kornia.contrib
+
+Image Segmentation
+------------------
+
+.. autofunction:: connected_components
+
+Image Patches
+-------------
+
+.. autofunction:: extract_tensor_patches
+.. autofunction:: combine_tensor_patches
+
+.. autoclass:: ExtractTensorPatches
+.. autoclass:: CombineTensorPatches
+
+Image Classification
+--------------------
+
+.. autoclass:: VisionTransformer
+.. autoclass:: MobileViT
+.. autoclass:: ClassificationHead
+
+Image Stitching
+---------------
+
+.. autoclass:: ImageStitcher
+
+Lambda
+------
+
+.. autoclass:: Lambda
diff --git a/docs/source/data/epipolar_geometry.svg.png b/docs/source/data/epipolar_geometry.svg.png
new file mode 100644
index 0000000000000000000000000000000000000000..5783d56c5e16735ba66097b2063661f8a4c2046d
--- /dev/null
+++ b/docs/source/data/epipolar_geometry.svg.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e1812dd9bf047c727b209e8973395ba1df5ff95ff8bf4d888bd19bd46c37270b
+size 113616
diff --git a/docs/source/data/pinhole_model.png b/docs/source/data/pinhole_model.png
new file mode 100644
index 0000000000000000000000000000000000000000..e423d6498fb25bbb4ba151f42a808b2e99031da0
Binary files /dev/null and b/docs/source/data/pinhole_model.png differ
diff --git a/docs/source/enhance.rst b/docs/source/enhance.rst
new file mode 100644
index 0000000000000000000000000000000000000000..fa0cb2737b5c720049d38cf0a40f572e5172fae5
--- /dev/null
+++ b/docs/source/enhance.rst
@@ -0,0 +1,59 @@
+kornia.enhance
+==============
+
+.. currentmodule:: kornia.enhance
+
+The functions in this section perform normalisations and intensity transformations.
+
+Adjustment
+----------
+
+.. autofunction:: add_weighted
+.. autofunction:: adjust_brightness
+.. autofunction:: adjust_contrast
+.. autofunction:: adjust_gamma
+.. autofunction:: adjust_hue
+.. autofunction:: adjust_saturation
+.. autofunction:: invert
+.. autofunction:: posterize
+.. autofunction:: sharpness
+.. autofunction:: solarize
+
+Equalization
+------------
+
+.. autofunction:: equalize
+.. autofunction:: equalize_clahe
+.. autofunction:: equalize3d
+
+.. autofunction:: histogram
+.. autofunction:: histogram2d
+.. autofunction:: image_histogram2d
+
+Normalizations
+--------------
+
+.. autofunction:: normalize
+.. autofunction:: normalize_min_max
+.. autofunction:: denormalize
+.. autofunction:: zca_mean
+.. autofunction:: zca_whiten
+.. autofunction:: linear_transform
+
+
+Modules
+-------
+
+.. autoclass:: Normalize
+.. autoclass:: Denormalize
+.. autoclass:: ZCAWhitening
+ :members:
+
+.. autoclass:: AdjustBrightness
+.. autoclass:: AdjustContrast
+.. autoclass:: AdjustSaturation
+.. autoclass:: AdjustHue
+.. autoclass:: AdjustGamma
+.. autoclass:: AddWeighted
+
+.. autoclass:: Invert
diff --git a/docs/source/feature.rst b/docs/source/feature.rst
new file mode 100644
index 0000000000000000000000000000000000000000..98296f05b591e68f6ef045055bc2f27060ad747a
--- /dev/null
+++ b/docs/source/feature.rst
@@ -0,0 +1,111 @@
+kornia.feature
+==============
+
+.. currentmodule:: kornia.feature
+
+Detectors
+---------
+
+.. autofunction:: gftt_response
+.. autofunction:: harris_response
+.. autofunction:: hessian_response
+.. autofunction:: dog_response
+
+
+Descriptors
+-----------
+
+.. autoclass:: SIFTDescriptor
+.. autoclass:: MKDDescriptor
+.. autoclass:: HardNet
+.. autoclass:: HardNet8
+.. autoclass:: TFeat
+.. autoclass:: SOSNet
+.. autoclass:: LAFDescriptor
+ :members: forward
+
+.. autofunction:: get_laf_descriptors
+
+Matching
+--------
+
+.. autofunction:: match_nn
+.. autofunction:: match_mnn
+.. autofunction:: match_snn
+.. autofunction:: match_smnn
+
+.. autoclass:: DescriptorMatcher
+ :members: forward
+
+.. autoclass:: LocalFeature
+ :members: forward
+
+.. autoclass:: SIFTFeature
+ :members: forward
+
+.. autoclass:: GFTTAffNetHardNet
+ :members: forward
+
+.. autoclass:: LocalFeatureMatcher
+ :members: forward
+
+.. autoclass:: LoFTR
+ :members: forward
+
+
+Local Affine Frames (LAF)
+-------------------------
+
+.. autofunction:: extract_patches_from_pyramid
+.. autofunction:: extract_patches_simple
+.. autofunction:: normalize_laf
+.. autofunction:: denormalize_laf
+.. autofunction:: laf_to_boundary_points
+.. autofunction:: ellipse_to_laf
+.. autofunction:: make_upright
+.. autofunction:: scale_laf
+.. autofunction:: get_laf_scale
+.. autofunction:: get_laf_center
+.. autofunction:: get_laf_orientation
+.. autofunction:: laf_from_center_scale_ori
+.. autofunction:: laf_is_inside_image
+.. autofunction:: laf_to_three_points
+.. autofunction:: laf_from_three_points
+.. autofunction:: raise_error_if_laf_is_not_valid
+.. autofunction:: perspective_transform_lafs
+
+Module
+------
+
+.. autoclass:: BlobHessian
+.. autoclass:: CornerGFTT
+.. autoclass:: CornerHarris
+.. autoclass:: BlobDoG
+
+
+.. autoclass:: ScaleSpaceDetector
+ :members: forward
+
+.. autoclass:: PassLAF
+ :members: forward
+
+.. autoclass:: PatchAffineShapeEstimator
+ :members: forward
+
+.. autoclass:: LAFAffineShapeEstimator
+ :members: forward
+
+.. autoclass:: LAFOrienter
+ :members: forward
+
+.. autoclass:: PatchDominantGradientOrientation
+ :members: forward
+
+.. autoclass:: OriNet
+ :members: forward
+
+.. autoclass:: LAFAffNetShapeEstimator
+ :members: forward
+
+.. autoclass:: DeFMO
+ :members: forward
diff --git a/docs/source/filters.rst b/docs/source/filters.rst
new file mode 100644
index 0000000000000000000000000000000000000000..35e66038ef5e09bc04107e43d04677e74783ea4d
--- /dev/null
+++ b/docs/source/filters.rst
@@ -0,0 +1,60 @@
+kornia.filters
+==============
+
+.. currentmodule:: kornia.filters
+
+The functions in this sections perform various image filtering operations.
+
+Blurring
+--------
+
+.. autofunction:: blur_pool2d
+.. autofunction:: box_blur
+.. autofunction:: gaussian_blur2d
+.. autofunction:: max_blur_pool2d
+.. autofunction:: median_blur
+.. autofunction:: motion_blur
+.. autofunction:: unsharp_mask
+
+Edge detection
+--------------
+
+.. autofunction:: canny
+.. autofunction:: laplacian
+.. autofunction:: sobel
+.. autofunction:: spatial_gradient
+.. autofunction:: spatial_gradient3d
+
+Filtering API
+-------------
+
+.. autofunction:: filter2d
+.. autofunction:: filter2d_separable
+.. autofunction:: filter3d
+
+Kernels
+-------
+
+.. autofunction:: get_gaussian_kernel1d
+.. autofunction:: get_gaussian_erf_kernel1d
+.. autofunction:: get_gaussian_discrete_kernel1d
+.. autofunction:: get_gaussian_kernel2d
+.. autofunction:: get_laplacian_kernel1d
+.. autofunction:: get_laplacian_kernel2d
+.. autofunction:: get_motion_kernel2d
+
+Module
+------
+
+.. autoclass:: BlurPool2D
+.. autoclass:: BoxBlur
+.. autoclass:: MaxBlurPool2D
+.. autoclass:: MedianBlur
+.. autoclass:: GaussianBlur2d
+.. autoclass:: Laplacian
+.. autoclass:: Sobel
+.. autoclass:: Canny
+.. autoclass:: SpatialGradient
+.. autoclass:: SpatialGradient3d
+.. autoclass:: MotionBlur
+.. autoclass:: UnsharpMask
diff --git a/docs/source/geometry.bbox.rst b/docs/source/geometry.bbox.rst
new file mode 100644
index 0000000000000000000000000000000000000000..bb90fa8fccfa8354f5db65683fa937b139f60af9
--- /dev/null
+++ b/docs/source/geometry.bbox.rst
@@ -0,0 +1,7 @@
+kornia.geometry.bbox
+==========================
+
+Module with useful functionalities for 2D and 3D bounding boxes manipulation.
+
+.. automodule:: kornia.geometry.bbox
+ :members:
diff --git a/docs/source/geometry.calibration.rst b/docs/source/geometry.calibration.rst
new file mode 100644
index 0000000000000000000000000000000000000000..ad6866aaed9c820c3e7b0cf4d54d0993769fed2c
--- /dev/null
+++ b/docs/source/geometry.calibration.rst
@@ -0,0 +1,126 @@
+kornia.geometry.calibration
+===========================
+
+.. currentmodule:: kornia.geometry.calibration
+
+Module with useful functionalities for camera calibration.
+
+The pinhole model is an ideal projection model that not considers lens distortion for the projection of a 3D point :math:`(X, Y, Z)` onto the image plane. To model the distortion of a projected 2D pixel point :math:`(u,v)` with the linear pinhole model, we need first to estimate the normalized 2D points coordinates :math:`(\bar{u}, \bar{v})`. For that, we can use the calibration matrix :math:`\mathbf{K}` with the following expression
+
+.. math::
+ \begin{align}
+ \begin{bmatrix}
+ \bar{u}\\
+ \bar{v}\\
+ 1
+ \end{bmatrix} = \mathbf{K}^{-1} \begin{bmatrix}
+ u \\
+ v \\
+ 1
+ \end{bmatrix} \enspace,
+ \end{align}
+
+which is equivalent to directly using the internal parameters: focals :math:`f_u, f_v` and principal point :math:`(u_0, v_0)` to estimated the normalized coordinates
+
+.. math::
+ \begin{equation}
+ \bar{u} = (u - u_0)/f_u \enspace, \\
+ \bar{v} = (v - v_0)/f_v \enspace.
+ \end{equation}
+
+The normalized distorted point :math:`(\bar{u}_d, \bar{v}_d)` is given by
+
+.. math::
+ \begin{align}
+ \begin{bmatrix}
+ \bar{u}_d\\
+ \bar{v}_d
+ \end{bmatrix} = \dfrac{1+k_1r^2+k_2r^4+k_3r^6}{1+k_4r^2+k_5r^4+k_6r^6} \begin{bmatrix}
+ \bar{u}\\
+ \bar{v}
+ \end{bmatrix} +
+ \begin{bmatrix}
+ 2p_1\bar{u}\bar{v} + p_2(r^2 + 2\bar{u}^2) + s_1r^2 + s_2r^4\\
+ 2p_2\bar{u}\bar{v} + p_1(r^2 + 2\bar{v}^2) + s_3r^2 + s_4r^4
+ \end{bmatrix} \enspace,
+ \end{align}
+
+where :math:`r = \bar{u}^2 + \bar{v}^2`. With this model we consider radial :math:`(k_1, k_2, k_3, k_4, k_4, k_6)`, tangential :math:`(p_1, p_2)`, and thin prism :math:`(s_1, s_2, s_3, s_4)` distortion. If we want to consider tilt distortion :math:`(\tau_x, \tau_y)`, we need an additional step where we estimate a point :math:`(\bar{u}'_d, \bar{v}'_d)`
+
+.. math::
+ \begin{align}
+ \begin{bmatrix}
+ \bar{u}'_d\\
+ \bar{v}'_d\\
+ 1
+ \end{bmatrix} = \begin{bmatrix}
+ \mathbf{R}_{33}(\tau_x, \tau_y) & 0 & -\mathbf{R}_{13}(\tau_x, \tau_y)\\
+ 0 & \mathbf{R}_{33}(\tau_x, \tau_y) & -\mathbf{R}_{23}(\tau_x, \tau_y)\\
+ 0 & 0 & 1
+ \end{bmatrix}
+ \mathbf{R}(\tau_x, \tau_y) \begin{bmatrix}
+ \bar{u}_d \\
+ \bar{v}_d \\
+ 1
+ \end{bmatrix} \enspace,
+ \end{align}
+
+where :math:`\mathbf{R}(\tau_x, \tau_y)` is a 3D rotation matrix defined by an :math:`X` and :math:`Y` rotation given by the angles :math:`\tau_x` and :math:`\tau_y`. Furthermore, :math:`\mathbf{R}_{ij}(\tau_x, \tau_y)` represent the :math:`i`-th row and :math:`j`-th column from :math:`\mathbf{R}(\tau_x, \tau_y)` matrix.
+
+.. math::
+ \begin{align}
+ \mathbf{R}(\tau_x, \tau_y) =
+ \begin{bmatrix}
+ \cos \tau_y & 0 & -\sin \tau_y \\
+ 0 & 1 & 0 \\
+ \sin \tau_y & 0 & \cos \tau_y
+ \end{bmatrix}
+ \begin{bmatrix}
+ 1 & 0 & 0 \\
+ 0 & \cos \tau_x & \sin \tau_x \\
+ 0 & -\sin \tau_x & \cos \tau_x
+ \end{bmatrix} \enspace.
+ \end{align}
+
+
+Finally, we just need to come back to the original (unnormalized) pixel space. For that we can use the intrinsic matrix
+
+.. math::
+ \begin{align}
+ \begin{bmatrix}
+ u_d\\
+ v_d\\
+ 1
+ \end{bmatrix} = \mathbf{K} \begin{bmatrix}
+ \bar{u}'_d\\
+ \bar{v}'_d\\
+ 1
+ \end{bmatrix} \enspace,
+ \end{align}
+
+
+which is equivalent to
+
+.. math::
+ \begin{equation}
+ u_d = f_u \bar{u}'_d + u_0 \enspace, \\
+ v_d = f_v \bar{v}'_d + v_0 \enspace.
+ \end{equation}
+
+Undistortion
+------------
+
+To compensate for lens distortion a set of 2D points, i.e., to estimate the undistorted coordinates for a given set of distorted points, we need to inverse the previously explained distortion model. For the case of undistorting an image, instead of estimating the undistorted location for each pixel, we distort each pixel in the destination image (final undistorted image) to match them with the input image. We finally interpolate the intensity values at each pixel.
+
+.. autofunction:: undistort_image
+
+.. autofunction:: undistort_points
+
+.. autofunction:: distort_points
+
+.. autofunction:: tilt_projection
+
+Perspective-n-Point (PnP)
+-------------------------
+
+.. autofunction:: solve_pnp_dlt
diff --git a/docs/source/geometry.camera.perspective.rst b/docs/source/geometry.camera.perspective.rst
new file mode 100644
index 0000000000000000000000000000000000000000..313f3963fe9ca2820192ffa8c1f47df7a45c33c5
--- /dev/null
+++ b/docs/source/geometry.camera.perspective.rst
@@ -0,0 +1,8 @@
+Perspective Camera
+------------------
+
+.. currentmodule:: kornia.geometry.camera.perspective
+
+
+.. autofunction:: project_points
+.. autofunction:: unproject_points
diff --git a/docs/source/geometry.camera.pinhole.rst b/docs/source/geometry.camera.pinhole.rst
new file mode 100644
index 0000000000000000000000000000000000000000..d88ba473b2756780641e1dd5191a803d66ec01e2
--- /dev/null
+++ b/docs/source/geometry.camera.pinhole.rst
@@ -0,0 +1,75 @@
+Pinhole Camera
+--------------
+
+.. currentmodule:: kornia.geometry.camera.pinhole
+
+In this module we have all the functions and data structures needed to describe the projection of a 3D scene space onto a 2D image plane.
+
+In computer vision, we can map between the 3D world and a 2D image using *projective geometry*. The module implements the simplest camera model, the **Pinhole Camera**, which is the most basic model for general projective cameras from the finite cameras group.
+
+The Pinhole Camera model is shown in the following figure:
+
+.. image:: data/pinhole_model.png
+
+Using this model, a scene view can be formed by projecting 3D points into the image plane using a perspective transformation.
+
+.. math::
+ s \; m' = K [R|t] M'
+
+or
+
+.. math::
+ s \begin{bmatrix} u \\ v \\ 1\end{bmatrix} =
+ \begin{bmatrix}
+ f_x & 0 & u_0 \\
+ 0 & f_y & v_0 \\
+ 0 & 0 & 1
+ \end{bmatrix}
+ \begin{bmatrix}
+ r_{11} & r_{12} & r_{13} & t_1 \\
+ r_{21} & r_{22} & r_{23} & t_2 \\
+ r_{31} & r_{32} & r_{33} & t_3
+ \end{bmatrix}
+ \begin{bmatrix}
+ X \\
+ Y \\
+ Z \\
+ 1
+ \end{bmatrix}
+
+where:
+ * :math:`M'` is a 3D point in space with coordinates :math:`[X,Y,Z]^T` expressed in an Euclidean coordinate frame known as the *world coordinate system*.
+ * :math:`m'` is the projection of the 3D point :math:`M'` onto the *image plane* with coordinates :math:`[u,v]^T` expressed in pixel units.
+ * :math:`K` is the *camera calibration matrix*, also referred as the intrinsic matrix.
+ * :math:`C` is the *principal point offset* with coordinates :math:`[u_0, v_0]^T` at the origin in the image plane.
+ * :math:`fx, fy` are the focal lengths expressed in pixel units.
+
+The camera rotation and translation are expressed in terms of an Euclidean coordinate frame known as the *world coordinate system*. These terms are usually expressed by the joint rotation-translation matrix :math:`[R|t]` which is also known as the extrinsic matrix. It is used to describe the camera pose around a static scene and transforms the coordinates of a 3D point :math:`(X,Y,Z)` from the *world coordinate system* to the *camera coordinate system*.
+
+The :class:`PinholeCamera` expects the *intrinsic matrices* and the *extrinsic matrices*
+to be of shape `(B, 4, 4)` such that each *intrinsic matrix* has the following format:
+
+.. math::
+ \begin{bmatrix}
+ f_x & 0 & u_0 & 0\\
+ 0 & f_y & v_0 & 0\\
+ 0 & 0 & 1 & 0 \\
+ 0 & 0 & 0 & 1
+ \end{bmatrix}
+
+And each *extrinsic matrix* has the following format:
+
+.. math::
+ \begin{bmatrix}
+ r_{11} & r_{12} & r_{13} & t_1 \\
+ r_{21} & r_{22} & r_{23} & t_2 \\
+ r_{31} & r_{32} & r_{33} & t_3 \\
+ 0 & 0 & 0 & 1
+ \end{bmatrix}
+
+
+.. autoclass:: PinholeCamera
+ :members:
+
+.. autofunction:: cam2pixel
+.. autofunction:: pixel2cam
diff --git a/docs/source/geometry.camera.rst b/docs/source/geometry.camera.rst
new file mode 100644
index 0000000000000000000000000000000000000000..d57e51440ae1b67647b582fe31c33f126f880242
--- /dev/null
+++ b/docs/source/geometry.camera.rst
@@ -0,0 +1,11 @@
+kornia.geometry.camera
+======================
+
+.. currentmodule:: kornia.geometry.camera
+
+.. toctree::
+ :maxdepth: 2
+
+ geometry.camera.pinhole
+ geometry.camera.perspective
+ geometry.camera.stereo
diff --git a/docs/source/geometry.camera.stereo.rst b/docs/source/geometry.camera.stereo.rst
new file mode 100644
index 0000000000000000000000000000000000000000..abe99b043fb24997b518378f335b0be03505c3bc
--- /dev/null
+++ b/docs/source/geometry.camera.stereo.rst
@@ -0,0 +1,160 @@
+Stereo Camera
+-------------
+
+.. currentmodule:: kornia.geometry.camera.stereo
+
+In this module we provide the :class:`StereoCamera` that contains functionality for working with a horizontal stereo camera setup.
+
+The horizontal stereo camera setup is assumed to be calibrated and rectified such that the setup can be described by two camera matrices:
+
+The *left rectified camera matrix*:
+
+.. math::
+ P_0 = \begin{bmatrix}
+ fx & 0 & cx & 0 \\
+ 0 & fy & cy & 0 \\
+ 0 & 0 & 1 & 0
+ \end{bmatrix}
+
+The *right rectified camera matrix*:
+
+.. math::
+ P_1 = \begin{bmatrix}
+ fx & 0 & cx & tx * fx \\
+ 0 & fy & cy & 0 \\
+ 0 & 0 & 1 & 0
+ \end{bmatrix}
+
+where:
+ * :math:`fx` is the focal length in the x-direction in pixels.
+ * :math:`fy` is the focal length in the y-direction in pixels.
+ * :math:`cx` is the x-coordinate of the principal point in pixels.
+ * :math:`cy` is the y-coordinate of the principal point in pixels.
+ * :math:`tx` is the horizontal baseline in metric units.
+
+These camera matrices are obtained by calibrating your stereo camera setup which can be done `in OpenCV "
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "%matplotlib inline\n",
+ "fig, (ax1, ax2) = plt.subplots(1, 2, sharey=True)\n",
+ "fig.set_figheight(15)\n",
+ "fig.set_figwidth(15)\n",
+ "ax1.imshow(tgm.utils.tensor_to_image(img_ref)[:,:,::-1])\n",
+ "ax1.set_title('Reference image, frame_id: %d' %frame_ref_id)\n",
+ "ax2.imshow(tgm.utils.tensor_to_image(img_i)[:,:,::-1])\n",
+ "ax2.set_title('ith image, frame_id: %d' %frame_i_id)\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### instantiate the depth warper from torchgeometry"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "warper = tgm.DepthWarper(cam_i)\n",
+ "warper.compute_homographies(cam_ref)\n",
+ "\n",
+ "# compute the inverse depth and warp the source image \n",
+ "inv_depth_ref = 1. / depth_ref\n",
+ "img_i_to_ref = warper(inv_depth_ref, img_i)\n",
+ "\n",
+ "# generate occlusion mask \n",
+ "mask = ((img_ref - img_i_to_ref).mean(1) < 1e-1).float()\n",
+ "\n",
+ "img_vis_warped = 0.5 * (img_i_to_ref + img_ref)\n",
+ "img_vis_warped_masked = mask * 0.5 * (img_i_to_ref + img_ref)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Visualize the outputs"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "fig, (ax1, ax2) = plt.subplots(1, 2, sharey=True)\n",
+ "fig.set_figheight(15)\n",
+ "fig.set_figwidth(15)\n",
+ "ax1.imshow(clip_and_convert_tensor(img_vis_warped))\n",
+ "ax1.set_title('Original warped image')\n",
+ "ax2.imshow(clip_and_convert_tensor(img_vis_warped_masked))\n",
+ "ax2.set_title('with occlusion mask')\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.0"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/depth_warper/download_data.sh b/examples/depth_warper/download_data.sh
new file mode 100644
index 0000000000000000000000000000000000000000..15f02f71d68e289433637a0ebf144d565d76b694
--- /dev/null
+++ b/examples/depth_warper/download_data.sh
@@ -0,0 +1,16 @@
+#!/bin/bash
+# This script is useful to download the example data
+
+DATA_DIR=./data
+IMAGES_FILE_NAME="MPI-Sintel-training_images.zip"
+DEPTH_FILE_NAME="MPI-Sintel-depth-training-20150305.zip"
+
+# clean previous and download data
+rm -rf ${DATA_DIR} && mkdir -p ${DATA_DIR}
+wget http://files.is.tue.mpg.de/sintel/${IMAGES_FILE_NAME} -P ${DATA_DIR}
+wget http://files.is.tue.mpg.de/jwulff/sintel/${DEPTH_FILE_NAME} -P ${DATA_DIR}
+
+# unzip to dir
+unzip ${DATA_DIR}/${IMAGES_FILE_NAME} -d ${DATA_DIR}
+unzip ${DATA_DIR}/${DEPTH_FILE_NAME} -d ${DATA_DIR}
+echo "## Succeeded to download files to $DATA_DIR"
diff --git a/examples/depth_warper/install_dependencies.sh b/examples/depth_warper/install_dependencies.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8d3dd2d3d8fb3fc4d099cb988499899993d3f1cf
--- /dev/null
+++ b/examples/depth_warper/install_dependencies.sh
@@ -0,0 +1,7 @@
+#!/bin/bash -ex
+
+# install torchgeometry from source
+cd ../.. && python setup.py install && cd examples/depth_warper
+
+# we need last opencv
+conda install opencv --yes
diff --git a/examples/depth_warper/main.py b/examples/depth_warper/main.py
new file mode 100644
index 0000000000000000000000000000000000000000..46c8d4de960c33fa52f87e55842d3342b2cb97b1
--- /dev/null
+++ b/examples/depth_warper/main.py
@@ -0,0 +1,106 @@
+import argparse
+import os
+import sys
+
+import cv2
+import torch
+
+import kornia as dgm
+
+
+def load_depth(file_name):
+ """Load the depth using the syntel SDK and converts to torch.Tensor."""
+ if not os.path.isfile(file_name):
+ raise AssertionError(f"Invalid file {file_name}")
+ import sintel_io
+
+ depth = sintel_io.depth_read(file_name)
+ return torch.from_numpy(depth).view(1, 1, *depth.shape).float()
+
+
+def load_camera_data(file_name):
+ """Load the camera data using the syntel SDK and converts to torch.Tensor."""
+ if not os.path.isfile(file_name):
+ raise AssertionError(f"Invalid file {file_name}")
+ import sintel_io
+
+ intrinsic, extrinsic = sintel_io.cam_read(file_name)
+ return intrinsic, extrinsic
+
+
+def load_image(file_name):
+ """Load the image with OpenCV and converts to torch.Tensor."""
+ if not os.path.isfile(file_name):
+ raise AssertionError(f"Invalid file {file_name}")
+
+ # load image with OpenCV
+ img = cv2.imread(file_name, cv2.IMREAD_COLOR)
+
+ # convert image to torch tensor
+ tensor = dgm.utils.image_to_tensor(img).float() / 255.0
+ return tensor.view(1, *tensor.shape) # 1xCxHxW
+
+
+def load_data(root_path, sequence_name, frame_id):
+ # index paths
+ file_name = 'frame_%04d' % (frame_id)
+ image_file = os.path.join(root_path, 'clean', sequence_name, file_name + '.png')
+ depth_file = os.path.join(root_path, 'depth', sequence_name, file_name + '.dpt')
+ camera_file = os.path.join(root_path, 'camdata_left', sequence_name, file_name + '.cam')
+ # load the actual data
+ image = load_image(image_file)
+ depth = load_depth(depth_file)
+ # load camera data and create pinhole
+ height, width = image.shape[-2:]
+ intrinsics, extrinsics = load_camera_data(camera_file)
+ camera = dgm.utils.create_pinhole(intrinsics, extrinsics, height, width)
+ return image, depth, camera
+
+
+def DepthWarperApp():
+ parser = argparse.ArgumentParser(description='Warp images by depth application.')
+ # data parameters
+ parser.add_argument('--input-dir', type=str, required=True, help='the path to the directory with the input data.')
+ parser.add_argument('--output-dir', type=str, required=True, help='the path to output the results.')
+ parser.add_argument('--sequence-name', type=str, default='alley_1', help='the name of the sequence.')
+ parser.add_argument('--frame-ref-id', type=int, default=1, help='the id for the reference image in the sequence.')
+ parser.add_argument('--frame-i-id', type=int, default=2, help='the id for the image i in the sequence.')
+ # device parameters
+ parser.add_argument('--cuda', action='store_true', default=False, help='enables CUDA training')
+ parser.add_argument('--seed', type=int, default=666, metavar='S', help='random seed (default: 666)')
+ args = parser.parse_args()
+
+ torch.manual_seed(args.seed)
+
+ # configure syntel SDK path
+ root_path = os.path.abspath(args.input_dir)
+ sys.path.append(os.path.join(root_path, 'sdk/python'))
+
+ # load the data
+ root_dir = os.path.join(root_path, 'training')
+ img_ref, depth_ref, cam_ref = load_data(root_dir, args.sequence_name, args.frame_ref_id)
+ img_i, _, cam_i = load_data(root_dir, args.sequence_name, args.frame_i_id)
+
+ # instantiate the homography warper from `kornia`
+ warper = dgm.DepthWarper(cam_i)
+ warper.compute_homographies(cam_ref)
+
+ # compute the inverse depth and warp the source image
+ inv_depth_ref = 1.0 / depth_ref
+ img_i_to_ref = warper(inv_depth_ref, img_i)
+
+ # generate occlusion mask
+ mask = ((img_ref - img_i_to_ref).mean(1) < 1e-1).float()
+
+ img_vis_warped = 0.5 * img_i_to_ref + img_ref
+ img_vis_warped_masked = mask * (0.5 * img_i_to_ref + img_ref)
+
+ # save warped image to disk
+ file_name = os.path.join(args.output_dir, f'warped_{args.frame_i_id}_to_{args.frame_ref_id}.png')
+ cv2.imwrite(file_name, dgm.utils.tensor_to_image(255.0 * img_vis_warped))
+ cv2.imwrite(file_name + 'mask.png', dgm.utils.tensor_to_image(255.0 * mask))
+ cv2.imwrite(file_name + 'warpedmask.png', dgm.utils.tensor_to_image(255.0 * img_vis_warped_masked))
+
+
+if __name__ == "__main__":
+ DepthWarperApp()
diff --git a/examples/depth_warper/readme.rst b/examples/depth_warper/readme.rst
new file mode 100644
index 0000000000000000000000000000000000000000..e0b21224d1ce0d5dc803fbec8491d6697c48d8e8
--- /dev/null
+++ b/examples/depth_warper/readme.rst
@@ -0,0 +1,47 @@
+Warp Image by Depth
+===================
+
+This example shows how to use the `DepthWarper` in order to warp an image from a reference camera to a destination
+by the depth using the epipolar geometry constraints assumig a pinhole camera model.
+
+Downloading the data
+====================
+
+You can download the data by running: ``./download_data.sh``
+
+Usage
+=====
+
+1. From root, run the docker development or build first if needed: ``//kornia/dev_en.sh``
+2. Browse to ``cd /code/kornia/examples/depth_warper``
+3. Install the dependencies by running: ``./install_dependencies.sh``
+4. Now you can run the example followingthe instructions below:
+
+.. code:: bash
+
+ python main.py --input-dir ./data --output-dir ./out --frame-ref-id 2 --frame-i-id 1
+
+.. code:: bash
+
+usage: main.py [-h] --input-dir INPUT_DIR --output-dir OUTPUT_DIR
+ [--sequence-name SEQUENCE_NAME]
+ [--frame-ref-id FRAME_REF_ID]
+ [--frame-i-id FRAME_I_ID] [--cuda]
+ [--seed S]
+
+Warp images by depth application.
+
+optional arguments:
+ -h, --help show this help message and exit
+ --input-dir INPUT_DIR
+ the path to the directory with the input data.
+ --output-dir OUTPUT_DIR
+ the path to output the results.
+ --sequence-name SEQUENCE_NAME
+ the name of the sequence.
+ --frame-ref-id FRAME_REF_ID
+ the id for the reference image in the sequence.
+ --frame-i-id FRAME_I_ID
+ the id for the image i in the sequence.
+ --cuda enables CUDA training
+ --seed S random seed (default: 666)
diff --git a/examples/feature_detection/extract_local_patches.ipynb b/examples/feature_detection/extract_local_patches.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..b2e2cf099b04a489f55130f6d5efd68cca9d5376
--- /dev/null
+++ b/examples/feature_detection/extract_local_patches.ipynb
@@ -0,0 +1,241 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 1,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "%matplotlib inline\n",
+ "import kornia\n",
+ "import torch\n",
+ "from PIL import Image\n",
+ "import matplotlib.pyplot as plt\n",
+ "import numpy as np\n",
+ "\n",
+ "img = Image.open('img/prague.png')\n",
+ "timg = kornia.utils.image_to_tensor(np.array(img), keepdim=False).float() / 255.\n",
+ "plt.imshow(kornia.utils.tensor_to_image(timg[0]))\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "torch.Size([2000, 5])\n",
+ "tensor([ 4.4487e+02, 3.2709e+02, 7.1538e-04, -6.9498e-05, 1.0999e-03])\n"
+ ]
+ }
+ ],
+ "source": [
+ "#Lets read pre-detected features in Oxford affine ellipse [x y a b c] format\n",
+ "ells = torch.from_numpy(np.loadtxt('img/prague.hesaffnet', skiprows=2)).float()\n",
+ "print (ells.shape)\n",
+ "print(ells[0])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#Now, lets convert ellipses into kornia LAF format:\n",
+ "laf = kornia.feature.ellipse_to_laf(ells.unsqueeze(0))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "def visualize_LAF(img, LAF, img_idx = 0):\n",
+ " x, y = kornia.feature.laf.get_laf_pts_to_draw(LAF, img_idx)\n",
+ " plt.figure()\n",
+ " plt.imshow(kornia.utils.tensor_to_image(img[img_idx]))\n",
+ " plt.plot(x, y, 'r')\n",
+ " plt.show()\n",
+ " return\n",
+ "visualize_LAF(timg,laf)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "torch.Size([1, 2000, 3, 32, 32])\n"
+ ]
+ }
+ ],
+ "source": [
+ "\n",
+ "#Now, lets extract some patches\n",
+ "patches_aliased = kornia.feature.extract_patches_simple(timg,\n",
+ " kornia.feature.normalize_laf(laf,timg))\n",
+ "patches_nice = kornia.feature.extract_patches_from_pyramid(timg, \n",
+ " kornia.feature.normalize_laf(laf,timg))\n",
+ "print (patches_nice.shape)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD5CAYAAADhukOtAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAdy0lEQVR4nO2dW4yd13Xf/+vcZ+YMyRkOb7pYlGRFiiNYsksIRhWkTt0EihHAdgEb8UOgByPKQwzEgPsguEDtPhRwi9qBHwoDdC1EKRzHQmTDaiukNtQWrl3bFa3IupiWqAslUhxyeJnh3M71O6sPcxRQ8v6vGXFmzjDe/x9AcGav2d+3zj7fOt85+3/WWubuEEL8+lPaaQeEEKNBwS5EJijYhcgEBbsQmaBgFyITFOxCZEJlM5PN7D4AXwFQBvCf3f2L0d9PjjV83+RE0jZojEVnSo5GsqGlp4THWxc2LVAvr94PftBRqqXRqa7G+6t7xIBd5czl1VZyfBDMic/FseDJtuB8pVL6nhsdzwfp4y0uLaHVaiUnXnWwm1kZwH8C8HsATgN40swec/dfsDn7Jifw7z7xB0nb6u130XM5WfxB0adzSpUytUWXXNmCeaX0Ag8GA368UnA8C95YkXMBQNErqG1ALoLoVSe6qOKg4P6zWaVg7QfO19GMX6oGPu//HnsmOd4a8GunEl0DwStSrcF9LAc+Nuq19PHIOAAUrW5y/K8feZTO2czb+HsAvOTur7h7F8DfAPjIJo4nhNhGNhPs1wM4dcXvp4djQohrkM0Ee+r92K+8yTGzB8zsmJkdW2q1N3E6IcRm2EywnwZw4xW/3wDgzNv/yN2PuvsRdz8yOdbYxOmEEJthM8H+JIDbzOxmM6sB+CMAj22NW0KIreaqd+PdvW9mnwbwP7AmvT3k7s9Hcxb7fXzvwsWk7b3v5m/xJyz9jmDQ6/GTlfnrWCnYBR8436W1AZMAuRu9YIe5xHbOEW7Go9cPdpKJCuHBY44Ug3IkAQbHvJq7SLfDVYbFxQVqe232V95Q/gMXFi4lx6endtM5e6emqG3fDLft3jNJbdNNbquNpXfdx8p8N767nJYU/+t//zs6Z1M6u7s/DuDxzRxDCDEa9A06ITJBwS5EJijYhcgEBbsQmaBgFyITNrUb/44pleETzaTpxRdP0GnvveX25LgHr1VRkkYRJEEgSGoplarEEMxxvsRhsU8PHlsgeRl5Sgdc1UKnyyXMTp9Lop12h9parbQ01O7wOb1AimxOjFPbrb9xM7Xdc+8/SY7vHt9F5zRq5HkGUCEZagBQBItcdPk1wuRZlgAGAP0inQiDIOFGd3YhMkHBLkQmKNiFyAQFuxCZoGAXIhNGuhvv7ui307uFc+fP0Xndw7cmx0skMQUAQHcr19kh55uZGAzSxyxVglphfpV15gJVYFDwecdPvJgcr07w9OIo8aMxwWsD7p+apraJRj19vHp6HADKVf681IMSTRaUkWIltwYF3zln9d0AoN8PLpAAt6C8F3muvRSU8GJzAoFHd3YhMkHBLkQmKNiFyAQFuxCZoGAXIhMU7EJkwkilt1KphEYzLb2USlwK6ZAOKOUgUaDR4RrEgOc5xF1mSK02D5JWYJGWx00ezCuCGnSvnHgpOf6hf5nuxAMAtx7k5f7rFb5YRaBTMmko6p4TyVqD4Eq1oGAfbXYTaFRFwRODWKsmABgU0RMa+Ehs7cvLdM7pN04lx7u9QHKmFiHErxUKdiEyQcEuRCYo2IXIBAW7EJmgYBciEzYlvZnZSQBLAAoAfXc/Ev89UCOZTQvLvNbZG2fSGXG37eOZUGfneSZULagxtmecz1sZpG2V4HhB4hJKQbZWqcJfh0OJishhQaOsUDLqFLxmnJW5//1+Wi5lMhMAIGi9VfS5pFStBRlxJOsw8ALpBsVrRNJhlNlWDk74zW/9bXL8tTdm6ZyF5cXk+MV53iZrK3T233X3C1twHCHENqK38UJkwmaD3QF8z8x+ZmYPbIVDQojtYbNv4+919zNmth/A983sl+7+gyv/YPgi8AAANJsTmzydEOJq2dSd3d3PDP+fA/AdAPck/uaoux9x9yNjY7wkkRBie7nqYDezCTObfPNnAL8P4LmtckwIsbVs5m38AQDfGRb0qwD4a3f/u2hCe2UVv/zJU0mblfnrzpmz6c3+54MChbUqL5Q4ERRfvHXfJLWd7aZ9PLQ33dIKACaM+7gKLl3Vg3dB3o9eo9OyUS2QySIhqqBpY4AFGYJsVj9ovTUIsvkqVS6v9YO2S0x6iyTRsGpjVCQ0aLE1CGTFLpm4d/8+OqdcS19XlfLrdM5VB7u7vwLgrqudL4QYLZLehMgEBbsQmaBgFyITFOxCZIKCXYhMGG3BSSuhWUtLSmOTu+i88p49yXHr8gykqPBep8tzwJ589Sz3g4yfOhVIRqWgr1wgh02Oj1NbtcxlqPlL6WwoC/qX9YK+Z9XAx16fryOrl1kEWWMW6GHdXpB916ImnCKZY4cOH6Jzxipc9iwF90dHkLUXzJua3pscZ33qAODAdDomnn32F3SO7uxCZIKCXYhMULALkQkKdiEyQcEuRCaMdDe+XDI0x9M7nc3dfPd5ct9McjxKVyh6QcJCUBDMoxY+ln5tNPDd7EGwC+5BrTMPkkzaba40zC+S3fhgZzfonoQi2KkvDQL/16nylqK1zLfVo0SSs6/w5I+vPfpocvyzD36Wzrlukj+ugrQAAwCSc7NmC1SI3/1nv52eE6z94oVLyfHHv/c/6Rzd2YXIBAW7EJmgYBciExTsQmSCgl2ITFCwC5EJo5XeKmVMTe9O2ooul13OnZ9Ljs/sP0DnjE9wiWR5dZXapianqK1Hap2VK0G7oKCeWZlIeevR7XAZyomOVgrOFclkHkiHfdJqCgCqpLVVdK5XTrxIbdPX8+e6W+J+3HHbrcnx+bPplmIAsKfE23mttHmbstnZ16jt9jveQ221WrpeYr/Nk39Ym69I8NSdXYhMULALkQkKdiEyQcEuRCYo2IXIBAW7EJmwrvRmZg8B+EMAc+5+53BsGsC3ABwGcBLAJ9x9fv3TOeDpumXtDpcZnjv5QnrOz3kbpxsO8iy6nvPWULubfN7+A+l2PFXnMt/eA7zWWa3CJZ5S8DJcDlooVSvpiZXggEGeX9gKqR/IUEZqDa4ur9A5F+cXuBs1Xnfv9jt+k9pWO+kMwYWz5+mc3nX8OVtZ5D7+5Mc/orZ+0Krs9pvenRyPMuXAsjOD52sjd/a/BHDf28YeBPCEu98G4Inh70KIa5h1g33Yb/3tybMfAfDw8OeHAXx0i/0SQmwxV/uZ/YC7zwLA8P/9W+eSEGI72PYNOjN7wMyOmdmxVofXGRdCbC9XG+znzOwQAAz/T395HYC7H3X3I+5+ZKzON6SEENvL1Qb7YwDuH/58P4Dvbo07QojtYiPS2zcBfBDAjJmdBvB5AF8E8IiZfQrA6wA+vpGTGYA6yb5qBy87naW01LRYpIvuAcDqCv/I8HqQ8RRVXzxwJi3LtTpcFroukN6uv+4gte2fnqa2clA8krWU8kh6I9l8AFAJCnCemz1Fbde963ByfIkUxASAQwfT0iYALK4sU9ulc/z5XF1On29u7gKdMzmTzswEgFePH6e2os/X6vSrPCOuWE5LmLccvvmqzsVYN9jd/ZPE9KF3fDYhxI6hb9AJkQkKdiEyQcEuRCYo2IXIBAW7EJkw0oKT7o5eP52F1O3xTK6VIi2HWZm/Vs0v8QKW0byixyWN+cX0MS9d4HLS8Ze5PFUnhQYBYP8Ul3/27uWyXJ+oaLNz9HtPmDjIJcDlhcvU9vobXE5q7t6THDfj0uaJl09QmwXS4SsvvURtjfF0ZmQX/Hp78oc/oTYPMg6jjLiTgY9jJKPv2Rd4YdQDu/cmxwdBppzu7EJkgoJdiExQsAuRCQp2ITJBwS5EJijYhciEkUpvVi6juistyVRbaUkOAEqNdB78gT284KS1uURSgGeNdYKXP6ukM8oOXp8urggArdd5Rlk/kBtPvcGlsrkLPGPLyUPr9ngWYLvNZcoXfvEctR0/zm0X5y4mxw8euJHOudziEuagw9dx6TLPiCsup6WomvFrxwN58PB1N1Dbhfn0YwYAJ4UvAWBpcSk53js3S+dMN9OZfh70TNSdXYhMULALkQkKdiEyQcEuRCYo2IXIhNHuxsNQKpNTBi2UGiQJotblr1VjVV7Jttvju/FFndv6pFZbr813WidnJqltpsZ9PBwoDT96kddcK8iubxEkcLSX+Q7uG2f5zn8vaP906rV0y675l0/SOZ1dE9S2tJTesQaASpWvVaeVViEmmvx627UnrRgBQKfPd+rfffsd1DYePNfTJGkIl/hztns1rUCUlQgjhFCwC5EJCnYhMkHBLkQmKNiFyAQFuxCZsJH2Tw8B+EMAc+5+53DsCwD+BMD54Z99zt0fX+9Yg8EAq+RL/xcDaWUPkS2ade5+ucSljkNBf0kLatedWyZyR53LOAfHeJLMb+1L1xEDgEGQOPF7dx+mtp/Np/0vB3X3uiu81tlLzz9NbRO7pqitTNp8LZe5NLRrLJLeeC288V1c3rzr8K3J8cuXuKRYK3H5df/1vDbg2IDLcq2gfdXixdPJ8XZQD3H6lncnxwf/51k6ZyN39r8EcF9i/C/c/e7hv3UDXQixs6wb7O7+AwC8g6IQ4h8Fm/nM/mkze8bMHjIz/n5OCHFNcLXB/lUAtwK4G8AsgC+xPzSzB8zsmJkdawWfQ4UQ28tVBbu7n3P3wt0HAL4G4J7gb4+6+xF3PzJW533MhRDby1UFu5kduuLXjwHg9YmEENcEG5HevgnggwBmzOw0gM8D+KCZ3Q3AAZwE8KcbOtvAYd10Jk+gdqA5ntbKqsYnVbiKg/4yl0j2TXCpbGY8batX+fFmJprUNr/I5ZiFFs942jPG20bd1Ey/eyoKLuNcmuMyVKPB/W+3uGRXIbKoG68lV63x7LWJCn9XuDwftKjqpltKFT3u+1iwvvUx7kenxNf48mVeX2/2Urp2XXMPlxT3HZhJjlerPKTXDXZ3/2Ri+OvrzRNCXFvoG3RCZIKCXYhMULALkQkKdiEyQcEuRCaMtOBkf1DgIskcGwTS2yRp/1Sv8knLQbsglPm8qUC6qJFp7aDlzsUFLq+djdoWBU/NQo8/tlqdpPQF0ttqkJFlwXqUS1xy7BVpW73G5/T7/BuWgRtw3tkK5SJdFHOCPZkAen0uk514hUt27S5/XgriBwBUymRNxnk25dPPH0+Or7b4eXRnFyITFOxCZIKCXYhMULALkQkKdiEyQcEuRCaMVHorlSoYn0z3teotpjN/AKDV6yTHO0FBvm5gu24Xz+QaL3O5o9VOazznlrj2s9JN+w4ARVCgsGHcdj6QypbaafknyirsEpkMAMaafK0W5uepbZJkKpoFUh55ngGg0+a28do4taGclvM6zh/zWjJnmnqZP9cDfulgtc/vq50ineFYXuSS7onuyeR4O7jedGcXIhMU7EJkgoJdiExQsAuRCQp2ITJhpLvxwABAene0F+3Ekl3rfp8nHtwc1O/qkh1rALhMdkYBYOBp22Ir8L3PVYEo+acP7qP1+Y6wkW333mW+c75/irehOnfxDWprB7X8ih5Zx6BuYLGyQm2snRQA9AZ8jdvkudmzh9eSC54y9Lt87YtgF79c4f63V9LHrBvf3l8ZLCTHBwN+3ejOLkQmKNiFyAQFuxCZoGAXIhMU7EJkgoJdiEzYSPunGwH8FYCDWNPOjrr7V8xsGsC3ABzGWguoT7g713cAuA/Qbi0lbZGM1iM13hpBYbJ+N9BPwG2n5nmSyVQz3f5p7ySX+c4ucznJylzmWwzkNZS4JHPnu9KJRiee+jGd0xzjiSSzc7y1UtHnUpORNd7V4PeXpaCdVK/g10ejyo9Zr6VtrQ5f396APy+9IMGKqY0A0OnxtSqRmojdoNZgQWosDoLkqo3c2fsAPuvuvwngAwD+zMzeA+BBAE+4+20Anhj+LoS4Rlk32N191t2fGv68BOA4gOsBfATAw8M/exjAR7fLSSHE5nlHn9nN7DCA9wH4KYAD7j4LrL0gANi/1c4JIbaODQe7mTUBPArgM+7OC2v/6rwHzOyYmR1rk3bNQojtZ0PBbmZVrAX6N9z928Phc2Z2aGg/BGAuNdfdj7r7EXc/0qiN+Kv4Qoh/YN1gNzPDWj/24+7+5StMjwG4f/jz/QC+u/XuCSG2io3cau8F8McAnjWzp4djnwPwRQCPmNmnALwO4OPrHWgw6KPduZS01QL5BKR+F8vwAoCVIDtpbpHLYUWZ++HldF21y6tcntq7Oy2FAUCrzedVx9IyHwA0J/jjrlbTstxCn9czW77A16MUpOZ1gpZSIFl79RrPNlsK6syVS6StFYCC1JkDgKWl9EfHWiABdoM2VLUK97/T4R9T+0WQ4lhNy2WDgvvRI9d3JL2tG+zu/kMAzNMPrTdfCHFtoG/QCZEJCnYhMkHBLkQmKNiFyAQFuxCZMNpvuRhQIi8vhfMMn5qlJZ7l1aCYI5EzAKAIJLtdDS55sfY+lRqXhTqBfLJraje1NYLCjJUga69fTfs/4fx4jRq3tYN2WOUWl5r2NNOPbXH+ZTpnbIyvozv3Yzlok9Qjj5u18gKAXXuDVk3BYy4H2Yi14Atly620/0WQ6Vcn11wkR+vOLkQmKNiFyAQFuxCZoGAXIhMU7EJkgoJdiEwYqfRWLgG7SMbWq7NtOs+QzjRaDYphNMo8O2m8ziWSqIhlpZEuzPhP77qJzvnF67PUdnCGF6pcXOS1Ow/MHKK2LincuRpk+k1NTVFbpTFGba+dOUdteyaayfFL57k01AuKjka975zmaQE1ksXYD5LQPJCBg1MBNS6Jtlpc6uuTwp2loL9dvUKkt8BB3dmFyAQFuxCZoGAXIhMU7EJkgoJdiEwY6W58pQxMT6Z3HpeX+O75q+fTu6PNeoPO2TPBd5ErdZ5wMTnBWyENSJKJBXXrJhr8XO/aP0NtT57nO91n5rit10sn3jRKfK3Gxnnyz/kLF6mtH7Rrukx2tFe56AIYT14qV/gu8/T0LmpbaqdVCAtaVyGoF+dBy65+O6ozF6gJ7XQYVsb58YpBVP8vje7sQmSCgl2ITFCwC5EJCnYhMkHBLkQmKNiFyIR1pTczuxHAXwE4CGAA4Ki7f8XMvgDgTwCcH/7p59z98ehYpZKjOZFu8XPDAS5RXVpKSxA37Q/qenW41FEpc6mpBC7JjFfStu7KEp2zP0gymV/i7Y52kRpuAHAwkJpeePVkcrznXDI69cYZaisFtd96Qb5Ip52WhgYDfn8ZlLiPPXI8AFhcWqa2EnmqB+CJKYOCX1ft4DFPjAdJVLWg3RRRMEslfrIyk3sD+XIjOnsfwGfd/SkzmwTwMzP7/tD2F+7+HzdwDCHEDrORXm+zAGaHPy+Z2XEA12+3Y0KIreUdfWY3s8MA3gfgp8OhT5vZM2b2kJnx96tCiB1nw8FuZk0AjwL4jLsvAvgqgFsB3I21O/+XyLwHzOyYmR1bDT53CSG2lw0Fu5lVsRbo33D3bwOAu59z98LdBwC+BuCe1Fx3P+ruR9z9yHjQE1sIsb2sG31mZgC+DuC4u3/5ivErayN9DMBzW++eEGKr2Mhu/L0A/hjAs2b29HDscwA+aWZ3A3AAJwH86fqHcoC0cprcxdsk3XFjup7ZzAGeFTTJ1TU8dZxLPKu8kxAajUvJ8Zuum6ZzFoq07wCwcGGR2up1Pu/1szwTDZ6WXlaDGmiXg5ZGY0FLo0iGKogEVA0yDpdWeEpcJWhDVSnxy9hL6euqUuX3uYIvB1orXNpqBFKZBetYn2DXfpBFx7LvNiO9ufsPyVlDTV0IcW2hD9FCZIKCXYhMULALkQkKdiEyQcEuRCaMtODkYOBotdMSULXOJYN9B9I2ojIBAHpB0cBSlWeNBQlxqFfTxQtXu7xIZWt1gdoWOlxunLvMM+nGgtfoxctpSabU4E91OTjeaqBD9YPLZ08zvSbdZa5tTk5yWe5iUKjSA/973fR1ELUOG/T58UrRNdfi8yr1QM/rkeu7yq/hPrt0gi+p6s4uRCYo2IXIBAW7EJmgYBciExTsQmSCgl2ITBit9ObAUiutDeyb5L3IaoO0NFGucWlicZlrJHfeTE1Y6nBpqEN6ea22uLxWtHhftmaNS4CrZZ6ldukS11c6pMeaBTJfrcIvg4k675m32OZrZUSj8iCRq1vw56xa5hNbK7xwZ0EyxwaBIx5k2JUbfO3HJ/m9041nxI2RfoBt5+cakMMFyqDu7ELkgoJdiExQsAuRCQp2ITJBwS5EJijYhciEkUpvJQMmxtKSx/mLXMa5YV9aluv1uZzRL7jUNL/C5zVqQUFEomssXOTHm5nmEk/vEi84WXR5+l3hfK2ak+nzFT5B53RJJiIAzC9zH53pPwA6rXT/tUqJr0c3ah5XcDmsVOcSVZ8tVYk/z4Hyhn6H+2/g/q90uI+1Uvqe21nkkmIVJNMykBR1ZxciExTsQmSCgl2ITFCwC5EJCnYhMmHd3XgzawD4AYD68O//1t0/b2bTAL4F4DDW2j99wt3no2OVyoZms5a07QZPhFntpHd2l5b5bqUHNei64PXd9pR426US0tu0zSb3fby2Sm2DJk8yWXH+1OwKiu9NTqbndQb8eN3uJLUtzPFEnm6fF4Y7vD+9w3/uEt/5r5a5j0vL3DY1yXfB2TMdJeT0B0ECSpCc0u0EaSiBmrDSSytH5aBlVLeTXkcPro2N3Nk7AP65u9+FtfbM95nZBwA8COAJd78NwBPD34UQ1yjrBruv8eattTr85wA+AuDh4fjDAD66LR4KIbaEjfZnLw87uM4B+L67/xTAAXefBYDh//u3z00hxGbZULC7e+HudwO4AcA9ZnbnRk9gZg+Y2TEzO7ZKClcIIbafd7Qb7+4LAP43gPsAnDOzQwAw/H+OzDnq7kfc/cj4mDb/hdgp1o0+M9tnZnuGP48B+BcAfgngMQD3D//sfgDf3S4nhRCbZyOJMIcAPGxmZay9ODzi7v/NzH4M4BEz+xSA1wF8fL0DuQO9XroNTrudltcAYHmQlq+W20FLnYInkozv4vJEVAdtop6WQibq6bZQANBwLg/2JvZS29469z+SHAtPy2HtFpdx+uQ5AYCZvXxes8FlyoLIV02yhgAwe4FLaOVKUJ8u6Ml03Uxa6j00zeeU29z2o5eoCQVXFWEF/whbkGuuVOfhaUweDCTFdYPd3Z8B8L7E+EUAH1pvvhDi2kAfooXIBAW7EJmgYBciExTsQmSCgl2ITLAoS2bLT2Z2HsBrw19nAFwY2ck58uOtyI+38o/Nj5vcfV/KMNJgf8uJzY65+5EdObn8kB8Z+qG38UJkgoJdiEzYyWA/uoPnvhL58Vbkx1v5tfFjxz6zCyFGi97GC5EJOxLsZnafmb1gZi+Z2Y7VrjOzk2b2rJk9bWbHRnjeh8xszsyeu2Js2sy+b2Ynhv9P7ZAfXzCzN4Zr8rSZfXgEftxoZv/LzI6b2fNm9ufD8ZGuSeDHSNfEzBpm9v/M7OdDP/7tcHxz6+HuI/0HoAzgZQC3AKgB+DmA94zaj6EvJwHM7MB5fwfA+wE8d8XYfwDw4PDnBwH8+x3y4wsA/tWI1+MQgPcPf54E8CKA94x6TQI/RromWEtUbQ5/rgL4KYAPbHY9duLOfg+Al9z9FXfvAvgbrBWvzAZ3/wGAS28bHnkBT+LHyHH3WXd/avjzEoDjAK7HiNck8GOk+BpbXuR1J4L9egCnrvj9NHZgQYc4gO+Z2c/M7IEd8uFNrqUCnp82s2eGb/O3/ePElZjZYazVT9jRoqZv8wMY8ZpsR5HXnQj2VC2NnZIE7nX39wP4AwB/Zma/s0N+XEt8FcCtWOsRMAvgS6M6sZk1ATwK4DPuzntFj96Pka+Jb6LIK2Mngv00gBuv+P0GAGd2wA+4+5nh/3MAvoO1jxg7xYYKeG437n5ueKENAHwNI1oTM6tiLcC+4e7fHg6PfE1SfuzUmgzP/Y6LvDJ2ItifBHCbmd1sZjUAf4S14pUjxcwmzGzyzZ8B/D6A5+JZ28o1UcDzzYtpyMcwgjUxMwPwdQDH3f3LV5hGuibMj1GvybYVeR3VDuPbdhs/jLWdzpcB/Osd8uEWrCkBPwfw/Cj9APBNrL0d7GHtnc6nAOzFWhutE8P/p3fIj/8C4FkAzwwvrkMj8OO3sfZR7hkATw//fXjUaxL4MdI1AfBeAH8/PN9zAP7NcHxT66Fv0AmRCfoGnRCZoGAXIhMU7EJkgoJdiExQsAuRCQp2ITJBwS5EJijYhciE/w/aAJ+DhIlh4QAAAABJRU5ErkJggg==\n",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "idx = 102\n",
+ "pim = kornia.utils.tensor_to_image(patches_aliased[0,idx:idx+1])\n",
+ "plt.imshow(pim)\n",
+ "pimp = kornia.utils.tensor_to_image(patches_nice[0,idx:idx+1])\n",
+ "plt.figure()\n",
+ "plt.imshow(pimp)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "torch.Size([2000, 128])\n",
+ "tensor([0.0259, 0.0937, 0.0711, 0.0760, 0.0541, 0.0933, 0.0920, 0.0923, 0.0532,\n",
+ " 0.0998, 0.0765, 0.0861, 0.0138, 0.0767, 0.0763, 0.0361, 0.0362, 0.0761,\n",
+ " 0.0609, 0.0360, 0.0687, 0.1401, 0.0891, 0.0789, 0.1057, 0.1161, 0.0797,\n",
+ " 0.0981, 0.0452, 0.1023, 0.1132, 0.0401, 0.1203, 0.0622, 0.0648, 0.0495,\n",
+ " 0.0720, 0.1553, 0.0989, 0.0774, 0.1441, 0.0856, 0.0725, 0.0851, 0.0792,\n",
+ " 0.1107, 0.1529, 0.0408, 0.0508, 0.0437, 0.0525, 0.0406, 0.0354, 0.0691,\n",
+ " 0.1553, 0.0688, 0.0901, 0.0929, 0.1040, 0.0720, 0.0589, 0.1485, 0.0977,\n",
+ " 0.0646, 0.0559, 0.0594, 0.0703, 0.0607, 0.0336, 0.0190, 0.1071, 0.1018,\n",
+ " 0.0327, 0.0767, 0.1362, 0.0830, 0.0534, 0.0972, 0.0783, 0.0951, 0.0646,\n",
+ " 0.0775, 0.0975, 0.0566, 0.0629, 0.0690, 0.0983, 0.0526, 0.0328, 0.1032,\n",
+ " 0.1318, 0.1473, 0.0996, 0.0936, 0.0882, 0.1427, 0.0555, 0.0712, 0.0933,\n",
+ " 0.0651, 0.1370, 0.1381, 0.0860, 0.0705, 0.0289, 0.1553, 0.1553, 0.0894,\n",
+ " 0.1423, 0.1200, 0.0969, 0.1087, 0.0460, 0.0743, 0.0707, 0.1124, 0.0928,\n",
+ " 0.0863, 0.0878, 0.0874, 0.0342, 0.1384, 0.1050, 0.0583, 0.0526, 0.0234,\n",
+ " 0.0545, 0.0402], grad_fn=)\n"
+ ]
+ }
+ ],
+ "source": [
+ "#Now descriptor\n",
+ "descriptor = kornia.SIFTDescriptor(32)\n",
+ "descs = descriptor(kornia.rgb_to_grayscale(patches_nice[0]))\n",
+ "print (descs.shape)\n",
+ "print (descs[0])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.4"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/feature_detection/img/graffiti.png b/examples/feature_detection/img/graffiti.png
new file mode 100644
index 0000000000000000000000000000000000000000..70eb91f5aa6f35270889b83edc84c6a71de08846
--- /dev/null
+++ b/examples/feature_detection/img/graffiti.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:33d874bf68a119429df9ed41d65baab5dbc864f5a7c92b939ab37b8a6f04eaa5
+size 947738
diff --git a/examples/feature_detection/img/kpi_winter.png b/examples/feature_detection/img/kpi_winter.png
new file mode 100644
index 0000000000000000000000000000000000000000..98d9c30ecdf718c3a00932987710d8d07556db66
--- /dev/null
+++ b/examples/feature_detection/img/kpi_winter.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bd51d44e58fe701ac03c3034c28efb14bb91558650ce8aaff0587c18f3c3c37f
+size 882713
diff --git a/examples/feature_detection/img/prague.hesaffnet b/examples/feature_detection/img/prague.hesaffnet
new file mode 100644
index 0000000000000000000000000000000000000000..5c44861ad670db9c70b5f07b467ec807d1c3bc90
--- /dev/null
+++ b/examples/feature_detection/img/prague.hesaffnet
@@ -0,0 +1,2002 @@
+1.0
+2000
+444.8692932129 327.0889892578 0.0007153846 -0.0000694976 0.0010998606
+382.4920043945 327.5836486816 0.0036619792 0.0000010596 0.0037941730
+427.6987609863 320.5351867676 0.0053326427 -0.0003054842 0.0143989604
+664.3941650391 345.4721069336 0.0080392826 0.0004128371 0.0095577212
+703.5554809570 330.3696899414 0.0060414295 0.0003746517 0.0123482598
+155.5833282471 285.7206420898 0.0072235172 0.0007098792 0.0111516770
+776.4520263672 286.4526367188 0.0057005053 0.0003364406 0.0134896999
+664.4790039062 341.5494995117 0.0081056235 -0.0000515848 0.0090715885
+473.4813232422 207.5876464844 0.0022928561 -0.0002687335 0.0139276385
+410.5299072266 371.5467529297 0.0081052557 0.0009486158 0.0087340167
+462.8622131348 291.2058410645 0.0010701956 -0.0000885655 0.0018108903
+117.3714523315 300.6103820801 0.0045663719 0.0001818053 0.0066788816
+702.6027221680 340.3789672852 0.0048175389 0.0001423210 0.0068590241
+616.6304321289 248.5519714355 0.0033996045 0.0001269837 0.0086467238
+511.4263000488 296.5299377441 0.0034542214 -0.0005397230 0.0082307803
+753.5486450195 282.4790954590 0.0037305898 0.0001392685 0.0076681306
+459.4837036133 327.4099731445 0.0077920663 -0.0003057048 0.0087386873
+242.6882781982 288.4577026367 0.0062148473 -0.0001821121 0.0125287436
+608.6663208008 353.4785766602 0.0057142898 -0.0001592515 0.0128472131
+706.5087280273 334.5704650879 0.0043647974 0.0001827361 0.0064635361
+502.4399414062 308.4587707520 0.0049869227 -0.0004025053 0.0062631923
+464.5415649414 362.6756591797 0.0058778785 -0.0022148052 0.0131272003
+446.4068298340 270.5690002441 0.0043887300 0.0001644087 0.0074030221
+438.5980224609 317.4469909668 0.0061415099 -0.0009065100 0.0117282905
+739.1531982422 301.1546630859 0.0009652464 -0.0000752759 0.0018861184
+127.5833587646 297.5066223145 0.0022459964 0.0000696016 0.0057972809
+696.4704589844 343.3880615234 0.0044104513 -0.0001237479 0.0081247641
+603.3996582031 231.4927215576 0.0049188230 -0.0000854923 0.0063646967
+442.9518737793 355.0119018555 0.0009574841 -0.0001200076 0.0019654592
+712.3952026367 334.5632324219 0.0063121500 0.0002915864 0.0118780108
+674.8591308594 337.0731201172 0.0004470558 -0.0000890944 0.0015759029
+660.3783569336 297.5696105957 0.0054620537 -0.0001586720 0.0134538664
+359.3623046875 322.6533203125 0.0057800678 -0.0002865304 0.0135932732
+504.6194152832 303.5458374023 0.0078734402 -0.0013150861 0.0108436663
+696.8230590820 334.8385620117 0.0004816969 -0.0000477447 0.0017541710
+408.4821777344 368.4508361816 0.0071050483 0.0004106164 0.0101424996
+253.5424652100 332.5509338379 0.0091940388 -0.0018655299 0.0082345884
+428.6085510254 330.5695800781 0.0033879417 -0.0001869165 0.0089421971
+622.7824096680 291.3536987305 0.0017271654 0.0000860406 0.0026469210
+454.9644470215 333.0879821777 0.0011012842 -0.0001615760 0.0016412602
+341.4337768555 379.3998107910 0.0068316143 -0.0020164656 0.0124138705
+677.2836914062 337.7106323242 0.0002717813 -0.0000427712 0.0010340573
+642.4738159180 221.5948181152 0.0024913277 -0.0003931839 0.0048576831
+320.4759826660 335.5616760254 0.0030317651 -0.0004266340 0.0042012054
+333.4438476562 289.2738342285 0.0061217882 -0.0016175817 0.0122530619
+442.6458435059 315.3321533203 0.0075117033 -0.0013308404 0.0105181569
+133.6101226807 296.5566406250 0.0064466898 -0.0000171519 0.0109486105
+573.8294067383 357.6184997559 0.0001311432 -0.0000070217 0.0003572843
+321.0911254883 251.1060028076 0.0010467779 -0.0000024832 0.0018179348
+307.5196838379 240.4499969482 0.0043675667 0.0001188374 0.0064120428
+65.6996231079 232.7638397217 0.0062239007 -0.0020062500 0.0133577352
+383.0115356445 322.9885864258 0.0020557425 -0.0000329039 0.0022522220
+334.9569396973 258.9391479492 0.0009947431 -0.0000819200 0.0019670553
+304.5826110840 257.4148559570 0.0036828634 -0.0002423943 0.0083966162
+377.5227050781 256.5892944336 0.0029618081 0.0002727038 0.0040001408
+461.5642089844 298.5322265625 0.0043838285 -0.0004563403 0.0069662412
+664.5181274414 337.5548400879 0.0076878206 0.0005026616 0.0100482777
+455.5781250000 297.3913879395 0.0048969365 -0.0003287640 0.0063133701
+134.5177612305 291.4938354492 0.0026491531 -0.0001094835 0.0046753758
+464.8716430664 283.0892944336 0.0008313367 -0.0001304508 0.0022997130
+545.5786743164 241.3467559814 0.0038325905 -0.0004546252 0.0078064995
+379.1951904297 300.6425781250 0.0013405922 -0.0001779071 0.0033790248
+289.5443115234 250.4231872559 0.0061326479 -0.0007397652 0.0129022272
+434.8229980469 348.9935913086 0.0009682337 -0.0002275607 0.0020593677
+430.9333190918 332.8317565918 0.0006366213 -0.0000806841 0.0011537502
+394.6194458008 333.5664062500 0.0035890222 0.0002690526 0.0082408739
+440.4236450195 285.5902709961 0.0045077801 -0.0005153338 0.0064248163
+438.9513854980 341.1596069336 0.0006757312 -0.0001158981 0.0012734395
+491.3551330566 235.5738067627 0.0067695193 -0.0003756872 0.0122146830
+363.3182067871 322.2538452148 0.0050548944 -0.0006094612 0.0151757281
+451.5636596680 290.4597473145 0.0069599613 0.0002014737 0.0098078027
+664.7090454102 293.4194030762 0.0017011594 -0.0001056616 0.0032306616
+748.5167846680 353.5566711426 0.0048290896 -0.0021395248 0.0154402489
+280.5837707520 337.3312988281 0.0050645415 0.0001400521 0.0135430759
+669.4501342773 346.5885314941 0.0028727560 0.0004019259 0.0040960005
+712.3934936523 302.6387939453 0.0050990828 -0.0011301858 0.0143636214
+135.0890808105 297.2137756348 0.0014206431 -0.0001461231 0.0032724261
+132.9497070312 289.0272827148 0.0010151347 -0.0001293745 0.0019497802
+303.3922119141 243.5554656982 0.0044648545 -0.0002281538 0.0066340677
+238.5008392334 299.3945617676 0.0047217663 -0.0002527388 0.0066674775
+415.4387817383 371.4974975586 0.0067695826 0.0012703463 0.0113298884
+706.6962280273 330.4194641113 0.0041574221 0.0000727590 0.0073144310
+660.4101562500 292.5905151367 0.0055612386 -0.0007163273 0.0127508482
+698.5524902344 338.5062561035 0.0043057152 0.0001980409 0.0073961313
+557.5354003906 346.5970764160 0.0036167006 -0.0007716407 0.0092945201
+612.4523925781 250.5772399902 0.0035391522 -0.0003037066 0.0088190166
+275.3966369629 270.3016967773 0.0057619568 -0.0007603273 0.0133753140
+426.8524780273 343.0272216797 0.0013000075 -0.0004237310 0.0038240403
+346.4567565918 298.4663696289 0.0031146694 -0.0008806156 0.0104532698
+330.9628601074 370.7790222168 0.0008643706 -0.0004558881 0.0023516829
+313.3058166504 336.3556823730 0.0068138535 -0.0013219113 0.0107574407
+352.3939514160 256.4110717773 0.0039328216 0.0000901256 0.0078959521
+712.9495849609 295.2115173340 0.0004574226 -0.0001198194 0.0018499696
+645.1967773438 271.0725402832 0.0010384714 -0.0000701551 0.0043537430
+388.5085144043 331.3029785156 0.0045898389 0.0003054208 0.0071979109
+256.4668579102 251.5234222412 0.0071318252 0.0009611521 0.0114444466
+578.5710449219 357.2190551758 0.0000885777 -0.0000020186 0.0002061014
+667.3221435547 295.4865417480 0.0064576077 -0.0005934249 0.0124072302
+664.4149169922 349.3393249512 0.0079568690 0.0002842981 0.0105763050
+143.2713317871 236.4599761963 0.0075599910 -0.0007190061 0.0104540614
+673.5913696289 346.6045227051 0.0056026485 0.0003910821 0.0062650065
+705.4086914062 343.7396545410 0.0071143992 0.0001196554 0.0098246215
+670.7086181641 348.9093627930 0.0008305195 -0.0000020537 0.0021054249
+708.4081420898 341.6354675293 0.0076561873 0.0009050188 0.0102067776
+459.2768249512 345.5883483887 0.0060645365 0.0004560786 0.0129151484
+135.5731506348 232.3048553467 0.0054223919 -0.0002558635 0.0131311230
+706.7540893555 338.3451538086 0.0072945380 0.0004191269 0.0098818596
+430.1595153809 333.5578613281 0.0003959359 -0.0000254376 0.0007840596
+287.5360107422 257.4226074219 0.0022393009 -0.0001426847 0.0058018952
+289.4175109863 255.7263031006 0.0067671686 -0.0001417362 0.0115669137
+294.5103454590 328.5306396484 0.0025751682 0.0000571583 0.0047941944
+661.4050292969 278.3025512695 0.0040351348 -0.0015783500 0.0188665688
+273.6372985840 293.3662719727 0.0047280784 -0.0020108393 0.0164398998
+384.7817077637 313.2109680176 0.0011673698 -0.0000005841 0.0017123325
+411.1138916016 305.0615234375 0.0009528450 -0.0001781126 0.0020506610
+369.5343627930 372.3979797363 0.0051101828 0.0007349373 0.0061421716
+718.3900146484 296.4743041992 0.0026108834 -0.0004081732 0.0044598537
+390.4522399902 395.5628662109 0.0031596178 0.0001658445 0.0036621836
+617.5847167969 270.4740600586 0.0068405815 -0.0009464133 0.0116996821
+462.4953613281 224.4841461182 0.0070819515 0.0008769016 0.0112325167
+625.3570556641 249.4343261719 0.0032038125 -0.0000718440 0.0103376042
+452.9417419434 279.1361999512 0.0005961643 -0.0000772949 0.0013791128
+632.5596313477 289.4926757812 0.0023585688 -0.0003583966 0.0051938542
+144.4324645996 285.4078979492 0.0045816991 -0.0003433535 0.0064366306
+276.5072326660 275.5437927246 0.0024348164 -0.0000400009 0.0055023497
+440.6152648926 320.3719482422 0.0067025172 -0.0008129567 0.0127986837
+652.4076538086 222.2564392090 0.0045984709 0.0002130383 0.0162200853
+251.5353851318 252.4714050293 0.0072447322 0.0004798038 0.0100681009
+534.7379760742 324.9753417969 0.0013454524 0.0001658257 0.0036117714
+611.4503784180 350.4254150391 0.0053328578 -0.0000906235 0.0130430171
+610.4499511719 356.6272277832 0.0034355170 -0.0002417479 0.0091432817
+694.5792236328 234.4026336670 0.0069175120 -0.0006873697 0.0119595416
+664.7997436523 332.9796752930 0.0004994749 -0.0001156239 0.0016247118
+695.1588745117 292.6893005371 0.0010043969 -0.0001810003 0.0045516291
+445.5578002930 286.7207641602 0.0079617565 -0.0006284681 0.0095809707
+770.5795288086 300.3918762207 0.0084075704 -0.0006440505 0.0098834224
+442.4828186035 296.4230041504 0.0053447224 -0.0000819541 0.0054808301
+432.6988830566 328.7627563477 0.0062532527 0.0004920475 0.0147026991
+427.3465576172 290.6411743164 0.0068966267 -0.0003980460 0.0113165239
+452.3374633789 312.3935852051 0.0058327029 -0.0001890326 0.0057603111
+405.4893493652 370.4143676758 0.0079212273 0.0009296224 0.0094953477
+367.0161437988 370.7612915039 0.0011161097 0.0000283152 0.0018006227
+390.8959960938 396.5923156738 0.0019746167 0.0001205113 0.0024083073
+293.6367797852 355.5296325684 0.0066423719 -0.0013127452 0.0112646595
+434.6357421875 333.4082641602 0.0054694819 -0.0008580956 0.0137446262
+327.4526672363 312.4911193848 0.0033102985 -0.0000762953 0.0036483798
+669.1304321289 190.9224853516 0.0006013846 0.0000229903 0.0012688193
+534.4963989258 256.5454101562 0.0029311692 -0.0002694500 0.0042317822
+621.5523681641 249.4113464355 0.0063779461 -0.0002436959 0.0111307949
+473.5609436035 371.4112243652 0.0046107396 -0.0007999542 0.0061191982
+605.3830566406 358.4644775391 0.0051940689 0.0002346673 0.0140290856
+313.4690856934 253.5264282227 0.0025304523 -0.0000106085 0.0047433190
+343.4442138672 295.4743957520 0.0034596180 -0.0011319605 0.0089790542
+772.4187622070 295.4400939941 0.0065392526 -0.0007262767 0.0107263243
+603.3687133789 295.7013854980 0.0092709567 0.0005696705 0.0085460758
+692.6687622070 343.5474853516 0.0066366051 -0.0003377531 0.0114456201
+467.5126953125 366.4679565430 0.0043053823 -0.0011588488 0.0075112730
+334.9345703125 251.0756988525 0.0009600852 -0.0000199709 0.0020106025
+669.3854370117 279.4606628418 0.0049602278 -0.0005057144 0.0171046797
+355.0011901855 343.1011962891 0.0008701530 0.0000967897 0.0021588800
+314.5950012207 367.4552612305 0.0027597542 -0.0012392839 0.0121911205
+435.5597839355 360.5913391113 0.0024182859 0.0001022225 0.0048523988
+718.3823852539 301.3782348633 0.0067225625 -0.0008580155 0.0119425133
+74.4457778931 224.5659790039 0.0020668779 -0.0003515085 0.0062646684
+703.2502441406 294.7668762207 0.0011699810 -0.0004078280 0.0043248967
+449.0037536621 289.1864624023 0.0011068159 -0.0001419588 0.0017652997
+730.3819580078 221.3996124268 0.0054108077 -0.0000772043 0.0144376419
+327.2389221191 268.3863830566 0.0071006189 -0.0005603841 0.0106446994
+592.4726562500 263.4497070312 0.0044717249 -0.0000102204 0.0066010472
+469.3744506836 208.6158599854 0.0037118481 0.0002017527 0.0186232403
+464.6090393066 337.5426940918 0.0045442763 0.0004924040 0.0067716716
+233.5203399658 301.4357910156 0.0039576357 0.0000201232 0.0073597347
+662.5372314453 334.1184082031 0.0003008605 -0.0000261850 0.0010459380
+300.5891418457 241.3093414307 0.0064874021 -0.0000622310 0.0111999866
+457.5089111328 361.3741455078 0.0038011326 -0.0018808497 0.0085177300
+455.0021972656 349.2538757324 0.0010686815 -0.0001695295 0.0017320103
+234.4985198975 312.6106262207 0.0040893308 0.0001242256 0.0071092481
+308.8776245117 249.3773803711 0.0018035820 -0.0000870507 0.0029297520
+262.4884948730 278.5822448730 0.0077223713 0.0005454355 0.0110148741
+731.5870971680 299.4390258789 0.0091188168 -0.0005539502 0.0094586406
+472.6299743652 294.6437988281 0.0063226810 -0.0025474280 0.0119414022
+428.3794555664 326.4660644531 0.0037183075 -0.0001519384 0.0097187459
+770.6154174805 291.5374450684 0.0059136902 -0.0009824757 0.0131698493
+313.5553588867 252.5419311523 0.0058817668 -0.0007738343 0.0120373126
+707.4505615234 298.5651550293 0.0059775654 -0.0012888110 0.0121077299
+130.1828002930 285.5926513672 0.0003496682 -0.0000760687 0.0008958819
+439.5189819336 268.6954345703 0.0072277240 0.0004498501 0.0099997316
+94.4590072632 256.5635986328 0.0027741285 -0.0003256994 0.0045870487
+314.5132446289 245.5100402832 0.0024718137 -0.0001732685 0.0047145034
+758.6229858398 284.4881591797 0.0036915038 -0.0001998622 0.0083700540
+324.3376159668 374.5491027832 0.0032586907 -0.0010317785 0.0102277603
+330.3139038086 369.9171752930 0.0003170577 -0.0001429578 0.0009525818
+760.4063110352 265.5341491699 0.0069959220 0.0002365723 0.0115749212
+271.6554260254 275.7092590332 0.0071786894 -0.0001810709 0.0104486188
+358.5742492676 366.4125061035 0.0064236773 0.0004205762 0.0137105733
+313.0075988770 254.9685974121 0.0017459388 -0.0000947230 0.0028018388
+125.3988876343 293.4401855469 0.0040110988 -0.0002011953 0.0076806238
+632.9085693359 290.6227111816 0.0014955960 0.0000131331 0.0033301690
+670.5653686523 292.4461669922 0.0021884546 -0.0002467288 0.0054705129
+460.4458923340 313.6037292480 0.0094730845 -0.0000935311 0.0093481699
+633.4097290039 271.4661254883 0.0020725578 -0.0001845291 0.0054492829
+327.3661804199 313.0478210449 0.0021626898 -0.0001124421 0.0022197054
+100.6402511597 238.6165466309 0.0049307765 -0.0003559436 0.0148612298
+271.4353942871 272.4638366699 0.0063411021 -0.0002017455 0.0120295463
+374.4224243164 273.4894409180 0.0085457666 -0.0000053988 0.0089735305
+539.7636108398 452.3516235352 0.0090332730 -0.0003520583 0.0094221532
+71.6202163696 254.4669189453 0.0071503632 0.0000135894 0.0123200091
+218.3108978271 310.3749084473 0.0003461874 -0.0000124025 0.0008211501
+327.4154663086 307.3539733887 0.0081979884 0.0000951692 0.0089978240
+441.5758056641 272.4407348633 0.0070644324 0.0002138191 0.0108792149
+597.0946655273 352.9992065430 0.0006274799 -0.0000392002 0.0030596154
+108.4775772095 238.4286041260 0.0018658035 -0.0000627396 0.0064720986
+436.7476806641 361.3848876953 0.0015673892 -0.0000966440 0.0029245641
+435.4860229492 285.2532958984 0.0073384875 -0.0004911348 0.0108230999
+397.3096008301 343.5146179199 0.0016987846 0.0000189599 0.0029684952
+323.3985900879 267.4346923828 0.0045354599 0.0000363738 0.0070851198
+345.4939880371 290.4953002930 0.0060839579 -0.0004833100 0.0118133621
+383.5259704590 332.5838928223 0.0051210029 0.0003441370 0.0056752274
+329.4709777832 291.4281005859 0.0055692410 -0.0016941803 0.0148440963
+123.6324996948 221.3419189453 0.0041581597 0.0010289832 0.0182148069
+324.7705688477 260.9242858887 0.0011188076 -0.0000771145 0.0018989979
+673.4364013672 279.3272399902 0.0059793042 0.0001142753 0.0133863026
+142.5117950439 290.5248718262 0.0029446171 -0.0000691093 0.0040179440
+670.6779785156 299.5256958008 0.0037701775 -0.0005683005 0.0074015805
+467.4990234375 332.4554443359 0.0047559100 0.0000893929 0.0061198440
+645.4763183594 249.5472869873 0.0020500331 -0.0004087830 0.0058106990
+433.5354003906 335.4606628418 0.0021529852 -0.0005989088 0.0055246754
+305.4183044434 349.4165039062 0.0022689071 -0.0001129593 0.0127429692
+387.5448913574 325.4415893555 0.0079576140 -0.0002189989 0.0096397074
+283.3782043457 299.4550170898 0.0046781115 -0.0017518296 0.0167097636
+700.3347167969 282.6742553711 0.0054601822 0.0007580793 0.0133774634
+64.6243133545 214.4948425293 0.0075944876 0.0000583741 0.0095037185
+633.2678222656 272.5883178711 0.0011802396 -0.0001883095 0.0042009717
+402.3859558105 338.5915527344 0.0054879845 0.0004449701 0.0137586938
+604.5005493164 292.4709472656 0.0101002287 0.0007355800 0.0095546264
+243.5689392090 261.4945373535 0.0076080216 0.0000517066 0.0091231642
+640.7153930664 342.6324462891 0.0062785940 0.0000112619 0.0116443345
+659.0034790039 347.0089111328 0.0005031740 -0.0001377547 0.0015290448
+437.4149780273 291.6181945801 0.0080448017 -0.0003442380 0.0097472686
+414.5532226562 288.6657409668 0.0070365202 -0.0005177854 0.0101873511
+154.3534851074 282.5578918457 0.0086169504 0.0002004217 0.0106867952
+341.5113830566 257.5340270996 0.0034709864 -0.0002836207 0.0094455527
+773.3587036133 286.4563598633 0.0055157305 0.0000389287 0.0143700847
+650.5984497070 269.4157104492 0.0031354588 -0.0003415695 0.0090678530
+317.3785095215 331.5411071777 0.0094611375 -0.0012688630 0.0082141925
+377.6471557617 215.3956298828 0.0051845368 0.0013982716 0.0145885032
+300.4546203613 252.4654388428 0.0028446573 0.0000195122 0.0045090509
+89.6040420532 254.4795837402 0.0069610877 -0.0007148490 0.0103791915
+684.4975585938 324.7033691406 0.0040593171 0.0017162457 0.0213109814
+636.7485961914 249.4916992188 0.0073645944 -0.0009337967 0.0107506700
+705.0579833984 343.0070495605 0.0004220503 -0.0001029469 0.0017271074
+499.1913452148 299.0939025879 0.0008660678 0.0000455988 0.0022064224
+531.4564819336 319.4501342773 0.0059214495 -0.0001377856 0.0128989872
+428.4827270508 316.5053710938 0.0023056851 -0.0001210237 0.0055638435
+452.5480651855 273.5963134766 0.0027774379 0.0000695186 0.0049339356
+91.5172500610 219.5521392822 0.0017051331 -0.0002522425 0.0074110557
+401.8340454102 318.6404418945 0.0002270200 -0.0000208519 0.0004854479
+373.5166320801 317.2586669922 0.0063606775 0.0001970028 0.0120907193
+732.5144653320 356.5272521973 0.0020674884 -0.0006478394 0.0059804176
+391.3054199219 335.6526794434 0.0038569185 0.0002994107 0.0078560682
+586.5721435547 251.2943725586 0.0065898914 -0.0005836522 0.0106388144
+639.4522705078 271.4465942383 0.0021646465 -0.0000895440 0.0063259508
+327.4486083984 318.5466918945 0.0035656504 -0.0001040088 0.0037039276
+381.4785461426 352.3742065430 0.0035115338 0.0009233993 0.0265341140
+766.5923461914 291.5223693848 0.0042365300 -0.0003969730 0.0076874029
+409.3096313477 343.0047302246 0.0009642782 0.0000586043 0.0019578468
+214.4098510742 214.3475189209 0.0056528221 -0.0006810365 0.0139275137
+90.5050582886 224.4763336182 0.0017635950 -0.0001975508 0.0079276245
+227.2481689453 298.4468078613 0.0015224054 -0.0001067769 0.0033477587
+657.3452758789 278.5713806152 0.0042775939 -0.0010477103 0.0178681742
+613.4815063477 269.5753479004 0.0075680115 -0.0007334567 0.0107235163
+706.4761352539 301.7171936035 0.0050449418 -0.0017882265 0.0156110944
+314.9372863770 245.2224273682 0.0017846894 -0.0001029853 0.0028927459
+679.5067749023 310.5979309082 0.0017353424 0.0000038790 0.0069573005
+553.4897460938 344.3818664551 0.0031899186 -0.0004712715 0.0098683406
+517.5219116211 296.5984497070 0.0026354047 -0.0008114785 0.0117409509
+333.2362365723 344.9125061035 0.0010137892 -0.0000568132 0.0018991983
+450.5566711426 269.2731628418 0.0056191538 -0.0008697134 0.0138942022
+392.8718261719 309.1956176758 0.0010376013 -0.0000962906 0.0018693662
+286.4545288086 332.6064453125 0.0046348544 0.0011678471 0.0155529799
+273.3480224609 337.4929809570 0.0049329069 0.0002364394 0.0140272984
+207.2706909180 298.3646545410 0.0012658215 -0.0002921241 0.0041879434
+732.9965209961 359.1075134277 0.0008698517 -0.0002630476 0.0024172016
+657.4899291992 349.1681823730 0.0002973955 -0.0000338762 0.0010457968
+523.5033569336 263.5109558105 0.0027240345 -0.0000098789 0.0041324482
+100.5170440674 212.4749603271 0.0030267953 0.0000789791 0.0105270846
+664.4319458008 284.5014343262 0.0030448684 -0.0002302620 0.0099769719
+586.4299316406 293.5330505371 0.0025207575 -0.0000828950 0.0050775334
+121.7294921875 301.4051208496 0.0003803452 -0.0001130798 0.0008855044
+350.1900024414 338.1571655273 0.0001366553 -0.0000300134 0.0003566153
+692.4712524414 338.4327392578 0.0036783530 0.0001544571 0.0079408288
+497.4237365723 309.4220275879 0.0076200240 -0.0005131621 0.0099896137
+614.6284179688 245.3769226074 0.0063688806 -0.0004000170 0.0122371595
+454.5531616211 315.5159912109 0.0083722025 -0.0009701983 0.0095128901
+408.4642333984 376.7102661133 0.0083941976 0.0010138499 0.0084252926
+66.4875640869 255.5029296875 0.0076263375 0.0003785064 0.0110207740
+99.0508575439 262.9345397949 0.0004999669 -0.0001744019 0.0014726633
+658.2841186523 263.4157714844 0.0054964395 -0.0006847583 0.0133099500
+615.2905883789 262.6447753906 0.0066877403 -0.0007484934 0.0123556210
+164.4736480713 274.3830871582 0.0065303780 0.0005704333 0.0113090146
+408.4893798828 348.6488037109 0.0036910570 0.0001100457 0.0078668920
+444.6757202148 356.6406250000 0.0062373080 -0.0021554306 0.0128865996
+507.5743103027 300.3703002930 0.0047303601 -0.0006827817 0.0069783428
+358.1059875488 305.7606811523 0.0001360296 -0.0000328600 0.0003464839
+321.4295043945 313.5472106934 0.0029246458 -0.0000283857 0.0041667433
+393.0815734863 301.2460632324 0.0008338608 -0.0000807759 0.0021979320
+554.6859741211 263.5252380371 0.0053612301 -0.0010514340 0.0153724104
+330.7219543457 348.5096740723 0.0041860682 -0.0009489546 0.0189870410
+357.0036621094 299.1343994141 0.0005197251 -0.0000551579 0.0013845576
+661.4155883789 337.2352294922 0.0060808333 -0.0004520302 0.0147456340
+681.0895385742 311.4393005371 0.0011623200 0.0000459221 0.0045226081
+373.5155639648 303.6150817871 0.0024930020 -0.0002715656 0.0049688113
+292.5291748047 251.6752624512 0.0063607725 -0.0006020239 0.0124770952
+673.4154663086 342.5733947754 0.0086717177 0.0011214972 0.0092375679
+357.1281433105 341.5914306641 0.0003530306 -0.0000497421 0.0008105545
+219.0414123535 237.1907806396 0.0007716051 0.0001819100 0.0025636791
+749.4978027344 357.7337951660 0.0059005143 -0.0020987680 0.0150690991
+424.4891967773 319.4011230469 0.0054017538 -0.0004355712 0.0144948792
+232.9354553223 302.9545288086 0.0014746147 0.0000118637 0.0029684517
+425.3374633789 323.4959106445 0.0057797013 -0.0002265571 0.0128231663
+169.0414581299 260.9740905762 0.0006394073 -0.0000418836 0.0012381027
+761.2192382812 239.4504852295 0.0083436109 -0.0001097598 0.0093033956
+591.4907226562 250.3582305908 0.0057830610 -0.0004938320 0.0126382736
+366.2819213867 366.1710815430 0.0002155746 -0.0000145327 0.0006027239
+278.3994140625 298.4640502930 0.0045504752 -0.0019080085 0.0161921903
+299.6312866211 326.4695129395 0.0046536140 -0.0002753396 0.0069635594
+745.4560546875 339.4566650391 0.0019996262 -0.0005319777 0.0064271875
+304.4429626465 363.4058227539 0.0028540294 -0.0014265811 0.0116263060
+397.3870239258 360.6620788574 0.0048794677 0.0001308526 0.0160327386
+343.3443908691 295.2912902832 0.0015184438 -0.0003848442 0.0032305466
+392.6533508301 368.3575134277 0.0070926216 0.0007177339 0.0118351690
+523.1589965820 263.3210754395 0.0018234355 0.0001700999 0.0028858427
+559.4785156250 288.5281372070 0.0017574374 -0.0004176336 0.0073169800
+118.5627822876 250.5958862305 0.0039608930 0.0018409815 0.0206170455
+486.4819641113 254.4698944092 0.0017314963 -0.0000201794 0.0067518172
+243.5825653076 285.1701354980 0.0059883501 -0.0004492133 0.0125613278
+419.4212341309 288.5380859375 0.0022167284 -0.0002549142 0.0056137955
+281.5391540527 315.6687011719 0.0047300057 0.0005995950 0.0163390469
+436.2305603027 230.4687500000 0.0045515248 0.0007816952 0.0182114914
+420.5101623535 216.4409942627 0.0046186168 0.0001924370 0.0065616667
+528.4402465820 240.5155639648 0.0073256334 -0.0019592177 0.0120103741
+179.5059509277 262.4218750000 0.0056564482 -0.0000562501 0.0054676831
+530.7171630859 244.7267456055 0.0085120182 -0.0020464370 0.0103906663
+572.6370239258 359.6348876953 0.0051370724 -0.0002836489 0.0145397717
+472.4520568848 204.2969207764 0.0032533738 0.0003190374 0.0218515825
+436.7317199707 330.4384155273 0.0053070053 -0.0009521982 0.0150996037
+142.5096740723 296.5748596191 0.0027762558 -0.0001127395 0.0041834833
+739.3082275391 336.9861145020 0.0011487354 -0.0000482480 0.0037963076
+341.5062866211 365.4221496582 0.0030044625 -0.0000086662 0.0099669173
+660.4653930664 344.5783691406 0.0056174430 -0.0000875951 0.0136088859
+426.4271240234 294.5632629395 0.0076650991 0.0005422322 0.0110482862
+560.5774536133 263.6376342773 0.0052948678 0.0000720971 0.0136781204
+376.4914245605 334.6250000000 0.0082826708 0.0003356456 0.0097063053
+563.4825439453 354.5762023926 0.0070020673 -0.0014701588 0.0104117077
+215.4791870117 297.4990844727 0.0018682271 -0.0001424087 0.0064436696
+304.5362243652 262.4898376465 0.0037296775 -0.0002167182 0.0077146534
+295.4607849121 337.4465637207 0.0060323253 -0.0009157531 0.0121982060
+464.5538940430 322.5463562012 0.0052838055 -0.0003352945 0.0055098915
+368.6211547852 350.5239562988 0.0033431707 0.0004392157 0.0208397433
+320.6193847656 313.4511108398 0.0020891025 0.0000928851 0.0026480411
+96.5053176880 238.6066589355 0.0048287841 -0.0000217995 0.0148192681
+290.4084167480 276.4652099609 0.0050775856 0.0001110466 0.0134365782
+686.8050537109 336.9353332520 0.0008180466 0.0000584650 0.0024819339
+633.4785766602 188.5647125244 0.0029107749 -0.0000981557 0.0042889705
+193.1187896729 259.0675964355 0.0005734224 -0.0000105429 0.0013652068
+561.7144165039 341.7216796875 0.0002072220 -0.0000292952 0.0006121043
+657.4426879883 290.4253540039 0.0024589892 -0.0002316616 0.0051621804
+693.1817016602 285.3353576660 0.0011729707 -0.0001126863 0.0041435985
+82.5217437744 224.5550537109 0.0018141810 -0.0003329351 0.0069756499
+413.7628479004 342.6874084473 0.0003809712 -0.0000394269 0.0007478919
+157.5338745117 315.3584899902 0.0071899332 -0.0001292059 0.0108439513
+380.9565124512 373.1789855957 0.0006819190 -0.0000160018 0.0011820068
+296.5423278809 247.4758300781 0.0027743280 -0.0004563374 0.0050288313
+576.4906005859 360.3432312012 0.0044855052 -0.0004477977 0.0182228535
+539.4465942383 254.4487762451 0.0064711906 -0.0020322711 0.0115049863
+406.9594726562 349.2319946289 0.0014288040 0.0002249157 0.0032885382
+337.0585632324 314.9266052246 0.0012160406 -0.0000462616 0.0016562364
+373.5877685547 361.8158569336 0.0057392707 0.0008231269 0.0128524778
+451.1556701660 342.4659423828 0.0010494362 -0.0001476335 0.0018743786
+376.5479125977 329.4833068848 0.0030578715 0.0002167873 0.0042552482
+101.5926513672 264.6953125000 0.0003398244 -0.0001388871 0.0009447394
+551.5535888672 347.6866149902 0.0062407972 -0.0013285073 0.0113116680
+722.5028686523 294.4191894531 0.0040311259 -0.0004171931 0.0072189528
+70.3776702881 257.4373474121 0.0068617542 -0.0000268801 0.0120138153
+254.4810485840 248.5181274414 0.0042547435 0.0002919153 0.0075169443
+614.5352172852 354.5419921875 0.0022673362 -0.0001165913 0.0058194157
+251.3498077393 329.4680480957 0.0085569294 -0.0008912492 0.0090461299
+341.1434936523 372.5913696289 0.0014672625 -0.0003981126 0.0038068886
+176.7225341797 295.5606689453 0.0063106804 0.0007328963 0.0122535778
+390.6523132324 335.1010437012 0.0018272372 0.0000973739 0.0024568182
+289.5221862793 347.4117126465 0.0063565243 -0.0007211791 0.0130369039
+150.5527648926 246.4317779541 0.0071805911 -0.0001876202 0.0120762819
+172.4186248779 303.7852478027 0.0043022577 0.0002135830 0.0067628385
+278.4878540039 310.3202819824 0.0046925247 -0.0008053511 0.0168637987
+700.5040893555 324.7089233398 0.0044818837 0.0004596579 0.0186654236
+183.5453033447 229.6542358398 0.0026904945 -0.0003441812 0.0117194140
+722.5540161133 222.6487731934 0.0071383263 -0.0000747901 0.0133299623
+377.8804931641 325.9368896484 0.0001345136 -0.0000286358 0.0003486672
+96.4962844849 221.5215454102 0.0027622343 -0.0003583423 0.0104206661
+462.6362915039 275.3941345215 0.0038847050 -0.0003439602 0.0086232200
+616.3883056641 290.4821472168 0.0048272610 0.0002880464 0.0061563272
+700.4157104492 344.3679199219 0.0072696777 -0.0000558201 0.0105424263
+615.2084350586 291.1644287109 0.0011817998 0.0000722239 0.0017135076
+521.3909301758 211.3545074463 0.0067299306 0.0001832225 0.0106934765
+563.5891113281 358.5010375977 0.0047480790 -0.0006272717 0.0063064210
+545.6760253906 306.4840393066 0.0002472205 -0.0000002845 0.0013070727
+210.8011169434 226.9598236084 0.0006513512 0.0001195656 0.0028937734
+483.5786743164 308.5041809082 0.0027161899 -0.0005276739 0.0043127243
+456.6852416992 211.6293029785 0.0082898373 0.0000325726 0.0110152420
+732.4522094727 351.5273132324 0.0031848249 -0.0009203925 0.0095799360
+400.9520874023 338.6568603516 0.0009220477 -0.0000379415 0.0021561305
+656.3474121094 344.5643615723 0.0042835553 -0.0004072066 0.0185665097
+467.5064697266 234.4352416992 0.0029887995 0.0002951768 0.0094147921
+454.5460815430 233.4359283447 0.0030994699 0.0005739519 0.0100973686
+143.2729339600 297.2388000488 0.0017670380 -0.0001496361 0.0029504760
+632.8438720703 189.5193023682 0.0014648866 -0.0000429514 0.0034725694
+197.9969787598 260.9529113770 0.0003355622 0.0000128751 0.0009196232
+95.3804244995 226.4743499756 0.0049899649 -0.0009141561 0.0144082429
+404.7185974121 315.4590759277 0.0001076533 -0.0000023482 0.0001965203
+519.5012817383 321.5721130371 0.0074650999 -0.0003614298 0.0111936042
+744.6176757812 306.5964050293 0.0037322047 0.0001891713 0.0080771539
+139.6731719971 243.6863555908 0.0064014355 -0.0010964192 0.0111099752
+495.6073303223 208.4278869629 0.0019668862 -0.0006428685 0.0154117579
+200.7486267090 303.4720153809 0.0072824270 -0.0014508446 0.0103700934
+121.6103897095 210.6009063721 0.0033668126 0.0004772941 0.0089325756
+371.1755065918 378.9062805176 0.0010857296 -0.0000339165 0.0017114136
+675.3097534180 306.6051940918 0.0068466240 -0.0002060843 0.0113539994
+601.3702392578 358.5914001465 0.0049048322 -0.0006357256 0.0156770386
+638.5132446289 339.5939331055 0.0037085053 -0.0007347485 0.0080555435
+603.5133666992 285.3991394043 0.0066453735 -0.0001941166 0.0046806624
+688.5020141602 292.5370178223 0.0016819186 0.0000083301 0.0077090473
+553.5438842773 318.5338134766 0.0025925224 0.0007680858 0.0137395486
+667.4743652344 298.6622314453 0.0066978768 -0.0007616690 0.0118794804
+631.0206909180 282.9330139160 0.0009285945 0.0000782104 0.0019472220
+644.9450683594 329.0107116699 0.0004901092 -0.0000415823 0.0015617175
+54.6127967834 439.5672607422 0.0102793220 0.0004314199 0.0079643857
+367.4994812012 322.6570739746 0.0060646841 -0.0002242292 0.0130055593
+484.9836730957 308.9226684570 0.0016135389 -0.0003039232 0.0028504315
+358.3662414551 319.2150268555 0.0058601280 -0.0004095023 0.0142806228
+588.9234008789 353.0830383301 0.0008629065 -0.0002290597 0.0051099928
+28.5230674744 446.5194702148 0.0057938574 0.0007126385 0.0053448668
+493.4424438477 308.5202331543 0.0044020857 -0.0005083940 0.0067359027
+182.6717681885 267.2354736328 0.0006348783 -0.0000286505 0.0014165203
+682.8876342773 320.9292907715 0.0006686432 -0.0000086404 0.0026545257
+285.5113220215 251.7058715820 0.0029935592 -0.0008684912 0.0102086933
+411.4193115234 289.5570983887 0.0070536472 -0.0000298851 0.0111730285
+378.9548645020 292.9838562012 0.0013110245 -0.0001677834 0.0033984801
+189.1728057861 226.9823913574 0.0007597898 0.0001453595 0.0065236571
+371.5629272461 301.3141784668 0.0060993945 -0.0012171285 0.0125006828
+651.4978027344 302.6883239746 0.0050618374 -0.0004079660 0.0179416221
+574.9796142578 272.5694274902 0.0013233899 -0.0003362466 0.0035067271
+333.4709167480 320.5215759277 0.0049083061 -0.0003250838 0.0064249490
+595.6653442383 250.4879150391 0.0060623749 -0.0001467999 0.0142996060
+322.5575866699 341.6190795898 0.0041827373 -0.0009209816 0.0074543809
+419.8555908203 307.5426025391 0.0059275860 0.0006885554 0.0150343878
+113.3816223145 303.4388732910 0.0073640822 0.0000527633 0.0099642947
+425.0772094727 256.6410217285 0.0008123733 0.0000075250 0.0023398169
+186.6217498779 227.3023529053 0.0022973290 -0.0003857316 0.0138296830
+326.9677429199 349.2150268555 0.0009437508 -0.0000821084 0.0019373482
+310.5621643066 364.4859924316 0.0015646352 -0.0011690658 0.0083057713
+139.0274505615 279.0165710449 0.0009511726 -0.0000455747 0.0018641525
+421.3525695801 336.6090393066 0.0054898160 0.0011052913 0.0158381276
+654.9711303711 272.8804016113 0.0005239133 -0.0000135467 0.0015531451
+389.2971801758 276.3891601562 0.0061262976 0.0001808277 0.0118105207
+637.0760498047 338.8912963867 0.0004612984 -0.0001007883 0.0016553092
+518.4381103516 278.2016296387 0.0051450138 -0.0001057992 0.0160164274
+529.4283447266 262.4339294434 0.0030633251 0.0000431188 0.0041758702
+749.5059814453 264.4292907715 0.0044657774 -0.0000959997 0.0167854782
+455.1864624023 344.4167175293 0.0056731259 -0.0006317873 0.0129389558
+254.4586181641 315.3705444336 0.0055148019 0.0003824923 0.0123921437
+386.4753417969 237.4463500977 0.0018603591 -0.0001366543 0.0070100841
+624.6096191406 359.6965026855 0.0063589327 -0.0025949762 0.0130703188
+192.5080413818 227.5384521484 0.0021887496 -0.0003809978 0.0130948247
+666.5909423828 308.7958984375 0.0040439526 -0.0005428679 0.0183635578
+302.5742797852 311.4399719238 0.0058582700 -0.0004922905 0.0126089863
+382.5770263672 345.5584716797 0.0036017906 0.0000699658 0.0187611878
+439.3774414062 232.4941711426 0.0047744638 0.0002316821 0.0151903806
+442.4996032715 310.4836425781 0.0079863407 -0.0002689688 0.0105055999
+160.6215820312 267.8142089844 0.0064436696 0.0011658225 0.0124854315
+324.5901489258 370.5525207520 0.0018212531 -0.0005797753 0.0067119990
+465.5251159668 323.1813659668 0.0021370968 -0.0000914061 0.0024249814
+726.5216064453 221.6474456787 0.0056492910 -0.0000155404 0.0138985729
+672.4286499023 309.4704895020 0.0034176679 -0.0001827220 0.0096909422
+443.5594177246 267.3691101074 0.0066426201 0.0005403279 0.0110808015
+398.1290283203 337.3620300293 0.0004219346 -0.0000360721 0.0007479784
+529.2166748047 260.8707580566 0.0017857228 0.0001469902 0.0028321077
+421.0594787598 289.2070922852 0.0009963877 -0.0000614451 0.0018113112
+503.0207519531 201.0956726074 0.0005395794 -0.0001156098 0.0036062878
+148.5273590088 297.4862976074 0.0027304834 -0.0003690132 0.0044609816
+340.4047546387 341.5729675293 0.0074574770 0.0005009159 0.0102758091
+200.8447113037 226.9134979248 0.0005677140 0.0002101536 0.0038039119
+400.4385986328 271.4408874512 0.0039715944 -0.0003031956 0.0076329964
+280.5543212891 256.5141296387 0.0042797267 -0.0013052775 0.0174707174
+346.8125000000 263.0869140625 0.0009271734 -0.0000401120 0.0020867346
+603.5459594727 235.4459838867 0.0074858265 -0.0006521527 0.0097398348
+582.5214843750 257.4322204590 0.0074575129 -0.0005243769 0.0099655967
+303.4678039551 342.4729309082 0.0055981940 -0.0008979202 0.0130412141
+579.4165649414 253.6397399902 0.0070789284 -0.0005831978 0.0104064848
+101.1069641113 275.1382141113 0.0005420043 -0.0002189369 0.0015135714
+428.9205627441 367.5414733887 0.0018008196 0.0002724108 0.0027499085
+734.5283203125 272.4683227539 0.0031475038 -0.0003896870 0.0107421754
+498.6402893066 293.0026855469 0.0001074252 0.0000110439 0.0001650812
+313.5667419434 348.6114501953 0.0024915596 -0.0003098330 0.0126359565
+176.5687866211 301.6048889160 0.0042102942 0.0005291781 0.0075995885
+655.4721679688 219.5777282715 0.0046504964 0.0001439599 0.0154208690
+673.4915161133 313.4971313477 0.0017612982 -0.0001043349 0.0074939001
+373.1990661621 304.9779357910 0.0012714640 -0.0000455110 0.0035942008
+337.4945678711 288.2979431152 0.0069415974 -0.0014051682 0.0119398525
+467.6149291992 260.2873229980 0.0022852852 0.0004361671 0.0134563874
+732.4699707031 225.4347229004 0.0031879744 0.0000874503 0.0096385172
+564.4960327148 286.5135498047 0.0065010493 -0.0009013169 0.0120456498
+747.0791625977 305.0544433594 0.0015062531 -0.0000859724 0.0035112042
+752.5173950195 277.6315307617 0.0021795155 -0.0001889012 0.0052357577
+555.3423461914 308.3528137207 0.0053877188 0.0012075310 0.0136016961
+712.5768432617 338.5292968750 0.0041632759 0.0004872417 0.0083016669
+327.5146179199 305.0584411621 0.0020337969 -0.0001403317 0.0024653180
+419.5770263672 303.3280944824 0.0070196004 0.0004755981 0.0101793287
+453.0226135254 320.8676147461 0.0011717376 -0.0001111575 0.0016237036
+639.4492797852 225.5822143555 0.0027418302 -0.0005243835 0.0048812334
+163.4316558838 303.2379455566 0.0062817642 -0.0012869796 0.0133029697
+215.2500457764 297.4389648438 0.0011443208 -0.0002088771 0.0043361164
+691.0801391602 324.7564392090 0.0010562134 0.0002109205 0.0047286889
+301.4703369141 276.4436035156 0.0035957247 -0.0002230797 0.0077501452
+112.3497009277 281.5078735352 0.0089867450 0.0004071861 0.0083993878
+396.5192871094 244.4148101807 0.0024952304 -0.0003564300 0.0128697241
+620.8932495117 299.5020751953 0.0016864974 0.0000169129 0.0027941440
+384.3995666504 277.5158386230 0.0038109743 0.0001474556 0.0077200579
+433.5035400391 355.4778747559 0.0040864446 0.0001652787 0.0075271446
+556.3964843750 259.5183105469 0.0054965136 -0.0012351333 0.0146767097
+725.5201416016 352.7011413574 0.0051907701 -0.0000874265 0.0140567636
+256.5550537109 255.4783477783 0.0067611798 0.0003184782 0.0112483446
+488.9238281250 308.9154052734 0.0006274402 -0.0000213963 0.0011464328
+572.0548095703 386.9876098633 0.0000806000 -0.0000021828 0.0002155575
+763.6614990234 349.4445190430 0.0041152216 -0.0007805661 0.0075153117
+187.4254608154 288.6770019531 0.0047924086 -0.0001945228 0.0165340789
+544.5457763672 309.5333557129 0.0015591687 0.0005065050 0.0076947468
+692.4891967773 311.5526123047 0.0031720097 0.0006127852 0.0240856968
+374.1378479004 293.2599487305 0.0003483901 -0.0000187366 0.0007958552
+500.5825195312 208.5837249756 0.0022715346 -0.0007660436 0.0132021960
+377.4822387695 251.4832763672 0.0029304547 0.0001656346 0.0041590277
+129.5935363770 221.4472656250 0.0046538939 0.0017353067 0.0170026086
+675.5100708008 182.4898376465 0.0023484016 0.0000996907 0.0050654756
+425.4711608887 231.4677886963 0.0020593170 -0.0000368956 0.0060713673
+174.8710784912 271.0537109375 0.0010044880 -0.0000045901 0.0019572289
+417.4702148438 321.5848999023 0.0003521223 -0.0000282561 0.0008117201
+689.5322875977 221.3140106201 0.0068217637 -0.0004313519 0.0111757955
+365.3486633301 350.7311706543 0.0034707505 0.0007914766 0.0219540484
+377.0095520020 363.1063232422 0.0007040805 0.0000273462 0.0010988769
+598.4290161133 283.5220642090 0.0096680988 -0.0007981036 0.0078307819
+512.5124511719 292.1404724121 0.0031981014 -0.0001943631 0.0095167570
+185.6385040283 233.3674163818 0.0052711857 -0.0008475104 0.0152959451
+310.9983215332 364.7623596191 0.0012262693 -0.0007964183 0.0044433721
+412.4869384766 313.4488525391 0.0035076693 -0.0002779902 0.0089603243
+495.5897216797 319.4529724121 0.0074895495 -0.0002585540 0.0113599459
+438.4231567383 322.5578002930 0.0055964221 -0.0003001647 0.0128477328
+382.6721191406 253.5180511475 0.0057457089 -0.0002170691 0.0130040171
+361.5334777832 377.6579895020 0.0074449908 0.0004611826 0.0098906066
+390.3308410645 400.6335754395 0.0079961680 -0.0019234091 0.0097868433
+125.4989776611 236.6247253418 0.0020953787 -0.0000766822 0.0065823635
+353.2875061035 236.3846130371 0.0063027977 -0.0012902888 0.0148740169
+679.0063476562 199.2917633057 0.0009377177 0.0000035562 0.0019786421
+642.8654785156 344.8570556641 0.0012460996 -0.0003245161 0.0037760604
+549.1604003906 289.1820068359 0.0008492777 -0.0002110617 0.0058623035
+401.5884399414 369.3796386719 0.0075072288 0.0003509760 0.0098591512
+349.7922058105 365.5372009277 0.0001957849 -0.0000419097 0.0005899268
+264.2215576172 341.6392211914 0.0072438912 -0.0003917323 0.0111553920
+478.8550720215 254.7011718750 0.0009878949 -0.0000679734 0.0052685724
+401.0692749023 297.1669006348 0.0007821268 -0.0000723156 0.0024408197
+507.4996032715 293.3630065918 0.0039902753 -0.0007441132 0.0078568785
+329.0131225586 277.0574035645 0.0009711539 -0.0001245074 0.0021327664
+290.5013122559 261.4910888672 0.0019916843 -0.0000859705 0.0060352287
+110.9335403442 292.8357238770 0.0005595278 -0.0001920050 0.0014221657
+197.5740203857 227.5362548828 0.0023924054 -0.0001635622 0.0131882001
+760.6169433594 280.3453063965 0.0036745914 -0.0001193095 0.0082860291
+467.5030822754 313.4727172852 0.0084981890 -0.0005874401 0.0084242504
+721.5595092773 239.4862213135 0.0048042345 -0.0003171525 0.0063858079
+383.3862915039 292.6158142090 0.0049944283 -0.0011093267 0.0161877740
+629.6492309570 270.5035095215 0.0052958108 0.0005629032 0.0131716747
+414.4106750488 385.5216979980 0.0034039514 0.0003993275 0.0038915053
+613.4545898438 407.3718566895 0.0073357229 0.0000661067 0.0098192757
+322.4027099609 318.6363220215 0.0052480702 -0.0000733645 0.0061417357
+192.8258209229 236.8147277832 0.0008903392 0.0000744806 0.0050057126
+730.9028930664 334.7220458984 0.0008120011 -0.0000921758 0.0025139477
+493.4912109375 309.6184692383 0.0004435274 0.0000149060 0.0007340823
+245.0734558105 283.1651306152 0.0014937803 -0.0002173789 0.0034811615
+654.5399169922 224.5684661865 0.0050004469 -0.0005824333 0.0149679566
+722.4776000977 244.5634613037 0.0028515081 -0.0000585310 0.0040872777
+179.0710754395 257.0413818359 0.0005873002 -0.0000755430 0.0013571882
+534.9273071289 240.9766845703 0.0009485379 -0.0000961605 0.0020235393
+167.4664611816 318.5200500488 0.0027342329 -0.0001107465 0.0041419896
+677.6195678711 346.2609252930 0.0071887369 0.0005492279 0.0108381948
+721.3503417969 266.6359863281 0.0052221101 -0.0002356994 0.0140109519
+252.4424591064 258.5790710449 0.0021876520 -0.0002938007 0.0054722494
+197.5319061279 303.5351257324 0.0079562021 -0.0012109745 0.0096005555
+374.7856140137 324.3689270020 0.0019964175 0.0000884243 0.0024796813
+105.5545959473 213.4982910156 0.0055356929 -0.0002286902 0.0131080225
+212.5452270508 429.7239990234 0.0069076521 -0.0007367387 0.0107171293
+520.7886962891 217.5528259277 0.0045765531 -0.0001690993 0.0071115051
+654.4769897461 304.5429687500 0.0022253720 -0.0002064223 0.0058898996
+301.5553588867 267.5736083984 0.0060494747 -0.0000426690 0.0135708824
+450.2890625000 377.7450561523 0.0002360785 0.0000249497 0.0005295733
+533.4738769531 224.4794158936 0.0063549597 -0.0000736261 0.0121980645
+343.5310668945 254.2707519531 0.0035683289 -0.0004113244 0.0085575730
+120.8720703125 212.3408966064 0.0012127332 0.0000679532 0.0041301604
+221.4962310791 226.4163970947 0.0023346841 0.0002763535 0.0050258469
+376.5745849609 243.3721008301 0.0049599512 -0.0007652731 0.0158507507
+722.4573974609 302.4744567871 0.0027199772 -0.0002609925 0.0045126891
+344.9688720703 345.0198364258 0.0009491422 0.0000091719 0.0021266732
+102.4776077271 277.8919677734 0.0003299514 -0.0001290176 0.0009782239
+562.5108032227 440.2716674805 0.0045907907 0.0009101158 0.0067270682
+579.4660644531 354.4619140625 0.0017083960 0.0002304119 0.0074097291
+339.5545043945 242.4293670654 0.0035079340 -0.0003686605 0.0084497286
+614.4812011719 333.5143127441 0.0030764218 0.0014094870 0.0248294845
+660.2712402344 282.5073852539 0.0044543850 -0.0007951831 0.0164960399
+382.6735534668 259.7484436035 0.0068247770 0.0001255314 0.0106000314
+342.7495727539 304.8782043457 0.0015368833 -0.0003256495 0.0032656796
+638.6656494141 292.5104370117 0.0059757521 -0.0016194794 0.0141660059
+746.9172363281 268.7774963379 0.0013591342 -0.0002583296 0.0038283833
+174.5335083008 260.3724975586 0.0084163044 0.0008384665 0.0093540465
+497.5289001465 248.5085906982 0.0028520047 -0.0004068694 0.0099494914
+290.4127197266 357.5180664062 0.0066860830 -0.0012914953 0.0119057484
+481.4681396484 248.4473876953 0.0021580439 -0.0007310720 0.0138808331
+429.1809692383 195.3202514648 0.0017393262 -0.0000394633 0.0027692150
+547.4366455078 256.3620300293 0.0050348085 -0.0019521137 0.0160853546
+163.5291748047 306.4752502441 0.0072029121 -0.0007560528 0.0115564410
+624.9898071289 271.0207519531 0.0007687869 -0.0001333690 0.0025680580
+149.4671630859 298.8249206543 0.0017042089 -0.0002421209 0.0028707618
+674.4736938477 301.5103149414 0.0074544675 -0.0011168616 0.0113333212
+737.5523681641 262.5150146484 0.0038179019 -0.0007867978 0.0182561446
+280.5877990723 343.3328857422 0.0052419296 -0.0002295629 0.0143922092
+307.4376525879 235.5225830078 0.0063519189 0.0004612039 0.0108623616
+267.5498352051 292.4265747070 0.0040761167 -0.0015539462 0.0180478264
+265.5390014648 223.4920806885 0.0019203274 -0.0003717246 0.0058803894
+753.7145996094 239.3621520996 0.0070842123 -0.0008205776 0.0114458138
+519.5280761719 254.4208984375 0.0042666150 0.0002743375 0.0070696902
+263.4743652344 314.5462646484 0.0041594212 0.0006466942 0.0197562706
+377.3772888184 337.6678771973 0.0060597626 0.0008670505 0.0119872959
+293.7040405273 276.7253417969 0.0065956241 -0.0005405514 0.0131829614
+244.4034271240 232.4943084717 0.0026732697 0.0002173166 0.0046380749
+379.4700927734 326.8336791992 0.0000959423 -0.0000203420 0.0002275153
+339.5530700684 251.5435638428 0.0050536268 -0.0006223897 0.0151599422
+323.5534362793 255.3597564697 0.0058509032 0.0006528524 0.0132940030
+477.5783691406 207.4942932129 0.0027868589 -0.0001491022 0.0299971271
+635.5568237305 323.4663085938 0.0028762468 -0.0018680425 0.0121105649
+282.5915832520 310.5162963867 0.0053160228 -0.0006945212 0.0147175742
+42.5133857727 213.5376434326 0.0068330015 0.0004982321 0.0108115906
+264.6466064453 308.5908508301 0.0040937355 0.0008925773 0.0179187488
+510.9544677734 291.0348510742 0.0007529778 0.0000977382 0.0024337403
+34.4357376099 441.6211242676 0.0058788271 0.0010105246 0.0054032635
+483.4128417969 317.4155273438 0.0084597878 -0.0009093657 0.0086639579
+723.0072631836 245.3483886719 0.0015628786 0.0000341255 0.0029880432
+327.5735168457 379.5503234863 0.0027044027 -0.0013868501 0.0055550695
+496.5055541992 297.5554504395 0.0077036293 -0.0012102569 0.0105130011
+697.2354736328 325.5739440918 0.0039614108 0.0012908784 0.0200328883
+572.6111450195 306.5001525879 0.0062822886 0.0007547301 0.0129129402
+640.4986572266 214.4726104736 0.0024547558 -0.0005162219 0.0049396646
+707.5097045898 279.3880004883 0.0072817686 0.0013722474 0.0116132339
+327.0413818359 331.0902709961 0.0011575497 -0.0000643470 0.0015391035
+191.0703735352 271.0228576660 0.0006360348 -0.0000446473 0.0013235850
+458.5817871094 233.5642242432 0.0062443791 0.0000217721 0.0123576215
+151.4743804932 253.5447387695 0.0088209072 -0.0003611457 0.0095688282
+169.3902130127 230.3626708984 0.0029644119 -0.0006665748 0.0106378524
+548.5273437500 318.4118041992 0.0039196517 0.0008842907 0.0189970341
+240.6660614014 302.4662170410 0.0069553219 -0.0005070607 0.0108279111
+377.4625549316 317.4260864258 0.0067674420 0.0001538618 0.0118234735
+614.8873901367 282.7841796875 0.0007142447 0.0000084496 0.0012877525
+502.4379882812 276.2675476074 0.0051361327 0.0001794047 0.0149309346
+302.5017700195 281.4310607910 0.0019818211 -0.0002555185 0.0065348791
+237.3036651611 284.8256530762 0.0014013883 -0.0001895823 0.0032964488
+586.5865478516 413.4313659668 0.0060690739 0.0000107552 0.0138836941
+290.7659301758 263.1038513184 0.0013976984 -0.0000653916 0.0034150388
+435.2991027832 255.0010223389 0.0011820317 0.0000156704 0.0039871591
+416.2280883789 210.7178039551 0.0108957542 0.0004587938 0.0084331483
+423.3237609863 290.5529174805 0.0071147080 0.0001092001 0.0121620940
+486.5243530273 213.3209686279 0.0029220737 -0.0015825061 0.0283835698
+753.5300292969 353.5220031738 0.0034138283 -0.0013516020 0.0103772059
+768.5747070312 228.5567626953 0.0075004073 -0.0008783133 0.0111785717
+374.6631164551 374.4190063477 0.0056858715 0.0010209349 0.0063838423
+527.5027465820 324.4812927246 0.0021958596 0.0000926385 0.0052671800
+688.4216308594 311.3147277832 0.0031094707 0.0001577887 0.0226940680
+458.6142883301 316.7681274414 0.0095898667 -0.0006717064 0.0085344091
+111.1735076904 262.9590148926 0.0005773621 -0.0001440872 0.0014626691
+572.4018554688 364.5285644531 0.0038686395 -0.0000499377 0.0082025975
+140.2899932861 248.4582519531 0.0071170614 -0.0002742518 0.0118826404
+462.4652404785 359.3104858398 0.0053902641 -0.0014618194 0.0147617273
+334.8827209473 305.3164367676 0.0018486471 -0.0002448873 0.0026644496
+218.5806274414 218.5454559326 0.0033145407 -0.0003747785 0.0098364167
+719.0838012695 350.9212036133 0.0004962079 -0.0001489318 0.0015289438
+592.4423217773 254.5967864990 0.0041197049 0.0002945586 0.0073539400
+550.6963500977 255.4851989746 0.0046787518 -0.0018363293 0.0170457009
+424.9058837891 264.6856994629 0.0008456359 0.0000228731 0.0023950965
+71.5246582031 231.3293609619 0.0059354012 -0.0024217106 0.0165058002
+209.5239562988 302.7459716797 0.0058647706 -0.0004945233 0.0131576043
+298.3469543457 323.1770019531 0.0069066538 0.0005372498 0.0111018382
+675.0902709961 182.8237304688 0.0015065239 -0.0000186349 0.0031068302
+174.4768066406 267.3319702148 0.0068891346 0.0004391210 0.0116852028
+259.5202636719 259.4409484863 0.0027736684 -0.0002342110 0.0104208933
+119.4960861206 220.5792694092 0.0043113511 0.0007927676 0.0172685143
+513.5537719727 199.5371856689 0.0029208842 -0.0006055498 0.0097663673
+373.7822265625 369.4247131348 0.0051138811 0.0006959436 0.0066627604
+637.7264404297 339.0234069824 0.0003129982 -0.0000284693 0.0009847565
+752.7387695312 266.2522888184 0.0052270461 0.0002086920 0.0140919527
+531.7385864258 241.6431732178 0.0073896139 -0.0019111889 0.0107928114
+278.5610351562 265.7669982910 0.0057162237 -0.0006243989 0.0141364140
+718.7262573242 222.5885162354 0.0068663466 -0.0000652905 0.0120253628
+698.5935058594 346.6078491211 0.0065278988 -0.0000586678 0.0115980394
+641.0944213867 227.0749053955 0.0013681143 -0.0002179560 0.0035690612
+681.3928833008 265.5075683594 0.0035139746 -0.0003131366 0.0083409566
+335.2037353516 294.5285644531 0.0080563985 -0.0009654292 0.0098538324
+657.1093139648 198.9371490479 0.0006368464 0.0000198241 0.0012320913
+368.5024108887 215.3240051270 0.0055645658 0.0009283185 0.0143107753
+733.5103149414 336.4435729980 0.0036757374 -0.0002349127 0.0079089478
+138.3858337402 278.0063781738 0.0003486834 -0.0000478632 0.0009015879
+549.5003662109 219.2833709717 0.0064029265 0.0006799080 0.0135786179
+76.5700988770 262.5242309570 0.0073565627 0.0003774387 0.0094546527
+719.0960693359 288.8145751953 0.0009046527 -0.0001288540 0.0019920112
+142.6163024902 273.4184265137 0.0048609842 0.0002161700 0.0063120299
+231.1426086426 292.6308593750 0.0014776154 -0.0000746675 0.0032628160
+587.5491943359 255.5246429443 0.0045613628 -0.0001603727 0.0072093648
+126.2636337280 261.0195617676 0.0003476421 -0.0000846870 0.0009311388
+569.4545288086 435.5023803711 0.0045934776 0.0010193909 0.0066100769
+382.8583679199 345.0925903320 0.0011638833 0.0000755651 0.0015954562
+757.5666503906 239.5045166016 0.0074907159 -0.0002258786 0.0098350532
+388.5924072266 306.3243103027 0.0055270903 -0.0003827771 0.0131733287
+511.5717773438 209.5960235596 0.0038036099 -0.0004886733 0.0189786926
+661.3187255859 333.5317382812 0.0056139836 -0.0004857202 0.0167459585
+444.7293395996 213.7932434082 0.0000565219 -0.0000066713 0.0003267923
+554.4353027344 284.5469055176 0.0029966775 -0.0010454404 0.0108490139
+548.4371948242 321.4376831055 0.0040200748 0.0006023329 0.0191564169
+422.8843688965 302.9277648926 0.0006488754 -0.0000808780 0.0012828808
+589.1721191406 406.9449462891 0.0015384553 0.0000323463 0.0030543071
+667.4798583984 269.4791870117 0.0033994759 -0.0001582848 0.0085911974
+684.5779418945 311.5390625000 0.0036796234 -0.0003175157 0.0186127163
+300.5015563965 259.6226806641 0.0055993292 -0.0007115906 0.0131015042
+551.2827148438 251.4450683594 0.0050572944 -0.0017173160 0.0149325104
+404.5107727051 285.6107482910 0.0056016585 -0.0007282197 0.0132575147
+585.3281250000 266.5117187500 0.0056722309 -0.0000502553 0.0119558917
+278.5118713379 261.4869384766 0.0030591537 -0.0007701322 0.0105016436
+420.8296813965 199.1415863037 0.0009136854 0.0000079763 0.0020644078
+327.4379577637 341.5461120605 0.0042933868 -0.0005894547 0.0069220141
+417.2929382324 217.6705780029 0.0066135745 0.0005956650 0.0119196717
+211.3656005859 211.5401153564 0.0062556337 -0.0005638577 0.0121431798
+678.6412963867 271.5393371582 0.0079447953 0.0002639547 0.0113567617
+727.4364013672 225.6142730713 0.0038115322 -0.0001364143 0.0094867656
+590.4206542969 267.7321777344 0.0040145214 -0.0003050463 0.0075354055
+590.5400390625 200.3961334229 0.0018227893 0.0008361888 0.0075537027
+527.0747070312 324.9587097168 0.0014185259 0.0001048534 0.0033020789
+678.5287475586 294.4861145020 0.0020300569 -0.0000947582 0.0063407449
+560.4877929688 313.6025695801 0.0015977533 0.0008171682 0.0079738675
+221.2149658203 226.9160614014 0.0007266316 0.0000928453 0.0026208581
+502.9031372070 209.1817779541 0.0008924557 -0.0001102274 0.0053712991
+557.5413208008 267.5479431152 0.0068877125 -0.0002068367 0.0144847650
+412.5096740723 351.4678649902 0.0038172160 -0.0001114633 0.0080464268
+353.0378417969 306.4948425293 0.0012213577 -0.0002253675 0.0039040642
+418.4496459961 283.4675598145 0.0066983085 0.0001865387 0.0108322501
+435.6130676270 267.2877807617 0.0070478977 0.0001912385 0.0115426695
+526.5158691406 318.4645385742 0.0022124473 0.0001123483 0.0052347630
+672.5334472656 284.4435424805 0.0020103438 -0.0000580089 0.0062797596
+665.4667968750 320.4863586426 0.0013751748 -0.0001010641 0.0091652628
+327.5754394531 296.5127868652 0.0029107430 -0.0003823743 0.0042599593
+287.4071655273 276.5400695801 0.0047903969 0.0000449402 0.0164813101
+434.4862976074 272.5733032227 0.0044247238 0.0000666147 0.0065463949
+568.5136718750 249.5560760498 0.0046671783 -0.0005761032 0.0066152602
+146.5684356689 237.5988464355 0.0068627126 -0.0006464686 0.0103733260
+271.5666503906 265.4172363281 0.0045176232 -0.0012791450 0.0171743613
+70.8327102661 220.7333374023 0.0014151870 -0.0002800286 0.0032284975
+265.3090209961 224.3708038330 0.0013656566 -0.0002619666 0.0038873374
+476.7050170898 370.4023132324 0.0073645492 -0.0008791992 0.0098573305
+515.0000000000 201.0807647705 0.0006045552 -0.0000711979 0.0032205635
+266.6351318359 390.6970214844 0.0075375480 0.0008437923 0.0105299829
+492.7111206055 313.5140075684 0.0072589526 -0.0001610397 0.0106232474
+643.5148315430 281.4105529785 0.0037528854 -0.0006412785 0.0080635455
+645.4686279297 233.9333343506 0.0003275350 -0.0000381244 0.0008815213
+370.7301635742 381.7927246094 0.0003635936 -0.0000594350 0.0008326366
+110.0771408081 290.6278076172 0.0003350604 -0.0000756778 0.0008734328
+542.5545654297 252.3706054688 0.0064009754 -0.0023190328 0.0140911993
+267.4790649414 384.4675903320 0.0045580370 0.0003290166 0.0073237666
+735.5463867188 265.6107788086 0.0022745000 -0.0004581775 0.0058027711
+198.1106872559 313.4886779785 0.0002183845 -0.0000039448 0.0005742111
+760.5390625000 362.6106872559 0.0097027514 0.0003929954 0.0075518154
+408.5203247070 239.3181152344 0.0044976417 -0.0002080451 0.0162233040
+61.5260238647 234.4003448486 0.0042699161 -0.0012645624 0.0078775566
+635.5337524414 296.5227050781 0.0022291541 -0.0003285119 0.0051372563
+542.6890869141 221.4743652344 0.0074184239 0.0009661389 0.0133975614
+676.3820800781 269.2850036621 0.0061704922 0.0001462616 0.0116396481
+349.4049377441 252.3019561768 0.0044026407 -0.0006197287 0.0083358129
+650.2615356445 189.1107482910 0.0004024868 0.0000584795 0.0007886169
+679.7807617188 305.4080200195 0.0064397496 -0.0006596277 0.0125730820
+699.6582031250 223.5254821777 0.0052988101 0.0001261635 0.0064097848
+596.5339965820 346.3366088867 0.0036764529 -0.0007091747 0.0195786413
+353.6217041016 249.6104736328 0.0038206521 -0.0001634725 0.0074934452
+385.5108337402 257.2782897949 0.0064072674 0.0000017216 0.0110878972
+636.4562377930 217.5320892334 0.0047527556 -0.0007784683 0.0061172023
+255.6065368652 239.7835235596 0.0065177940 -0.0010266203 0.0111431871
+338.4953308105 294.3647155762 0.0080397809 -0.0013300746 0.0104700383
+116.7883911133 211.4617309570 0.0063659125 -0.0002201045 0.0124244299
+489.2398681641 309.4982299805 0.0066722040 -0.0004227543 0.0107522598
+719.3776855469 227.4327545166 0.0038061794 -0.0001913937 0.0075821537
+575.1129150391 280.7422180176 0.0008163851 -0.0000867039 0.0023814694
+663.3165893555 269.4183349609 0.0053286306 -0.0007423658 0.0158168562
+560.4790649414 342.1996459961 0.0042995568 0.0002287017 0.0196747836
+382.5142211914 213.5881195068 0.0051913881 0.0007033048 0.0145152779
+473.5364990234 261.4480895996 0.0014892075 0.0000809015 0.0084640682
+592.9812622070 211.0288696289 0.0007647075 0.0000061733 0.0025675683
+629.5241088867 264.4003906250 0.0029943427 0.0006479804 0.0113964630
+694.5809326172 224.4567718506 0.0075383061 -0.0009911302 0.0103297010
+417.1471557617 356.9880065918 0.0006673751 -0.0000102529 0.0011246657
+199.1270446777 218.9631042480 0.0006064042 0.0000850788 0.0037303572
+565.5529785156 290.7268676758 0.0009113961 0.0000153785 0.0048982189
+210.5720977783 317.5279235840 0.0092962570 -0.0008523394 0.0089276787
+198.8459014893 296.8854064941 0.0011468655 -0.0000912441 0.0040284288
+485.0743408203 262.9893798828 0.0007171585 0.0000566217 0.0027998819
+373.5122070312 386.4418334961 0.0033824565 0.0001051967 0.0038680846
+118.6115646362 206.3433990479 0.0063697877 0.0003099310 0.0137183936
+474.8770141602 202.6709289551 0.0008968998 -0.0001047960 0.0056691584
+416.5731811523 207.3979797363 0.0113793835 -0.0000672434 0.0066657374
+284.4507446289 261.5628356934 0.0037463072 -0.0003151101 0.0085318005
+714.2307128906 288.5402526855 0.0052955253 -0.0013880513 0.0138039859
+487.5484924316 405.4515686035 0.0026894985 -0.0001409967 0.0046804957
+331.0463256836 268.9444274902 0.0010501576 -0.0001219491 0.0020423969
+758.6064453125 224.5668029785 0.0024857812 0.0000979674 0.0050957575
+542.7868041992 288.7999877930 0.0008651932 -0.0000055490 0.0054650069
+777.6567993164 258.4619750977 0.0063473647 -0.0003753223 0.0124785872
+312.9670715332 342.8473815918 0.0016483810 -0.0002372872 0.0030912159
+295.5475463867 254.3898620605 0.0022709488 -0.0001127118 0.0050559891
+286.5797119141 298.4502258301 0.0043571740 -0.0008911762 0.0182503350
+678.4583740234 194.4257965088 0.0043506180 -0.0000433796 0.0070557571
+249.3564910889 231.0144958496 0.0015155762 -0.0001653520 0.0029512441
+686.4682006836 322.4265441895 0.0041621020 0.0014386046 0.0196538512
+559.6125488281 283.6031799316 0.0054528755 -0.0009036997 0.0134104360
+662.8871459961 182.6966705322 0.0008553756 0.0002057943 0.0022079577
+635.4382324219 212.4459991455 0.0086980145 -0.0002356272 0.0082008801
+160.4189300537 271.5953063965 0.0043189023 0.0002195917 0.0071132118
+304.6085510254 366.8724060059 0.0057422481 -0.0025977758 0.0146057019
+468.6702270508 359.5350341797 0.0058819768 -0.0003821873 0.0119736772
+148.4769592285 291.5274963379 0.0044593257 -0.0005217055 0.0067536868
+177.9477386475 317.6002197266 0.0002122546 -0.0000551716 0.0005709776
+229.4450225830 235.7632751465 0.0082571469 0.0001652491 0.0093657142
+254.6249084473 328.5891113281 0.0081353784 -0.0011783941 0.0098325461
+343.4190673828 286.3802795410 0.0065675438 -0.0002875524 0.0112402942
+361.6905517578 365.5814208984 0.0068483097 0.0006237502 0.0133510763
+251.5087890625 412.5368957520 0.0043495549 -0.0000186557 0.0068256524
+501.5674438477 256.4473571777 0.0046515823 -0.0003470958 0.0163586121
+456.4944152832 355.4687805176 0.0025305504 -0.0006846769 0.0049787699
+526.5283813477 318.7223205566 0.0018398497 0.0000609295 0.0030569746
+501.6327514648 197.3129425049 0.0051732361 -0.0001702059 0.0137703326
+739.5024414062 225.2933654785 0.0063329781 0.0006614391 0.0111402944
+475.4314575195 329.5772094727 0.0067211753 -0.0002349349 0.0112497518
+556.9946899414 307.0000915527 0.0008567896 0.0002413584 0.0053065442
+654.4803466797 263.6324768066 0.0051936465 -0.0004641689 0.0149773890
+721.5448608398 337.4203186035 0.0027992090 0.0004541409 0.0109340921
+541.5174560547 284.5508117676 0.0059748054 -0.0021380261 0.0133255050
+524.4765014648 279.5429992676 0.0026984080 -0.0001055900 0.0113830706
+587.0238647461 362.9602661133 0.0007887395 -0.0000798407 0.0025033765
+310.5410156250 369.5237731934 0.0054324763 -0.0020139553 0.0145315528
+472.6040954590 291.4580688477 0.0062980037 -0.0027675007 0.0136403171
+333.5998535156 385.7466125488 0.0001902438 -0.0000607342 0.0006277272
+177.0981292725 231.1546630859 0.0004779026 -0.0000057449 0.0015884872
+607.6608886719 232.5326385498 0.0066819694 -0.0006184460 0.0104553523
+459.4893493652 303.4685668945 0.0049610678 -0.0001155866 0.0057094097
+660.3779296875 275.4481201172 0.0046590902 -0.0015682485 0.0161991082
+667.4497070312 214.3986206055 0.0025755442 -0.0004734248 0.0124672493
+166.4354400635 267.6440429688 0.0062191295 0.0008822858 0.0129562169
+298.3684692383 332.5484008789 0.0068219304 -0.0000332115 0.0108670304
+327.5375976562 323.5944824219 0.0059866891 0.0000263245 0.0054788385
+554.4542236328 288.3974914551 0.0030118311 -0.0006680725 0.0096662026
+227.5565338135 225.5571289062 0.0040522586 0.0000955712 0.0068888292
+342.6703796387 344.6545104980 0.0051283669 0.0001785294 0.0141412709
+446.3988342285 232.5542602539 0.0031413687 0.0002320576 0.0097730039
+635.2438964844 297.5071411133 0.0015819247 -0.0000904518 0.0031342015
+395.8001098633 367.5290832520 0.0043856064 0.0001097172 0.0069699166
+237.3780212402 230.2893524170 0.0077880500 0.0004517743 0.0125791635
+309.5813293457 327.3959960938 0.0054074097 -0.0011505263 0.0061974311
+614.6320800781 257.5151977539 0.0020534061 -0.0002437904 0.0056700418
+496.8626403809 256.7023010254 0.0011759291 0.0001007697 0.0035999289
+476.1250000000 325.2248229980 0.0001108069 0.0000110817 0.0001525287
+690.4838256836 269.6496887207 0.0037486542 -0.0001450441 0.0088418759
+360.6928405762 299.5103149414 0.0040067909 -0.0025207088 0.0201325938
+260.5605163574 320.7702636719 0.0055324230 -0.0000656963 0.0122629246
+630.8844604492 324.8845825195 0.0007173831 -0.0002145690 0.0027986446
+468.7095031738 254.8456420898 0.0008442575 -0.0000107386 0.0060423897
+563.6200561523 256.3651733398 0.0063836654 -0.0004327536 0.0129158814
+617.5507812500 397.5191345215 0.0042008879 0.0004168038 0.0073702089
+521.3586425781 224.4846954346 0.0048259497 -0.0003663453 0.0064650732
+177.4093933105 363.6241455078 0.0051651266 0.0003116690 0.0062233564
+721.6602172852 259.5400390625 0.0067868279 0.0008272973 0.0107042585
+411.3955383301 248.7540588379 0.0049499944 0.0002177440 0.0179135408
+660.5142211914 322.4193420410 0.0029777770 -0.0009863885 0.0241914280
+740.5252685547 389.5370788574 0.0050443653 -0.0003934822 0.0061153378
+80.4263000488 235.6403808594 0.0058186175 -0.0003963513 0.0139524648
+561.4552001953 251.5697174072 0.0055360338 -0.0006039305 0.0130343502
+418.9926757812 309.3072204590 0.0014875825 -0.0001011978 0.0030722839
+524.4846191406 256.4979553223 0.0047314074 -0.0001624779 0.0065110992
+599.4082641602 351.5759887695 0.0028955771 -0.0007426349 0.0126422802
+426.5142517090 302.5765686035 0.0043427725 0.0001489144 0.0073275706
+721.5840454102 217.4697265625 0.0040497831 0.0000199051 0.0080350973
+393.3994445801 274.4106140137 0.0022763461 0.0000434861 0.0050359913
+651.6246948242 249.5254058838 0.0021525144 -0.0003507076 0.0054393737
+159.3961334229 284.3952331543 0.0069232108 0.0009570983 0.0123464093
+771.2921142578 278.7149658203 0.0062780203 -0.0000114710 0.0121493693
+681.6551513672 202.1291198730 0.0003737111 -0.0000505037 0.0008486898
+319.5006713867 373.5445251465 0.0046990323 -0.0006249932 0.0151953353
+174.5309753418 218.6225891113 0.0014967291 -0.0002030444 0.0080901487
+580.7220458984 416.8859558105 0.0014300771 0.0002481624 0.0032678335
+263.1065063477 308.9176635742 0.0011886781 -0.0001950773 0.0042198733
+527.1635742188 228.8746337891 0.0013655130 -0.0002129114 0.0031676292
+554.5496826172 351.4258422852 0.0043378877 -0.0006161729 0.0065131201
+544.8637695312 255.0056610107 0.0006120791 -0.0000314794 0.0012956555
+641.4797973633 335.3385925293 0.0047368668 -0.0021002698 0.0168889668
+596.7775268555 286.6020812988 0.0019084369 -0.0000931628 0.0023832561
+283.8243103027 343.4805603027 0.0058041387 -0.0010374766 0.0158172008
+415.1941223145 353.0134887695 0.0014368717 -0.0000135706 0.0032445791
+541.2527465820 240.4845275879 0.0059333607 -0.0013253862 0.0144442925
+78.5942230225 227.4772491455 0.0054806722 -0.0012784213 0.0175511930
+710.5274658203 224.4685058594 0.0067823222 -0.0001927384 0.0108448081
+182.4086456299 285.6961364746 0.0048082685 0.0003723968 0.0146932770
+416.3806762695 268.4779357910 0.0039797332 -0.0004326328 0.0083730910
+124.6141052246 224.4766387939 0.0039484506 0.0010830956 0.0194086470
+172.6710052490 314.6109619141 0.0080498988 -0.0002518886 0.0089872228
+439.5065917969 211.6479034424 0.0049939021 0.0008488623 0.0165525954
+620.5831909180 219.1618804932 0.0070512611 -0.0010616336 0.0109483125
+398.8563842773 375.0282592773 0.0007398346 -0.0000058146 0.0011001878
+62.4033508301 229.5788269043 0.0040697595 -0.0012359568 0.0090734567
+412.3750610352 334.6284790039 0.0064670099 0.0004356396 0.0122996662
+590.5573120117 216.4606933594 0.0053744991 0.0005181934 0.0130296359
+481.5940246582 295.5928649902 0.0051648985 -0.0012307799 0.0149214864
+715.0913085938 246.9212036133 0.0017210537 -0.0000003582 0.0027224757
+666.9792480469 272.9268493652 0.0005222318 -0.0000371715 0.0014414497
+473.5731506348 289.4763793945 0.0022703786 -0.0008663719 0.0066198241
+668.8995971680 260.9560546875 0.0008165006 -0.0001553397 0.0022440010
+428.5268859863 364.4920349121 0.0080230460 0.0012035710 0.0086592501
+362.8216552734 377.4124145508 0.0018162755 0.0000138158 0.0027316699
+677.4095458984 220.4452667236 0.0059276721 0.0000684471 0.0113308439
+721.1331176758 238.9399108887 0.0016356653 -0.0000641265 0.0028184040
+238.5207214355 416.5100402832 0.0068069408 -0.0011292938 0.0104038632
+643.0764160156 260.9223632812 0.0004196623 -0.0000711267 0.0018139230
+472.4454040527 212.4736175537 0.0018186648 -0.0002210663 0.0075453026
+599.4177856445 297.6616821289 0.0090148123 0.0005130814 0.0085970294
+251.5814819336 240.4974822998 0.0068801627 -0.0000266038 0.0122049060
+138.6698455811 225.4827117920 0.0021262413 -0.0002024486 0.0061543453
+653.0161132812 250.8001861572 0.0011280079 -0.0002244762 0.0041416865
+537.1682128906 231.0173187256 0.0008065891 -0.0001422978 0.0022492292
+378.5192565918 275.3964538574 0.0043258839 0.0002670485 0.0068856417
+410.7695007324 231.0736541748 0.0011109011 -0.0000218135 0.0047227438
+320.5283813477 274.5514831543 0.0021432315 -0.0002932814 0.0052834512
+494.7781677246 202.5474243164 0.0007400438 -0.0001190682 0.0067491713
+134.5779113770 227.4649047852 0.0032759926 -0.0001336372 0.0088532092
+527.0513305664 278.8719482422 0.0012425226 0.0001917143 0.0038821746
+43.3937606812 444.4463195801 0.0062588728 0.0008543556 0.0046160519
+238.4613952637 245.5711212158 0.0033914116 0.0001261591 0.0092497049
+350.6755065918 322.4254150391 0.0055055772 -0.0008552770 0.0140982913
+514.1806640625 290.6799011230 0.0003124606 0.0000026556 0.0009402102
+766.6163940430 297.5964965820 0.0030591136 0.0000467693 0.0045825313
+206.4735717773 303.2843933105 0.0021466482 -0.0006189136 0.0055903811
+123.1194839478 285.3353271484 0.0017482877 -0.0002082180 0.0028621848
+352.5026855469 239.6304168701 0.0061595757 -0.0008164080 0.0124042733
+445.7343444824 237.5390014648 0.0060096206 -0.0005914383 0.0143948011
+671.4654541016 320.4918212891 0.0014302870 0.0003374122 0.0082526375
+625.3597412109 212.5697021484 0.0082097342 0.0001926501 0.0103761032
+762.4660644531 290.5544128418 0.0044324473 -0.0003472138 0.0078425407
+415.4572143555 197.5522308350 0.0047392836 0.0006255002 0.0071554789
+559.4316406250 318.4492797852 0.0023605609 0.0010928256 0.0134796984
+248.8228149414 299.5159912109 0.0015048414 -0.0002470809 0.0032047345
+554.5472412109 312.3363952637 0.0014784648 0.0009972092 0.0084483204
+129.4859161377 258.5129089355 0.0042447452 -0.0001429467 0.0068497993
+657.3926391602 308.4288024902 0.0035063212 -0.0023416630 0.0259390511
+588.6098632812 297.6224365234 0.0078314217 0.0001233812 0.0094445851
+503.5046997070 317.4339294434 0.0029255487 -0.0002302036 0.0043723620
+448.5917053223 344.6982421875 0.0060051773 -0.0012477775 0.0120517798
+662.3272705078 212.6703338623 0.0040767426 -0.0000130473 0.0187192746
+106.9854583740 219.1110076904 0.0005805853 -0.0002386890 0.0030862410
+413.5354919434 341.5402832031 0.0051375632 -0.0003124168 0.0135956826
+589.6079711914 414.6901550293 0.0071258871 0.0001499028 0.0117693571
+731.5512084961 388.4218444824 0.0086092427 -0.0002057061 0.0091532739
+286.2961120605 341.3029174805 0.0059550521 -0.0009631884 0.0149047663
+548.9141845703 233.0371246338 0.0005085422 -0.0000556696 0.0014654691
+363.4401245117 345.6130676270 0.0021488755 0.0007362932 0.0131903021
+565.1392211914 281.0733337402 0.0006854291 -0.0001503732 0.0030767308
+296.7207336426 260.6074218750 0.0011366088 -0.0000036442 0.0019070584
+273.6287536621 413.4935913086 0.0075146812 -0.0007322694 0.0096322000
+684.9991455078 191.0186004639 0.0005284831 0.0000061929 0.0013672663
+88.3069763184 264.4736633301 0.0086863339 -0.0003235540 0.0085997758
+301.4618225098 262.6473083496 0.0057187737 -0.0001873320 0.0150065208
+270.5019226074 286.4792175293 0.0020288322 -0.0003836878 0.0059317108
+544.7216796875 244.7874755859 0.0063036019 -0.0011125568 0.0121291140
+475.2729797363 334.4599914551 0.0071833315 0.0006508166 0.0116911689
+394.4877929688 257.4414367676 0.0028983315 -0.0000592440 0.0116153285
+517.4717407227 218.5381927490 0.0040769037 -0.0002419562 0.0086770523
+274.2519531250 342.5836486816 0.0054266872 0.0001369289 0.0141911553
+341.1041564941 282.9933776855 0.0009119899 -0.0001407265 0.0019733878
+668.7748413086 269.2565002441 0.0012773080 -0.0000412676 0.0037094143
+414.7836303711 265.0602111816 0.0007890785 -0.0001088847 0.0026062492
+182.4380493164 235.4158935547 0.0053186440 -0.0008725597 0.0136440033
+140.4675292969 219.6203765869 0.0033281692 0.0005600880 0.0095018791
+328.9879150391 380.8839416504 0.0015761536 -0.0011347587 0.0036241794
+747.5691528320 223.5138244629 0.0064746425 0.0006826384 0.0111260237
+343.5734252930 262.3927612305 0.0071530715 -0.0012310504 0.0100634834
+508.5127868652 327.6244506836 0.0076579875 -0.0003369919 0.0102416510
+471.5765380859 321.0076599121 0.0021691772 -0.0000607208 0.0023737636
+558.6525268555 296.4949645996 0.0062022256 -0.0005116657 0.0119972480
+179.5117034912 232.4325256348 0.0026709209 -0.0002872858 0.0103748105
+485.6751098633 249.3739624023 0.0023957829 -0.0007016037 0.0126779331
+310.1502685547 262.1963195801 0.0002470413 -0.0000224592 0.0004919302
+629.2503662109 290.6200866699 0.0037960673 -0.0010842299 0.0194281805
+283.4227294922 329.3957519531 0.0017132594 0.0001498895 0.0073346049
+511.4831542969 253.5583953857 0.0026289488 0.0000772989 0.0048509184
+183.4590759277 292.4844360352 0.0068025491 0.0003402905 0.0126547860
+392.2956237793 289.6033325195 0.0064169182 -0.0008532257 0.0127882306
+321.0707092285 275.0970153809 0.0015100966 -0.0002742581 0.0035886301
+496.5650634766 229.3415374756 0.0078105638 -0.0003289687 0.0117327422
+412.8347473145 256.4716186523 0.0010459318 0.0000858780 0.0043049217
+261.1444091797 294.8270874023 0.0005885377 0.0000132168 0.0014764356
+541.3295288086 242.4240112305 0.0061620087 -0.0016996420 0.0130661372
+393.4444885254 274.7452087402 0.0014280676 -0.0000471879 0.0033378375
+203.5283050537 434.1865234375 0.0061562140 -0.0005663071 0.0121852374
+516.5344238281 259.5754394531 0.0027763604 0.0000217931 0.0046489812
+414.5417785645 200.5251312256 0.0029671849 0.0001377371 0.0036806420
+663.2476196289 360.6085510254 0.0015539018 0.0000731863 0.0028466389
+414.4498901367 343.4359130859 0.0033306505 -0.0001683206 0.0090192948
+257.5339965820 230.5191040039 0.0022202225 -0.0004714455 0.0050568567
+517.4993896484 245.4001770020 0.0052126977 -0.0000119353 0.0137026105
+602.4562988281 299.3149414062 0.0084666228 0.0002554087 0.0084068291
+162.4620971680 317.4166259766 0.0052927798 0.0000025526 0.0059896940
+313.1090698242 276.8055419922 0.0009905138 -0.0001051343 0.0020383939
+769.6113281250 207.4879302979 0.0063857017 0.0009761659 0.0123459427
+75.4310531616 253.4245910645 0.0069586765 -0.0000365157 0.0115557499
+422.3459777832 316.4841003418 0.0023830999 0.0000038288 0.0060661179
+204.4453430176 290.4812622070 0.0022097647 -0.0001619596 0.0055957208
+300.8396301270 273.0232849121 0.0008758033 0.0000121372 0.0020751376
+282.5234069824 305.2536315918 0.0032092428 -0.0007113512 0.0093042105
+407.5160522461 333.4055480957 0.0031799613 0.0000098841 0.0099779656
+737.0264282227 266.9187011719 0.0014176186 -0.0002737838 0.0034684003
+374.3067321777 349.6536254883 0.0002226026 -0.0000306401 0.0005554386
+195.6422729492 250.6597442627 0.0045926073 -0.0014834239 0.0165281650
+570.5847167969 281.5444030762 0.0071398560 -0.0006946145 0.0111033395
+651.6232910156 343.4397583008 0.0037829536 -0.0012239802 0.0247472525
+114.7462997437 306.9912109375 0.0016747029 -0.0002464516 0.0030161969
+252.4836120605 338.6139526367 0.0049214065 -0.0017002310 0.0070876637
+511.1477050781 408.8636779785 0.0010175485 -0.0003321470 0.0019028753
+105.5461196899 218.5509033203 0.0014729927 0.0000238774 0.0077500669
+525.4773559570 326.1773986816 0.0003307564 0.0000078627 0.0008494124
+418.4278869629 240.3620452881 0.0056975977 -0.0004862020 0.0143762473
+535.4852905273 233.6480560303 0.0033989169 -0.0003166375 0.0085422406
+580.5808715820 306.7844238281 0.0059414697 0.0003014239 0.0139995106
+526.6007690430 224.5643768311 0.0075552855 -0.0010813929 0.0096455440
+282.9523315430 328.9390258789 0.0011542760 0.0002129760 0.0040751128
+459.4079589844 230.4602355957 0.0020292320 0.0003512628 0.0064454190
+655.6690673828 283.4753112793 0.0031776472 -0.0009696528 0.0107443817
+650.4928588867 273.5132751465 0.0040934691 -0.0003679884 0.0091740871
+253.5284118652 216.4633636475 0.0033530176 -0.0001998146 0.0094119674
+637.4939575195 186.4256286621 0.0069147428 -0.0011884174 0.0107979970
+516.3695678711 205.7278747559 0.0050434121 -0.0005589701 0.0142838201
+502.0252075195 269.4567871094 0.0001990217 0.0000207243 0.0006253119
+262.3724670410 388.4909057617 0.0068821167 0.0006493102 0.0105588203
+154.5335540771 317.6902160645 0.0068876552 0.0000145829 0.0105496421
+528.9747314453 301.1346435547 0.0004528661 0.0000100560 0.0016926422
+352.6851196289 326.6954650879 0.0063942168 -0.0004078942 0.0145568838
+287.4887390137 308.4487304688 0.0054041604 -0.0003796921 0.0146211507
+682.6066284180 346.5063781738 0.0037751109 0.0002078105 0.0085578933
+681.1725463867 193.1439514160 0.0014332570 -0.0000642319 0.0033119859
+624.7097167969 216.4582366943 0.0082817990 0.0002474240 0.0105337966
+384.8990783691 243.3069915771 0.0013244272 -0.0000130998 0.0040726042
+425.5604248047 216.5218658447 0.0044862335 0.0005008169 0.0063819611
+192.5262603760 276.5719299316 0.0033860018 0.0006767120 0.0233075693
+673.6480102539 246.6981658936 0.0064238380 0.0001878919 0.0108723035
+258.7572326660 231.2403869629 0.0014737449 -0.0002513818 0.0035783129
+254.4798431396 225.6350250244 0.0066218874 -0.0006636048 0.0122124888
+691.4084472656 235.6414489746 0.0065924618 -0.0007504990 0.0115171112
+321.4776306152 394.5873413086 0.0078410516 -0.0002326751 0.0101874443
+712.7360229492 281.0137939453 0.0008894261 -0.0000554846 0.0022450597
+382.4507751465 369.5071716309 0.0038808729 -0.0000403027 0.0077050608
+692.4560546875 397.6009826660 0.0049204705 -0.0004396247 0.0066609057
+208.9713592529 236.8587646484 0.0006566297 0.0001116699 0.0029104729
+614.6094360352 200.3584136963 0.0040220995 -0.0003792307 0.0173560847
+405.4874877930 243.5469665527 0.0025516436 -0.0003145064 0.0119170770
+234.3934326172 295.3903503418 0.0044304626 -0.0003885161 0.0078087184
+159.3851013184 306.6209411621 0.0047583459 -0.0002926405 0.0065076160
+274.5296630859 261.4772338867 0.0045676148 -0.0015975803 0.0179500896
+672.8274536133 320.6576843262 0.0010307921 0.0000785994 0.0048019020
+402.5232849121 256.5563659668 0.0017841236 0.0004736334 0.0069301431
+99.7373886108 268.5194091797 0.0068904646 0.0000314875 0.0107081691
+242.9690399170 219.0888824463 0.0005121598 -0.0000084956 0.0014190344
+678.6685791016 209.2720031738 0.0046832282 0.0008736363 0.0165966675
+646.6422729492 296.4025573730 0.0076263403 -0.0004952692 0.0109139606
+453.3833007812 211.5873565674 0.0073127742 -0.0000312806 0.0115663828
+373.5279541016 215.3878021240 0.0031877875 0.0008938863 0.0107179563
+583.4971923828 352.5339050293 0.0053706747 -0.0004036214 0.0129799796
+575.5217285156 251.3386840820 0.0077289348 -0.0006679981 0.0094190249
+483.5258483887 332.4543151855 0.0028034702 0.0002581615 0.0045730392
+529.1408081055 203.0825805664 0.0003634412 -0.0001001858 0.0022430243
+768.4567871094 284.5644226074 0.0032598092 -0.0005193300 0.0089571327
+604.6876831055 256.7246704102 0.0056899879 -0.0003664827 0.0126846926
+330.2423706055 382.6222229004 0.0074613956 -0.0017364868 0.0105943251
+740.4618530273 310.6466674805 0.0038614438 -0.0001725593 0.0083958041
+241.4734802246 256.5178222656 0.0043967967 -0.0000357137 0.0070583234
+113.4049148560 266.5127258301 0.0069862744 -0.0005069349 0.0109749455
+332.6577453613 381.6669006348 0.0068810321 -0.0023393154 0.0117467381
+177.7109527588 321.5104370117 0.0050590117 -0.0004245123 0.0064383168
+166.4445495605 214.4847106934 0.0018075253 -0.0001329815 0.0067289532
+254.5232543945 223.3769989014 0.0022530551 -0.0003006884 0.0051975627
+609.5340576172 223.4744720459 0.0025048987 0.0000455454 0.0047865696
+403.5467224121 228.4910736084 0.0027792556 -0.0010645026 0.0110137649
+330.4849243164 401.4694824219 0.0080189854 -0.0005296539 0.0103575513
+390.5376281738 259.7366943359 0.0056663491 -0.0000764878 0.0129614593
+402.4537658691 239.2563629150 0.0027344832 -0.0005183956 0.0109749548
+112.5555191040 232.4800109863 0.0027085422 -0.0002876259 0.0112543814
+755.4696044922 399.4924621582 0.0040527945 0.0001284135 0.0078533720
+366.5350341797 381.5332336426 0.0049505867 0.0004467174 0.0060668699
+227.5016784668 316.5070800781 0.0025915969 0.0000708557 0.0045673749
+725.3822631836 238.2874755859 0.0072372206 0.0002475998 0.0100841550
+218.2173767090 257.9845275879 0.0002050743 0.0000404407 0.0006643034
+603.5185546875 347.3087158203 0.0018139285 -0.0001696627 0.0082689049
+464.9269714355 219.1224517822 0.0003761144 0.0000257672 0.0020194640
+562.5463256836 365.4401855469 0.0028654553 -0.0006912958 0.0044043134
+182.9435729980 239.1332397461 0.0007043834 0.0000653501 0.0027018420
+371.4961853027 285.4593811035 0.0025940551 0.0002132732 0.0051716077
+194.5512237549 295.7069091797 0.0066908756 -0.0016054278 0.0111262444
+527.2647094727 210.9920501709 0.0012154634 -0.0000296152 0.0037735382
+538.4287719727 224.6483459473 0.0039804857 0.0000890248 0.0074628503
+361.4624633789 282.2014465332 0.0004193896 -0.0000501596 0.0007708702
+689.5234375000 344.4076538086 0.0068896497 -0.0007872557 0.0120245749
+133.5723571777 279.3668518066 0.0073090433 -0.0008488484 0.0104057770
+252.5201721191 264.4013061523 0.0022047835 -0.0001451205 0.0054644621
+546.9021606445 264.7464904785 0.0009832693 -0.0001195933 0.0019479363
+740.4633789062 312.4925231934 0.0023084939 -0.0000870390 0.0053504524
+300.3009033203 366.3910217285 0.0058924342 -0.0033817603 0.0156719014
+571.4663085938 324.5040893555 0.0018755581 0.0003339754 0.0065340297
+487.3705749512 208.4986419678 0.0024740342 -0.0019324465 0.0307310689
+185.0575103760 298.9313964844 0.0007816182 0.0000229183 0.0025124166
+735.5711059570 324.5907897949 0.0052982387 0.0005310480 0.0130920131
+413.6060791016 239.4986572266 0.0035030008 -0.0001374085 0.0095485859
+217.8646850586 214.5743255615 0.0047962489 -0.0008605169 0.0159380697
+405.3327636719 352.4154968262 0.0043343706 0.0001485180 0.0071406025
+519.4725341797 308.3764953613 0.0045292615 -0.0000510269 0.0072487975
+753.6204833984 357.7381286621 0.0071206884 -0.0011221028 0.0126802437
+213.6436462402 433.4248657227 0.0072424449 -0.0002566337 0.0109868580
+605.4650268555 346.6059570312 0.0028121313 -0.0005803214 0.0105329137
+600.6413574219 347.6030883789 0.0025286502 -0.0006685347 0.0129348198
+726.6915893555 231.4664306641 0.0061643138 0.0000802962 0.0137308547
+259.5897521973 303.4765930176 0.0031792799 -0.0004870917 0.0112805748
+229.4460601807 319.6459655762 0.0092221629 0.0004089794 0.0085676499
+576.8470458984 361.2724304199 0.0008303150 -0.0001117340 0.0025165563
+483.8165893555 208.5151519775 0.0025216551 -0.0016419784 0.0323291570
+637.3634643555 335.4597473145 0.0055316426 -0.0017473078 0.0133229606
+329.7261047363 301.9819946289 0.0001485251 -0.0000222720 0.0002978157
+563.5539550781 347.5117187500 0.0034423335 -0.0001924766 0.0097956117
+258.6026000977 299.3573913574 0.0043816720 -0.0013873525 0.0172454417
+618.4928588867 202.2253875732 0.0047370233 -0.0001311736 0.0162527971
+504.8837280273 253.4631805420 0.0015058044 0.0000815203 0.0030590165
+588.6107788086 246.6396179199 0.0059949034 -0.0004754492 0.0122182565
+470.2792968750 373.9490356445 0.0001562087 0.0000023393 0.0002890957
+326.1758117676 274.3106689453 0.0001645906 -0.0000323200 0.0003194840
+416.4948425293 272.4461975098 0.0023486593 0.0001546544 0.0049658380
+569.5580444336 441.3614501953 0.0050330595 0.0008218280 0.0070249732
+322.4074096680 363.6462707520 0.0045859097 -0.0003301104 0.0160977840
+432.5698242188 339.3489379883 0.0058161919 -0.0016730992 0.0133657251
+597.5729980469 261.4337768555 0.0043403506 0.0000791735 0.0067948904
+216.4641571045 221.3810424805 0.0050860038 -0.0005027573 0.0179887991
+564.6146850586 263.6582946777 0.0055837939 -0.0005359637 0.0143513279
+205.3872985840 254.7015991211 0.0055834432 -0.0000706251 0.0141656976
+766.2711181641 304.3473815918 0.0098854499 0.0004768099 0.0076802578
+102.4062957764 206.5564117432 0.0059263986 0.0002040651 0.0128199924
+730.4652709961 241.5541992188 0.0039622686 0.0002003938 0.0078053246
+549.9105834961 233.3160400391 0.0002837754 -0.0000202137 0.0010477075
+248.5545806885 236.4490509033 0.0062737023 0.0000918777 0.0120197991
+668.4788208008 202.5433654785 0.0047067977 0.0004495264 0.0152777722
+73.5729064941 241.4699707031 0.0026017295 -0.0004320364 0.0045483476
+156.4132080078 195.4390563965 0.0022781319 0.0006829419 0.0140358051
+283.4438171387 294.3149719238 0.0040497757 -0.0012150332 0.0178947113
+365.6019592285 287.5471801758 0.0021349490 -0.0000036971 0.0055868980
+22.2837886810 247.6619567871 0.0078164935 -0.0002667707 0.0117547736
+298.5954589844 354.7185974121 0.0058170599 -0.0006927117 0.0137733249
+307.4017333984 279.3288879395 0.0055045462 -0.0002772135 0.0140746236
+314.9599609375 263.2085876465 0.0011382797 -0.0001740409 0.0020892688
+715.6889648438 390.7187194824 0.0062407996 0.0000540984 0.0123647479
+522.6017456055 266.1310729980 0.0001815200 -0.0000012197 0.0006774019
+217.2526397705 432.6334533691 0.0085541764 -0.0000683309 0.0096574808
+495.4864501953 224.3584442139 0.0055032233 -0.0004786850 0.0135451350
+327.4874877930 264.4370422363 0.0072671371 0.0001040760 0.0094020115
+262.5121459961 426.4850769043 0.0028363268 -0.0003224900 0.0046076388
+639.3674316406 192.4732208252 0.0063436604 -0.0006127169 0.0109508904
+645.5971069336 216.4115295410 0.0037558354 -0.0007819976 0.0094858566
+700.3220825195 351.4099121094 0.0065086810 0.0002890225 0.0115617588
+270.5856323242 226.4769134521 0.0030987575 -0.0008893566 0.0093229348
+240.5491638184 252.5737457275 0.0014869502 0.0000095764 0.0028404072
+679.4467163086 212.5442810059 0.0031158514 0.0005212107 0.0096520670
+683.0889892578 303.3197326660 0.0007516560 -0.0001817327 0.0027486295
+651.6509399414 356.5006713867 0.0034028124 0.0011084978 0.0091721630
+538.6489868164 259.6229858398 0.0055905217 -0.0016334062 0.0145893497
+728.5016479492 217.6401672363 0.0049735056 -0.0002220096 0.0158581976
+245.6707916260 254.2135772705 0.0003330733 0.0000475595 0.0008193127
+530.3133544922 305.4617004395 0.0002989462 0.0000097021 0.0011041820
+96.1526336670 272.3887634277 0.0074439109 -0.0007061707 0.0102632642
+416.5312194824 314.5082092285 0.0062555210 -0.0000463740 0.0116708660
+665.5410766602 275.3533935547 0.0030637716 -0.0006068189 0.0107938480
+341.4298706055 383.4389343262 0.0067305709 -0.0020722342 0.0118510788
+430.9902648926 285.2491455078 0.0017321305 -0.0000032844 0.0026887578
+461.3954467773 209.7775268555 0.0061884490 0.0004455386 0.0115813073
+772.6480102539 238.3775939941 0.0088103721 0.0008129089 0.0102051999
+709.1256103516 271.1568603516 0.0008930942 -0.0000442845 0.0019876123
+103.3799667358 256.3964233398 0.0057904245 -0.0000743238 0.0125659769
+614.4948120117 361.7346801758 0.0060893446 -0.0012712685 0.0120144337
+246.5461425781 313.2834167480 0.0069525884 -0.0007105431 0.0115350392
+750.4942016602 330.5446472168 0.0014421487 -0.0001362331 0.0079166573
+678.5923461914 250.4724426270 0.0073774070 -0.0003094722 0.0099035911
+364.8287963867 345.2660217285 0.0013684048 0.0001732976 0.0032179083
+372.3712463379 247.3898468018 0.0050687110 0.0002405847 0.0144540705
+80.5176696777 230.5083160400 0.0021090109 -0.0002180938 0.0061853738
+655.2115478516 363.3166503906 0.0015421456 0.0000938181 0.0029635858
+661.6641845703 237.7932434082 0.0002009611 -0.0000184948 0.0005930350
+232.3976287842 269.3843688965 0.0059244474 0.0003091903 0.0151649741
+644.4044189453 263.5375061035 0.0029146022 0.0004854214 0.0104009034
+556.5439453125 363.7179260254 0.0075826035 -0.0022925523 0.0107850265
+489.2215576172 316.6495361328 0.0016761811 0.0000489986 0.0026902282
+589.1074829102 337.0069580078 0.0003685896 -0.0000102781 0.0019854319
+738.1799316406 230.4134368896 0.0054575582 0.0005684489 0.0126853343
+310.6121520996 263.3750610352 0.0026805017 -0.0002101559 0.0044721724
+431.5095825195 189.5761718750 0.0069599091 -0.0003440315 0.0110362992
+397.4990539551 268.3027954102 0.0061217933 -0.0002480269 0.0116905952
+71.1130371094 233.2119140625 0.0006590708 -0.0000929487 0.0011858940
+558.4570312500 358.4310607910 0.0034228996 -0.0004009078 0.0040730718
+321.5380554199 275.4564514160 0.0058313240 -0.0001529763 0.0116152344
+367.0811157227 314.9613037109 0.0014049172 -0.0001487176 0.0033159771
+435.4986267090 383.3865356445 0.0026214677 0.0001080844 0.0048987987
+246.1953582764 209.8319702148 0.0001459729 0.0000244571 0.0007890019
+520.4818115234 275.3516845703 0.0030862512 0.0003058685 0.0097593637
+469.4390258789 309.4345092773 0.0105277617 -0.0006222033 0.0093816109
+580.5764770508 362.3465576172 0.0030997905 -0.0000613719 0.0105293216
+456.9297180176 255.1115264893 0.0006194537 -0.0000125755 0.0030893451
+477.5724792480 388.3590087891 0.0071821972 -0.0012252074 0.0116181150
+486.5414733887 239.5501251221 0.0019758940 -0.0006336927 0.0063110404
+716.5794067383 338.4203796387 0.0052370303 0.0015410350 0.0165941548
+612.5759277344 299.3116760254 0.0012322690 0.0000650366 0.0016980051
+26.5417690277 253.6148376465 0.0051054470 0.0000764208 0.0062340512
+568.4912719727 311.4299316406 0.0013772488 0.0004873875 0.0088626994
+133.4621276855 257.4457092285 0.0064169532 -0.0009418270 0.0115054213
+658.7492675781 321.2505187988 0.0010888502 -0.0003575683 0.0048395470
+640.5300292969 360.3940734863 0.0058206762 0.0010346242 0.0127005689
+358.5873413086 230.7672119141 0.0053325607 -0.0009632421 0.0146944560
+337.6240539551 272.4657287598 0.0083050346 -0.0010546264 0.0105103320
+536.3825073242 285.2886047363 0.0010020048 0.0000701205 0.0045221508
+191.5789184570 212.5772094727 0.0026691330 -0.0005340456 0.0111212507
+417.5448303223 247.5978851318 0.0026535869 -0.0000530193 0.0116121201
+465.7300109863 221.5196075439 0.0002447127 0.0000381199 0.0012208049
+678.9888305664 207.2424011230 0.0014691028 0.0001796020 0.0039524883
+718.4702148438 239.5325317383 0.0086702667 -0.0008420600 0.0099187000
+331.6682434082 307.5459289551 0.0001006409 -0.0000188501 0.0002196981
+242.7519531250 221.7161560059 0.0003030085 0.0000329097 0.0011863657
+228.7758789062 317.3482666016 0.0016813923 -0.0001236656 0.0027080930
+296.4886474609 215.5249481201 0.0032499151 -0.0010223826 0.0106531736
+459.5033264160 352.5365600586 0.0048471089 -0.0004506421 0.0159508828
+256.8851623535 224.4205474854 0.0014379428 -0.0002148374 0.0032642970
+152.5126495361 243.4782714844 0.0028149062 0.0000317301 0.0041137994
+188.6357727051 389.5405578613 0.0083197765 0.0011452558 0.0097969929
+610.9168701172 223.2350158691 0.0013466264 0.0001782106 0.0033360226
+542.8218994141 324.8146667480 0.0011173300 0.0002366030 0.0044411551
+161.4298400879 259.5034484863 0.0027796177 0.0002205565 0.0041144169
+503.2188415527 440.7343750000 0.0018370744 -0.0000451010 0.0024199965
+417.1195068359 273.3076477051 0.0013114043 -0.0000505344 0.0035250087
+155.5950164795 269.7095642090 0.0048900340 -0.0001556063 0.0062103174
+734.9431152344 325.1922912598 0.0013015550 -0.0000148620 0.0034683493
+300.5237426758 216.4355773926 0.0029808730 -0.0006536773 0.0107039781
+249.2185058594 225.6048278809 0.0069940710 0.0002475608 0.0111211585
+357.3814086914 297.6296997070 0.0026196144 -0.0012354986 0.0130602457
+669.5956420898 276.4435119629 0.0052998122 -0.0002959995 0.0142067047
+276.9211120605 264.8771972656 0.0005917925 -0.0000563615 0.0012802770
+48.5917968750 438.4519653320 0.0041479566 0.0004285375 0.0029033273
+600.8806762695 223.0574188232 0.0008434804 -0.0000889124 0.0021861694
+632.9647216797 345.0210266113 0.0013257596 -0.0001877459 0.0033487284
+752.5324707031 209.4228515625 0.0047843531 0.0000251449 0.0152674606
+667.4413452148 313.5677490234 0.0026281511 -0.0002471061 0.0120873414
+208.5321350098 421.4354858398 0.0046704989 0.0004345811 0.0064803297
+622.5045776367 355.4939575195 0.0023379102 -0.0004985128 0.0053840103
+251.3079681396 233.4343261719 0.0057900967 -0.0000600950 0.0075877579
+726.6198730469 205.3827362061 0.0025999031 -0.0000064355 0.0121898502
+511.5337524414 223.7948303223 0.0063385540 0.0003872322 0.0122655323
+451.5458679199 242.4521636963 0.0024305957 -0.0000652152 0.0134093724
+268.5444641113 218.5460205078 0.0017099926 -0.0006406961 0.0074137766
+269.4001464844 438.4543457031 0.0074488455 -0.0006860382 0.0105793048
+409.5178527832 272.4257507324 0.0036509649 -0.0001631058 0.0083476603
+257.3553161621 319.6004638672 0.0058435001 0.0002445100 0.0120795881
+497.2554321289 235.4859771729 0.0076060896 -0.0001836475 0.0131084565
+277.4490051270 408.4265747070 0.0032806871 0.0001021250 0.0040097376
+264.8617553711 235.0351715088 0.0006044321 -0.0000807080 0.0014581433
+609.6292724609 404.7150573730 0.0066477093 -0.0000219858 0.0112188775
+376.4228820801 344.5436401367 0.0023410656 -0.0000131690 0.0067927181
+436.9363708496 261.6113281250 0.0013630381 0.0000646169 0.0034583278
+149.1810302734 314.5480957031 0.0003504601 -0.0001598850 0.0010368775
+297.9608154297 275.2801818848 0.0003761276 -0.0000504463 0.0008048207
+474.9703979492 380.4823913574 0.0001061098 0.0000146569 0.0001796630
+66.5542678833 227.3554229736 0.0062971418 -0.0015969708 0.0139315287
+388.7190856934 338.5972900391 0.0063097584 0.0006826581 0.0120995045
+273.7041625977 289.5019531250 0.0032329555 -0.0007382321 0.0106948223
+60.4783821106 213.5554351807 0.0042560636 0.0000313786 0.0072793891
+552.5143432617 200.4624176025 0.0022863031 -0.0001097264 0.0130885299
+309.6253967285 276.5047607422 0.0070100226 -0.0002823251 0.0109490464
+694.4133911133 237.5160217285 0.0063313306 -0.0008741873 0.0118358843
+673.3201293945 199.3416900635 0.0068133255 0.0009454824 0.0107081290
+751.4590454102 340.5101013184 0.0016709844 -0.0006342841 0.0070725265
+70.3698043823 388.4060058594 0.0077295024 0.0016603353 0.0108809518
+605.6583862305 363.3614501953 0.0000819147 -0.0000139490 0.0002213017
+255.2337341309 300.5991821289 0.0037109666 -0.0007333023 0.0094330683
+699.4934692383 228.5248565674 0.0070980079 -0.0003180786 0.0099336663
+188.5005187988 292.7007446289 0.0040333690 -0.0002506911 0.0080575580
+474.4394226074 364.4748229980 0.0045915321 -0.0003404522 0.0065294886
+90.6492691040 235.4938201904 0.0050656414 -0.0002056092 0.0144387372
+620.9113159180 192.4648742676 0.0012340408 0.0002507362 0.0038697822
+521.4663085938 292.4046936035 0.0034303032 -0.0006306767 0.0260596313
+720.5130615234 324.3437805176 0.0037234256 0.0008871860 0.0226922967
+529.5333862305 231.4075012207 0.0061698998 -0.0010622473 0.0120546669
+468.5259399414 241.4538421631 0.0015023288 -0.0001814626 0.0077626593
+765.5225830078 265.4511413574 0.0026480453 -0.0000433266 0.0043293815
+630.4605712891 309.6065673828 0.0033842504 -0.0004403652 0.0090649752
+74.7759780884 242.8453826904 0.0016677584 -0.0002302011 0.0027720979
+442.5155029297 440.4426879883 0.0080206487 0.0002712194 0.0095900195
+237.2955627441 258.5947570801 0.0038435431 0.0002714509 0.0081318133
+401.2050170898 276.7194213867 0.0013601313 -0.0002794626 0.0036441160
+387.6726379395 297.5860595703 0.0048772157 -0.0003536604 0.0153534682
+634.1529541016 393.6983032227 0.0001270024 -0.0000029238 0.0003751595
+477.4408874512 234.3631744385 0.0039122752 -0.0003375782 0.0190077424
+583.2772827148 213.0180511475 0.0007850556 0.0000625202 0.0025997746
+738.9200439453 315.1578674316 0.0009065479 -0.0001218818 0.0024982309
+564.4918823242 444.4542846680 0.0034105484 0.0001149686 0.0038469450
+290.6819458008 242.8126678467 0.0014291526 -0.0001472843 0.0031114283
+114.3332138062 251.6617584229 0.0046826252 0.0022843177 0.0198889989
+274.4399719238 299.3542785645 0.0028211095 -0.0010827931 0.0106753940
+609.5264892578 255.5131072998 0.0037836810 -0.0003845687 0.0085286330
+216.6589660645 429.2965393066 0.0077071227 -0.0005841593 0.0094397310
+530.1336669922 224.2810821533 0.0070630838 -0.0005298993 0.0106628500
+727.7412109375 209.5949707031 0.0041002529 0.0000987357 0.0178729575
+255.3975067139 304.5650024414 0.0063891727 -0.0003999994 0.0110414177
+380.6888427734 349.6988830566 0.0032109101 0.0001143040 0.0244903807
+544.5986328125 279.5126953125 0.0016612483 -0.0001916453 0.0070809303
+670.3705444336 360.3495788574 0.0074708005 0.0001053860 0.0105717909
+560.9487915039 269.0969543457 0.0004641072 -0.0000822762 0.0015875788
+488.7687072754 285.1857910156 0.0007665961 0.0000502501 0.0022616964
+578.6926269531 266.5180664062 0.0063323444 -0.0009768137 0.0151202371
+379.7078552246 210.4286804199 0.0052746884 0.0004684156 0.0172854997
+706.4835815430 223.5281372070 0.0031664111 0.0001286309 0.0043542897
+571.0520629883 324.7996215820 0.0011101954 0.0004259435 0.0052054911
+706.9531250000 262.5888061523 0.0010385073 -0.0000037863 0.0019426590
+247.4795379639 239.5971221924 0.0039440370 0.0000560152 0.0082350122
+419.3760986328 385.4059753418 0.0074583422 -0.0004253619 0.0095121423
+717.4475097656 243.5745391846 0.0085530719 -0.0004814602 0.0086807888
+394.4277954102 355.5160217285 0.0033807436 -0.0001916475 0.0092012389
+361.5255126953 385.5388183594 0.0049600233 -0.0001515343 0.0060824342
+550.9908447266 215.1134338379 0.0004325262 -0.0000934535 0.0019340699
+417.5837402344 323.5783386230 0.0057300734 -0.0002705620 0.0122877816
+307.5273742676 337.5052490234 0.0045768740 -0.0013336808 0.0082576470
+771.1718139648 335.5385742188 0.0047497959 -0.0027700947 0.0183960702
+640.7360229492 289.8220214844 0.0061656735 -0.0018941553 0.0126550300
+558.5993652344 438.5999755859 0.0071745086 0.0015391239 0.0108388448
+636.9356079102 184.9245758057 0.0013624523 0.0000326808 0.0033691453
+477.5630493164 321.4867553711 0.0031971289 -0.0001966454 0.0036992889
+503.2325744629 226.8179473877 0.0005881393 -0.0002281957 0.0032106501
+492.4203491211 396.4712524414 0.0030621239 -0.0003063955 0.0041451096
+184.9747619629 281.0780334473 0.0008999003 -0.0000485711 0.0019883774
+463.0171813965 270.8334045410 0.0012863924 -0.0002699795 0.0043954095
+69.4322586060 238.4120635986 0.0063814144 -0.0014145534 0.0144806011
+537.1403198242 278.5665588379 0.0007326399 0.0000085336 0.0027265239
+483.0956420898 297.1156616211 0.0009735328 -0.0002060942 0.0019693661
+421.5281372070 340.4179992676 0.0048246374 0.0005112816 0.0168258194
+124.4599685669 272.6368408203 0.0028912162 -0.0002707994 0.0041171536
+62.3876457214 238.5307617188 0.0043735644 -0.0011705434 0.0081216414
+520.5203857422 312.4889831543 0.0068915766 -0.0001122640 0.0104151415
+762.4134521484 256.5050354004 0.0043112901 -0.0004683500 0.0074974755
+638.4430541992 427.4299011230 0.0076344367 -0.0009289911 0.0107969139
+720.5031738281 329.4335021973 0.0046236184 0.0001839495 0.0192401335
+187.4011230469 279.4437561035 0.0019474911 -0.0001043174 0.0062860101
+598.5963745117 229.4902648926 0.0079170447 -0.0009873675 0.0101432474
+506.5538330078 244.3656921387 0.0035768254 -0.0000493886 0.0078999661
+740.3568725586 209.4912567139 0.0028520939 0.0003055393 0.0103886193
+91.4658432007 268.4168701172 0.0026861958 -0.0000899004 0.0043719187
+630.3594970703 229.2151641846 0.0002020153 0.0000066094 0.0005888867
+248.8267211914 330.4955444336 0.0017442338 -0.0006217359 0.0031798247
+596.7942504883 410.7560119629 0.0015963557 0.0001157861 0.0030809706
+741.4075927734 342.5378417969 0.0033628882 -0.0011093755 0.0096873194
+678.9631958008 273.0321960449 0.0004927895 -0.0000598221 0.0016110073
+723.4416503906 210.3964538574 0.0047541065 -0.0003578680 0.0154486597
+190.8214874268 216.6404876709 0.0041205077 -0.0016339615 0.0195478834
+212.8128814697 209.3936767578 0.0002234949 0.0000527845 0.0012284822
+677.3869018555 279.4884033203 0.0069081807 -0.0001716272 0.0102724470
+166.9494476318 225.0845947266 0.0010306983 0.0000002608 0.0042354786
+421.5993957520 271.2106323242 0.0037426169 0.0001044301 0.0075649060
+471.1158142090 379.1062927246 0.0005859839 -0.0000317164 0.0012396786
+144.3723754883 381.4565429688 0.0051251277 -0.0001174757 0.0059182383
+639.3254394531 198.8891143799 0.0015075183 -0.0001272752 0.0031009282
+176.5414886475 212.2600555420 0.0036215202 -0.0010766902 0.0241366364
+173.3820648193 309.4560852051 0.0076332577 -0.0003603607 0.0101693403
+465.4437561035 263.5640258789 0.0047631213 0.0001179808 0.0160083603
+599.5811157227 403.3860168457 0.0069301296 -0.0014047119 0.0109658251
+491.4507751465 208.6549835205 0.0028757979 -0.0018519562 0.0285476688
+48.3252449036 352.3770141602 0.0087151462 0.0017913321 0.0090535581
+466.5056152344 448.5660705566 0.0055279490 0.0000196223 0.0050946274
+226.6742401123 209.8247222900 0.0001475250 0.0000339304 0.0009180584
+384.5224609375 282.5028991699 0.0020104791 -0.0000441977 0.0052946657
+393.5039062500 391.4536743164 0.0034066513 0.0003860526 0.0038205045
+100.5018920898 220.4795684814 0.0029690901 -0.0002755163 0.0119946292
+642.8773193359 307.2743530273 0.0008055256 -0.0000906706 0.0025282651
+415.1999816895 364.8071289062 0.0018687480 0.0000821108 0.0026296736
+763.6011962891 210.5152740479 0.0055590831 0.0003247304 0.0166335106
+382.4287719727 239.5010070801 0.0045332713 -0.0013718508 0.0176621228
+211.0004119873 218.9428863525 0.0012423894 0.0001007912 0.0038482437
+287.5996093750 214.6135406494 0.0043562669 -0.0011699368 0.0176951233
+397.6181945801 214.2929687500 0.0044957087 -0.0001827140 0.0165297687
+152.3875579834 214.4981689453 0.0022670662 0.0008647122 0.0139794797
+74.6554641724 435.3776855469 0.0068494873 -0.0005017161 0.0123178586
+728.4135742188 286.5474853516 0.0052831024 -0.0000188338 0.0136448704
+633.5343627930 185.3137207031 0.0002175393 0.0000398194 0.0005788875
+477.1131896973 221.1928710938 0.0003554099 0.0000431203 0.0022165463
+526.5459594727 310.5213928223 0.0021197274 0.0000647609 0.0052379761
+594.4533691406 359.5021667480 0.0017127282 -0.0004353671 0.0069955364
+408.5351562500 329.6853942871 0.0050774668 0.0002869960 0.0139996335
+398.9325561523 390.8289489746 0.0013797309 -0.0000123623 0.0013648674
+262.3708190918 341.7777709961 0.0003530429 -0.0001344054 0.0009402141
+594.3293457031 372.7134704590 0.0075058057 -0.0022555990 0.0119130127
+495.4634704590 261.5660095215 0.0046692560 -0.0008500256 0.0149257183
+340.3145141602 347.5768432617 0.0036648840 0.0006222820 0.0212325212
+713.4195556641 354.6243286133 0.0058756201 -0.0005093208 0.0132408096
+530.4304199219 220.4268798828 0.0052142139 -0.0002947944 0.0065564411
+766.3981933594 374.5721435547 0.0074749175 0.0004151460 0.0097731622
+264.5241088867 399.2194213867 0.0080578411 0.0003235293 0.0116913496
+677.2495117188 270.8003234863 0.0012907662 0.0000102051 0.0034924415
+468.3978881836 201.5530853271 0.0014540133 0.0000665913 0.0083751725
+572.5631713867 253.4879302979 0.0076574753 -0.0004511700 0.0099488115
+309.5251159668 348.4855651855 0.0028966814 -0.0006926958 0.0146560231
+493.3458251953 227.6576538086 0.0067975502 -0.0006352701 0.0140178269
+186.9233856201 219.1883087158 0.0004896657 0.0000379050 0.0036974074
+686.3162231445 345.5526733398 0.0063647302 -0.0004679120 0.0117020244
+269.7023010254 389.4734497070 0.0072769360 0.0003926023 0.0108181546
+437.4606933594 227.2875976562 0.0040396787 0.0017891224 0.0196823925
+163.0598602295 234.9216613770 0.0008863743 0.0000127144 0.0021662337
+753.3337402344 419.4293518066 0.0087292707 0.0000149806 0.0086731091
+291.4537963867 295.4049987793 0.0025041008 -0.0005066555 0.0145381922
+419.3794860840 225.4920196533 0.0020361496 -0.0000543139 0.0060006781
+356.8601684570 352.8853454590 0.0006518920 -0.0000502746 0.0011367014
+149.5466613770 195.5528869629 0.0014007310 0.0001547260 0.0089008650
+138.3416290283 272.4724426270 0.0072762449 -0.0005820653 0.0113209095
+180.7214813232 366.4733276367 0.0081166932 0.0005343285 0.0100378664
+255.5350494385 429.6279907227 0.0042653936 -0.0000786502 0.0072278897
+310.3604736328 292.6349487305 0.0015947142 0.0001443543 0.0185981560
+586.6973876953 418.4939575195 0.0069188224 0.0001659630 0.0113161216
+134.8426666260 240.8936614990 0.0015663338 -0.0001293835 0.0034181464
+409.1369018555 279.0427856445 0.0008357161 -0.0001162939 0.0024039438
+690.6346435547 306.5687255859 0.0041948254 -0.0003926685 0.0191346146
+475.5386352539 274.4843444824 0.0019818156 -0.0003794768 0.0066509778
+713.6777954102 272.5218200684 0.0064410372 0.0001720718 0.0115925353
+434.3145446777 194.3943634033 0.0069995662 -0.0012790072 0.0102377096
+714.6550903320 238.3857269287 0.0078167161 -0.0010298509 0.0098207053
+431.5736694336 226.4599914551 0.0031659093 0.0001436093 0.0102691595
+41.6011734009 325.5187988281 0.0083432952 0.0011368447 0.0087522119
+156.3731079102 262.6591796875 0.0075040925 0.0001006193 0.0094723832
+385.1531066895 283.2623596191 0.0014637810 -0.0001169708 0.0035238955
+283.5438842773 233.5271453857 0.0036156555 -0.0005919476 0.0080845095
+656.9731445312 284.2768554688 0.0010073644 0.0000127524 0.0020274746
+745.3995361328 209.5851898193 0.0051482818 0.0005129111 0.0141287455
+425.4872741699 225.5867767334 0.0021698745 0.0000051921 0.0054431912
+382.6783447266 390.9786376953 0.0012789641 0.0000212918 0.0015421781
+594.5225219727 413.7172546387 0.0044603264 -0.0001050948 0.0069015808
+397.5570068359 274.7171936035 0.0067619728 -0.0008271978 0.0114383558
+457.4638977051 224.4624023438 0.0041068294 0.0003195131 0.0073538157
+406.5025939941 307.6130065918 0.0073508476 -0.0010077948 0.0112199225
+670.9826660156 205.2205505371 0.0009251491 0.0000207122 0.0020468403
+479.6599731445 343.3231201172 0.0042615058 0.0012177186 0.0075236452
+622.9670410156 279.1469726562 0.0009594333 -0.0000656897 0.0021079755
+344.7040100098 228.3912811279 0.0057320138 -0.0006598034 0.0160481967
+292.4184265137 289.4848327637 0.0014699460 -0.0006240647 0.0090159262
+741.6911010742 262.6400756836 0.0045236917 -0.0010994517 0.0171629526
+309.5916442871 217.4765777588 0.0047151642 -0.0009168597 0.0162749365
+66.5110321045 387.6235656738 0.0088658873 0.0015407745 0.0098122982
+671.6861572266 273.5533142090 0.0063662021 -0.0001221406 0.0119953994
+549.6759033203 268.5862121582 0.0055893371 -0.0010849236 0.0135969082
+710.4246215820 353.4130249023 0.0067465305 -0.0005823490 0.0149028189
+578.4671630859 317.4426269531 0.0023404160 0.0010268815 0.0064678262
+714.3838500977 205.4488067627 0.0073491698 -0.0002136745 0.0110311639
+545.1846313477 280.6412353516 0.0010828301 0.0000163722 0.0050720819
+707.5746459961 288.3930969238 0.0039016837 -0.0003844308 0.0082042264
+520.7486572266 237.1156311035 0.0016993978 -0.0001500126 0.0029529987
+527.2662963867 310.6481018066 0.0015161737 -0.0000104297 0.0034172086
+618.4692993164 348.4765625000 0.0020544289 -0.0000319951 0.0064380076
+160.6358947754 195.4259796143 0.0024384405 0.0003004635 0.0143815819
+753.4621582031 223.5688171387 0.0024429036 0.0000797756 0.0054434123
+418.2968139648 213.9730072021 0.0001046142 -0.0000229098 0.0004282294
+645.5567016602 306.3123474121 0.0051318090 0.0000063874 0.0143125271
+623.5750732422 241.5002746582 0.0018731107 0.0002191051 0.0059886132
+312.6369018555 311.2426147461 0.0014684130 0.0001063549 0.0036789244
+143.3462219238 258.3725891113 0.0054755113 0.0001783879 0.0062015392
+383.4114990234 363.4671020508 0.0025877799 0.0000244276 0.0056405985
+624.9244384766 241.0693817139 0.0011476512 0.0001351896 0.0046923780
+114.5125961304 256.4941711426 0.0046890937 0.0017311568 0.0157651883
+485.4863281250 414.4688415527 0.0025321955 0.0001812174 0.0046218676
+570.4550170898 200.4074859619 0.0038693093 0.0007405678 0.0180922896
+454.5728759766 450.4392089844 0.0085850516 -0.0004162304 0.0093368534
+404.2006530762 374.7267456055 0.0094058923 0.0009326185 0.0079260822
+697.0926513672 400.9832153320 0.0015772474 -0.0000999576 0.0027594010
+664.9157714844 287.0060729980 0.0005897608 -0.0000262318 0.0014566914
+365.3071594238 374.2950134277 0.0087526590 0.0006663284 0.0115515618
+325.5169067383 359.2639770508 0.0048608165 0.0006476891 0.0179320127
+459.4342651367 321.3766174316 0.0094706975 -0.0006719152 0.0095871855
+298.4655151367 291.3872985840 0.0034366162 -0.0014715838 0.0281197317
+142.5354309082 214.3630065918 0.0030376553 0.0006178383 0.0097596059
+297.6955871582 234.1159820557 0.0003694189 -0.0000334153 0.0007637276
+606.4769287109 205.5239715576 0.0032521798 0.0003280793 0.0095396722
+316.6052246094 231.5886688232 0.0050134505 0.0003061557 0.0141450083
+372.6960144043 284.8340148926 0.0014222011 0.0001303004 0.0036087090
+541.4807739258 199.3909759521 0.0022634303 0.0003975224 0.0127054080
+771.4646606445 406.4828796387 0.0037658175 -0.0006256698 0.0076467134
+654.3614501953 382.4414672852 0.0054703169 -0.0006023149 0.0058619143
+520.4310913086 284.6149597168 0.0042259921 -0.0005729283 0.0181445386
+308.5251159668 388.5827636719 0.0084679583 -0.0019788744 0.0109527716
+199.4502258301 212.4664001465 0.0022290873 -0.0001271765 0.0056452136
+444.3989868164 340.6047363281 0.0036288248 -0.0007601245 0.0082225855
+485.0699768066 415.1356506348 0.0016381947 0.0000905497 0.0029458508
+735.4976196289 217.7142181396 0.0053489320 -0.0000455585 0.0134195313
+716.2332153320 387.4116516113 0.0065381192 0.0003434754 0.0125410175
+558.1297607422 322.6606750488 0.0001747512 -0.0000436151 0.0007274616
+765.6458740234 215.5129241943 0.0055987127 -0.0002287331 0.0132028768
+61.0375099182 222.6801147461 0.0010858659 -0.0000087650 0.0019100824
+575.4835815430 199.6061859131 0.0018234093 0.0003375251 0.0067873979
+702.8024291992 356.9955139160 0.0004575884 -0.0001649938 0.0017263672
+145.9139862061 262.1193847656 0.0003514468 -0.0000605949 0.0008042144
+435.0415344238 248.2526245117 0.0011497075 -0.0001288522 0.0041620610
+735.6380615234 389.3025817871 0.0077599138 -0.0007768834 0.0093505792
+169.4456634521 250.4172973633 0.0030727091 0.0000652020 0.0048198435
+30.5994949341 231.3665008545 0.0075431336 -0.0000724954 0.0102248201
+116.8844223022 233.1938476562 0.0006546159 -0.0001962439 0.0028481344
+399.5394287109 223.3912658691 0.0030195636 -0.0007806183 0.0099239070
+633.4857788086 419.3165893555 0.0062510204 -0.0001509459 0.0127022890
+526.7411499023 285.3564758301 0.0006912398 0.0000896052 0.0025919175
+517.5197753906 432.3601684570 0.0092760818 -0.0007944843 0.0086643603
+261.0892028809 336.5417785645 0.0017188119 -0.0008226665 0.0036667669
+464.4492492676 370.6397399902 0.0027228768 -0.0008868107 0.0048182020
+152.3961029053 263.4170837402 0.0055809822 0.0003906090 0.0056447466
+150.4871063232 303.6241149902 0.0028040262 -0.0003677221 0.0044838269
+535.4315185547 200.5586853027 0.0016824440 0.0000365115 0.0074884878
+222.3640441895 445.4458618164 0.0086632045 -0.0008420621 0.0094606429
+601.9234619141 382.2763366699 0.0001274538 0.0000188252 0.0003571768
+744.5357055664 319.6101074219 0.0028074987 0.0004997629 0.0129105849
+428.9977416992 188.8055572510 0.0007545480 -0.0000935998 0.0024014106
+724.4687500000 260.3641662598 0.0062244046 0.0001963794 0.0119443024
+724.2479248047 286.5379638672 0.0055548428 -0.0001748253 0.0126734702
+235.5148010254 235.3719482422 0.0028205789 0.0001854902 0.0045324848
+112.6919708252 441.2963562012 0.0087600397 0.0009293973 0.0092012165
+636.7435302734 319.0205993652 0.0011103048 -0.0005071079 0.0041737366
+309.3649902344 306.4459838867 0.0029673029 -0.0001199327 0.0113640390
+247.2903289795 322.6470947266 0.0075864517 0.0004894692 0.0120590320
+292.3843078613 214.4992065430 0.0032217726 -0.0011599248 0.0109383008
+278.4712829590 234.5388488770 0.0019696341 -0.0002371410 0.0063834526
+589.5092163086 260.3497619629 0.0046403222 -0.0000473088 0.0064518745
+428.4880981445 248.5196228027 0.0032503372 -0.0001795476 0.0094315177
+140.3274536133 404.5714111328 0.0075661475 -0.0001859577 0.0102792643
+308.9603271484 230.9543304443 0.0005017398 -0.0000700689 0.0014461280
+630.5620117188 183.4893798828 0.0069847577 0.0007973642 0.0103212753
+366.1957702637 287.2007446289 0.0013397817 -0.0000004002 0.0037350003
+244.8584594727 336.8101196289 0.0011969103 -0.0004673432 0.0020107713
+98.3991012573 351.6888732910 0.0079089906 0.0008496454 0.0096413940
+118.4947814941 215.6461334229 0.0056948443 0.0002351251 0.0161437429
+580.5376586914 358.7470703125 0.0029954782 0.0000334850 0.0100748241
+554.8225708008 268.6382446289 0.0013653837 -0.0002459374 0.0034019831
+277.3166198730 343.4271850586 0.0056927735 0.0000550510 0.0159774851
+522.4882202148 416.5754699707 0.0030505173 -0.0001169659 0.0038648543
+164.4922180176 281.4947204590 0.0022783021 0.0001438878 0.0054882946
+248.5879669189 373.3777770996 0.0070934608 0.0004987692 0.0100301765
+173.6828308105 279.5614624023 0.0029804083 0.0002479427 0.0103283729
+757.5788574219 330.3101501465 0.0031368285 0.0004200985 0.0221038219
+727.4017944336 357.3514709473 0.0041338112 0.0000940087 0.0080703832
+251.0507049561 238.7257995605 0.0015303532 -0.0000680994 0.0027094737
+48.6236686707 448.3514404297 0.0102063222 0.0023576990 0.0080718622
+273.5780334473 232.5538024902 0.0053536179 -0.0012656425 0.0134536931
+511.6640014648 303.7256774902 0.0046207365 -0.0005439533 0.0075971563
+206.5137939453 429.4288024902 0.0029532542 -0.0000280638 0.0042026467
+759.6706542969 377.4478759766 0.0075047989 -0.0003626363 0.0107441386
+161.5761413574 215.4994812012 0.0029141456 -0.0001474255 0.0105712246
+472.4990844727 223.5717010498 0.0028689406 -0.0003091995 0.0100795869
+294.2545776367 396.5219116211 0.0079954593 0.0002200420 0.0098106554
+458.5344238281 268.5854492188 0.0033563308 0.0000244387 0.0093481168
+273.1797180176 353.1123352051 0.0009368981 -0.0006881164 0.0025530232
+479.5385437012 375.5634155273 0.0044335471 -0.0004166208 0.0067723710
+599.1401977539 200.7282409668 0.0009970886 0.0003325194 0.0045717214
+566.6316528320 272.6547546387 0.0013680555 -0.0002707050 0.0037857944
+595.0170898438 360.8836669922 0.0012443528 -0.0002197805 0.0045230137
+419.2751464844 219.5015258789 0.0000702923 -0.0000104955 0.0003048953
+212.6341400146 295.5537719727 0.0062867166 0.0003398584 0.0134138623
+100.4908447266 449.4715270996 0.0074220914 0.0006891364 0.0099261897
+150.9223175049 305.0862426758 0.0016681706 -0.0003591184 0.0029997868
+665.4639892578 365.5285644531 0.0030142027 0.0003510452 0.0043460149
+625.6018066406 371.5657653809 0.0071343477 -0.0011746676 0.0107820388
+244.9803161621 412.9449768066 0.0006465737 0.0000561942 0.0011384565
+491.4596557617 413.4340209961 0.0028522364 -0.0000745546 0.0042835511
+132.5538482666 193.6593933105 0.0045417836 -0.0002876153 0.0164619051
+658.9247436523 407.0787658691 0.0011764434 -0.0002957951 0.0016137260
+158.4452056885 325.5671997070 0.0076286574 0.0000329297 0.0109697226
+475.1812438965 330.8267211914 0.0021779514 0.0000813503 0.0024876511
+634.5383911133 425.4170227051 0.0073778601 -0.0009984359 0.0104594715
+696.7416992188 214.5229187012 0.0077046664 0.0002928439 0.0094772819
+495.3154602051 403.1762390137 0.0016392116 -0.0002725466 0.0028953520
+744.4682006836 403.5629272461 0.0028493141 -0.0003618952 0.0046935319
+389.0302429199 370.6497802734 0.0016048306 0.0002007324 0.0032209901
+424.9755859375 222.8853607178 0.0004644217 -0.0000374835 0.0015636194
+61.4340476990 296.5258178711 0.0065810368 -0.0005131123 0.0110718096
+262.8766784668 282.6270751953 0.0008249391 -0.0001263095 0.0025242623
+303.6130065918 412.4441223145 0.0073837074 0.0002823183 0.0097447233
+513.0886840820 417.2946472168 0.0010234837 -0.0001751640 0.0017356257
+315.7513427734 389.7565612793 0.0091769341 -0.0006237077 0.0101600317
+575.3994750977 201.0508422852 0.0009782158 0.0001823504 0.0045984373
+495.0773620605 262.7307128906 0.0013696342 0.0001199506 0.0035045617
+747.5839233398 229.6249237061 0.0036382312 -0.0000515793 0.0079523474
+355.4257812500 215.4594421387 0.0032920176 0.0001328990 0.0092453426
+207.5130157471 417.5063171387 0.0074561960 0.0000194700 0.0099003511
+80.3322143555 261.3759155273 0.0079304352 0.0000934476 0.0103048552
+297.4152221680 280.6191101074 0.0032068635 -0.0008117398 0.0115996832
+695.4664306641 375.4224853516 0.0043661967 -0.0003607813 0.0068417699
+252.7189331055 384.6681823730 0.0071969144 -0.0006679017 0.0101769920
+317.0166625977 219.6052246094 0.0000631397 -0.0000031565 0.0002745611
+568.5871582031 201.4581909180 0.0010064112 0.0000775691 0.0050400151
+508.4608154297 258.4392089844 0.0069093141 0.0004793245 0.0129984654
+312.5308532715 269.5421752930 0.0025881205 -0.0001757324 0.0045820307
+614.4765625000 307.5314636230 0.0049132616 0.0001241242 0.0060481955
+476.4539794922 296.2416076660 0.0063116057 -0.0018033008 0.0139953885
+560.4434204102 248.5286407471 0.0061691734 -0.0003520153 0.0123451138
+141.3821716309 231.4429321289 0.0070353113 -0.0008672118 0.0105278231
+443.4532165527 251.4119720459 0.0045687933 0.0004421530 0.0167866219
+431.4129028320 374.4792480469 0.0042311731 0.0006501846 0.0072806226
+344.4758911133 402.5326232910 0.0035471055 -0.0008117629 0.0038126432
+304.9733581543 373.0719604492 0.0005316823 -0.0004458435 0.0017691200
+140.5287322998 363.5743713379 0.0044603185 -0.0000302183 0.0067394595
+278.7378540039 236.8663330078 0.0012460498 -0.0004220386 0.0048370659
+707.1107788086 394.8980712891 0.0008676996 -0.0000336302 0.0020480724
+274.5625610352 303.6195373535 0.0018354029 -0.0004252431 0.0080873780
+725.5313720703 306.4823913574 0.0058937599 -0.0009723432 0.0127439545
+398.9549560547 223.0375671387 0.0009153538 -0.0000892693 0.0056450120
+262.5466613770 349.4719238281 0.0025355516 -0.0013017029 0.0053835623
+164.3473968506 250.5811157227 0.0053081820 -0.0000528235 0.0145774791
+679.4594726562 253.8185272217 0.0075191166 -0.0006908808 0.0100592487
+726.8649902344 236.7307128906 0.0016416345 0.0000853110 0.0031520748
+219.6146240234 292.5436401367 0.0065010735 0.0002525878 0.0116291828
+710.7002563477 233.0929107666 0.0016763955 -0.0000792324 0.0027554466
+382.4350891113 397.5347595215 0.0029461416 -0.0001630796 0.0042185243
+397.3516845703 237.5035400391 0.0048123505 -0.0023313812 0.0186884124
+513.5230712891 308.2864074707 0.0042922520 -0.0001940402 0.0078701042
+629.6174316406 317.3572998047 0.0021158475 -0.0007432337 0.0065735956
+635.6033935547 263.5368652344 0.0017826175 -0.0000912337 0.0066416045
+233.4218750000 318.4231262207 0.0046668053 0.0003346855 0.0064433916
+652.3281860352 282.3751220703 0.0048880144 -0.0009026446 0.0165828094
+481.2552795410 407.1272277832 0.0014932906 -0.0001894834 0.0030755212
+335.5693359375 403.4266662598 0.0053059701 -0.0008651118 0.0057593537
+553.5244750977 237.4933319092 0.0066765412 -0.0000746077 0.0105112139
+88.5292510986 443.5978393555 0.0040394273 -0.0000082009 0.0071847336
+674.5857543945 242.4457397461 0.0027604655 0.0002306567 0.0043321322
+161.5133056641 264.5958862305 0.0067114076 0.0000659015 0.0124371881
+453.3532714844 431.4363098145 0.0077857268 -0.0002607721 0.0097477967
+492.5386047363 334.4700012207 0.0025776417 0.0004201001 0.0048553925
+615.5473632812 437.5007629395 0.0047518155 -0.0009823830 0.0066360408
+472.3545532227 336.6012268066 0.0068665436 0.0010004522 0.0117125511
+505.5064697266 440.4519958496 0.0081999162 -0.0008824021 0.0087427776
+369.4883422852 355.3405151367 0.0054412922 0.0009661810 0.0180001948
+388.0943603516 348.6562194824 0.0000861509 -0.0000052982 0.0001946487
+544.4501342773 207.4561157227 0.0034527492 0.0001741024 0.0084039159
+425.4270019531 222.3385620117 0.0002900219 -0.0000182266 0.0009404735
+479.3017272949 327.2018127441 0.0068486165 -0.0012493684 0.0118257543
+516.3928222656 224.5187225342 0.0045760530 -0.0004366271 0.0080566686
+278.1228027344 346.0797119141 0.0002896466 -0.0001635899 0.0010066637
+497.5427246094 394.5690002441 0.0050986768 -0.0008506328 0.0060775103
+595.4900512695 273.4455261230 0.0027504279 -0.0004032044 0.0042504673
+300.8831481934 129.0844573975 0.0008394227 -0.0001365796 0.0023104378
+439.6620178223 196.4977569580 0.0055955020 -0.0008431411 0.0146730924
+556.5479736328 444.5631408691 0.0054978961 0.0005653726 0.0056224475
+624.5010986328 186.3843994141 0.0042631212 0.0012208838 0.0070954422
+200.8603363037 281.0469970703 0.0013368163 -0.0000884734 0.0036397083
+314.5251159668 216.4875793457 0.0016866900 -0.0001591999 0.0079376409
+423.1338500977 245.1436614990 0.0005374504 -0.0000792405 0.0016940865
+352.4190979004 349.6067504883 0.0019121938 0.0004336172 0.0142868040
+493.2863769531 333.5428771973 0.0069666076 -0.0002457497 0.0101515567
+554.5192260742 314.5356445312 0.0045440611 0.0010992752 0.0182871465
+446.4558105469 226.5106811523 0.0016986323 0.0001111848 0.0070922850
+616.9739990234 386.8585205078 0.0004957247 -0.0000368415 0.0014618387
+310.5831298828 230.1945037842 0.0003240141 -0.0000215565 0.0009038582
+629.6123657227 206.4500122070 0.0065419315 -0.0000939077 0.0116721708
+104.7335357666 243.4436492920 0.0070388005 -0.0008402284 0.0166441575
+429.6799316406 211.3445587158 0.0095522581 0.0005663107 0.0080476403
+390.5462036133 281.5681762695 0.0022932314 -0.0000730965 0.0060226647
+249.5019226074 335.5242004395 0.0088780196 -0.0016598615 0.0089157755
+145.6191558838 221.4427337646 0.0021815370 0.0001378037 0.0067117373
+744.4786987305 398.4757690430 0.0044954694 -0.0003155527 0.0066694310
+337.3016052246 432.4912719727 0.0085349483 0.0002909875 0.0094084395
+325.4550476074 227.6194763184 0.0035476468 -0.0001548102 0.0086526349
+619.4357299805 313.4403076172 0.0047589908 -0.0004121502 0.0068807686
+674.5519409180 212.4770660400 0.0043871296 0.0003260083 0.0162059031
+570.8681030273 370.8092346191 0.0006194302 -0.0001081103 0.0013027902
+729.4369506836 431.4397888184 0.0088881422 0.0009712798 0.0080165677
+249.3854064941 219.3695678711 0.0000598853 0.0000121172 0.0002847592
+587.5225219727 416.8781433105 0.0015441040 0.0001833163 0.0032286413
+199.1701202393 321.2503662109 0.0005434872 0.0000452938 0.0016108695
+542.4695434570 443.5011291504 0.0032790878 -0.0000876673 0.0035416430
+451.4779663086 261.4210510254 0.0044667074 -0.0004175187 0.0160550084
+652.5550537109 320.7418823242 0.0030487066 -0.0027482824 0.0259794742
+592.5075683594 275.4059143066 0.0043195793 -0.0007292829 0.0070774546
+350.4196777344 215.5093994141 0.0029874849 -0.0002215316 0.0097908117
+440.4031372070 300.6264343262 0.0083957165 0.0001772202 0.0086013591
+66.6459197998 352.7180786133 0.0039082863 0.0003703111 0.0078135980
+698.5054931641 395.4878234863 0.0044137961 0.0001478300 0.0075257039
+313.6969909668 306.5709228516 0.0003651711 -0.0000315973 0.0008160923
+429.5405273438 295.4563598633 0.0087453052 0.0006766990 0.0102430945
+527.4745483398 451.7387084961 0.0079913903 -0.0003319645 0.0094559388
+734.5253906250 420.5041198730 0.0093315952 -0.0001766570 0.0096401973
+27.5292510986 208.6421508789 0.0081298659 -0.0003720697 0.0094762668
+374.5694580078 222.5964508057 0.0018843877 0.0002758022 0.0066040708
+436.6165771484 368.4223022461 0.0076299887 -0.0003290615 0.0092435898
+167.5672760010 296.2626342773 0.0024838811 -0.0000627978 0.0049414909
+320.5544738770 209.3607635498 0.0037168760 -0.0003432866 0.0194227863
+550.4874877930 449.6197814941 0.0085268458 0.0001681312 0.0082165208
+595.2358398438 274.8762207031 0.0017065710 -0.0002987055 0.0028280837
+751.5509033203 404.4764709473 0.0028254443 -0.0003156181 0.0043789526
+156.9872741699 291.2789916992 0.0016305929 -0.0001953701 0.0032566632
+133.5380401611 125.5167617798 0.0020416828 -0.0009674843 0.0063877176
+635.4743041992 358.4100036621 0.0040135523 -0.0000631433 0.0074642096
+239.4733428955 432.5283508301 0.0075907209 -0.0012085838 0.0096007586
+614.5045776367 385.5011596680 0.0023006839 -0.0000492647 0.0051440001
+169.6635437012 217.5185546875 0.0032603804 -0.0006818746 0.0103819324
+150.1856536865 294.4354248047 0.0002270620 -0.0000591042 0.0005649599
+107.5245819092 436.4608459473 0.0036682787 -0.0000041140 0.0032878905
+191.4446563721 312.5421447754 0.0030188134 -0.0000060813 0.0041141030
+350.7763671875 386.0562133789 0.0001930656 -0.0000626555 0.0006152156
+128.4107818604 204.2742004395 0.0059174639 -0.0002985068 0.0129393721
+388.6725158691 253.1709289551 0.0010232286 0.0000152265 0.0023935682
+640.9143066406 351.0243530273 0.0015199757 -0.0001775134 0.0036309669
+624.8084716797 393.0576171875 0.0016172733 0.0002156204 0.0037231769
+599.3190917969 365.4954528809 0.0013194954 -0.0002059538 0.0034371184
+522.5069580078 246.1532745361 0.0061389706 -0.0003622104 0.0143939229
+752.4930419922 228.6813049316 0.0023466076 -0.0001753190 0.0055204462
+350.6277770996 266.5642395020 0.0043950486 -0.0002706045 0.0069536506
+614.5395507812 313.5217285156 0.0028346700 -0.0001722452 0.0047826814
+634.5425415039 356.5325622559 0.0024975871 -0.0002020103 0.0046921852
+572.5647583008 352.1808471680 0.0035157967 0.0001528787 0.0093440469
+610.9623413086 274.7591552734 0.0009687995 -0.0000620228 0.0019934960
+567.3816528320 381.5834045410 0.0047520921 -0.0009329554 0.0066920286
+764.4697265625 380.4672546387 0.0070228507 0.0004423370 0.0112349773
+149.5403594971 228.5055236816 0.0021079939 -0.0000968192 0.0056763543
+768.5184326172 450.4445495605 0.0072964607 0.0004560720 0.0101388423
+607.6750488281 407.5610656738 0.0069590998 -0.0001373848 0.0113783833
+574.5999755859 220.4130859375 0.0051607001 0.0001361732 0.0142866243
+207.5178680420 280.4602966309 0.0044158413 -0.0007174243 0.0175976679
+396.9240722656 354.9556579590 0.0010882050 -0.0000049974 0.0017215309
+264.5270996094 265.4557495117 0.0021962381 -0.0002413169 0.0063480986
+618.0764160156 386.6063842773 0.0003026103 0.0000445344 0.0010346101
+736.6407470703 414.5304260254 0.0082383957 0.0000395143 0.0095820697
+347.1394958496 315.0793151855 0.0010340124 -0.0000822344 0.0022392480
+742.3646240234 379.4649658203 0.0074596023 -0.0001111273 0.0100988224
+648.5444335938 318.5441284180 0.0014005585 -0.0012028314 0.0092136767
+195.4767761230 293.6568603516 0.0071999128 -0.0017336718 0.0125406757
+261.3493652344 243.2534027100 0.0013489685 -0.0003437249 0.0033433733
+589.4793090820 219.4088439941 0.0055697048 0.0004124921 0.0141159408
+340.4969177246 332.5202636719 0.0027230149 -0.0000344239 0.0043151653
+588.4502563477 423.4748229980 0.0027346199 -0.0000999117 0.0046899174
+626.4752807617 352.4640502930 0.0023479136 -0.0002200682 0.0049317409
+698.6478881836 233.6188507080 0.0046567004 -0.0002186193 0.0068743210
+623.5706787109 222.5623626709 0.0049922816 0.0000415144 0.0057473886
+772.6420898438 423.5438232422 0.0064594867 0.0002865823 0.0127310148
+631.4996948242 403.7478942871 0.0086841062 0.0014795365 0.0099974200
+607.3970336914 386.5229492188 0.0071090455 -0.0002703116 0.0108010555
+604.5229492188 199.5039062500 0.0034557090 0.0002066532 0.0211005155
+543.6975097656 224.7047119141 0.0064049894 0.0005780764 0.0123878466
+675.3038330078 242.6197357178 0.0015939651 0.0000387745 0.0028009363
+397.4445495605 278.6526794434 0.0043129367 -0.0008196339 0.0084972698
+113.5327835083 212.5000457764 0.0037178779 -0.0001109025 0.0095821992
+303.4237060547 291.5913696289 0.0012418274 0.0000464433 0.0098074954
+297.5602722168 210.4509582520 0.0035490124 -0.0007756156 0.0105335526
+430.0550537109 386.0507202148 0.0001366450 0.0000051987 0.0003415323
+83.4674148560 427.3771972656 0.0075567192 -0.0003836502 0.0104847588
+615.5742187500 449.4114074707 0.0052618133 -0.0005189779 0.0060367356
+489.4905700684 386.4805297852 0.0027764621 -0.0001131874 0.0043973317
+569.5827636719 422.5785522461 0.0078652380 0.0006694188 0.0087114703
+614.9830322266 386.8111877441 0.0014189808 0.0000021923 0.0031104130
+608.5408325195 199.6155395508 0.0035787134 -0.0002451911 0.0217065327
+612.4771118164 204.5893096924 0.0022033246 0.0000074247 0.0066973730
+619.4298095703 362.6259155273 0.0026813920 -0.0004171944 0.0040628458
+411.4617004395 225.3795318604 0.0019249760 -0.0002687550 0.0060246573
+341.4096374512 394.4386901855 0.0031771071 -0.0009777826 0.0042241369
+625.1270141602 197.1586456299 0.0013879212 0.0000645201 0.0033697283
+125.5679931641 277.6175231934 0.0079843113 -0.0005024773 0.0098748365
+598.3997802734 295.0398254395 0.0019146848 0.0000480638 0.0023923186
+621.7382812500 244.3828430176 0.0034222747 -0.0001003767 0.0086676823
+663.4443969727 218.5863189697 0.0051017576 0.0005892726 0.0139083620
+645.5128784180 243.4492034912 0.0021919641 -0.0007394534 0.0057795118
+446.7815551758 226.6831207275 0.0009935466 0.0000570329 0.0050357049
+39.5286674500 357.3671875000 0.0050355545 0.0012051746 0.0061695017
+229.2720336914 269.6328430176 0.0057318835 0.0002813392 0.0147406291
+365.5931396484 300.6917114258 0.0035498415 -0.0010609848 0.0093145035
+260.3471069336 263.4255371094 0.0028223170 -0.0002528744 0.0105972700
+255.0926208496 389.2912292480 0.0015297132 0.0002140963 0.0028928397
+258.9045410156 420.9456176758 0.0007162890 0.0000727463 0.0011190455
+401.4849243164 395.5406494141 0.0031630974 0.0003683389 0.0036259284
+276.8282470703 358.3890686035 0.0003239474 -0.0002115099 0.0011136800
+591.2326049805 376.4696655273 0.0059329015 -0.0013029276 0.0127565712
+583.3408813477 420.1427917480 0.0074771112 0.0004696937 0.0111277550
+468.6371459961 351.3052062988 0.0054396628 0.0012339290 0.0139431525
+166.5508880615 209.3201446533 0.0019063931 -0.0001140384 0.0071373479
+226.5069274902 256.5578308105 0.0021764436 -0.0002855867 0.0057643857
+744.6748046875 220.6299896240 0.0081400322 0.0009678847 0.0104283793
+139.4894561768 359.1908569336 0.0077354466 -0.0001385206 0.0108678648
+730.3430786133 340.5942687988 0.0046118493 -0.0012059074 0.0169285703
+247.4906005859 272.4960021973 0.0038188293 0.0001735826 0.0081411609
+72.4836807251 350.5269470215 0.0059946114 -0.0007557813 0.0124796527
+30.4368190765 394.4117126465 0.0056039137 -0.0001588576 0.0058327517
+537.6016235352 245.5254974365 0.0030019197 -0.0004764798 0.0045081582
+254.5023651123 416.5089416504 0.0024034115 0.0001675244 0.0050465311
+309.4961853027 271.6681823730 0.0092540514 -0.0001557196 0.0107905120
+255.2527618408 325.2621154785 0.0014022628 -0.0005474825 0.0032447218
+285.2903442383 274.8020324707 0.0013913210 -0.0001269603 0.0040207165
+66.3394088745 309.4288330078 0.0076677958 0.0006705716 0.0097083943
+387.0854797363 230.4762573242 0.0010276339 -0.0000603861 0.0049981470
+620.4985961914 364.3359069824 0.0067035989 -0.0019057833 0.0116191544
+640.3884277344 430.4266662598 0.0077249585 -0.0013663496 0.0100538274
+650.4876098633 351.7657165527 0.0056242798 0.0018197487 0.0138640339
+233.6304016113 241.3982543945 0.0058680545 -0.0003201653 0.0123147452
+314.5011901855 291.5842895508 0.0018034290 -0.0001703061 0.0185543429
+29.6811752319 295.4199523926 0.0062908917 -0.0001135306 0.0132713541
+493.3876037598 408.4982604980 0.0077171903 0.0007474215 0.0096871611
+569.5708007812 355.3553161621 0.0062615904 -0.0002474261 0.0117376195
+451.4210205078 279.5455932617 0.0070356829 -0.0002897657 0.0125189554
+192.5353088379 323.3543701172 0.0082985060 -0.0007487477 0.0093787881
+536.6358642578 244.6556091309 0.0067384029 -0.0017882036 0.0103886239
+745.6036376953 262.5147399902 0.0044567091 -0.0005645295 0.0192266610
+390.4215698242 285.3266906738 0.0057331822 -0.0004006348 0.0142884431
+74.7187423706 338.5892639160 0.0080350703 -0.0004003251 0.0102102067
+371.5530395508 220.2265167236 0.0000593830 -0.0000098396 0.0002779662
+689.0671386719 391.0746765137 0.0006058482 -0.0000893460 0.0012133312
+606.5416870117 364.5610961914 0.0069571766 -0.0006842676 0.0127892774
+638.5440673828 363.5084838867 0.0053080954 -0.0003763753 0.0134952366
+246.3278350830 255.3062286377 0.0078372983 0.0002089568 0.0108963605
+606.5978393555 445.4506225586 0.0089353416 -0.0012421706 0.0094285179
+269.4351501465 304.4513244629 0.0029887713 -0.0003237401 0.0115974871
+745.4498291016 238.3533172607 0.0050251829 -0.0007782241 0.0146564608
+553.5986328125 362.0970458984 0.0002164547 -0.0000367662 0.0006106176
+721.4981079102 440.6293640137 0.0081786560 -0.0002737876 0.0096123172
+190.8405761719 313.1631469727 0.0015523534 0.0001415829 0.0030937004
+459.1652832031 266.9109802246 0.0007505949 -0.0001256063 0.0025347411
+538.4824829102 204.6950225830 0.0052737482 0.0004902788 0.0130508011
+630.5033569336 358.6015625000 0.0043539046 -0.0006892763 0.0090450151
+213.5567474365 447.5182495117 0.0080232667 -0.0006099602 0.0091591850
+499.2179260254 413.3587341309 0.0009815490 -0.0002197316 0.0021421316
+245.7304992676 273.4485473633 0.0057591759 -0.0000220870 0.0134265162
+632.8503417969 207.5522613525 0.0075709773 -0.0001714151 0.0107473210
+717.0717773438 392.7947082520 0.0012737083 -0.0000671710 0.0036303985
+764.6611328125 359.4515991211 0.0036107260 0.0000826799 0.0039420705
+285.0391235352 286.5025634766 0.0008656841 -0.0000420066 0.0024635568
+393.4775390625 322.5792541504 0.0042016334 -0.0000492435 0.0073014246
+379.1013488770 237.1157989502 0.0012643371 -0.0000374349 0.0040878025
+671.6979980469 214.4633941650 0.0028358118 0.0001156107 0.0120768920
+126.5756225586 338.5270385742 0.0072835968 0.0003120838 0.0098939054
+54.5803947449 225.6051483154 0.0043268376 -0.0004503292 0.0067324238
+585.1915893555 322.9950866699 0.0006771511 0.0001759651 0.0030919376
+723.6386718750 225.6242675781 0.0061192606 -0.0000984754 0.0134568019
+425.3148193359 225.2044372559 0.0011870860 0.0000995127 0.0036439707
+350.6401977539 289.4807128906 0.0049790610 -0.0009977603 0.0157160014
+119.1993865967 218.9689331055 0.0009627120 -0.0000416821 0.0044250395
+645.5308837891 202.3763122559 0.0020388383 -0.0001299299 0.0059323544
+130.9583740234 139.3028106689 0.0012401732 -0.0003437318 0.0039350945
+75.5030975342 217.4496612549 0.0026609460 -0.0002783477 0.0114233522
+633.1483154297 354.9503784180 0.0008564927 -0.0001330519 0.0021152387
+65.6768951416 391.2908630371 0.0078645051 0.0012099133 0.0097658224
+532.6442260742 250.5852661133 0.0058237561 -0.0011720322 0.0063674012
+275.4804687500 222.4749298096 0.0018210253 -0.0005894301 0.0066753356
+510.3459777832 288.3594360352 0.0033775982 -0.0000929121 0.0086559430
+250.5703887939 379.3484497070 0.0074095172 -0.0006638853 0.0107155498
+464.5264282227 443.4017639160 0.0084015671 0.0004401607 0.0082404558
+179.5776214600 218.4779357910 0.0036069411 -0.0015739425 0.0203040689
+359.5144958496 248.5175170898 0.0052527892 0.0004184089 0.0153325386
+22.4135761261 372.3075256348 0.0097077060 0.0008510049 0.0108114835
+432.6224670410 436.5594787598 0.0048209853 -0.0000269836 0.0063697919
+313.6183471680 387.3027648926 0.0084868120 -0.0002194745 0.0093427012
+587.5298461914 204.5231628418 0.0021859233 0.0006595416 0.0067262566
+589.4487915039 385.6735534668 0.0075049326 -0.0004516435 0.0141716292
+673.6258544922 355.3998413086 0.0077689965 0.0007433360 0.0102056973
+579.5109252930 293.4460144043 0.0036494837 -0.0003452682 0.0079766624
+147.7492065430 446.3955078125 0.0076561556 -0.0002336046 0.0103876693
+274.8621520996 314.9187927246 0.0010666936 -0.0001269057 0.0042404900
+302.8561096191 293.1547241211 0.0009618987 0.0001047244 0.0046979850
+248.5764312744 209.6323547363 0.0053539625 0.0002157242 0.0134356199
+306.4962768555 430.4622802734 0.0050840769 -0.0005348527 0.0057113948
+196.5290069580 254.6310577393 0.0034671761 -0.0005424363 0.0095853489
+341.0409545898 333.1348571777 0.0016964170 -0.0001208350 0.0028995934
+649.0902099609 309.0746154785 0.0012938944 -0.0002561428 0.0042984919
+645.0616455078 242.7693481445 0.0011282244 -0.0002288797 0.0041085626
+504.4643859863 414.4665832520 0.0072459495 -0.0006312766 0.0108321896
+272.6083374023 248.5006713867 0.0053989240 -0.0008460598 0.0136777898
+536.9801025391 264.7908325195 0.0017183699 0.0001099451 0.0032607603
+156.9797668457 250.8943176270 0.0006394173 -0.0000650274 0.0012488770
+101.1134948730 232.7234954834 0.0006797295 -0.0001600921 0.0031585605
+206.9106750488 330.9242248535 0.0019634592 -0.0000741963 0.0026116925
+755.4984130859 431.5989685059 0.0050873063 0.0000585839 0.0062229517
+291.4301147461 303.3483886719 0.0028883538 -0.0003078502 0.0111158472
+562.5477294922 378.6391906738 0.0048870845 -0.0015152062 0.0070090112
+585.5093994141 350.5807189941 0.0045368597 -0.0006220238 0.0158674512
+135.0746765137 125.3089218140 0.0014010277 -0.0004764416 0.0037325243
+621.1934814453 223.3440093994 0.0009204914 -0.0000739958 0.0020600795
+247.6124725342 447.6299133301 0.0079283603 -0.0015451740 0.0096214702
+752.9042358398 404.6407775879 0.0016902548 -0.0003065295 0.0027348809
+541.4105834961 201.0377807617 0.0009389118 -0.0000682711 0.0049418849
+228.4103698730 218.3964385986 0.0055821948 0.0001286366 0.0124430256
+461.3186950684 353.8372802734 0.0001513335 0.0000007371 0.0002657115
+34.5857048035 365.6312561035 0.0086560296 0.0019209364 0.0107994182
+271.5682373047 410.4071960449 0.0070177633 -0.0007365978 0.0118389847
+518.4915161133 249.4564819336 0.0032138606 -0.0001223313 0.0046011764
+483.5809326172 431.6560668945 0.0053214044 -0.0000174840 0.0056319362
+247.4873962402 419.5075073242 0.0058650603 0.0000919150 0.0119486917
+277.5957031250 412.4779052734 0.0079919389 -0.0000826584 0.0091847200
+454.5698242188 226.3679504395 0.0066438210 0.0005025640 0.0116144847
+479.3222045898 346.5999450684 0.0069370186 0.0015165965 0.0122047216
+399.5064392090 351.5080566406 0.0026431440 -0.0002082477 0.0043615131
+602.9130249023 276.6798706055 0.0010530658 -0.0000841020 0.0018282413
+338.9041442871 403.1988830566 0.0007404717 -0.0000901799 0.0011295617
+591.0379028320 400.4383544922 0.0016435188 0.0000756810 0.0029480055
+499.6093750000 399.3707885742 0.0050240709 -0.0005418813 0.0062050475
+305.6624755859 202.4723510742 0.0085874535 0.0000383999 0.0093185352
+442.4729309082 247.5471801758 0.0031592415 0.0001038838 0.0103002675
+148.6924591064 381.5469665527 0.0081946366 -0.0001532997 0.0087417969
+37.5946960449 420.5220336914 0.0062630391 0.0007452148 0.0052059349
+632.5078125000 391.5587158203 0.0046515851 -0.0006405564 0.0064180382
+115.2685165405 219.5556335449 0.0031507974 -0.0002019022 0.0105470363
+466.3277282715 309.3739013672 0.0087141730 -0.0006344644 0.0077479393
+135.4664459229 216.5422515869 0.0036117709 0.0004884265 0.0087316446
+357.5119934082 357.3875122070 0.0037368131 0.0009693587 0.0185808223
+586.1782226562 201.6367492676 0.0053171571 0.0007861694 0.0136262299
+537.4816894531 424.4388427734 0.0076710898 0.0001345727 0.0093107102
+482.5656738281 210.7928924561 0.0008464304 -0.0001187090 0.0075575700
+80.3981246948 217.4667205811 0.0025526371 -0.0005750174 0.0120718637
+346.7809448242 353.1295776367 0.0008791726 -0.0000868147 0.0020137844
+455.5166625977 277.4295349121 0.0061782654 -0.0008036675 0.0108320890
+336.4475402832 341.6410522461 0.0076390142 0.0002506333 0.0097122639
+28.5600090027 261.3142395020 0.0083686113 0.0004050806 0.0084090186
+240.4344329834 271.4346008301 0.0039301384 0.0001748051 0.0079516210
+125.3119506836 267.1277160645 0.0015991331 -0.0002509311 0.0029795754
+390.6024169922 254.6080780029 0.0049496945 0.0005682450 0.0147211971
+718.4420776367 209.4326477051 0.0040416527 -0.0002161817 0.0074246801
+416.4739990234 389.7497558594 0.0091410810 -0.0004043356 0.0086807162
+68.4282150269 349.2770996094 0.0041084662 0.0000877594 0.0075008408
+209.5553131104 256.4114074707 0.0036828851 -0.0002992269 0.0078085852
+462.5169677734 200.3825683594 0.0015729996 -0.0000619491 0.0073822304
+713.0623779297 206.8060913086 0.0013247133 0.0000432290 0.0033885005
+589.4796752930 372.4120788574 0.0040301606 -0.0007529072 0.0075977221
+624.9829101562 332.6088867188 0.0004633651 -0.0000376670 0.0017041940
+489.1605224609 386.9437866211 0.0019060813 -0.0002073367 0.0022968689
+598.4970703125 266.5555419922 0.0044496902 -0.0000944293 0.0069062607
+107.3792114258 437.1093750000 0.0023047447 0.0001287925 0.0020908965
+106.3944473267 251.2711486816 0.0052114003 -0.0000558591 0.0147362724
+289.2320251465 291.0543823242 0.0011804615 -0.0000215343 0.0047053113
+624.5355224609 308.5456542969 0.0028704996 -0.0005115942 0.0052727796
+485.3876953125 224.5852203369 0.0046329340 -0.0017116456 0.0182273891
+277.0004882812 222.4077148438 0.0013503412 -0.0004488261 0.0044308575
+292.4898681641 235.5247497559 0.0060704267 -0.0013400117 0.0132523840
+698.6549072266 260.3516540527 0.0038463462 -0.0003483449 0.0081456769
+73.5117568970 317.4116821289 0.0082496610 0.0015113892 0.0099706165
+593.1281127930 293.6241455078 0.0011033592 -0.0000324713 0.0019267645
+212.4950408936 451.5619812012 0.0081015108 0.0000462305 0.0089268126
+699.5821533203 237.6555938721 0.0039651063 -0.0007152431 0.0069310237
+60.4799041748 351.6730346680 0.0077032363 0.0024749015 0.0108640483
+238.4626922607 232.5250549316 0.0044016587 0.0001784296 0.0076786755
+336.4036254883 242.6392211914 0.0046081454 -0.0000671845 0.0160459504
+639.2781372070 375.3697814941 0.0063033774 -0.0003688688 0.0129337069
+282.2509765625 388.5661926270 0.0079575917 0.0004605493 0.0112860529
+223.5489654541 241.4945526123 0.0024329547 -0.0002249543 0.0047103073
+265.6096191406 330.3681640625 0.0053360909 -0.0002726556 0.0140699986
+159.0238494873 322.9742431641 0.0004896442 -0.0001692413 0.0015603059
+501.4088134766 193.5772857666 0.0027944637 0.0002152448 0.0104427366
+540.4736328125 289.5736694336 0.0059002871 -0.0031489246 0.0155736580
+34.4917030334 392.4288330078 0.0082351081 0.0008183285 0.0096193198
+96.5785446167 449.5209960938 0.0066514076 0.0007999658 0.0112311933
+725.4838867188 423.5075988770 0.0096070394 -0.0000748271 0.0096934140
+768.6039428711 410.6035766602 0.0040301508 -0.0003769889 0.0074539888
+593.5360717773 367.4389953613 0.0041211522 -0.0012585702 0.0075599640
+31.5251655579 226.4279937744 0.0084590493 -0.0002723297 0.0090303719
+24.3790130615 436.2866516113 0.0086479932 -0.0000461726 0.0091068791
+31.5267620087 249.4913635254 0.0031687745 -0.0001103770 0.0034658089
+44.4289360046 354.5486755371 0.0058360305 0.0017950938 0.0065128328
+356.7601928711 260.9022521973 0.0017048721 -0.0000519177 0.0027678076
+160.3455200195 323.4450378418 0.0046921642 -0.0001194669 0.0065038013
+593.5966796875 312.3158874512 0.0037185366 0.0002220765 0.0079834061
+303.5035400391 386.4157714844 0.0028744247 -0.0005140044 0.0040260204
+646.5667114258 289.4519348145 0.0063274736 -0.0011006895 0.0151737118
+368.5337829590 219.5334472656 0.0063238791 0.0003991591 0.0112198191
+303.2473449707 387.2133178711 0.0017717984 -0.0001978966 0.0025828090
+730.4338989258 337.4716796875 0.0052942480 -0.0007786449 0.0155917760
+135.3439178467 403.5524291992 0.0044725370 0.0000477226 0.0066552013
+649.6958007812 312.3841857910 0.0035137699 -0.0010121930 0.0239873137
+584.8859863281 203.0592193604 0.0005927279 0.0001511533 0.0027673934
+163.6204833984 325.6282958984 0.0043987324 -0.0000408337 0.0066949138
+327.0021972656 243.0612640381 0.0009438726 -0.0000337692 0.0020982388
+28.5600624084 287.3539428711 0.0039900513 -0.0000048594 0.0078550894
+377.6101989746 284.2918090820 0.0045434576 0.0008186644 0.0170624536
+60.6890602112 442.7726440430 0.0075667962 0.0010310235 0.0125635369
+451.5022277832 282.6511230469 0.0046562469 -0.0001854819 0.0077562341
+674.6190795898 195.5888519287 0.0084162224 0.0005284057 0.0081586968
+660.3358154297 360.5117187500 0.0066984403 0.0006033209 0.0104325274
+188.3939514160 240.4578704834 0.0034110066 -0.0004475650 0.0089352457
+405.1007690430 359.0016784668 0.0019437665 0.0000360314 0.0029037315
+215.4761505127 270.5903930664 0.0028409113 -0.0001223150 0.0098632984
+445.6083679199 245.5960693359 0.0024655345 -0.0000235099 0.0111583788
+610.5145874023 409.6449890137 0.0073808231 -0.0009265802 0.0110893371
+710.4928588867 217.2981262207 0.0098160934 0.0007999972 0.0108870268
diff --git a/examples/feature_detection/img/prague.png b/examples/feature_detection/img/prague.png
new file mode 100644
index 0000000000000000000000000000000000000000..d7145c3d436cb1842459cf55db663758c9e88c73
--- /dev/null
+++ b/examples/feature_detection/img/prague.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6ec6c1ba02df41d23ae4761ed875969c80e154dcd303e69640ba9f6de4fff7ba
+size 608585
diff --git a/examples/feature_detection/img/siemens.png b/examples/feature_detection/img/siemens.png
new file mode 100644
index 0000000000000000000000000000000000000000..4138560b0bf0278d2de60fbc5b7edc2eee6fc4a7
--- /dev/null
+++ b/examples/feature_detection/img/siemens.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ae516c12258a3505fd3081850dd49d20628ff1284925f39946b58ce66501819d
+size 1152762
diff --git a/examples/feature_detection/local-feature-adversarial-attack.ipynb b/examples/feature_detection/local-feature-adversarial-attack.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..38d45b68eb90f04fef3aad98c09243558a243250
--- /dev/null
+++ b/examples/feature_detection/local-feature-adversarial-attack.ipynb
@@ -0,0 +1,589 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We will show how to use differentiability of kornia local features module\n",
+ "by performing an adversarial attack on image matching process. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 1,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "#First load libraries and images\n",
+ "%matplotlib inline\n",
+ "import matplotlib.pyplot as plt\n",
+ "import torch\n",
+ "import torch.nn as nn\n",
+ "import torch.nn.functional as F\n",
+ "from PIL import Image\n",
+ "import numpy as np\n",
+ "import kornia\n",
+ "import cv2\n",
+ "from kornia.feature import *\n",
+ "from time import time\n",
+ "import torch.optim as optim\n",
+ "from torch.nn import Parameter\n",
+ "from kornia.color import rgb_to_grayscale\n",
+ "\n",
+ "img1 = Image.open('img/graffiti.png')\n",
+ "img2 = Image.open('img/kpi_winter.png').resize(img1.size)\n",
+ "\n",
+ "timg = kornia.utils.image_to_tensor(np.array(img1)).float() / 255.\n",
+ "timg2 = kornia.utils.image_to_tensor(np.array(img2)).float() / 255.\n",
+ "\n",
+ "timg = torch.cat([timg,timg2],dim=0)\n",
+ "\n",
+ "plt.imshow(kornia.utils.tensor_to_image(timg[0]))\n",
+ "plt.figure()\n",
+ "plt.imshow(kornia.utils.tensor_to_image(timg[1]))\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#Lets define some functions for local feature matching\n",
+ "\n",
+ "def distance_matrix(anchor, positive):\n",
+ " \"\"\"Given batch of descriptors calculate distance matrix\"\"\"\n",
+ " #https://github.com/DagnyT/hardnet/blob/master/code/Losses.py#L5\n",
+ " d1_sq = torch.sum(anchor * anchor, dim=1).unsqueeze(-1)\n",
+ " d2_sq = torch.sum(positive * positive, dim=1).unsqueeze(-1)\n",
+ "\n",
+ " eps = 1e-6\n",
+ " return torch.sqrt(torch.abs((d1_sq.repeat(1, positive.size(0)) + torch.t(d2_sq.repeat(1, anchor.size(0)))\n",
+ " - 2.0 * torch.bmm(anchor.unsqueeze(0), torch.t(positive).unsqueeze(0)).squeeze(0)))+eps)\n",
+ "\n",
+ "\n",
+ "def match_snn(desc1, desc2, th = 0.8):\n",
+ " #Lowe distance ratio criterion\n",
+ " \n",
+ " dm = distance_matrix(desc1,\n",
+ " desc2)\n",
+ " vals, idxs_in_2 = torch.topk(dm, 2 ,dim=1, largest=False)\n",
+ " snn_ratio = vals[:,0] / vals[:,1]\n",
+ " mask = snn_ratio <= th\n",
+ " idxs_in1 = torch.arange(0, idxs_in_2.size(0))[mask]\n",
+ " idxs_in_2 = idxs_in_2[:,0][mask]\n",
+ " matches_idxs = torch.cat([idxs_in1.view(-1,1), idxs_in_2.cpu().view(-1,1)],dim=1)\n",
+ " return matches_idxs, snn_ratio, vals[:,0]\n",
+ "\n",
+ "def match_xyscale(xy1, xy2, s1, s2):\n",
+ " dm = distance_matrix(xy1/(s1+1e-8), xy2/(s2+1e-8))\n",
+ " vals, idxs_in_2 = torch.min(dm,dim=1)\n",
+ " idxs_in1 = torch.arange(0, idxs_in_2.size(0))\n",
+ " matches_idxs = torch.cat([idxs_in1.view(-1,1), idxs_in_2.cpu().view(-1,1)],dim=1)\n",
+ " return vals, matches_idxs\n",
+ "\n",
+ "def match_nn(d1, d2):\n",
+ " dm = distance_matrix(d1, d2)\n",
+ " vals, idxs_in_2 = torch.min(dm,dim=1)\n",
+ " idxs_in1 = torch.arange(0, idxs_in_2.size(0))\n",
+ " matches_idxs = torch.cat([idxs_in1.view(-1,1), idxs_in_2.cpu().view(-1,1)],dim=1)\n",
+ " return vals, matches_idxs\n",
+ "\n",
+ "def visualize_LAF(img, LAF, img_idx = 0):\n",
+ " x, y = kornia.feature.laf.get_laf_pts_to_draw(LAF, img_idx)\n",
+ " plt.figure()\n",
+ " plt.imshow(kornia.utils.tensor_to_image(img[img_idx]))\n",
+ " plt.plot(x, y, 'r')\n",
+ " plt.show()\n",
+ " return"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#Now lets define local deature detector and descriptor\n",
+ "\n",
+ "device = torch.device('cuda:0')\n",
+ "sift = kornia.feature.SIFTDescriptor(32).to(device)\n",
+ "descriptor = sift\n",
+ "\n",
+ "resp = BlobHessian()\n",
+ "scale_pyr = kornia.geometry.ScalePyramid(3, 1.6, 15)\n",
+ "nms = kornia.geometry.ConvSoftArgmax3d(kernel_size=(3,3,3), # nms windows size (scale, height, width)\n",
+ " stride=(1,2,2), # stride (scale, height, width)\n",
+ " padding=(0, 1, 1)) # nms windows size (scale, height, width)\n",
+ "\n",
+ "n_features = 2500\n",
+ "detector = ScaleSpaceDetector(n_features,\n",
+ " resp_module=resp,\n",
+ " nms_module=nms,\n",
+ " scale_pyr_module=scale_pyr,\n",
+ " mr_size=4.0).to(device)\n",
+ "\n",
+ "timg_gray = rgb_to_grayscale(timg).to(device)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Let's detect and visualize features"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "scrolled": false
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/home.dokt/mishkdmy/.conda/envs/fastai1/lib/python3.7/site-packages/torch/nn/functional.py:2693: UserWarning: Default grid_sample and affine_grid behavior will be changed to align_corners=False from 1.4.0. See the documentation of grid_sample for details.\n",
+ " warnings.warn(\"Default grid_sample and affine_grid behavior will be changed \"\n",
+ "/home.dokt/mishkdmy/.conda/envs/fastai1/lib/python3.7/site-packages/torch/nn/functional.py:2751: UserWarning: Default grid_sample and affine_grid behavior will be changed to align_corners=False from 1.4.0. See the documentation of grid_sample for details.\n",
+ " warnings.warn(\"Default grid_sample and affine_grid behavior will be changed \"\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "lafs, resps = detector(timg_gray)\n",
+ "patches = kornia.feature.extract_patches_from_pyramid(timg_gray, lafs)\n",
+ "B, N, CH, H, W = patches.size()\n",
+ "# Descriptor accepts standard tensor [B, CH, H, W], while patches are [B, N, CH, H, W] shape\n",
+ "# So we need to reshape a bit :) \n",
+ "descs = descriptor(patches.view(B * N, CH, H, W)).view(B, N, -1)\n",
+ "\n",
+ "for i in range(2):\n",
+ " visualize_LAF(timg, lafs, i)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "#Now visualize matches\n",
+ "matches, scores, dists = match_snn(descs[0], descs[1])\n",
+ "torch.cat([scores.mean().view(1,1), 1-scores.mean().view(1,1)],dim=1).repeat(2,1)\n",
+ "\n",
+ "for i in range(2):\n",
+ " visualize_LAF(kornia.color.rgb_to_grayscale(timg), lafs[:,matches[:,i]], i)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "scrolled": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Opt iteration: 0/110\txyLoss: 3.202\t DescLoss: 0.9046\n",
+ "num desc matches 4 num same locations detections 143.0\n",
+ "Opt iteration: 10/110\txyLoss: 3.184\t DescLoss: 0.6725\n",
+ "num desc matches 3 num same locations detections 148.0\n",
+ "Opt iteration: 20/110\txyLoss: 3.129\t DescLoss: 0.5323\n",
+ "num desc matches 8 num same locations detections 138.0\n",
+ "Opt iteration: 30/110\txyLoss: 3.185\t DescLoss: 0.4797\n",
+ "num desc matches 15 num same locations detections 137.0\n",
+ "Opt iteration: 40/110\txyLoss: 3.083\t DescLoss: 0.403\n",
+ "num desc matches 28 num same locations detections 134.0\n",
+ "Opt iteration: 50/110\txyLoss: 3.083\t DescLoss: 0.391\n",
+ "num desc matches 36 num same locations detections 155.0\n",
+ "Opt iteration: 60/110\txyLoss: 3.184\t DescLoss: 0.3503\n",
+ "num desc matches 52 num same locations detections 161.0\n",
+ "Opt iteration: 70/110\txyLoss: 3.071\t DescLoss: 0.3321\n",
+ "num desc matches 60 num same locations detections 161.0\n",
+ "Opt iteration: 80/110\txyLoss: 3.108\t DescLoss: 0.2958\n",
+ "num desc matches 76 num same locations detections 147.0\n",
+ "Opt iteration: 90/110\txyLoss: 3.073\t DescLoss: 0.2872\n",
+ "num desc matches 75 num same locations detections 152.0\n",
+ "Opt iteration: 100/110\txyLoss: 3.087\t DescLoss: 0.2764\n",
+ "num desc matches 85 num same locations detections 139.0\n",
+ "Opt iteration: 109/110\txyLoss: 2.95\t DescLoss: 0.2284\n",
+ "num desc matches 91 num same locations detections 128.0\n"
+ ]
+ }
+ ],
+ "source": [
+ "device = torch.device('cuda:0')\n",
+ "timgp = Parameter(timg.clone().to(device))\n",
+ "optimizer = optim.Adam([timgp], lr=3e-3)\n",
+ "\n",
+ "num_iterations = 110\n",
+ "\n",
+ "log_interval = 10\n",
+ "\n",
+ "for iter_idx in range(num_iterations):\n",
+ " # We want image to have valid pixel values at any time\n",
+ " timg_gray = rgb_to_grayscale((255*timgp).clamp(0,255)/255.).to(device)\n",
+ " \n",
+ " # Detect\n",
+ " lafs, resps = detector(timg_gray)\n",
+ " \n",
+ " # Describe\n",
+ " patches = kornia.feature.extract_patches_from_pyramid(timg_gray, lafs)\n",
+ " B, N, CH, H, W = patches.size()\n",
+ " descs = descriptor(patches.view(B * N, CH, H, W)).view(B, N, -1)\n",
+ " B,N,_,_ = lafs.size()\n",
+ "\n",
+ " # Location loss\n",
+ " xy = lafs[:,:,:2,2]\n",
+ " scale = kornia.feature.get_laf_scale(lafs)\n",
+ " xy_diff, closest_lafs_idxs = match_nn(xy[0].view(N,-1), \n",
+ " xy[1].view(N,-1))\n",
+ " mask_det = (xy_diff < 5.0) * (xy_diff > 0.5)\n",
+ " det_xy_loss = (xy[0, closest_lafs_idxs[:,0][mask_det]] - xy[1, closest_lafs_idxs[:,1][mask_det]]).pow(2).sum(dim=1).abs().sqrt().mean()\n",
+ " det_scale_loss = (scale[0, closest_lafs_idxs[:,0][mask_det]] - scale[1, closest_lafs_idxs[:,1][mask_det]]).pow(2).sum(dim=1).sum(dim=1).sqrt().mean()\n",
+ " \n",
+ " # Descriptor loss\n",
+ " mask = mask_det\n",
+ " dm = distance_matrix(descs[0],\n",
+ " descs[1])\n",
+ " pos_dist = dm[closest_lafs_idxs[:,0],\n",
+ " closest_lafs_idxs[:,1]].clone()\n",
+ " dm2 = dm.clone();\n",
+ " dm2[closest_lafs_idxs[:,0][mask],closest_lafs_idxs[:,1][mask]] = 100\n",
+ " min_neg = torch.min(dm2,1)[0]\n",
+ " descriptor_loss = pos_dist[mask].mean()#(descs[0, closest_lafs_idxs[:,0]]- descs[1, closest_lafs_idxs[:,1]]).pow(2).sum(dim=1).sqrt()[mask].mean()\n",
+ " descriptor_loss2 = (1.0 + pos_dist[mask] - (min_neg[mask].detach()+1e-8)).clamp(min=0,max=2.0).mean()\n",
+ " detector_loss = det_xy_loss#+0.1*det_scale_loss\n",
+ " \n",
+ " # We want also not to deviate far from original images\n",
+ " reg_loss = F.mse_loss(timgp, timg.clone().to(device))\n",
+ " loss = 1.0*detector_loss + 0.1*reg_loss + 1.0*descriptor_loss2# + 0.2 * det_scale_loss\n",
+ " \n",
+ " # compute gradient and update optimizer parameters\n",
+ " optimizer.zero_grad()\n",
+ " loss.backward()\n",
+ " optimizer.step()\n",
+ " if iter_idx % log_interval == 0 or iter_idx == num_iterations-1:\n",
+ " print('Opt iteration: {}/{}\\txyLoss: {:.4}\\t DescLoss: {:.4}'.format(\n",
+ " iter_idx, num_iterations, det_xy_loss.item(),descriptor_loss.item()))\n",
+ " with torch.no_grad():\n",
+ " matches, scores, dists = match_snn(descs[0], descs[1])\n",
+ " print ('num desc matches', len(matches), 'num same locations detections', mask.float().sum().item())"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# Now visialize all matches, which survive SNN=0.8 Lowe criterion\n",
+ "timg_at = timgp.detach().clone()\n",
+ "timg_at_valid = (timg_at * 255.).clamp(0,255).floor()\n",
+ "timg_at_valid_gray = kornia.color.rgb_to_grayscale(timg_at_valid)\n",
+ "i1 = Image.fromarray(kornia.utils.tensor_to_image(timg_at_valid[1]).astype(np.uint8))\n",
+ "i1.save('kpi_at.png')\n",
+ "#plt.imshow(i1)\n",
+ "#plt.figure()\n",
+ "i2 = Image.fromarray(kornia.utils.tensor_to_image(timg_at_valid[0]).astype(np.uint8))\n",
+ "i2.save('graf_at.png')\n",
+ "#plt.imshow(i2)\n",
+ "\n",
+ "lafs, resps = detector(timg_at_valid_gray.to(device)/255.) \n",
+ "# Describe\n",
+ "patches = kornia.feature.extract_patches_from_pyramid(timg_at_valid_gray, lafs)\n",
+ "\n",
+ "B, N, CH, H, W = patches.size()\n",
+ "descs = descriptor(patches.view(B * N, CH, H, W)).view(B, N, -1)\n",
+ " \n",
+ "matches, scores, dists = match_snn(descs[0], descs[1])\n",
+ "\n",
+ "for i in range(2):\n",
+ " visualize_LAF(timg_at_valid_gray, lafs[:,matches[:,i]], i)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# Now check if matches survive RANSAC\n",
+ "src_pts = lafs[0,matches[:,0], :, 2].data.cpu().numpy()\n",
+ "dst_pts = lafs[1,matches[:,1], :, 2].data.cpu().numpy()\n",
+ "\n",
+ "H, mask = cv2.findHomography(dst_pts, src_pts, cv2.RANSAC, 4.0, 0.99, 100000)\n",
+ "\n",
+ "inliers = matches[torch.from_numpy(mask).bool().squeeze(), :]\n",
+ "\n",
+ "for i in range(2):\n",
+ " visualize_LAF(timg_at_valid_gray, lafs[:,inliers[:,i]], i)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import seaborn as sns\n",
+ "\n",
+ "color = 'g'\n",
+ "for img_idx in range(2):\n",
+ " LAF = lafs[:,matches[:,img_idx]]\n",
+ " pts = kornia.feature.laf.laf_to_boundary_points(LAF[img_idx:img_idx + 1])[0]\n",
+ " pts_np = pts.detach().permute(1, 0, 2).cpu().numpy()\n",
+ " fig, ax = plt.subplots(1,1,figsize=(12,12))\n",
+ " fig.subplots_adjust(hspace = 0, wspace = 0)\n",
+ " ax.imshow(kornia.utils.tensor_to_image(timg_at[img_idx].mean(dim=0)),cmap='gray')\n",
+ " ax.plot(pts_np[:, :, 0], pts_np[:, :, 1], color, linewidth=5)\n",
+ " ax.grid('off')\n",
+ " ax.xaxis.set_major_locator(plt.NullLocator())\n",
+ " ax.yaxis.set_major_locator(plt.NullLocator())\n",
+ " plt.show()\n",
+ " fig.savefig(str(img_idx)+'.pdf', bbox_inches = 'tight', pad_inches = 0)\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import seaborn as sns\n",
+ "\n",
+ "color = 'g'\n",
+ "for img_idx in range(2):\n",
+ " LAF = lafs[:,inliers[:,img_idx]]\n",
+ " pts = kornia.feature.laf.laf_to_boundary_points(LAF[img_idx:img_idx + 1])[0]\n",
+ " pts_np = pts.detach().permute(1, 0, 2).cpu().numpy()\n",
+ " fig, ax = plt.subplots(1,1,figsize=(12,12))\n",
+ " fig.subplots_adjust(hspace = 0, wspace = 0)\n",
+ " ax.imshow(kornia.utils.tensor_to_image(timg_at[img_idx].mean(dim=0)),cmap='gray')\n",
+ " ax.plot(pts_np[:, :, 0], pts_np[:, :, 1], color, linewidth=5)\n",
+ " ax.grid('off')\n",
+ " ax.xaxis.set_major_locator(plt.NullLocator())\n",
+ " ax.yaxis.set_major_locator(plt.NullLocator())\n",
+ " plt.show()\n",
+ " fig.savefig(str(img_idx)+'_inl.pdf', bbox_inches = 'tight', pad_inches = 0)\n",
+ "\n"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.4"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/feature_detection/local_feature_detection_example.ipynb b/examples/feature_detection/local_feature_detection_example.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..04f0c7f3af210431ca42535ac0d04453c3f58b10
--- /dev/null
+++ b/examples/feature_detection/local_feature_detection_example.ipynb
@@ -0,0 +1,372 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 1,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "%matplotlib inline\n",
+ "import warnings\n",
+ "warnings.filterwarnings('ignore')\n",
+ "import kornia\n",
+ "import torch\n",
+ "from PIL import Image\n",
+ "import matplotlib.pyplot as plt\n",
+ "import numpy as np\n",
+ "from kornia.feature import *\n",
+ "from kornia.geometry import *\n",
+ "\n",
+ "def visualize_LAF(img, LAF, img_idx = 0):\n",
+ " x, y = kornia.feature.laf.get_laf_pts_to_draw(LAF, img_idx)\n",
+ " plt.figure()\n",
+ " plt.imshow(kornia.utils.tensor_to_image(img[img_idx]))\n",
+ " plt.plot(x, y, 'r')\n",
+ " plt.show()\n",
+ " return\n",
+ "\n",
+ "img = Image.open('img/siemens.png')\n",
+ "# Image with synthetic pattern from SFOP paper: \n",
+ "# http://www.ipb.uni-bonn.de/data-software/sfop-keypoint-detector/\n",
+ "\n",
+ "timg = kornia.utils.image_to_tensor(np.array(img), keepdim=False).float() / 255. / 255. \n",
+ "#Yes, it is not a typo. \n",
+ "#This specific image somehow has [0, 255**2] range\n",
+ "\n",
+ "plt.imshow(kornia.utils.tensor_to_image(timg[0]))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Kornia has a module ScaleSpaceDetector for local feature extraction.\n",
+ "It consists of several modules, each one is tunable and differentiable:\n",
+ "\n",
+ "1. Scale pyramid\n",
+ "2. Responce (aka \"cornerness\")\n",
+ "3. Soft non-maxima-suppression\n",
+ "4. Affine shape detector\n",
+ "5. Orientation detector\n",
+ "\n",
+ "The output is two tensors: with responces and with local affine frames (LAFs). You can feed LAFs to extract_patches function to then describe the corresponding patches"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "ScaleSpaceDetector(num_features=50, mr_size=6.0, scale_pyr=ScalePyramid(n_levels=3, init_sigma=1.6, min_size=10, border=4, sigma_step=1.2599210498948732double_image=False), resp=CornerHarris(k=tensor(0.0500), grads_mode=sobel), nms=ConvSoftArgmax3d(kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1), temperature=tensor(1.), normalized_coordinates=False, eps=1e-08, strict_maxima_bonus=0.0, output_value=True), ori=PassLAF(), aff=PassLAF())\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "#Lets detect Harris corners\n",
+ "n_feats = 50\n",
+ "mr_size = 6.0 \n",
+ "nms = kornia.geometry.ConvSoftArgmax3d(kernel_size=(3,3,3), # nms windows size (scale, height, width)\n",
+ " stride=(1,1,1), # stride (scale, height, width)\n",
+ " padding=(1, 1, 1)) # nms windows size (scale, height, width)\n",
+ "harris = kornia.feature.responses.CornerHarris(0.05)\n",
+ "\n",
+ "harris_local_detector = ScaleSpaceDetector(n_feats, \n",
+ " resp_module=harris,\n",
+ " nms_module=nms,\n",
+ " mr_size=mr_size)\n",
+ "print (harris_local_detector)\n",
+ "lafs, resps = harris_local_detector(timg)\n",
+ "visualize_LAF(timg,lafs)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "You can see that there are lots of paired detections. \n",
+ "That is because softargmax output (almost) same locations for nearby points.\n",
+ "To emulate classical non-maxima suppression, we could add \"bonus\" to responces, which are local maxima.\n",
+ "Thus, first detector would output all local maxima and only then the rest of points."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQ4AAAD8CAYAAACGnEoDAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOy9e5RkV133/dl7n3Pq1nXpqq7u6u7pmZ6ZzGRy6SQkJMHwgAgqAcNFREXfV1/1UfCCID4iitcl3lAE8cELiDyAPgIiCISbyEUQQiAkTpjMMJnOdHqmp3t6urq6q+t66pyz937+OKcOIC41LnjN+675rZWVdKWr6px99v5dvt/v79fCWstlu2yX7bI9EpP/1Rdw2S7bZfv/nl12HJftsl22R2yXHcdlu2yX7RHbZcdx2S7bZXvEdtlxXLbLdtkesV12HJftsl22R2zfEMchhLhdCPGgEOIhIcQvfCO+47Jdtsv2X2fi663jEEIo4AzwbcAF4B7g+6y1p76uX3TZLttl+y+zb0TGcQvwkLV2xVobAG8HnvUN+J7Ldtku23+ROd+Az5wH1r7i5wvArf/yl4QQzweeD5DNi5v2HcoghUVhGFqPgggIrMIgsAhcEQEgsVgEFgisgycirBVoJHkR4lsHsEhhsVZgEChhCK2DBVyhk3eDg2VkFVJYjBUAKGEIrIPEIjEIQIj4O7FgEURIsiJEYQmRaCuJUOREgABG1kFiMEg8ERFZiRSWyCpcoTE2vieDiH9GILFoK9AoFAYlDA6GEBnfrwUhSH5PMs4TTXKVLhopTHx9VuEInX4mCByh8a1LXoQMrJuumxDx5wEIQApDZFX8qQKMFeRERM96uGgiFK6I0utQwiABC4RWIpI11EgE8bqGOCgMGRFhIb3fMFmPyCqEsOn6ukIzSp7tyLqMd8H4fUJYRsYlK8P485J1y4gw/SyFIbQKg0QSr4tK7m18/aFV6CR2el/xmiviV4fWTb83I6JkXxiksMmuBA+Dj2L8REbWYUIE6GSfeGhCJCZZ4/He0cj0OXloBtbDFVH6mkUg0mct0v1gktcHJkNBjgisAkjWm2QN4v0GpM8ysC5T2Ssf8WG+9957t6219X/5+jfCcYh/5bWvqYestW8A3gBwdClnP/TBCitRmX6yIIVk8QEUlrIcsRJV6eoci+42vnXpmCzTqotGUJU+K1GV2zI7/P1gnrwcYZKHFFjFfmeXjs0AcHo0x1Fvk6oasBpWAaipHhU5QiNYiyrMqz00AlcYfKsoihBPGFajMq7QdE2WQ84OnjCcDqc45OxwIpilIgcAeELTMVmyIkzvOURRV102ozK+ddnv7JBNHOLZsE5F9Qmtk75vYDIc8zbZ1CWqqoexki1dxCA55G6zGRXxhCYrQrZ0ESUMRemzoyeoql76GS09QVYGzKs98jL+vtNBnWnV5Ww4zaLbpGtySAye0ABkRUhV+YRW0tQF2iZPRQ4oSp+qDDgXlfCtS0UOaJs8h9wddOKo+9ZhYDL0rceC06ZtshgrmXO6LIc1XDQhikPODnVlORUW2NETLHmbNHWOrIjo2Ay+cfGty6K7g4vhRDCLJzSuiFDJlppz9jgdzLDobuNhaJscM6rHWlRm0W2zHNZQWDSCmuzTMVmUMLT0BCXpc8qf58bcKn3rUZQ+x9w+TS1pmRxdk6UgAlwR0TU5inKIb10WnA6+VYRW0jVZIHa4FemzGlapqR6bUYW60wHA2Hgf+talrvpILCeCWWqqx4LTYS0q0YxKFNWQuurGzsjGR9O3LgAagcIy53Q5HdSpqR6hdShKn01dQmG53mtxz2iaw26LrNAcH82l1xxah+++4guP/DALce5fe/0b4TguAAtf8fM+YOPfeoNB0LUOXZOjofbY1GXqbp/NqEhFDVgLaxS9SyhsciDiza+loGOyhCjWo0lqqseOMRzyttiIJtFWUlRDuiZHx2bSzVvIrrIWVQmsouHspdHgxGiOY94m2srYYRiP0CraJo8vR5TEiIbq0TI5Fpw2K1GV9bDK4zMPsb2c59qT67iXNOWuz95ujmu7A/LdkH7bw8tGiDLsTOSZLvfIToZsFYuUrhyxdqxMpdjHFZqCCJAYsjIkK0LOhvEmgXjzNJw9skKzFlU44rZYDmtkRcgxr0lT59I1HDuSseNq6wIVOaBMyIbOx9EKxWF3i/NRlXlnl7oaMjDjDeuwGlbY0RNcnblIx2Q55HY4PpqmmRzeOWePU6NZ5txdusZNN7DEsBmVycr4u0tixNmoTlH6yfOWFETAcjjFjulRkT5tnefe0Tzzzi6rUXxPRTnEs5qNqExRDll0t8mK+Oe8HNE1WZq6gCc0p0bzFKVPLXEaBTniVDDDkrfJiaBBXXXoWy8+iBbmnV0AvrlwmpYu4KIZmAz3jLIccVsYK3HRtPQER7ytZP0lfZNhUxdSR5CXo3T/nA5mMFbiCc2iuw1AUYaEVrIWVXBFxKaewBWamzPrnAim2dFZmlGJihpwwNllOZzCty6e0GgrOew2AViNauTFiNBKrvG2WNcTuCJiLapSVT0UhjWdQQnDelQiK0MW3BanRvPckFlLM5Cvl30jHMc9wBEhxEFgHXge8P3/1huUMGxEZeqqQ4BiwdmhbbKUpM9y0GDRbaIRFOWQogySaBOxHk1Sdzqs+NNU1CApbyQKS1aELLhtVqNJbvS22dAea7pK0fi0TY4jbpN+4tU1IonKIVt6gooacDqYYSlzkabO4VuXQCtOR3NkRcCh5ha1L/Rx7tfcenKVyVMD3J5J78cKqBX7RGVFWJZkSiHWF8gtw75OG2fPIEeWOeKIdIhtBgdd/CWXrasn0EuCS48pM5PbA6BjsrRNPt1IG1EZbSW+VUkWELAWlSiIgL7J0NZ5Ft1ttnSROadLWxdYcFuc8BfwM5soLC09QWgdaqpHOzkIGsnAxFlZXo6oqAEDm2EzKlJTPVbCUvr/VoMp1sNJKmpAQ/XZ0Vnqqktb56moASEKhaVrPJq6xBFvixOjeYpySEH6SGE47LboW4emLgBQkQMKIsR1dplTIz46OMSC20rLwrbO0zU5sjKgm2RlXZMjK0KWMhfQCNo6jxKGrskRWIVGIDFphuJbl4IccXK0j8PeJQDaJs9ht8l6VOGGzBZt46RZWkXFAazhdFFYfOPSThzvorNHU+fQiHQtw6/YU12TpaULKGHSLEkjGJgMl9AoEe+ZQ4ljAnhctslyGAcAV0acDOaoqw4Lzg6r4RRnQzfNukIUeTFCYfCti07KZgSU8NmMyhSlT4AkNOo/eZz/dfu6Ow5rbSSEeCHw94AC3mStPflvvcdDk5cjNBKFIS8iWrqAJzVLmXXaJktoJa7QrIRTFOUQhaWi+jRUn6bTxRURZTliYB1cEVf+YZIirkR5XKFpqD0UltWgTiETAKTlUMPZw7cuxso4ynqb3OfvY87dxTcuiztNFu7c5YoPNSnfF0fOuYygf5VH+zvzdJYydK/JcHGuTDQhaZkiBRnQcNpUpU/T5BmYDFXVI7SKwFd0mnkOPrRN+YEhmRMR5Xt8jr1vi2NsEUwq1p9aYe8ZGZZvmsF1NFkZsqlLSRnRw9gYD+jbeKOjejScNg014N7RPABrURklDDt6gm/OLzOyirNhXKa0TR7fusy7Oyw4baoyYmD7bERFfONihMQVERU1iDMIEdJw9tiIJqk5scNRwnB8NMc13iZtk8Ekzmde7XEmnEYSHxrfKhbdJm2Tp6UnKMgRbZ1PD3LD2WNgMmzqEnXV5b7RNEXpszxqUFEDljIbSGHSw9Y3GYrKp6F6hFZyOmhwyNtKAkgUl5vOLithlUU3DkQVOSQrQjajCoe9S5wNZjjqbRJah1biPO8bNajIAXWnw46eSINQVmhOB3WWvC261mEzKtI1Li1TQFvJMa9J23ishlNpNhNah7wcAaQlzaKzy2o0iW9drna3OReVmFNx+bEjNE0z4oS/wM25ldjBi4nE8RiyMsA3HiXpM6N6hEg2ojIKy9lghmOZDXb0BBIDTuwkb8hscGI0S1EOv67n/OtOx/5n7MqlrP2d91yVpqenR3PcnFulazxcoWnqYvpwToxmOeZdom+ddJHGaf2OniAvR/jGjf+fMCy622kUPD2a5brMOpu6RF6O8IgBw771kvpxj42ozCF3h9WwwmR/gHq34cAHdpj6Qh9hoX1Vls4dWR7+5hrySoN2FAOTISvC5IC4abkwxkI0At+6uGgMEo2gIAKyIqQsRzRNPgXl1LahcW+HwgdC6h/r4g4M/pTDhdsn6X6Xy/CGGDsY26KzR9vEPzd1kbbOM+fGG9dD0zIFGqqDwrKlJ2jqEjdkLnA6mKEgR2kk7CQZHoArohQDCKyiIEd0wyxTD3fxThjCFYfJXp/J7gCtBb1iFluGZqOIXpK0juZ5cqXD+/oz6bUMTIa66rIaTpGVAdrKeC2spKZ6uCKiKAOausB6OMlhbwuNJLQqzRbaJh87L9VJHcVqOMV+Z4e2yaeYV3zQI1xhOD7aB0BRDuNMyCqK0sdYSYCiJoesRpMURMCWLnJDZoOVsEpejhiYTIJLdKhKnz2TIUDRNVm6Osecu5ticb51qcsBJ4JZQutw2N1KM8X9zg4zakjTZGjqIkXpE1qVXmdoFVIYiiKkIA2+FWxERaSIS76j7hZnwmlK0mfO2WNHx873hswGp8Mp+iYT41XBNEcym2npVFUx3qawtEyOJy0uP+KzKYS411r72K95/dHgOI4s5exr33uYohyyHk3ScOIUXWHS9LmuunEWInR6cLo6xyFvi+WgwTHvIhUZcDKYJrQON2Y2OBeV4qgVzFBRAypywCHX526/Tkn6VOSQtsmRlyPWwlq6gavdIepNmiv+VxNnz7J7RY5LdxRpPn2C7NGIvo2xj5ocUJQhq1GZmhywrstpur0a1eJMxd2mLEdc0hMEVjHvdFiLKmgE13vbfM6fo+50MFbStx412efu4WFuzq0w7LvMf3KP+Q/sUfy4j/Itnf+W4Z6fPMDeLXmOuE3aJpOukUzYmIII2NRl5pzdxJFlaagOXZNNgb6sCOlbj4bqEFrFlo7LkboaphnERrvIwU+0qL2/T/kzQ5zhl/fKqKgwZQEKZMfidjQyxlUxDrRumGD96WVyz4jYrWfxMLRMPs0QWiafPGObBIyAE6O5GOeRI4pyyGZUoaZ69K1HK5qg4ewxrXp0bOyoV8MpQutQV3HJV1EDFDbOKqMakrhkucbboJ8AhONn3k+Yu0oSiVtJKVhTfVbDKSqqH2e1ye/HpZygKAN2dD4F1gtyxHo4yaK3ne7ZuhrSNS4LTsgH+weBuLwryBGHnB2WwykqaoCHpqpiZ91O8LS1sEbd6aTOYGxzzpC1KE/b5NNs7ph3iYFx2dRlrnS3GFmV7ufQKioyxkQAAiSPO7D6iM/mo9pxXLmUta+/c4FmVKIgRym4dl1mHSksFRmxEpbY0sXUm2/pIgU5imtREaasibEyjZ7nwyo3ZC+wo/Pk5YimLlKRA84mziUrQ2qql7IDom2YflOPo2/Zwu0aVp9S5dRPzFK8aUhoHQKryMqQ5VGDhttGJ0BYvKF8SiJOSzNCsxxOccTd5kQQZ0jLwTQNp83p0RxPyj/EZpKmayvZiCZZcFv41k3xh7rq4AnN2WCaazLrnGnN8Ph3P8TC69tkWxGtW/Oce3GV1q15XGkYmAwdk2W/s0NHZ5he62HOCJy2IdMJEUMYFjxykyPCKcXoGofz5Sm0lSy628yogG3tciac5uj2JlN/0mff37SRIxg2HDrfnqV9XQ59ncI/5BA4ivuGi9yWP8uOzsd51Bocu6+J/ISm8oUh7obBAsOjLs2nFhhe7eFdYTh3YJKMG7EaTnHEu8RaVEVbSd3p4Cc0q4cmKyIyQtM0+ZSx8ITmeq9F20iWwylqqkdRBmwkTFVRDtFWphhLkFCyrohoRiWuzqzjYQgSZzujelzSEwkmkaOjszwud46NqJgyGX3rpfjNOOuJnVSMLcypLsvhVMq81FSPrsklwOpmEvj6lKVmQ8cYksKyqUssOG0Gxk2zC0/oNKsYYycdk2XJu0jT5CmIGN/Z0kWu8TZZj0pfw+CNKeisDJPMVrMaTfKMQyce8dl8VDuOo0s5+8fvO4BvXWqyT1mO6CaHyBWGpi5QV302kjrbFRENNeD4aI4Ft8WOnkhovwxtk+eYu03XuJRlyJqeiBFyEcW0obPDg+E0WRFSV12aukgYSG5603mm/6SL1zdsPrVI98VZ7rlikesz6ylKvxbWqKoeC84eK1E1ff+is4vEsmOyiU5D0k4ialaE6UOtqT6bupTet2+8VJ8yrbr0rZe+f0zTjT/DFTqOpJ0a173zAgt/tkumqWndkufkr89SnRpg3ieofmzA7Mk9VOfff67BrOLSDUW2bi8SfqtkfTTJja85z4F37IKxnP/OSVa+q457c0ifbPq+8VpcnblIFAj4Jzj64W3U5zWF1eDf/V6dFfSv9ug8KcvwGRnO7q9Rkn7KkC06u5wOZmg4bRSW08EsRelTUX0KIuB0MEtejlIwMi9HzKseTZ2jZWL2SCNjtsZkY72GlTScLhtRGVdEqXPxjUdF9anJAQExvtXSEzwue+6rnHssEQhxhaFlcgA0o1KMIQQNsiIkL0dxuSxGKYA5dixNk8dDp+xfRQ5ZjeL9NM4WG06XgXFZTcqPI5lNlkcNFtxWXDYSlzdjWr6iBrR1noazx0owTVX1KEmfe/1Fbs6tsKMnqMgBHZOla3J89xX3/scPZWKPasdx1XUZ+6fv209NDtnUE3RNLhUlAdSdOM2uyAGu0GnaO44GEINl8eGMI5Cf1MZNXUw1EOOa87DbTFH5zOmQoy/dovhAwOa3Fzn14gbVa4fp+7NCsx6V0vq/roYEVpIVhpWoTNfkWHRabCWsjLEywU/iqLYaTlGRA0rST/UJJTGib12yCZ3miojQOsw5uyyoEfcHX06zx7Te6WCWw+4WfeuxHk5yu1zl/Fsz3PiH51G9WDwlgL2jWYY3u7SvyXHxyjKl+pDNiTL53IhCP2C6N+D0uToLp3c5dKqNuivEa2q0l5QdI8vF55Xo/FSO9nw2xRh866alVtd4mC3B/BvaLLyrjdM2REVB57Ysu9fm6V/rsTeXQ00ahkWXiZZP6U0BR9+2hdCW0U0u4VBQOh47me41GTZ/bIJTt89R9GItzbiEiJmJGKze0MUkq/BTsLGhOrjCcJ+/Py1x83LEIadHaOGfhossets0VJ+VMKYuuyabMk1jzYuxEt+6X6NfGWevUnyZNavJIX3rUJEBA+PQNrnYGSVCL9+6nE9K34bTZi2sseC2WA3rNJw2WRGmJcfpoMGiu50yhAqTBrisMDRNJt3vsW5jSFZErEcVbss28a1lZOFu/wAFOeKI26SpCyw4HU4EMdB7Pqyy6G1/XTGObwQd+4gtsl+mAdfCGke8TZpJZB4/1LgeHaUUamgdNCaN+iXps+C0AZLon0cKw2owRSPXoY/CE5qa6tHSBWq2x+Lrd6n9YY+wqHjwz+qc/Nb5BGQVZEVIiIjRdhmmQpyuiVInoa2kIgds6lgMZYzkaq/FcvhlIVucPeyxZzL0E9amZfNpeXTEbXI2HHP0ih2jqCbl08Bm0vKqIEeshlMsuC08oTlxV4Vb7lzF6Vp0VqB8S/dKj396zRXIKy111SUykh0K1GSPpi6Sy4WcmpyhPZcn/G+KZTvNvN1h4WfbNO7skYhnUX2Di6Gt82kGEBjFWjDNkX6LhdfsUvrrIUSWC0+dpP3sHFtPKBB58bMppAxZrHDsNnK0fkkjfhRmfr7D5KeH+E/J8aEPX8Vj77qA9/aQIz/TYnaxyxdfNE/7mTmySuNbxfmwyhNyq5wKp2LsJqxQ8LZQWIpyyGo4RUGOmHN2KcgRWRHRNjkuRLlE7BWrQU8HdTyhUwB93tmlICKU6rIeVTjstgiMomUKmBHs9XJMFEccyW7TNPkU+LzG2+Rk0OCGzEYMKttM6swgFvkVpU9ddQmtoq6GzKkBIYIDzjm+MGpQdPzEGTu4QnM6mOWIt0lBhJRlmASUWAcTWsWis0fH6tSBN3WJuurw0cE+jniXUqlCDPQ7uCJKHFvMht2QvUDXfBlQ/3rYoyLjOLqUs3/3gSorUZXNsELN6THn7KbUVsxSdNIsYzMqU1TDr1L1jZmAeEOEZIRmz2RwUyVkTFu2dZ7cQyGP/bnzFE4EbN0xwalfn0HVLDpRmq6GU0yrboppZEXIWljjCbmLfHywL80C+tZjM6pQkCOqiUjLNy411ScvIjZ0kYocshzMoJEsuK0U1d+IJmMGxNll3unQ1AVkIthq6zynRvN8b/EB7g9qLDhtWglAt7OX54bfXWfubR0Gcw7nfqhK+0k5ws+63PaHZ5F9y/LP1Nl6wQRNG5d2ceou6JtMqi5t6zzlcMChn9th5v1dHvzeac7/VIXr/nqDqbf2scDqL9Y487xpXKXpmwyP+eQFpn+hS2YnZOM7yxz/8X1ccXSHtaiUsjDnwxoV1We/s4NG0NQlXBFRV1129ARYy+xbOtzwWxfoXp3h7jcu4kwZyh/xufJ1l5g4FbD1LROc+e1pHq7VY+zHuOiRINcJmQ562CL4RYeqF3KXf4BFt/lV7ISxkpYpUJN9tnSReafNpi7hoikIH3tRMH+yQ/BFRfHBEaXdIWIPnI7G29Mo/8tnIsqJWI9TUvSLHsOqx95VWex10F/KEE1LTo/mmHY61FWHlp5gWnXZ1GUCq1h0t9nRE8w5ezR1gaL0v4ZZ6ZtMSnmXpE9VDTBW0DKxbuWQu82OzqcMV99kGNgMi06LfsLiVVWPts5TU33aJpeybW2ToyACzkdVnvefU44+ukuVP3jPEQKrYtGRydBQHXzrkBVxhB/XjGMwdHygm7qIi2be6SCxDKyT4ghjpemp0Txzzi4GSebTEU984TKRozj5igbD70gASVNIPbq2kifkLnLPqEZFDtJUsyJHtBOKriYHnA3ruCJKH6YndKwfSaLOwGSoyAFbupjqHwIbZz6BVQmLE/cqjCnhsSQ6Zhp8To3mOeRtIX1D/a96HHltE9WzmCTL+JdmJQgD3f0ZzI9nuOtJ8+zV85gEfGzpmJ3ojTI88QUPUfrkiC++dI4LL6iQVwEFEbC3luXmXzxP+dM+rSfkOf6qeRZfvcvhd2zTP+Zy8vdnGVzrperJ8fM6H01y2G1xr7/ADdkLrIZVuiaXKl/PBtMcy2zQ0hNc9Y8XufZFFxnWXR541yzNapF2mOdpf/0lKq/sghD0HpfB2TXklkPU4GvvVU8Kdo/lGSy5DG702HriBFHWoW3ycUDR8YGqL3cpfnjE5D8PqJwc4m6bdK1Ghxz8uoMuS3qlDE5J400ahjmHnc4E090OpiPIdCK8PY17SZNbDRkLMcMZSevaAtwkuOcpB+gezMYgb0K/e0Ina95O2a/x3q4qnxOjWeadXcpyxE5Slo0ZlzGdPwb2XXRMz3qXWI8mYypdmFRYprAccHbZ0MWU5RvTzAU5+v8fOHrlUta+7n2L1OSAvnXTyDimDauqR1GEbOhiIuSK69Xx4VqPKpSkn3LvM6rHcjiFJzRbUZGS8nFFxJH3XuLoy5r4B10+/udXklkIU+oy5tTDFK3uW+erKMS80Nwzmueou8VqVGPO2aWt83hJ81hb57k+s86JYJaCHLHkbXMqqKUIed969E2Gw24ziTjDFEBddHbxraJvPbomljw3dQ7fONQ/22P+nXtMfniAM7JYYHDQZefmAv6sQ7NQIlcekR2FjHZd8jsBM5/oUj4fp84W2LylROdZGXafk2eQyZAlYPFlO8y9s8Op35lh63lFAEKr6JsMNdVDWUPtrwYc+Y0m2hW4Q8Op58/w4M/MkMnEWdwY96jIAUqYFDweO5TDbouWybGTyKPHjYsQp/Sz/7zHDf/3BXpXZlh5Sw3nQ5bDd26TvztAmPjaewc9Wt9coFkpMVnt4WddJvoj1J6hcCnEOxmRPx0gA9B5waUnF7HfqxD7JNt/l+Hwh5oUlkOshN4Rj95Shv61HuY6yUNH6zQmYspTI1Kafayi9Y2bMnfjoDCterQ7WTKnIuoP9Jh4YETxgRHFhxKh19UZzj99kq07ikweHLIcTDPv7KaMYFxOxfvWt7GTW/K2WQ5jlWdWaFwM56LJVCm9kfRwhVZxY/ZCKnn3MJwJp1PVKsS9O+NWja7JJgrjuMx+9uH7H/HZfFQ7jiuW8vaNd86ni/GVfP/4kC6oER8fHqDhtNNIPG52G9eTHZNlI5rkmHeRM8EM8+4uNTkgQ0TxdUP2v6rN5uNKtN5QYDlfxyCTh+On6e3V7jZd66SHfdHZ5e7hQZayccPvjp5Iaut6IjtupRqARbdNU+do6hK+camoQYrR7HOG3Dea5oi7TYhkR+c5H1a5KfncvnXSpqr1sMJVn7nIgT/apfjPI3RBIAeW4YLLx/7XUVgU+MZLN0u84WM9Q5jUuOX3Dlh66SZhUaKLkty5iGBK8fDzq5iB4Ko/3GL1RZOcePE882qPvnWpSp9LeiLNenRb8u3P+RK5cyG6JPnIu69CHxQsOG1WwyqVRGAEpDLsmP0xHPcPsOC2UsT/mLfJlp4gJGY45p02LV3gcR+5SPkn2piMQI0sw0MOe3fkuPSkCWZfu8f0Jwec+7lJvvgT82mDY9w812E1rGCQlKIB7ucNi+9vUb+zj0yyEwvsPjZL+xkFWk/L069nUtHfGAgdU+ljZm41muTmTIvlMKZTlTAp03cpyXavcH3uD0oJziaYV3uMNhTqTsuxD21SOh47kf71HsvPm+LCsyvkM1GqHfGtiysisiJMyus2XZNFCpOC9nOq+1Xan+UwblDNJ5S/b92UVarIIf1Ecj4WRbZ1PtWWjKn6r2ep8qgYHWgSJeVKMP1VTgNIpbJrOkNF9ZP+hDh9y4qQOWcv1gEk0vGlzAVapsB+dwdXaNbDEtVf7LH/VW0uPKvMpbcWWc7XaTh7ifw7xj1apkBoHS7pHBtRmfVoEoBNPcE1mfXUa9+a2U21JAAyaUv3hOZUMENTl8iLUSo4M1Yyo2KnUZJ+XEpFxbRkOB3M0DK5lNyyC3oAACAASURBVDK0G/D4H13h2h/exLsUcepHZhCBpX1jjhPvn6N2aJBGdClMqisIrGIzqlCRQwoi5Nwzpjj+1nlEBGIAX/ztWdpHclz5202O/eEW27fkOfWiWdq6wLouJ63scUOfJzS7gzzf8lNnyG6EnPuNSYyEJ/3oGfbvxZ2q06qLsZJTfixtV8KgE4l/2+R5fO6hGGC2iiPeJfo2xn4WnV28hFoufc5H/fYwbsUfWS68oMSDH59h5SVTrF9f5Yt/vo+VZ9Y48KpdDryrRVaGtEwBV+hYMIViztlDaEvpQZ/JTwyQA8tonyKqCAQQZRzaT8lSnw1RGGTSN5JPOqH7ZgxufllBuhE5sZAswYPG8oDxez4+nKOW4EbaSvrWZTTrMHq+4nPvXuThz0zx0MumsCO44Rc3+NZvPUP5r4ZMhv1UHd1McKGsCFkOZmKaVg7xTVwC3jU8BEDX5Lh7eBBtJXkxYmAzHHF3qagBrYQ6PhvWKSQ07ZiNK8gAD01JjDjk7lBIpO9fL3tUOI4xgLmU2aCheiyHdVomTyZpGR+YDKvhFC76ywKc5MEBzDm7ZEXESjBN2+TSSABw0++tMfu2Lud+osJnf/8QMhO3vIdW4aGpq27cK6E6LDqtVHOxlFnHNx5tXUi6RjMoLBtacDaYTj9/LaqghKFvPb4l16SuOhxxd9PU1xWaHeOl13TP8GCcJTmxwGtMwWkkx957iVtvP8f0PV2Wf3WKu/9ikSvetc1wweVDf3IN53M1zkdVCiLugSmIgLrqpDS0K6I4+0mubfvWCe565yGMIzj2B1tceEWZ3gEPq2Dq8wOu+5V1wkHcBTqmj6/3NsFabvvlhynf7fOlVzbY+IEKZ95YJ7MRcfCHt5F3Ryx+fJe5j+9y9YkNeu1x3R7jRTXZT8RNeynL4QqNKwxtk2Ey7LPv13e57fsfRgrD5968n92bcky/rU/vYoYzwQyuiNiizLnfq7L7+BzXvvwilbtiHcdm0p+RHYS4fxrx2CescdVvXmJ0yOXU22Z4wz88kQe/0OCB35ildrzP0u0X6fyVpKEGrCbdpwOToSBiOtg3cVA44rZomzxFGbKedFcXRMDAOiktPVazdmyGxYTJASiIgJOjfbhC87npA3zxx/bx8Ien+MJfLBDVJTf96hqP/ZY1pv+yw/3t/bhCx1iG0DScvZiujSZp6Qk0MpHcx2zJYW+LutNh0W1zpbvFJR3rSBrOXtqMN6Nihx3LEYZUVB+N4GQwx6YupPf69bJHTanymvceTlHww26LtajCVlKrHXZbnA1rzCd0a6zfcKmrIZu6wFqC5BdEwJzTZVMXaEYlrvzLTa77jQ0u/dAED/9aFSWI5cYmk6o6FTaVfI8xkr71YoGQdbg5u0HXKI6P9lFTPQKrEk1GSEBcr4+/f17tsRrVcEXEorNLXmg2dJ5mMk8D4hbztslxyO3Q1F7cXxLmePIfPUjjT7q0b87y8KuqRPsUR567TeHhEXe95yCZxShVLh51twiQNHWRhuqkBzNuzruUNuctjxoc9rYwy/DE7zlL5EjyrZD7XztL8UTAwb9o0XlMlgf+fJbp+pDT4RQ12SfznpCbXnKB8z9T4YGfnmdmuMfs33SpvHlA/nz4rz5D/1qH88+c5Mx3T3OwusueyZAVUSxyEl3UumW23WVnN8uRVzeZvN/nzA/Uaf5CgTDvUFkdcN3tG6x9xyQXX12ia7JplnflsMm+Z+/g9TT/+KErcCqGmX/ocOCXdsk3Qy7eVsK8xKF5S56VcApXRCyPGjx94iSXHs5z7S9cpPbZAef/+yQrL6+C/PLImK7JUpT+V+FmbZOnrjpU5Ij1qBTjGokStCBHdBINSUUOWHTbdE3sMNsml2IXsQYovv+63CP7qYij/7NJ+V6f4bzD6d9tcPG2eDzAeE+MxYBZEXHc389N2XNpf9E13gYBMtWgFGU8LqKi+vEauXs8ENS40m3xT8NF9rs7+NZNgdmaHHDjgfOP+Gw+qjGOY9dl7JvvnGU5aNBw2qyHk8y7u7R1IZWE35rZZVPDShJxv3KgyfjQLDht1hO15cGPbnP0x5tsf1uBe1+3QFfEreZjXYbCfBVLMpYLF0TAajhFVfWYTg77F0fzNJy9lD1pm/izxptlrF4cszxtXWDe2eVMMhLgsLvLiaCBb1yOeZtfpT7c9os89eVfovh3PueeN0nvt7J4rsX/Y8nSKze47zX72HxmOa2JxwNiwqQ0KcphCtIuZTa4xz+Q6hQqcsTZsIZBMn3XHo//wYcJC4p/uucgJquofWjADT+7xqDh8eBfTrOzr8DORoHn3vHPDBddPvr2o1zxt9tc9apLqLalt+ThRgbvwYgHfr/B7qE89Vaf7MmQ6U90KRwPCUuS1Z+t0vr+HIWPRMy/t03xs6OvGjsAYFzo3Zph5Y4p2s/KQRau/c2LVN/c596PLdDeH5esm3qCggiwxwW3PXeFrTsKWCFpvKdL/yqXld+YQt+i2LmYQ94Ps+fauB2D2jMM/AzlyoCoKJj6/JD8pwO6T8vwyVcfZiIbUJE+a1ElHfAz1k2MZ640VB/fKjaicjr7xBVRyoSNM7u2yacMihQxvlCSPlu6yLTqptRrXgToTwmWfv0i3opm+fumePBlM8gYmyYvRzRUn38aHGYpu5YO9Il7mAaUZcjn/HjUzZy7m5btDdWjqQtsRmUW3BZAKpQc7zVjJU8++OAjPpuPasdxxVLevuF9C2wmA1oqKsYGxsBV12QJrcPp0SxHMpspOl+SPm2TZz2c5JrMesqONO7f4/rvW6d/lcfZt00xyjmc8Bc4ktlMqc8xn369t82FKJdKusdA55gWHjczDRKuvShjQc8nh4eoqEEqgR/rGPomk3ZijvUgX9k1O+fsct9wkauz6zTDIo/91XMcfPsOmy8t8eH/fhU1t89is8XVT9xk50l5/vF1RymogI7JfhXt21B7CQuTpK1qL9UwBKgUBNQImlGJ6/5mjWt/eROA9h052n9c4q7RfhaPb3PLj51jVHU493dVJl8xYObOLp971wLX/vElih8e0by1wJmXTbOxNMlkt8cTbz/LsOFy9r1TnNdVStLHty5Xnb5E5Xf6TH56iM4J1NDSn/bYesoE+gjM/XkHb1dz9gfrTAQ+hY+FVNaG+NMOl36xSHibw8EnbLPyzCl4teJjg6Mcy2yk2WDl+T7HPnIJq6D7wjwXH1PA+5Ch8ck9cptRup+shKgk0a7E7eqvoa2HNYfWCwucedo07oxOS6yqGrAZFZlWPfrJa+MhR+MRgxXpczqYScvDzagSTwVzW1Skz47OU1d97vUXOOxtpc9nPIFsSxcZDVxuee3DLL5ph+G8y5lX1jl183yqDxr36IRI2kl2M5aa19WQ1aRUK0o/bcirq34KWC+PGhTkiLrToRmVWHBbHHAG7N938RGfzUe147jquox9+bsewzHvIl2TpW895tUerjBoBMvBNK6ImHfahFZRVT53DQ9yzLuYDuE55jXZ0VnaWzm+9emniSYUH3rHNeTq4VcBYPudXXzrcM/wELfmH2JHT+Bbl6qKJ1EtB3HXoSsMp4IZIMZQNqLJWNFp3LSxbdwUpYSlIEfkRdwB2dSllK0ZmAybQYn6WpeDF1pEHYmzp1HGULnHZ/IDQ85/d4WHf6uGdGMdyTW/cZHGX3X4/CcOoBYsrWR0X1aE6SG90m2xYzz61sNDExC39+e/oubuWy9t+X/Ms9fIRyEP3DHLTb+3xumXTNN9cRbfOpS+4HPt/3UR/6hD7lTI+R+YZPJLQ0r3+Jx9eY2HfqiOkSptMc+/LeSml6/xmb84hHqKTp082rLvN/c4+OadeCbsQcUD72+wLYvc8iPnKH9hyMZbJ7nwTaWYnRIDjn2+TfaVfYr/HLD+9BL9bIZDH9rmri8cxCvEWNRc1KfyS11qfzPASBhMuzjakm1GRHnJxSeV2LqhSOWGIa0jeTYKZbrkuTGzhkEw8BXVDZ/d+3Mc+8tNSvfGa2QFdJ+c5cEX1glvcNIJYeNxh3GGV2ZHT3DI24qvRXVZiaosOG1OjOZZyqxzOpjhhswGq2ElHVc4FieOsa21sMb3TFzgU37cAlEQEeHn4dhLt8ivhqz9UIWPvvQqcl6QBhtXaFaCaYpqmDJfY6lCS0+w6G6nwWlG9WiaWK8zDkxjDdG806apizz90AOP+Gw+qh3HkaWc/ev3x8DmuDz5puyI+4MYP+gbj6OJtBbgkDPgvmCKrs5xc3aN1WTSkW8crv3JTaofH/Cx9xwle1WYZgItPcGC20onRLkJ8OpbN3UG44exHlXSvgcPQ1GGnAymUyCsmEwmq6h+SuVmRRiPPExmN2w+VGD/B3eZ/kyP/APB16Tq/9K0Fw8FGlznMv2OHhvPLPPQ79fxjZtGwLEMf87ZxcOk/S7jcQPxqMG4ge/mbDyt8fhommMXL3HsCZc49fMznH/+JDf9jzVqH+jzxffOMbg6dqqTH+xzwwvXsRIu3V5k9oNdzry2zujZHk1dYM7pcnw0x35nh9HI4danrBLWFZ/520PxsGcjWPrZDRbubHP+hypEN0kOvmiH1tMKjOYV83/e4fSr62x+Z5lmVEIJw/XeJl3rsOLXuOaNGxx9VZP+MY+JLwUc/6N5lp82w7XDDRaev8PE3QHtx2eYuC/AGVo612c492NVtr5lgg23Sl110pp/rJQcz6OtyUEyCnGKRafJ3Mv2WHznLpfumGDy0wO8tmHriRN86Zca5K8M8K2TOv+xrqWuhpwKZlhwdtL+qDHlPp7FMUjKCoWhqUvJJLtc2lB3xG2lFHJRDmnpCapBj8Ov3Gb+LR1aT85z/2vn6eRyeEKz4LTT5smmLjHn7NI12VTwNae6PJgMSxoHxPFs2PNRNdUM1VWXtajKcw7/8yM+m49qOjayik1d4pCzxxFvi7bJ8/eDMqdG8xzzLiVzNqOEhstzf1CjKH3cJPJnRUhNjjjwgTZTH+5z4SVl9JUyTRMXnE46u3EcuQE2ozIV6dNwuolir89yMBODs2GNpi7iW4ez4WTqZOK5oBENp82is5sODDo5mqdmuxTfPeLIHVs85SnLHPmDbWTfsvbMSR763Sk+/Y6D3PWRRR74RIPRrKI377H8N3U++wcHaf0/BWTOMv2/e8gAanf1ueaNlyj6MR09bhFvqHhG6roup/c3SIYwb+kiN2bWcEXEajSBtvEQZvn+mLXqPcOjoAI+/8sHiCqKgy/doTuKs5TWfyuABGmIncYL66zcMcVqNElFDjkd1Hlcdp0tXcR6gjM/Ok35uM/86TZKGI6+ZouFO9usv7TMxq+XOfsddU7/jxmmPthn7o0dLn5fkVPPjKnbiuqz4OzwYFhjLaqwkNll+MIMD/zBLBNfCtAZwbG/b3H91gUOPKdF/t6AwX6XymdG9G7KEOYl3YNZVp9WY0XNxN2mapBgP3GEX3S3CawitE48m2M81MkWOPeKKrtHcpTv8TnxwVnWX1am8sUBT3jmQ0y/vgPapu35Y21K17jkRdwv1IxKrAZTcbdzVI5HAeoJgFRCfsRt4luHmhzQcGKR2UpYTSTlPVbDOvNOGydnOfGr83zpFTNU/3HALd9/DrcZK0TXogqnggZhMl09DmJ++j1rUZlFp5U6yJaJQdMAxbTqUpVBOofl622Piozjqusy9lfedX388FWXORWwEuUpyoBuQmW2kgcDscJxvEkkhoIcMdpy+ebblwkPKD7+jqP0ZDamO5NINJaCZ0XI9V6Hu/x66qUh7j69NbvKcjiFQTLn7Mbtzon8ewxUjSeSNVSHogw5PpqjoXbJvyvi6j++SG41onfUY/U5Nfw7HJwFy0o4lc6baKg+uV/22f+Xu9zzjgUGN8eipHFKec23X0T6hsGsR/VzQ4KqYvXHJun/SJae57Eaxv0b86rHps6nazJOYcdrNXZ0NdXjxhecp/Swz+mPNdhKmIHyR3yue8EGJ180y95Lsky80+e6n7+IdWJdzafvO8QX3f0sZdeSYbr9VIVYkCPCbcXtt32JjR8t8eCTGzz5eQ/S/q4cn/2dg/h4FOUQd6h5wmPOIrTl7i8cQE7Gz65rchxwdlmLypgkdh1yd9iIihReE3Dr/1wlKoDJK2TXIEOLzQha1xSQ0lA+46M6ho1nlXEea1l7Spl8Q7Ohi3FX6Gg2BZDHQq851eVcNJl2WJvjgpu/6xw7313go684Rn474JZfW6XxkS7bNxc48fpZ9kr5dNbFtOomjF8zff6rUY266rAeTaZDd7Z0MZlOfzEZlNRLe6TGatp20tAZNzoOU/Hi5Mf7PPZFa4xqDvf8xQH6V2TSKfISk7bWH3P73DeqJqMh+rQTButsWKciY4r3CrfDho6bJMddtd928PQjPpv/6YxDCPEmIcSWEOKBr3itKoT4ByHEcvLvyeR1IYT4o+RPP35RCHHjf+TiRtah4ewx5+xx1+AIp8JkKEsyTi6wiqXMRepOh4rqU1ED5lT3y12jwRTX/9oFVN/wqd+5grI35HHZ9XSK1Fj/nxWxxPxzoxrNqMS6LieTqkNuyKxRkIbbsk10Mne0k8xyGCSdrVkRUVdB0n3oshaVmLjoc80PbnLTS9cI84qzf1bjsx9cZOv5RaJ9kuVgmgVnh0V3mwXV48K5Igtva7P2vAorj5lmR0+QFVE8pm7ZIX8mZOUH65x8+yxn3zXFcMnl6Cu3OXxHE3XccNjdwljJ2XCS9YT3D63DkreLm/TAHPMuUlM95p0YeS8/MKR9bY68jFK15+CpLpeeNcGxP9nEPgCND3YIpyQiAhVZCu8KOOxtJd3KW6nD8ISmGZVwpzSt2/JMvn/Aza9aJZhSfOlXZghw4klackDxvSNUYJEa9n2+kwB6QZrxjSX3W1GR1bASswQ/7TGaVDh9kF2N48fvVwNLZXWA0hZ/n4PUMPORLo2Xd3js49aY/rE9Fh/c5VQwQ93psDxqpHRu32RYSwb9bOoYWNxdynPmB2aovbPP0vo6h+darL2+wvKrppi8f8DNzz3P3Easx6mpHlIYjrpb6YStlkmazkTIkncRKQxVNWBadTnkxZPjF5zOl//EhzAxYB5NorAc9w8QJmrhAEVN9dl9coFTb5/B9TXf9D0PM/+leILbXMLoaQQlMeKeUS0ekZnc33jKW2gdvCQrfyCoEVrFvNpL5r7q/8hR/A/bf6RUeTNw+7947ReAj1lrjwAfS34GeBpwJPnn+cCf/kcuIidCZPL3S27MPUxNxod8TU+wEk4BsKOzKdC34LR5MJxmSxfpmhxXfnKT+of7PPDiOSpXDciKiDt7V6W9IXXVYdEJ0tKmKH2OZTaoq27SjBSDsKeCGvcH8UTuquqlk6zHtqlLLIflRMykUR+wfNvTT1O6z+fsK2q8/91LDJ6WJauilOuvqR5nwzrZRNNx0xsuxP0jP1VKAdV1Xabh7FH/XEz/mm+PJz9t3FjiXW+4kTNvqqP2DN/03FVKr/NpRQWmVS+ZIh5v5HNRLv0jPavJmgFM7vTJbUZsXz3Bff4+jJWc8BcYmAyf/5VFoknJ0i9tUP3cgKCiiIqCncfkuOb1F5kM+4m8vkojGc/niij9eyHhtzkULoSUPj9i5flTdAq5eOq502ZlMMXVf3qRnWvzRBXBxAfjv//RNR5VNWDPZFh0t6mqHvPuLg0nHp48uTpA9eNN7vigM4IHfrrBZz++yP337OO9//t6Pv23V6Bzgt3n5jjxD7M0f3KCyt1DrviOLR7/mrNs+0UW3FYMUKKZVt0UAxoLB+edDpd+YgLjCMqvG7JjsnRtjpPPnuNTbz5CthWx9JyLuOd0jJ1In5bJU5ODdIjxMe8SW3qCYjKBbTmYjh2sCDjqbrEWldiIylSSyfxdk+VGL26TOJbZSFXR6VBkGbJ67RSn/q6BLkiu/OEtOueytBOMo6HixrUbve30XvxEcTzWa3RMlgVnJ1WQnk1KIo//lx2HtfZTwM6/ePlZwFuS/34L8OyveP2tNra7gYoQYvbf+w6NwDcuG9FkwoA4hIlaTyZA08nRPNd7rXjIT/L7ntBkCbj2jy4S7lcMXuCwFtbwkwzGE5qWybMW1rhvVKWh+hRlzN+PvTXAiWA2HfjjingOxFpYA2A1oYgPOYOEavWpiz7l/8Pde0bXVZ3r/r+52u5Fe6tsSZZlS+4FDKaGmkBIaIEUQkglgRRIh5t7SCflkJBCQno9yU1O6jmBJARCS0hCQiBgjHGTLduSLUva0taWdi+r3g9z7eWcMe7/tOHxH4yzvtgYD3mXueaa7/s+z/P7Votz3zXOwqo4ux/o57GrV5EzKkFeSE4rM2VlA8HWtJ2kVdRJ/rTJ4iui2IMquv9ldsJ4k7taWCmF2cFEUMtGlTaLL4iy56E+8i9Osunzs5z0wSnmWgl6tAqD2hIFJ0FUsVBwyfoJ3Y5Pv1PnZVNWG7JJqLL+PTUywVq9gtrlkf9fSZLPttGaHlrFZem0KLPvSRLJ2/TcWw1i8sLCwUEhobSCLE7zRPleXRUKL49LqpynEBY2Iw8XiEzZ7H9HD3NnJglvswNOyZSdJu+kAOlxkaNGQWahyurXzaP6GjM7LNi9PUft5hChEYeosNkSPoqtKdQ2GCi7PAqjCZ6+aYhH/rCGQy/tpu+rVc5/+z6W2eXgRJNQTBK+CbKTWD5pd2H2aMxck2Lw7jJmXgv6ZaEzLZ76+RCq7XHmmyborZR9FIX0hJhex/0sR+yH7Hgw+p63E2QUGWC8WpcPnRlbCjUG1TKPtQZoeTqr9TIx3yvjeEqQa9pyDWYHUjz+3WHUlstFb95LrNIirTR4tDlCTq0w5YR824UkF3ZGr5281gAShcuoXggyZY/n9d9tjvZ5njcL4P/a6//5/wv/OPgf/bCWa9DwQujClloIz8BByPrNiQblydOmjFTb0+5nnZEnrTQY/WOR6C6LsRt7sVS5kFU8toRmMD2V1XqZ1aG8LFucGIesblxPplLn/UTzTn2a9nkdeR8pUPKluofMXqYc+YTM2ynU21zW3zZH+eII2360jJoIcfJDhxn6zCLrrp1j4+V5Np8zyxVn7OBF5+9m7aVznPi6aTa9axbV8jhybhctVwKoOtiBhNIivMumtimErrgUnVjQqyg5UVpJg9mvJNlzY45V/7LAqTcept3W/NfdwPJxjMs0GxXXHwc6aGW5cdQS4SBZve4Z7DS7yKkV6i8L0+6SClhjwcFaq9I416A1pBH7lUXDk67M/N/1TXRh8+GLXsU7b7keD5gPpXjjgzfysfHLeKIxKs2B9xZp96k0LjRortOIHrUoNmR/perIMXbMt4VbnkapGuakN06TmDcD7p+nCkRMJp0X3ajMa7ETUhq+MUpqT4uCKadm8a42O25fxrOfGCD7SIPud1dRXKnRmLaTjJt9WJ7KETtD3dPYbCzQo9bZ/sohhAMjDxaYsrIMahXCwoa18My3BojPtFnz5gJtS6PlaTgovq6j442apeHKtdurVhk15v1kuDBTdmfjkg+qohslrEjg1iErGfTMclop0PqM6gVano62zmX7N5YRPmyx+i0L5Owqp/sgsQ4JsLPWC07S15DEmba6gp8VVixMFPJOilFfGHa8ruM9VflP4R9BsmOFEE8JIZ5ql+SRTQbWyLCTaUuazILAVcWkR61KoY3aoOhG0bGJfbFNbVmIo1d2BbGAJipTdpKGG+KZdi95OxWAcnJqmaIbpe4zQDox9ANamUcbo4xoi7Lf4Oq+sKbJgC6nJw6CS348xbpvzbH/JT3Mbk7wvFdNcNbZE2x8e56R7xbR5l28bpjfkqBwUZz6qSGafTqJeovc4/KIv/WGo5x20WHO+eo4a6fyAbwnMdOiNBzxvShVSTxT2iT9CdJua5D9N/Wy72O9dP++ztoPzYMnw4114TJtdfFUOyPNT26MtGISrklh1GwszYAmjWktV6fkRqUuQNcpbpVAJOFCLR3ioN3L1CVp+h6rsqJakL4KRfp1evyw5388+nN+OPYlACxLZc2dE2RusPjjSzfxpQsuIf6gyX3OVm5/6dXc/4MTAfj5e1/E/5k/S4YwKSbTvtHLshROeMcMxh4H4UFrUMMVoNddrJJkx1ieRt1vKuadGIXlCfSGy7pGnpIb9T0mTfa8qp89H8iRu7/K1h9OMaiVGNLKwQmwc7obM7uICRt3jaC6JkT6nhYjvj+k5EoIV/tUnT235+jdVqP/mxUSismQWiPmK4RlzyRG3c/YkOtLgsGivlhv3paTOQWXtG9iA6Qp0UmRFHJqM+D3nvb74/SwsNHO8tj/2V7ST7RI3NxkX7snoA9KM548tYWFxc72IBm1Rk4rs1pvBvyZkhPlRCNP/u+GC8fj+u9GB84JIfo9z5v1S5EOiuo/jX/8e3bsuhNC3oi+QMFH8R0yJZlt3OwNckV1pKwcZAf+seZKQn+26X62zvht3di61FIU/XFryZV8kR6lwbjVTcI/yUguRuTfqAFLjuSanBqZxELx8YIRH1OYJadWmHG6yD5YQ//oEq1lKqvuK6D8GhqbdXb97xyLZ8aorg2xPFaWZYmvFB3UlmQjq6Zz3okHmHtlnKkNXaz6bYG+O6vkvlhl7uI4u2/MoZZdSEls4KLTyVi1fWREKZCd739tL7mlOiu+uIg9JFh6d4ynW8uD8qbj6sw7MYYNaW76wc4zqN7Wj1JtgRC87Tf3UXUjtIRN91AVD7nrOy3BRiNP7ZIQyjc94n80GbtkQOaoCoc5J05WqyFcF+H5UG7XxYtHwdDB8zhpcRzDc/hT90aEaWFo8nny7r/+K+lza3xgxav59EM/xvWkiG7tN+bo/qNMHfMETHwzy4bLJGXNLKkU4onANWr4tv1wl3xftaUQA1mJouzENZavCzPzWJL+z5bZdXE/3QNSWdnhuy46UQa1CrvNXpZrSyxcEmPlFxfxluDp2HJODR/G8hTmmiRGaQAAIABJREFUnTjOlQqFh2KsunOB7RcO8uToYOCcdYQFnkJYMQNiW9UPG+4EB1uatAas0BcYM/sDTu8mo8hRO8K21jBbw4d5ojXEiDEfNI6nbD9v5oomxozDyGeKLG6NsvSGKHk7xaBWYtqUKXJRpR2IJ1Xhck9tlK3hw4yZOTJqjanjvGnAf//E8WvgDf7v3wD86u/+/PX+dOUMoNwpaf69y/EUGj5geNHP88xpZdJqnVG9QFapM+Q3KWXGqJRub/7aDPUBg20vGWZQLTOgSkxfJ4otKdoctruoupEAIdgRa2WUFi1Xx/Jn/TJrNErelszVjuY/LCyO2F1kjtY45d1HwAM977Dw6ji/f3g1D969nqUbouxYtxwREjLIlw4/tIDpqTzTGqZvrIpwYPbCFM036Dz9k+XsfqKf3TfmyDza4AWXH0BxoKKGcTxBn9r0p0BS0t4RIk1aPexrDTDxnjSLV0YZ/WKRpSdigZdmQCsHSVFv+usbufOjlwLwlU/8lExTPhVF2yTrB+7owiHasLDj8ubu21Gl6hocWZvBDYHxrPTAxIL+gCyrcI9lXoQ8CzcZAc9DNNusbsxgo3CwHuPzkz/gzNIYLaERVlxStBGWTdU1mHfirD8ww/KvLGH3SBv8kbemWcodGzObqhqcFjtekKoboZ30s2dLKg0fqXBqZJIerUJYcTjwoR4Uy2Pdd+coOIkguqDqGpTcKDvbA8GEqXayPAXEd5mcHD7ik9Y0XBRKTpQdty7DSQiW3SrX4KhekFkeniLpcngMduQBwgsa67JRWWLQH/vntFIg4tthdpNQTNaFZkgpFhtCs8zYXTwvXAisDabPRvnLdaMsnhtl02dmyR2tBqeJk0NTgWel5Ebo8QWJ60IzhPwpyvPCVQycIPz5eF3/4YlDCPET4HygWwhxFPgo8Gng50KI64AjwFX+X78PuAQ4ADSAN/5nXoQqXEzk6Mj0Jx0AeTuNqkmVXN0xWK0Xebw1zEZjhuzRBl3bmuy+JUcuVqblaZh+827KzhCjzaSdZUiTfd0jPuhJxSPsWexoS6J9VpFjS6kklbmVMmVbGsQA0tsanHPtQVTTY+HSKJMfyrLU52MlRZmxdj8bQ9OBorCjOHyyOUKPVmXUmMN7Vr7X4sYYMSHDfGu9BuPvyXHoum7Wfn2ONd8psOGf8uzelGPfhTmGtEVZo9ppzoocpOgrI7eED/N0e5gDH+nh8id3cvYtB9j52xx6GG656DWIZhssizXxElXka+q3K+iVGiR7oG1yw7Ov4TOb7qLuhNiozCLC4DYFiafk2C8ValJdHya1u0mJaJAi34moQ1PwHAUc0PBQGiai1sQayrKqUORwuAczHGGluUBTGBwyeuSRRggOvWEZlqdRa4cZ+V9F2kmV8IKDExHse1cf6Rm5yD0BVpcMby7YEg3pIFAVF9ORa6RLb1BHojULjsxUqXghWit0Fl8YZfBXJeY+EMdFBSF9IACrfW7sQauH3CpJm1vx0yL5PSk2lGfxmoJcvIKWcphKZii8LMbAd6qs3LaAfqYbYEg7odNTdpqKGybj1YJE+yoRpuw0MWGSURs4ro/U9Hm/dV/p2dEZzdtJdpjNQHui+mgQB4VDn8py4oumSdzcgh95THkZhrTFgEXUcENMmj2S9+LntCTUJn9spSVsXBzz8hyP6z/cODzPu+b/439d8P/4ux7w9v/qi3A8JRgXuZ5C0h9RDvnU8LH2ABtD0zzalBBiB0HzbnlDjF2co8trgO8G7Ai6JJPFpuAkyNupwM1acBKs1YuERZ68kyRvp9kcmmXGTjBtdwUErwG1IW38P4atHzqC4sKha7I4t+vMW0nCSCdlTJikVcmu6FDHOilcG0LThBWLtNIidaiJlVJwc1LGXnJ1UGBUn0fJuix+MIL7fXAjgi1vm0G8XbDsFpdDjuy1TNtJNhtLpJUWh6xuVugLOGnBrtv62fqGo+w/e5gfKZsRcRsvbEAyhqg1mDPS2Ag0v7YXjRaoKoMf8TB/oTKoLVFMxMmUG5Q3hOja2SJ8oE1hJE1rrUbqoRY724Os0Au+GziKrrQBgfC84MQhSlXcbBp9tsRQs8Cu0ADCkU/GjFvn3tgWVrXnwPO483Xfpu4ZnPOdA0R3W0y/NMHg3VXGX9rD8ngFZ598re1BDTei4HqQ00qBLycmLHJ1eXoqJSJklBaTdleASig4MSxUli6J0n1/g8LTSYZOK1G0Y6iKFPTZhxSG71ti9IEF0mPy5NFzX52e++p4KtgRBa3hIlxYjoxz8ICT3jzF5DuycEmI6HKLvJWS0yw/B2Os3c+60CwpxSIklpjzYxM7ZrUetSrNk6JFwZYlmGyKzrPGyAfh2z1qFcvRyKiyXLUHFSY+lGHNLQvYP1HY9uphon7ebVjIiVpYPxazWfV0xtr9qMJjUC0zbnWz8b96Y/4713NCcq4Jl7yTYtpJSZWckPH+BTtJWmlyTnRcohnVGo4nMwnW3z/LwtYY7oDCsFZBES6KkP2QjH8DZ5U6LU9iGDvmr4xaY9zqouRGJKNULzBlJ4NywPEUVutFZuwIA3eUOPUDR3AiCvXlOtMfT1LwA3AVH7XYyTuVU5p0kJNasJNBknlasdFKHk5GYUCrMWnL7v2QWqPoxhg3cyAEdlqheEGUhatinPjVaXh3me2V5cHTZ6fZxZjZ56dOGdxx4WV88L0X85fIKC9depK4YuPpGl4sjGi28eJRHNujqPsQKAEoCl4khGjbwdE/2tVGtTwWXi2bpKs/VZR4hYyCUbHJqUtM213UPUOmddtJ8PzAXwRRz2JAb8qNRFVIOE3KegwvbKB78oHwSPYEPEMDz2OFXiK5t0nPl6oUr4gSHbNlvuhNOjN2gp7tNTyg9Xzdnyp1aPaySVx0ozRL8gFhJiXtvhpQ4+Wpc1At45wsp0Vb9h+l4MRIizru/QpnveIAZ75gkoHPldF0h73X5mgPqpSfF+LRZ0d4YN86Ht+5gr+Or+BHT53CUw8v4/E7VlA/xcCouqz5VIFzzjnE6qvnGf7LApv1OSatHpnGr5VJKyY7zBxlP7JPrgs51coq7aBs6Bjhsv462GBUcXzqXMmRLNw97X50IUvP9qsMSueFWfapEgPTS4EStjNBkdKFBAU3StUNk1RbrDNmmXaOKXSP1/Wc2Djafl7mtCXhRDpSUJNQmjzTHpIiFxS/79EgfrBFdMzCeYlKTiux0+zF9RQsX7EYE6Z/PJTNwo41X4agRIMb5ozIBNO+FX+sPUBOK/nciggDd1YY/FKFhbOi6HWX+ruj6Lrrbxi2P6JM+RMP+eVvMPK0XF3WtnpR8mzVBnknhCh72EmFw77LtuSGmHGiAUls0YnTHNKJTNr89VMr2PWufrJ3NbjsI8+yTp8PGoOdOL6SE8ONRQj1pShoSeJOmyvau8HzUCoNPFUBW960c5rcOBQFvJCOaLQQbdNXnarMD8oZf2ltFNeA1CMt6nsMaokwig3VaoS00iCrNCi5MsUbVQUhUPBwgZeUnsY1NBTPJepZ1DEYbBTQcJkKZcm3DETbBg/GzB5OvG0aK6kyfks3qQNNPAOOpHtwEEQeNBHAM1cOklMbrDbmZTLWbo/UJxvMntrDxJf6qWphSgnJz0n4KW1TtoxAKLkRCn6vpJYP0ftolY2XzHHeDQfQii7TH0zxh0dXceCuXg7d0o07pGDbKomUSUyVn01Cs4ilTZZGYhSuiLPv81J1sHRDlEPvy6BMumx9w1ESV9Q54ZkpGVrtRpm00kHswaheJK3W0XGYtLrJO1GmnRQzdoI+32PTCXIuOgLXZ/V07AIAY+1+VuiLWKgc+FQPQoX1t88FYcYJpUlStANoWEfH0cnrUPFYq3fmF8fnem5sHK7OtN3FutAMA2qVhn/U71UlX0WO0eRm8kRjFdl76ngCdrxQassGfcVcJxmsk75U+jvEYmeWbqHS42eX6gGGwJQlhdpgubZI97/UGL2zSP4VcQzFoT2ocuiKFDN2F1U3zEErG5xOTD9SriNr7vycgpNkzOwn7Ye40AI3JAJFaUIxZQ9HuOh+dkZ7s05yT4tBpYx5k8ahm7IM/LKC9hnLF6bJxZRRa/SoFY5cniGkuFxZ3c6EluHSyg4Uz8WrN3BTUfA8nEycibBc8BvrUyAEXkke8z/yt5eg4mFtlk9mdQ8sXBoDD0559xEE8lTR51QY0srMO3EZE2CnwHFQ/anK9tByLik/y/JmAaMpn6ZOOMQts/cAsEvtx00nQBFYGYPctjLpx1oU3x4ntbOFYoEdU9lgzNG7v0L8iIk5pBLbajLtxJn0zWE9uxus+c4Cry/+mdWtWQ6Ecnz38ov49GWv9OFYTVZoxUBrUhIxXB1WPFTkxDfMEGmZHPh8lqd+t5ydbxqg1C9jFmPCxDRUjJYtgdiOFLMVnBhJX/AWFhbWsEr5hDCRv5jsftsAz/xhGVO3pUnONznh6hlO+scjrHdmCStyMlKwkxQ6ehzFIqyYQa8oobQCLGQHi3HMKGcHzdcBfYmwYrGn3c+knSUy6DDx+gzJ37Yo7E5S9528dU8Pkus6fpyo0g5O2jPPEQHYcb0iipToxoTJYbuLSaubsO8HSSqt4APXhc0l8d30PFSjdGqEdp8ceVb99CbdzymYd+KkfBzjkJ9F4HpKMG+vugaTVjcN95g2YMh3xNa2hVj9gQKFs2MU3hcn/libqZd0gSYCwxwQqPU6zsesWgtYnUnRZq1/SuiIzbSUg1L1SCsNCnaSvC0RCUPaIlm1jump7F3bj1rziB80ebY9yLM3DDB5VYZVXy3Sf1+VI1ZWQqMUKcz6wnXfBt+kuD/cT8aps8nKI8IhlGoLYTuo82UOK2kAzqgdRNSbuKODeLrGmtubZNQWs8tSWEmFFbuK7L2iHwFED5oM/bOs7WuxEE+2lgeNwM6TTfXLlW8PX0RDNbhl4hcQD+MgeHFxOyPtedpCoxWOoNQaIAS57CIrv7xIK6ux91W9GE84eAooLY9SW2PlO5YQwL4P9rCzvSywrsusjGMtuYH2EuOJQVAVKCzxjZdcyuu+9l4qXsintWusf3YOxYLwPpuxt/Txq3tOZOHlcepKOMjnLPogLKcqqCQiTPuArU5M4zH3teTrLJwfI7TLZtRcoB3S+MMr1vLEAytZeF2Mld9bZPXFBarjERmxoFUY8tW9lqcyoi36AGyH3e0Bv9TtwkEEDteMKsmAOa3KkK/XyKo13yBZlvfHmzK4EcFZ3zoQjH47k0M5LbPJ+ml2h8zeAElxPK/nxMZhCJth7Rh8ZrUxH6RbRf3du4MVdJuQ2NfGOl2j5MT+TUpY1TXkE0K4jFtdHLEzVP/u1JFVa4yZ/ZLypdaYd+Jk1RpTdpqWq5Oxq5xzywFa3RrzX0uiPAiKA43L9SBSvzOfjwmTRf9p2IEpdYxHJTfCITuDLhwU4cljaDyOKMsJUkxpk1Xrfs6GDOPJaWVi58sb0rkftoaniKkm+z7RS+1Eg4EPlTildgjAFw1Jw1p5gyxDJiK9tITOuUu7cFOyMYrn4UVCgV7l1NYkMc1BnV3ETUXxdJXHm8OEFZvq2SFiD7eJn9KUmRwXJgjnbTwBkR0SgFVyosw7Cf/zFOieTKmaJMPn+i5hZWue2w/9M+DRa5W5Y+BSXBQ8RQEhwLbRmy59f66y8JYYXbEW6V1NWv0aWtNlzTsWSB5o0e5VGXtBP1tCU/5mJXsWP5k5LVgzOi7btUG8kA49XeC4LP/xJLefdxkfv+5NrH2swMpXyyiFPTfnmLklxebkLAm/kbjRyAecExWXcNmGlOf7UpqsNvL+UT/CvJOg5EbkulxnIFyY2SHVoTmtxHw4yfQnunjih8MoJY8XXb2H3u0VSk6MnWaOjNKSvTlPJ6dWyNspslpNZpP6mhsTqXIuuWFGtEXGzV7mnLgc46o1md2htjgltEiup87s65P03lNjcGLJj4do+GW0fIDmnTh3l7dyanjKl6FHjus9+5zYOExP4zFf8dhwQ+xsDwYehkUnysnGAkUnTsmJ0t4lJKlsc4iTQ1Os0JaCAOKDVq9URLohhrSyf4qRjcpOevkKvUDJibFaLxNWJNoxp1aIKW02fXmGyAGbJ29bQTupkflrnfagyuE1UuYbEyYzvqLVQQS80roboujGAgdjWmmSVepBN10RLrG+NpEFi16nRsVPOav4ORqqXxJ4g4Lq1hAD91ZoeSoFO8lApMrTtw+h1lyWfbhMzg+n7dSv198sywHb8ngmNsyJzSN4hoYXDcvpiuviReQEKuJZvLT4JIQMlIosKU4ITRNV2vztopWEFhyc7Srt1RpRy6J6moGnwLlXH+T8G/ez9fFJmm3JSdWRQqym0FFtG0uoHDB6WWvNowCToR5+H14LSIEYtgNCIVSwsTIK21+1jIxiktzTorJKfg6ZB+RrGru5j5wuS6Ok0qLqGkQVm8QPjiV1V5UQz2oDiLYF/vSm857Pffav9L22TNGQR3/rFQpHrAxpxWXOiZPTqrR8K3vBSVK1wxhzDk6PwjpjVobvTCmsvmuOrR87zLmvPMCZZ06wae0MJ9woZUkveO0+LnzeGFuvmuKsfzyA8XMLfdTmb/86jJsSPO+1E5z41BSnhPKU3RC9ao0Zu4t5/1QKMhe0R634YPIWeSfEkFrjsH8K6ZTXHXn77+tr2GPFmHPiHL4+gxsWbPx6PlBL5+0UR+wuLD9o+8LEbsatLOPtXPDwPF7XcwI6bQhbTkCENCOllWMx9lm1xtNmd5ALKXw9xK51/fR5Ffa0B9kSmmJIqzBlJ/0Gnv/ExyGr1slpZeadRJDyNaQX+UNDJkF3REDGrM2y75Y5/LIuZs5JsYIFkrva1DaHSKtNYp4lSfUs4XpSWzGqFyjYSTaEZgkLhzGzh7ydDoBD8ojbpOoaLGyIMWBWcPbB+Vtm2GMmMD2VIa3MTrM/GOEOX75E761Vas8YJDY3mbaTVEcjHHp7llVfKDLxZJa5E5Nk/ePpltBR+YGEDPbTy2m1AySmZ2loEVAVvJCBMOWi+VtshCsqT3N37+nUVB2l2mC3OUBCabL1kjmsDyoM/KJMfZNB/I9tvLBH+YIwrfUG2e/VyT1UZX1knuY6jURT3sRhbP514stEPIu6YvBIbB1nNcZZ2S7w3uKDKJ4LjovbFSe6YKLVXQ7dmCGdbDK/PcSKqkvPX2TPytUFrT6dZy5dxjDyWF/ye0nTdpc8tfjXDn0AV8iTjKhU8TIpsGzWWnPcUvwtB/Ru4g2LPZFBwgMug/YSM45Bxccs9miVwMDHuECru7RWanR9p8H63+SJPyPfnxMVLG2IUDovTCURwUnC+jvnqWwIU19jEJmw6f1ZlQFfXFfeGmL65Sn67q4w/NZF9vxrjtYqnaIbw/RUBjTZ+OwVtSDf1vUUCfn2whRc+VBA6UgKHFxPkFRaLA8fSx+bSmUYed0Cue9UMW9WyfelgvT9on8Sr3tS+zSsLQX9k+N1PSdOHLanMqK3gjRoqadokFVr5NQaK7QlNhuzJJQmXbsamFmV1LJGQHM7aPVQ8ufhipCCsZITw0WRsGE/+3FIqwQE+Q6LdrVe5KDVQ9fXmyiux/R7JDfDKDvEjpgsboz6wTMVDlpyvGp6KlNWhqIbZcSYZ0+7n8ebwySVFmuMfBAx2OuXQU82R8icJEuu+M42v6ytZtrukgFEnspybVHyM/QCxZfFsBMKJ3xjhqwiTxcJpcnEG7tppTXWfUUmonVEQnnbXxCK4EBsAAUYEWVZ+1s2uK4cpwB3GRuIOCZvnX0YT5d1ry7kWHa3mmH66jSD95SpDIYILTiEj7qUtkSZeE+WR58YYewbvRx+ZRemfux54yF4sOtEPtl7Odesew+3x57PjxOnIYDzK3sIY3Nx5Vk+Pv5jtjRkPH/8yTYnnXOU066Q/105IUz5vBCq6bF0cZhE2Aw4IB0+6tffeZUsS/zr0fAqvJABlo3XaiOabXrMMh87/HOWlCgPdJ/MMmuJX3afxnvPeiVv+dWbKbkRXKQZsCOcmrG7qD8qTzyjty+w6pMLOKbCxPu62PFQP3c9vYX9/9LH7GfSND9iMP3OLuwuhdYmnUOf7Wb/L3p4eMdaxh7sY/LmLkQdRj9fJDTnoNoua14/T2jRkjJ1PMK+orPk9yQsJLCq4fdvJKBaupI77NfO59ARi3VgXtteOYxwIX1v8xgkXciysketEhMmT7eWseiGj7ty9DmxcTgo3FdfSUaRad4JpSkFLb5uf7eZ48nWctlb2GVS3hSm5MZYoUuH4zpjTjob1TINV6dgy7xIqdCTyeObQ9PsNnsZ1qRKcMSYZ9zMsdPMsaEyy6qfLXD0ZWkSwyY5tYZ9VN5Y3iicaMhgYJB9koYXCpCQJUeWRoO61DpU/ECVlqdRdKP0qFWGjQJ/7RuinVVJPNpmS/hwUHd+4LLXExY2y7UldraX8VR4mMlrM2Tvb6DukallFiqJZIvD12foeqTJ8FgtmLJUPL92tWymkZtIL3W8kHHMP+JfR3tW8rPUabywsoszFvYiLJvPf+LVJJQmg1qF0tsiuJogvevYIls6OSqTvmM1qi8OM3VrF4UL5L+zLTLMgojy1dHL+HNmI1bTxl3Wy/b4SgC+MXgRbVQKepI+uxL8zPgRk9KmCNM3yv7M/OVxYo+bOGFB9/0N0o16YDOftjLk1DKRg0XC9rFSZbZvOSyW5fvr7gLH4ab8fRieze3LruAt+d/hIPhT7gS8sMHa7ywGAKsetSJHnZ7Hup/O8vzb9uEBs+cneeLeYfbf18vEDT00VxusjhQo+XAw1xMMaRWaCR294kcEWFliusmh0W4K70xw6IEefnbXVpbOjaI1PKJ5i3XXzhEVLdJqnZIbDuImj1gy9Pig1UPL0zjk53ksOuGgKdtRRHcmgVF/7Kri4q2EpU0Rlt0rxXFhYQVEuCkry7BvtS86cXabA8fnZvWv58TGYfiNvsN2EkM4gSu009AZ1JaIKSYVO0TqYJPKOhkY4yB8mbF8ioyZORmtZuQlbcsX3bgohIXDRmOeKT9fo+AkuDB6iBF9geR9TRTTY/z1PbRchbkjMTK/kzP09F1NeEeTZdeVOO2mwwx9pMSGL86w6YE5Mkfr5NQKZ0QmsHwvwqBWCjaTnFpj2k6TVhusDheYuKib3t/X6Gq2eLC0iS+ffyGi1uC133wvjzdHWKEvsDk0jftmFTOpsO7WOVTXpepIcPOBa7pxddB/0aJgS8iT6JiPNZWaLnULcbsJrototYMmKYBot/nxwPlMGN28N/9bcnqL7r/MUnKjjFs9NHoM5l6TIP2IbNLaUUHrFI3l2iINVz4RI7Mmo19eYFt4ORUlArqGMinrfjceRak22JceJq+nOGNpH45QeTK9mju6LgRg56f72fa7IR68cyOTL5OS/uXfXULoULkzhTFts/kdM0QsKdMeNeZQhItotjmnsidYM6LagO60fG9CcEllByc1j/C9/ufz1tmH0D1blrazS3jhEGO3xAO5fN5Oo0y7jL52kQ0fmkN4UHpRhANf6yW0SUZDdqzpBV98tuiP0cetLIbt0NT0QKNR9WFKu9sDTNlphk9e4MDXevjlPSfQWGaQ3dXg9MsOE5mzJI/Fk9T6Xk36glxP8YOWpUcl6jvC624ogE1X/QdXJ3h72u5Cx2HpsgipZ1uok17QY3umvYzVxjz7rCwJpSkh4vz7Ydn/1es5sXHInXwR0/eJdGjhINmtA2qDtFpHq7soNrhZWetmlQZ5O8W21jAVJyzzQO0keSd5zMGI8JtgEXaaOVThMml1ExMme8wuJq0MiXta1PoNNvx0lhNPm+bCc/az6g5pcut6vEn39hrRGZPYM22G7llizdfm6b+hxNZzj7L+5Dyp/92g/7EyC+0EKp70xAiXMbOPnFbG8qE+hctiqC2PwikJrj77CfneuxIsv2uOzeEpTE8atp4KL2fsQ32knmyx6Ycz/qjZJpYxKZ8TIfobkx6lHIQNATz/hh3UhDxyx50WaCpeLPJv+gJeyMBpWXxy5VUonssnJn9KQndkyI1ok3dSLNwUx8opUrk5rKFoctM5YneRFm1O+sAciuNx5+iVUmTmetCVQrRNlGIJdA1RqfNoaBUn1yfx8BBti3PNg7g6zF0k9QSnhydR4/LYHpp2ePxzIzz1wj52fHyQnj/VWfWGBWJLcgx660kXcnLrCCe0po+9l7ABjouo1InT5k1Lf2annuOFc0+zxpzjL3HZmPWSMYTnccup9xMTFhU3TN+eMme+bILeHVWmX51EOPDkVcMMqjWZD4sIovZyao1hbUkKu+wsPWoVreyip2UY0JBWkQJApUGvVmW1XmSs3Y+JSmxjm78+PExzQCO8x+bUKw8T2ivxnTm1wpBWQhcOK/QFNhhFBrQlBtQqCSEB1Wm1gYviaz9s0v6mktNKQfrb+MVSo7Py/g6TxfJlA4ZP+YsG0ZnH83pObByK8Gj5eYkyGrDCiFYLMkL3WN2yZ1GSL7eV1DBwGNBswopFVquxLjTrm9VsFFxSSjuIa8tp5cCVqAuHNfq8FMa04YTvHiXztybxWZPuX9SZOyXJoY9nOXyL1D7s/0kvE3/u5de/OpEDf+rjoW3rGB/L8cTdy9nzyT7qZ4cY/E2Jk153lJc/fzuD3y/jtbxAhNTyWRimpxI+w2JaS3Fic4pVzgJoKspCGWE7fOLlr6Pl6ZioDOlFyq8IU3xBlMHPlBndK5WTK7Qae1+cIzprYT4j+bMZvw/ioEBUbhyuroErnapuKhY4WfE83GSUmarKrcuvoteu8ImJn5BZbASffTkWpnp2WKrTKx6G55BS2vSqVbTvWhh/aDPxDxkKDQ1hO1J6XqnhpmKyNLIdvHSCh3pOQsP1Jece59T3UzonQiUpQ3srLYPcJ6UGZuH8GBPPl9EH5VdHmPtCit5tVQYvWKTwwzi9ccF7Sr8Vb3DyAAAgAElEQVRjQY393aJRZPM3EuJlxb8R80xG7SLLnRIfG76Ko5r8/igscvOv/5XlepG8k2T0zwWed80hbF1l9129JPa2MQdVvLOh7mmM6AsBiLzl6uxsDzDnxFmhLZFQmiy04mhVl9l4ys+mDTNlZSn6WIKd7X5iisl4OwdARYux+/NSG6M2XE545SzpvzSZd+K+C1cm5+f9YGEZYagREyZJ0Q5CexwEk3Y2gEH1+P26+mCY0kkRBu8tBQlgQ34PbN6Js0afZ8bqYsjHpx63e/a4/rT/5tXydKasLPOOpLiPW1kWHN0nu0kr98mhGWJV2XQsJSL+KUJhRF8gKmTpUXHDJJVWkBuhCzs4FqaVBkVb4gSPWGn4F8ELLtjPyKcWEcCeG3M89tRKWt8MU39DmD2bZE0YqtiMmTJZvOBGiSltzJDKxKYe6q8NsfvOHPc+sZGdX+2nujxE360VzjpvgjU/nyMmWoHE/YO7ruQjF17FTwbOI+G2CXsWbjwKfqNRXaxw2OwJyhxdcdl+2zLsjML6N+VZkV9gxo6QOlv2H1bsWghGswAhHL7yo38CoG6rUsPR8HsVtj+Kc1xEy8KLR9nVPcJtvZexwiyw8qVFIhMyHaxcjpB4qIWjC6LTNomvt9hp9jP4YJkVn1gk/8IEf756FZ6m4jkuIBDhEKIhvxthWnhCcMTI8mhiHTouaa9Fn1lm4kKZhbquucTmN82y4jdLmCkVLyJYbeSZsbtwPYU/XTbKA3dvgCF40Yf38k9T/0TarrM7fCxMbqQyzXm1vbw3/1uuWXgMkCK4Gwdey5PqEJ7f22mdLCHfI/oimW01Rt5clM7ZX6XIz3SR3N7mr9ePoBsuGcWm4UpwV1JpsSUkb8YjViYg2acPyid3/5oaK/RFwr6Zse6GyDspTg3LLNGNoWnG2znCwqJ2RojS6WFMQ6PZr7Px+jw9O6sBnS3vJJmyJPJj2pan4EmrmzEzx4bQtAyIdhKcaOTZaORJKCZj7QFG9EWGtEX2X9hLck8bdV4+IHa0B9GFw5ZQiXknzubwFJb3P9CrouKy2phjuSZj/KLKMXdswYmRVRqyXqvK2juUlieNZ9rLgGOslJxW9ce5TRQhs0qlO7URBMQuzUS48G37OeN9kzR6dWZfIY/OM29J4kYVqq5O1TUIpWVjdnYhRa/vaOwQywtOjF616rtjLXrjVaxLNXb+bIDHfryS5rDO2vcXOOnaafryZe54/asY+oc2OC6PxNfTFDopu4FRKgciLa9W57evPCPo7Ri4xHNttn9vGbQEW66dpj5jcLg3g5lRyexqMmMnpJwdSKktqkvy93VXk9OUbn+E6d9EotFCVGoIx0WptngitopbkpdhLymc8vIjrLy3yLpvzmGUXNqjGla3wurPLHDWp8dZ9q4l6icaPHnHMDmjgqg18OI+r8ORPYiOXgRVgOvyo/5zEMCGhhwZN0/S6dtRpvvyRaJPtNn2mWXUzzKI72zLhiEuurAZ1QuENtg89P21HAz1BvX5efX9wZp5T+FB3n/kl7ygshsBfDl7Ae/PXslMKoebjCLaspF67Zd+SUJpMb8/wslvPUp7QOOpHwyxK9nD2XccoJnTaF4tXaiH7Hig9ym6MZ5s+zBzxaTlGuSdFLnd8pQ0uzHGjJ0ipVjE/B7dgLZE3pFhQi1PZ8goklMrkrtyQ4Jo0aJwfQyzR2XTdbOkpxrBJGSFvkDDDfG88DSLTpzNIVmiSnqe3GQsBDvbA5TccOBWTigW/afJ12TslEbNjN/T2GkmcVHIqQ3qf5exezyu58TGoeAxaXUz7ySoewYlJ+oLjDxWaGUOWj2yEeiftrS0w2a9wUZjJkD1hYXFuNlL0Ykx7aR8VGTNJ4FHJb7xrwbnXnKQyJ9NDn4ow85f9BNp2zSHdDLpJiouz7YHMVFRh+Ri7T1c5YidAWT9qPhKv87mVPd0Gm6IaSeFgUPx9Bh7f9bHgU9007WtwQlnz/DOvb9iTWMGL2zgNkwORHMYuFxT/Zt8MnoeXn8volLnjvMv9qE6CofMXmZGu9j77V60OYfzXnGAnvEq1Q0h9L3SqNepxefsOM4B+XXOhbrkSca0EJYjR7MAIR23twuaMgXMUxX29q3lpsxrqA8brHxnkdFvLHD04jTl/gjNbp3mOo2h71Zw44Lt3xpEjzqEFQsvGUfUW5L87nkyxMfx8GIRhC03ksOtGBYKfXYFx4CNd+d53lUTaC2XPT/MMfPyNPMb40SnLDLFKkmlheOP0HsXqqx6UYkV7QKfG3oJV578fv45JvEe2yPLuSN3MTf2XsPu0ABH9S7uC2/AS8URbQtlfglPlZvoutAsTktw0g3TCMXj2e8PYGRdNnxnlthOi8kPZhiKScVmyYmyzljioNmL4ymoSNXvltBMYJuPP9PGiQmqK2T5echOUXJDxIRJww35oGeHAa0qGTc+RqF4VgwzqxL/o8kD396AcGD9W+cQpse079YOC4ujdoQV+gJV1whS0DvZpMCxgCnFouiGGLeyTK9L4AkQz8p+1qTVI+XynkJOlTKC4v9EHYcQkpwlLclN32CUJO+kmPy7LI1207dSh3QO23JhdMJ+w8Jmhb7go/taUhBmZfl9fT0KLt6vFS64dgwvAw/+ej3l62OgCrxFaPeoVLwQunBYri8y3s5Rj4eprgjRu7v6b8DRQCCwWXTiskPvp0BN2130qFVMRWPiNVmu676OeT3FFYtPcXX5CbyQgZuKUVTi1IXB1aW/sdpbwI3oeCEVJ9cFqsL7974U11NYbcyhC5u9WweY+pcsjis4+ZVHCZkW4UVZA3f8Gx4K8V1tPAEHksukC9ZxYW7h2AftSucsnienLpaNqNbJqynGfthLs1sDD/ofLhE/2CY6YxIZs2n3quhFl/WfmKOxKKcAXjQEui5VmyEDDB1PUxDlGqLelD0I18VENloVE7q+1SB/VYLf3ruRidNkg3r+PL/39FuZ9dFydYa3LbDqygIj83N8rPtyfm+swWm5zKUky/cLfS/mwcwWFsMpNren+WP3Jnmy8jy8kI4Xj1JdK2+UIbXNmjvnSYy32fn5AVrDOrVdIYbuXGLpkgjtlxgBc3VLaJ5xS8rB5VpskFFbjFndsnFvC7oebFA8N4qqELB6QIKmir5EvOqGWXTCjPhygUUnTl0NsXhxlO7f11m2fJHdn80RHzNZ+7U51hhzxITJpNVNVJGxl0U3xpSVJSnawWRl0QmT6ZgmgR6lTVap48YV7BGV4b0yj3fUmPNPKJKQaPE/1KsSQjZ18naKSaubHrVCQmmyVpdAoI5NWCRlDedUFQ5aPZj+2FZCaCJMWt2cHJpCxeXp1jJiSptlRpFT7p3hzHdNUDshxO5f5IivkSVP3Q1JAHTKkwG+TlSq7UJ5hrQSjc06kWctwpgM+EnoBSfBkFam5EbIqRU2GJIA3/J0cloJw9effOWyK8iGLG4dkOSIsyr7ufToY4iWhXAcSnqMBS3Bxw78hP7pIyjVFmqhDLZD3022z4wJk1MrbAnN4G7UyP+qi/JImPjfLPQ5l2ZBxfY3jqobpntnnfqIQUvREdPSp+EN9ASfs6dreJEQhEM4XTFom1J5qausuGmJcNFm4nMZSudHiR9po1U8ajmD/e/uYc/b+8j8tsGll+5i5JEFuQEJfHVqpxRq40XDaBGd083DvK/8MFHsYJEtbInxp4+uZnlmKbCZOxugNmKw8f45Ys02J37yKBuunsNWFd43/BqeTK6WExSQ5VfnUhQ2WHlUPJ5y+/HSsuT0VBUMnctO/RsAe59MMfitMgeu6uYvp68mPdfg/LeMY6VV/vCR1bietLInlBbjVoqiI/tgHT7rpCUTvGJKGx4ThBYcKpdHfC+VbIx2iPWdJLmOO7vlqYybvfKBZieZOz+B2vJI7moz94Ik+ZcmWP61JaJ72hyxM2TUGg1XNtVHtEXfq6ORVhvBRMX1cQqupzDjyBQ6E5XZjUnCOy1aruS6JJQWVSdCyYmSVepB3ODxup4TG4fUYyTZEponp5WkA9RPMerRKsGXlO6SN3ym6mdf+CeADphJFS6Hbekl2RyawfEUNjw5Q+bmMpUzQjz6g1GOJLoDUM1qfQm17lGJhsmqdd9yX0XFZdLuonRmhPCsTf3ZMDvNftJKEx2Hw3YXCaUlg2NQUHEDTmnJjfCxC65iYOYgnx//P6yqS43DtJbm7UuPcGpzAs91cV34SO5lGJ7Nx4u/JtmqSq9FJARLZb5x6cWYnio77U6YghsiPWQwe1ea/OkJhANnnH+YrV+XQrReu0zqL03Kz4vwwXt/hggZuImIvJk7pYrrIkpVPENHK1QgGsFLxHjb3MPkHq5y6K1ZIr+3yDzcwNOg3a0iVI/NH8yz/mtzWDkVpemx4rpFvj35bc6v7GHQXOLixe1cVfob7yo8xJcnv89dez/Lrfm7ObV+MPBZ1K4K0/1MnfNuHWfGTNLwQjwvMkHeSVN6cYTQX03OP3c//d+rMv26FK8J3ciB2IDcNIRAtEyZAQJQqeFpCqsaszgIDmaGEZW67LW0TW77zQ8CR+jWLxzB7lKofTjEVnOCldcuolQ89n2vl1CPg4kMRZq0uik68QCVMaRZWH7uqOmp6MJh691HsGMKC+fHguT1jFpDFW4QhJ1QLKJKm4oX8l3bpjShqQ3ECf6C3yHzU5/58DKcuMLgHWWyao3V+gJ1z6BHreIimHZSvgo6yqTVjY4bZKUmlBYxXyBWcqI0NumEZh2yxTrP+E7mHq1CjyYRlYPqMbDY8bieExtH29OIijYl3+aeVlpBYyjtB/MA7AjLZqhbFuwxcxwye8kqUjkaFW02GHP0+F+8gyB2uM2Gt85RXxFi4pvdGGFpKqr4YTR7rG7MqEa62Qo8AHk7JUn0SoO5FyVxNVj72zyGT4FreTpDWsnnkmosOnJOvlxbxEHwxgeuB9OSx3jATUpR1p9S6zmkd/OBqbuJKg4IweHUAB/vv5J+q8TnZn5KX3MRNBXSSbywzvs/ez0nGkXyfs/mgUYOS1MprEngRKF6QZj092WXf/hHiyhtWHhxhLydxktEUcp1hOMiSlLMJhw/jVxT8TQVRRP8w/SveEnpafKhNKPfKNL7pxr7bujDHNAonh7jj39czZ67+zjyni7s9RpOVC6ZZU45WDzvzt/PmxYf5ZzyXqoixN2Z0/hw75VcveEmbCFv4OlrkuTfmSD38yon3TTFRmeWmccSbPn4Ufp+XEEAngZ/+tkoT31kmLYRkT2aUhXmF+XmYcqyQBgGomkyyiJHjCxW08ZLyAnV3B0aeSfpF0jQ9WiTwpsT7CwOcsIrZ0gcaPHYl0c4sLbPp53JHtmQXgx6ZWPtfu6vD3Pdr98SYEYL+5J031Nn+jUpxrUceTtFRq0RViw/H0WGAh+yMjzdXEHLD9/ebCzImEcE5Z4wZp+KeNZj3kngphQm35ih53d11o0tsM+SylHLUwkLBx2HHrUZCMza/gZ2yOz1GTFdcq2qDdzVcoMWRzzOiByi5EQDwptUrP7/7I4VQgwJIR4RQuwVQuwWQrzb//Pjyo9VhUtYOKTVBg1XD+q7khulz0/kHu6Rx2+npEo8o75AxQ3jegILFccTTNkZieHzLM56/wEA9v5TL/WkDDk5aPb6EGmfopZyaZdUDKQQKqm02BCapuXpiIxH4aw43b+qk3XlZGW5tsRGI+J/wVrw88bMfmLC5DeX3MnYzUPBsVpY8lcbhY/2XUlb0VjfmgXHAc/jmdx6Pjh4FV1Ogy8c/iHrajJsRzRN+h6ZZ6fZxYi+QEIxWe4HL6erDcgoPPT59ez4uQwzMo7I97PhhnkuuG4vXz/vm5xb28cJ5jSjPvNjTXOWrfUJLio8zbvnH+Bn41/i+TUfROy4HH5PF7/8wwmU/ncYreYS6nLo0WpMntDNX25Yxb5v9/LME4P8evcmXr/8en7adRpzfiyhC8wrceaNFPNeFGFZrF04RNiTo2BrUmF6XYqFs6L031Nl9aY5XvCq/az5+RzTp3UxeXGG0KID3fC1a14myx9VxbMdRCwCjoMbl4vfHsiAptLTLjOrpWWjV1EQjRYfXfcbOYb3l7bdpTB/UpyXv2o7kWmLvd/LYZ+v+FzhVCCiq7phtoRkStaG8DS3PvRy1t0+wccvuwYVj9O+MYFrCGavT7DOmGWd30cYaw8EY1XTP7FuCR+R8QnClFwfP2XOQaE2FKK3ILnHdTfEzLUpzKSK82UZFrRCWyImLPJOlLAiPS4xP1/k2fYgQ3qREWOehCIfpuuMWdJKi6mYbOA7ZUmFG9RKqMJlubaIiodynEuV/4w71gZu9jzvaSFEAtgmhHgIuBbJj/20EOIWJD/2H/i3/NjTkfzY0/+9f8DzTWlZpYGBS9ELc0b4MEU35B8XhWTLJuVTvLFk+GEt0sdRciNklbpM4PKbVd53XVJPtv8vd+8ZJllVrv3/1k6VQ1d1mu7pyaGZAMMMMAwZJedwREXMIIiKimJWVIwHj4KoJEUUFBEFlZxBMgwwTI49PdPT3dVdXTntqp3eD2t3oec973V8/3+u9+I6++NMV3d19V5rr+d57vv+8fIPZtM7p8lOK0S3WsVCRXVdgrtazNvQQMm4xMdbLHvfGFrJxQOacQ0noaAOQH2xSvhpi8G7J3n5XbOZrZS5oTiP06LbmHBkPyStNHxqlorlKfz89F/z08wJ8APaY0EUhYIR5+edx/HViXtxNIETC6LtnWSj1sNnF32I7+z4Hf+x93f8KbWa2zvWYAWCXHPoUVz24rOAhPgkqTM7l6OclFkQ5lx5UlI82H1mCmF4pDY2mH1zni/b9//T5/z1qfv+4TOX1yvhudzWdSQ7nCSXfuoJ5qp5Ju0ISsmlHAtIpo2wmWdMYnoaCaVJPuiR6ezn16kZ/GbyEPojFkeWtrKsPMya+i5Ocjbyn6/ll8tekCfA7FYJTDlYEYX1V/ZRf5dBK6Mx8+9Fln9jDNGyUcp13HgYJRqWkydVQZTlJqRNlhGKS9QxqYZ6wXYQzRZXPHYvinBxPYVUS57EanMMDnjfGK1OlbV3zmLXwm4GRA7TDbHImJAKTyEJfsO+zuf8ey9l8MYiXkccUaryt8MO5gfjf2TqkihWl4breRTdEPO0UlvFWXSDbVTmiJ0ipjTo0yq0LOmA3tzqZUDP0YjpRDIS8ZBWq8SSLcbPjDPrjwUmGxE2GH0sNCbaZXjR58mEtSZJT22fkCxcBo0sY3aMva0UB6TlyDtQtpn0YkxaMenedmJ++f1fctH+P1//Ssr5ODCNe6wIIbYgsY5nIrEJIPmxTyE3jjY/FnhRCJGchjf9n36G4U9EJp0o3WqVtFJnk2/4maNPkXNDzNOq5EMqbkzQOVFlSkRwPcXnrMTa4cRBYZPLhZn3kxy5Y8KU3hXAcB1ydgR9g80hDw4Tv88klJE3oavKsB6vDo0eXZZN5RbKTpfYkyappvzAu79aYcW2EcZOTzCw/xRDdpR+tcoOs4e8EqVLLZOxk+SFS80N8N2j/ighEtMmM9vBjYV4RtuPydxTdNoVuqYmKYSCeIbOSCDGJ2d+gI/lnuLd+RdZU9vBb7uP5rmuxXzlRx/hqs//GheFpGgQ3dxk7BhJp1N8jYMVFIxfFYeYICtiTNaj/OqHpzD/7xnSZoljG1tZF5nLmsJW9q/vZUjv5EfzzmHYlicGLyh5qDk3zMR4EsWBSqfEYbqeQkRvtVmsQWGhZotg6LhdSfY5Hr/vOwrRdbj8rAoZ0lqLaLPGe0svscQc4+lbFlDtCJJeUKEeCZDeUWHh56dY9YV95B8O8/dPLmDbl7pZ+vUMp6Zf4IGug2UDVlEQ5aqc3Fhv5m64kTiRfabUJwjB1DXy/Q9bnfQreZQX5NcmXjcZPjPF81+ZBx2CJYFxhqxOcnaUWKAhm+JemH6//Pz6QSfx7uCrXJG5j2/2ns2oFeQzUw+xT0sy9umYzG/xMRsbfHDY9GSr6ITJ+/05iWKUvqs9PlBrc7OfvkSJ4Habfk2aInvUKsMnp5l9W4HIYxa9Z5T8vkXE70/IeMkIrfZIdvq0MQ0LyzlRxqNx9mMCq6hJsLanoAvXP30JutQ3DYJvxfV/lcchhJgDHAi8xH/ixwoh/jt+7D9tHEKIjyGJ9vT0qYSFTQa1/VRThYvp6G3yuunqsgm1n0FyY4MpIm2rcNGRiV5FV8qZD751GK3qsu4LMxm1Ouh8osZJ120mtr6JqwuyR0XZfFmSwv5hYmMNVn9sL69+fjbmGtnRlo0nmz2NJF27qsy8q0D/rWX6f1Ni4NclKvsHmPh0jMI7QjgoLNSzhH0XouuzRfdZKVYxyr4TI/ArAA8xkYdYhCGjiy67wrnltdzccbQUZXketVCQH0eP5u/xQS7OPsnXRu5mONjFnxuH0X1xmUbCYHxvghW5Uaz9FSadGKuf3w1A7rAIuUiUGCYx0aKuBznva0/y21OO5QDdxqqrXDz6CHVh8Nv4ofyx/yhaoRBK0/I1HT6GUjGZvVlqBWpLDWZp+XaE3mL9TZewF/EBTLaLZ2gopZpswhbLZCMJJnUN4gYHNveySBnHOxbi1LFQSYoGowtSWHdrzLi5TM/1Fc46ez2j70ywM9DDRbmn2B7pZ5eSliVdwMCNhtsnDlotlEoOF4FqW3ihAN8fvBurpLDi0b30/rJMbKtcKNtu7GTLO/tYqE36I/QwYdFE1yWGYFqK7SB41wOfYjA9hZEdp9Ouojs2nyk9SbdT5vMz38uW0/r59uN/lI16peGjMFTSqgwNrrs621s9uCjyhObq/qQkQMovgXXbBR0fddpgwomirHaodhkkH22QP1NC0gf0HDU34GtbBJNOjLhikvL9NJN2nKRaA1VuWJ1xWY5GKiYWYebosqwNCouhVjd5tc6c/5vF/t9c//LGIYSIAn8GPuN5Xln8g3nqP3/pf/Fv/9s56R8RkIv3D3pZ/2lW8wzCyNpuRXAfpn88iwhpuW8s10nfXiPpNnnNHmChMcF8fbI9mUlXK/T+ukzupDAx2+Tc89YRW9+kMaCx/qo+MqfF0RLyadSp1tjXncQTMLg2w6trZhETFkmlRcaJMCkStBbr1L4RQExAz2Nltny8h9l/y7Pgo1PU9tdpXGVgHaAw5pPWTJ9mvjgggT+fXvWw3DhUVSo5WxamYlBXApw69Sp3dh5GqSeFqMpNUOg6a8MLeLVzMUdn1vPe4ot8bvdfsVYolN4RBJ90sGdBGkrQ9x154xcPl/kOSa9BaXOAxRvHib3a4qShX5B06lSFwe86D+cvkQOoGBHpZC038II6otFCKApX/uDDfO2Lt7Fm25AM1lkGTd9zM2Kl0YXDiCXVlHjem6+dmMLrTMmpTSCAZ+iykel6GAc3aW3Q2mVlxQ2hqiV61TJ7vQ4mL47T+74S0V83mfvrHHqzhIvgRyO/57bkGl4NzGZP9yyUmikbzTlp1vOCUarZIH1Oid+e/wsCl1jEnmqitDyq8wxsA7QWTJ4QJ41sDru+7Dqt1jA9jRFLmtZG7SSfefD9DN5QAE2lH9lg/7fqWg43d3JL6kg2di9CqTb48vsu4vu/u5ma37iPKS0/ocwirFjMNyZxUNq/b96JElaalNwALVSckkIjrrezZ3Rhk3XjNA/SSGyQIKdpkddQq5uVoWGKTphZWp6cG2k3ZcOiiYuCg+DQ0G5ybggnKOiq1Bj1koy2OtoP05XBfWxu9fyrS/1fuv6ljUMIoSM3jd95nne3/8//v/mx05fjyQ86ppjU3QA7Wt0yMNYNklYamMJBFzLNa3xpnO5mlbHNMfqWyhDYPq3BsB0lLJqkHq6jV13KkRAHn70XM62z69/TvHDqPJZEMoQ8GX2/MjDJ82Y//V0FqgcHiN9vErms5RPibVxPabM8u5QmW7/ZQ/dLVXqfKLPp3h5Cj9gs/FGWI87ZxZ5LU1ifiqIY0kRXdMKM2QkGmWyTw/IrwrCnJUVZmkJFBOh1yxxd2sx91UG5EH3viihXQVV5OriAp/sXsdDOcnR5M0c8s5MeS47V3nHBdlxNoFhyTx68Ksu86/NoJQc/phUnLNh2XA/XvXQULw8cgOWqiHINYdmoeZlHgaYiLBsvEqLniXGUL7qI9R6VeQEiMZuKHZIJ44Fx6q4su9JKXb7Ppo0XCaI0QjjhgOTJ2g7CdnA7YohGi5XxveiK0y6rprGTZS/AfD3HhmYfRKH1SZVPvfZJ1ux4nVOK6zi4McxFhWe4iGewJhQqIkjKlX2LW7f9nJoaJOY0mGGX4Epo9qqMvS/O8ClpvFkeR66WJ7HpwKNRX2uR9qMOZmkFen09zuV/+wCDN2alac91CbvSd3N4ZQf3JlZwV2yV5OMGDPRMiQ+/8UF+e8Ct7LK6QCsSLLdgk0tsqkmg2EKruFSNILGOBlOxGIHFLezZKopwSVVq1OKGzPFQmnTpNXRRoLQ0yLwH84zmkrgJhcX6JIeGhhi20yi4dIsqA1qRiJ/eX0cyW8pukG61IpufAqp+T+RNOqHFkJVioZ79V5b6v3z9KwhIgXxmbvE878f/8F/T/Ngf8L/zYz8phPgDsin63/JjVVyWG2WeN3toeWp7lp53oqi4mK5OXG1SdEP07C+PZF2bqozul8QSKjoN0kqDHU6UznuqOAHB3D/nyJ0TZv3X+xiPdLDEyDBsp9GFjYvCTivui2UsdpzSzcpvjqBvdehfUiTjxDnAmGKfHSIibLJugHBPiw1Xz2DFRaP0f6bM5pt6yRwXZ+FVWeZelyf9Yo0/X7eSaFoGCc9UZWBQwQ0Dec5a9grXnH4Ci6+XSk5LKOwOdnNMbgP3zvcHT/kSaJpsypktCU5qNNkem8n20AzuqB3MnZM3MHFUnFjZJPZKi9p+OpEtFnZQsO+dSUTSo7gghHuAYGxOgpoI8tyaWYhSE0IBvEgIT9dQag08TZUJWqGAnAL5486OjRf0QDkAACAASURBVHWmVkcZsZNtgHeLpt8EbhEQjsz5ALnpBA3UUg2vUsPrTiFqDZSJPISCNOMaoiQBW7M1i81WhJpnkLXj7HB6WRXcQ9ENscTIoYxWeCm8gJfETJYlJvjmxF9wETyfGMRxYUFrkkVmhnXh2YxpSZY1R5kRLvDYXwdJzKxhIkOjO1+stO+taUFWRGmSFHX61Srrmn0E/EV1wd2fYOGtRZxUBG2ihOK5rG4OA7DV6OH6mSfjCUXK6/1T9twvmiifcTjl4c2IVx3Ce63/4729AHl6sOIKpWUhApttqqdLsdg0WqPuBlCXyPe8eHiCPStSbR2HdIsXGbWl9qVPK7Qbp2m/H1j2AoSsFmrDIx+NYHo6i/USrzVl96BbrbTzPN6q6185cRwOvB/YIIRY5//bV3iL+bGvNOWiPiiQYciOtgNPQOry99odMgpwZpxFkUkSGxtsOkeOwoZsGWUvNrj0vlgBBTZd08vI6fI189RJhu10WxSUVKQSb1KRApr46SbO9wTzf5Nl8t/jWJ7G043ZbSDO9lYPcdVEP8YmelWThV+dwvmKwrPfXkDrRzqtY1TmX5Hj3eev5aVb5hCYbZNxEiwjQ0TIp1fdNbjjzOt4j/JJxBdkSvjTySV8KPMU6UaBvIjgdXbgTRXwdBXPCCMaLTxVwVNVlEaTU+obUS3w5kDsVy3GLoiz9Vs9xFTpDp6eNDl+NGIQG9UzmXF/i/HTBEIReLomiWvTxreWhaepiEIZAgYDhTyBjEN9mRQiVdwgCi6bzX5WBPfSr5aoeLrscVg2wrJBUfF0DZIxPE2BcBC3K4Gaq1CJBdFqHhPNGBVXsmcdT2GhMcmInSSlWmxt9fKNyy8k1tiLl4whWhYb1T4+u/DDfGfn7zmqvIUbe4/np9GTpBZFUxEti5+9+zcEf2BDEByh0qtUGbXjhEtvLuRpOv00z2SUKDGlQcXTueDuT7Do5inZq7FUuu0yn518iMWmfM49oC/C0eQ9I4CeVpF3lddybHETkUua2B0KxUOD5N4TJrc0SmuGylQ0hhJ36beL5PNh3JxCz44ynRtrhJ63UFseXXfXWT06zLaPdbHu8H5iqkmmI8ps8ph5jdcbc8gaeZYaY+y1O8g6Efq1MsN2BwYuCIs6Abr8RLGiE8YtyE2tI1Vnm91Lzk/wTyoNsk6sPW18q65/ZaryLP913wLeIn6sh8DyRWB77LAsTzyVLq3sS39hRWCSvKOj6y75lWF6nq6wSJtg0o3JvIJxwSkflU7JDV/tZddp3QTxA3CETVg0iSkuXWoN1xPstTvaG8O+ZJKu91To/X2ZzKdihGc0iWmNNmpxkTEhw3LRyJwfJz1lMvCTIicWNrP7uhSjZyRp9aosuijLoe/Zzba/dGP6H23NTzKPKibb7B7+csa17Lu5E7YqvK708SFg0Jrg2c5lKMUqXiyCkpWjQFRFktlyRYJui3NKa8locfp/VWb8pDg7ruzCEco/idfm6FNS/IPwfRJhPt37GF/qej+UawhXunHlYpGnBU9XIZ0Ey6bjKXmSsA5RJOrB9+UMBsbJuTIPw/I0qZvQNbkR1U2o1iEcAtNC1BqodRMvEqIvJZ+kHdU6atptv8+sEyFrxxkSLZYExomt3QfBAAiBMyOFOllkxAzz6UUf5Ut77+EzYw9wRGgz1804icmyyuXPPUb5eanrmLNxit1Hd6LiygZ64c2na9ENYno6hj+RCAqLvBfl4kc+xJJfZORnEVA4de8LXDj1FAoez8UWcXhlOyIUQslXSClN3p9/luMqMoFsfXiAP6dW84bay5XX/4WME2dQn0L1QHdk07WiBmnFNdQ5Hi/vP5el548R+nOLZZ/LsPu9afqeKrHyI6PMXZ5n3+cTGLNlyRkoO+wXHPWxkGFmaQUftqSRs6PoOG3cY93VSft6lHRZ3st6wmVlcB91VyMgHMacmC9Y/B9oqwcIC2knH7U7UPB8zKGU2rqewpAVx/Q0NrV6KZ0aJLDXwVsveSvxqskJF21Fr8ibY+fZPSw3Jtvwmx2WpHjP0UpYnkLN0327cZWMk8AQDs9+dAGeEHRdIzMuLE+TCeltkLR88oxYaR6/dBEvfGMOHU/WmXNeHneX4PkDFvLy7bPRKi5zP5wn2JC9Ddv/g7U8zc+QVFk2cy+tpMJQZAY2gkX1cUTNxAsHZQ9EkRsG45Oga3jxKOc13yDpmvTaZf6WWsXun6XQtTfdsQv1HHP0qbagaUArU3SDPsTYgGwepy8tG5h+LY9lI8wWwrSkSrPZYuquGLUBg3WDA9TdAP1aQY73EAz4ye0ptYowm7K0sWzceBgvGpabUFCOR2m2mDwsxfawnIoV8rL5/UpjXtvM2OcHL2XsGF4iKkuzSh2lJOFNXixMwQvyxQXv5+fdx7HMHOWXQzfxqcrfSY3WCB9i40QEMx8pYbpGm64n/iGXd3qyMaAVCSoWeSfKZx89nyXfn0Cognfk13Pzuuv49OQj7NC6uGT+Rey0fOqZ43CcuY0bRn7NO6pbuD+1kp3BHgTwanQejit4ujaI48kmZc4PIA6LJjk3QlBY1DyDVUHpOUk91KDZrbL320nWPjnApu/3EC62WP7BDOGr5ck02mjS7yeDZe24TEJHoeiE6dcL1D1peHORgrNpGqFbkvfZcCSFjtdWipqezi4rzXarm7fyeltsHDYK3WqVXq3IisAYWd8dOMfHF8zTpUw8pZosNTLkTozgaIK++2WexYLLswS3W1T3D9CcoxJI2AzZUudf8cOP626Amh8iLMdweTKO1F+k1Dpun8KuD3Ux8Kcic5+f8seyFptavW0Q03Ij409xshQ+GGHbzV3ERkyOPnUnJ96+EXcJvP6zAWLbTZb9SPaDpzccwAc4dUrbdbTA+s/3MBzoYn5rsp1E7qRjcgNpNKG/F1oWZxbX8p7CS7jAjYkj+UXvCXz7rPe1v3+vWuOp+gJJklNrGMIh7wTbx9Netc5VrzyIOim1FziOdLcKgZOOSZds3SSqOax8eYTMKXFimtm+8etewCfmGaSVOjuavTJ/IxyQr2208IKBNt8EReDFo/ziKz+llZAnr3nVKd/xm6HiBsk5kXb2yDUnny65K5YtX2voMrlseoObLHCvPZcLF17CQ9FlnNTawMpj9tFzUZHyoiDhB5pE7QaG30AX0TeHeNOw5awTYYle4+OPfoAzv7eej048zq27b+QLY/diazrf7T6NLy/4AJNWACJy0Z1WW8/nsg8xHO7hknkXckP4MCmh9zyE2cSzLB477yDyTpQROy7jIIQtR85KXQKkccg4UYJVi56ny2RPiVIkQkM3sM7XGX+yk72XJpn5oJyOBQpyolh0ZBQEwJjVIY2cToQ+rSA3SN/DMmbHpJmzJl+vJ21cIKXWaf5D2TpoTLyla/ZtsXHowqHmS7izTkj6QFyDrCN37XXNblxkTNsuK81UPEbxyBCp++pE72qSfqzOji914aDQ7NMo+3N2y9Paga9JpUHex/ot1HO+ItKh6IYZsjrJ2jHsz6s052vM/WKeeMUkM60PcWTDadhOsKPVQ1iRFvuhY7rZ8OgMxg5PMOs7RQ48aRS16DD5pRjxl+QTJOFrTULColeTZiZFJnFyxwnXs3tRJx2tCk4qIsVOLVueOjyPFVPbuHrfHXw88xgugi/OuYB7Zh4pIUTAZd/+JDHF5BVzFgeHhokpDWo+IX3U7vCZux6jTpQROwV+f8CLhuVEJBqS0xXXxe2Ic3h5Gxou2dMiPp9DKikVXBxPli4ZJ87SwCgYOkqhKo1lPtzajYdkwlgwgGjJp7s3Sy7i8k7pKHVR/FxWSWZvear0zhi6v6m5KIUySrEqSzVFQYRDeP09TIkwV911Cs8+NY+hCzsJ7HToeL2BUXY55h07GLwiQ/KmOj2b30xUX3xfhq7bqux3dYatJ0TZ8Ilv8tOR2zmzvoHdRhffnnEmn+h8D88k9sOzHZxUnFBNvn5+K8sv00fzpfTZjOkd0oGrCHkaioZleed53HXymrbmIuaH/qQUE9N9s0SK/bWJ2vIonh4ka8dl6p2dxDQU9lyR4vXvyHSzzutqhB5rYQiH+XqBAd+otrU5gxWBMZ6tLW4/EExPp0+rkFQatHb4MRN9CV40Z0tNidVNt1oh50T/3ytH/19cTT9B20EwW60z5oSJKbLHYCFv2KVGRgamKE1iisnUqRHST9bZ/1vj5A8OM/mRKDP/WMRcoLdJWSm1StpfuMN+VkZK1NlhpZm0Y3RrFaJWk55tWVZv3U0hFyJ3WIgZt1dY8MEse3/XwRa9j288fA7LvjfMvhs6+MqShxiyUgxoeTY1+1gyI8dzN8xjxkNlVl43wqrP7qM2W6fZrRKYdFCK8inc8CTFXhUuQsg/4qjdwSELd6Pt81CqLVxDI13Nc0R1K++obmG/2j5MIT+bH804lY3NBIKGlFg7Dl1P1nG/IZ/ieZ/3IkdxMqy25hmM2h0yz0Qts+/c2fQ9mZfai7osjdxoEKVqotQaHNXYzj4jhbtUtG3ipifZrSpue9Pd2uqScvByXTZvI0FEzUSZKuB2dqBUani6LM20BQ5OUDBrc57J8ySEOaw0qbtyTPqjoROJNZryKd+yZBCQZeOkYyhVyb/1DB0lV8SLhvmPwbvoUhuMfSnOyBcTRF9tsfyiMYyyQ/rpGn1/Lv/TvTX/0/5UQ1GoGmGeC81nU3IuL2mzqUTi8pTjedJ9q6l05yc4ubUNgL+mD+auviNxEkG0fE2WZh4I20bkiniJGHvO7ea3F10jm8jCxfRU5utZxpwYvVqFYStFq6ly6C+GKa4IsnbpHAmgFhZFJ0LGiWDgEE3KB01lVoDBj03QvFrj1TP6iSsmCi6DgXEyTpgDQntkeepKh23Flaa4jk11Wt0qkRlNcGkzZaX6OkvuLTa5vS02jpBikbGTBJUWeVeO1II+NLrs6izSJxm14yTVOhvMAZYERymfEMT1YcWbf9iDrrpoFRc7plD3AtRt2UXP2nEG9BxdaoUN5gC9ehEdh4V7Myz+ZZb4AyaG3xvp503rcXpdnY4VdVJn1bj46b/zpcn7+cql7+IWcQRff+Zehq1O4qpJ1jHo1qo4pyk8dfICFj6aZeDXRQKvyO85+B0pb+l8o8ZRa/fhJhUCIy30goOx2SJaN0nWTS6IP8HBa4dY1MygALv1Tl4IzWNNY4g/pNfwZMdyyOYhlUDUGu0E82+ffj6f+Otf6VdL7bp2XXNmG3XZrxXIOREsVK697Ab+/QGZD4KuQbmKYgXxNJVOq8IBlWH+GD+IG4aO4pZFv2PCkdmu00HGOg7rmn3M0vIopZo049UaEmSdToKhS9yjojB+wgwydoLlgTFqSwyCG23p+BSSEWx6fm7Ex2zcRASl0sBJRVFzFfA81LEcXjjYRjsQDPCJBx+gT62z2epkQCtSdIMUVoWZvDLOwGcLbLs6zfbVvRgZi5NP3UL1yAAvf2U2X3vmvaT/VMPOl6GnU77vuik3qnAAz9AQZoBoLstV2T8TcOUTfbeaRjRb6KN1eVoLB/GEwNM0CAa47P570YVNzolQ92SubcZJMF/PUfGxpHHFZPa9U8TGmmz/bhfzA9l2XkeXWmPMTmAodZz1Kq4G99++nLMvf4P9vzhGIR2memQA0wsAzXYANsheW68ugepJpU5sY5PWcq2t3YhoTQa0Mq+ZMxnQcxSd8Fu6Zt8WpYrtKczRp/7p5p+eDCTVOgG/djVwGTByGDhM5uPtUY8bUogJC9cQWKZKTGlIdZ1PlJ+uGZNqnZRZ5cCrRjjshGE6/lYnf3yYzPVJHn9iIRu3zODxjQt59sm5jJ8UR7Gg/64SX5iUZjFdkSKtb685mRs/eDZdapkROyUB0EqDhYE82ZOj3P27A3n5N1IDNw3QSjxlknpPns6Tpoi90UQvuJx55gbSDzVQmx7veeNFigNh7ogexMX9H+Tv4YWsaQzxRGwJv4mulv2DVLJ9UhCm7z1oWfzsrLPIueF2FH6XWmZXq7t9YhjQSjieQkqts/XrSWndFwISMdxkFDcZ4bzSK7gIHkivIvRxhREnKpWQPkIw53Nc+7WCFLUJIfsQnidZtHVTJoDVGrixED+8/OZ2BN7E0jjJzQ1GWjEMpBjM8RQu/sPFvkFNEueUcuPNtHSQJYzPv7300YdJKnVeafa3x/TTAU+Z06OU5weY890CEc0ktzBOZX6QhqFz0aaLSd6aw6makJZwalxXNnLDAYTlICwHLV/kq/kHGbDyPB1eBCA3FMeVo2ZV8RvLNjP2z3PpY48QUxrowmHQKDBHkyebWNZEf6zFgmsnWXHFPpZ+cIy5X8tjRwSR21os+NwU838yRe+jFdxRj7Aw2WV107+pRHVRgHhXg6d/MZ/KvABHfnIn3lZB2Qm218oBRhnXU5hvyAeS6ensKaUJ72qRWRojIloEFYt5WgnTk5S4ohtua6PequttsXEA6D4DRRcOs7VG20gE0PRUhq3Otgu2R22w6pa97Xc/5ybpWxAJiJdlKaPitnMga56BhcrcbJYl50zQc2uV0fcn+NWjR9C6NsLzx8+hd36NnXoXVkhj38wUu3+R4sZ3HYGGR9GP5b8k8yidZhGvJ4U+MsX3jjzND4b12G51ExOS9Tlfn6TeKcew073RwkVhtt7RzdhNSdZf2kdhTYjNv+imstqgNmCwdUMv6SfqXPmdf+Osief5YOkFHg8v5j9mnYkXks1SYdm4ySiequLlCzIW0NBRihVGrQ661DKWp7YZGrqQKVtN/01UXINbj7hFPm39caxotOgq5zi58AaPpFcwpURl7wOXimuwy0rT9EfjZX+hmp7WLlWcGZ2gKHiFkvTitCyUUq0dbjNqd9BcrqLUPPqGy/SoDfq0EoZwmHdnAbcjjqibOJ1x2c+wXZlMFjDk5qgoUKy0yfFpPzgn5mM9k0oDU9V5/fszCY1bDHxPOlbzB4YJPO+w5MYxvFQCz3XbkYm4HqJYkZtG0wLP4+zGelaae/lZ5zsZD0iLuuL3koQt81PcaIjOZVXCikzYkmE+KpVtgq5ry6w+cTfvXLOdwY9mWf6zMXperJBeV0M4UJkfJJ5pkH6pRvfPKvRdVGTlYaMccuxeDvj3EcJrTWoHSD7y3FSRXbem8YKC476wlYoZanNht1khP5msk3lanl61RP+2AsKF5nIZJKTi+ogFG9PTiCkmCR9L+lZdb4uNQxEew1YKy1Mlrb7VQcUNtrF3Od+8llQaBIXNznqS9N9q7Dipm4lzosz8fQlt0qGe0CEvmSbyWOfS6y8mLysYfPcEsdEmz94yjxe+Ph+ty2GnFWfUJ9BHlCZp/2dm3CR3bz2Ga6NHknDkiDZtVbl63x10TE3KBlkyxg/fcQYX//RTmK7OiCPDaqcB2QClA+ViKwSC7Dikm13Hp8hfEWbnHV3sPTGNrao0O1V2ON3s2ZDglZu/xcn2Du5IreHquefi1kzZwZ+O56uZUtodCiFiUfmET8X4/QUnUXMDDBoZik7Y154kGTTGKXsBlhuTZOykzCHxpx9uLIRotnhX5jkEHn9MHCJ/RlMu0qCw6VYrkhovZBK56enstVNyfKxrKDVT9gk6O/B607Jkcb12KdKrFTEOkD+v9lqAPXacHa1ukkodUW/6pY1AnSpL2b0qoFjGjQZxIyGwHT72/Atk7CS9apkutUZaqZF3DXrVEhVX5nDqB7uMXxhn8M4Jljw0wbc7ziLRaHBga5+cziSlGle0LOmjCQYQTSl+mz26iw8UnuO52CIe6lqF50+43IAuM0xDAXI/17noznsxhEXdV2FGXm6x8gMjLD9unJnXlKh2BNn7tSQv3jmb7Zt72PKJHrSKx9DnOnnjr/08d+98Hv77fjy6fjHP/2kuW6/sxh5QWP6rMbQGRF61SDxTZ0crxWRPnKHvpAlvsjjr1tcoumEUIftMMt3cZIfVScZJ0LVenibM/WXnQWafqmxo9crgYif8PxM6PU13L7phZmsFgopFzQ1QcQ3yThTHk1blshfA9DTmvpBDL7q4Z3lsv6QHYXl03lTFWCgI77QotkIUfTRkxonj2IKjPrWDUNbipd/MZubxdRYak2357qrgMHvsDoo+7s8QDtdd/G6UQpkHZx3BL7okvtDAodsuc2XuPhRVOkrdeJj+R6a48+TDKTphJp2onyQlS4naQf6C3+thugZFN4yBzEituwbxbU2c2Qorf7qHd5y1jWimydD1ab72xX+TJwNoe1g8XZOgZb/u90LyVKMUqii1JteccTYZHwlherrv9wlTdMJk/RGeIlwuevJpvIgUN3XQ4OTyeh5PLGMi2IGnCESh7Icza21xWdEN+bVyhBWBMVClx2X6fQjHRSnXUUrSA+N4SjvE+Y05/TR7VBY9LnMmBo0JrjruXPkktx1pABSi7X8REXmaUSo1vvDA3SzWJ30DoUbd1UmpJqansb45QM0z2GF1knMjrP30LMoHBei8rErnQ3UqSpCjS5vkRqGpchMI+xuSZbcVqB+vP48pdK6bfZqcavlTIuGPiD/zt3v4weK7UYWLgkfQbLHf+yZYft44kS0t1l/Rx33PLOOF389l7MIE6mqP8nMBVly5j9wxYdZf2E/dDZBWa8QUk3wgyszVDV5531ye/808xo+N44QFRtnh8A/t5vDzhujdXsY+WSd7RoSZ15UI7W2h+l4fB8F833syT5+i75ES1YUG+S65OVTcEHU34IseGyTVOsuM/6GliuXJ2feYE8N0dfq1InvtFLO1AhGlyUJjkq3NPtmse8DGjilMHRGle1GdwplhOm6vsa0vhVZ30XZ59GpFcn4H/4A7xkm+YjJ0VRpjlcNDtUUMW6l2gKvMimygCtePBNQJjJbAkUfZoaB0Fj4XWYjAYz9zjO+N3klvZQql0pDEtFiIa489kS9tPkdiC/ycDGWpj6vcKcuHpFKn6IaxPI2BLTnUnEvqwRpzfloge2KMNx7tY93xA1x97m3s+vBMebIRAs/Q3ozPsx3ZiKzUJTktHEQ0LdyQ3k43a/mp2ym1Stx3YkaUJnVfJIVlg+NwXv4lNM/hzugqKQizpY29V622SwEppLNl401pkXWkpb799ULg+o1MLx7BTcelgcwP003rNfKnhIk92URUXLJORFrwPQ8vHMBJROQirtalsMxxZfNXVSm68mmZc6K+Z0ZlxI4zbHUx35hAx8EQDv1qiXjY5NhTv0pWifO10b+wLjKbo0ub6bTLsvwxdFkOeR5Obwei0WRpY4QD63u4o+NQSrmm/DpF/s1K+8X5wP1PUffkpuvYgkDGJvFGk9TGGju+2sWjTw1SujRIpK9Ft1phzO6g8EyEFZfto7afwRvX9TMzWCCsNKm4QVxPYamRYZsl4yCVPS69T5cZfU+Cp5+Yz6areonuabH/GaOo19hs+XwPngrzr5cbRUwxKToRabADGHeJr21SPk06yLNOyOfPNn2xmEbeifKs+da6Y98WG4eK7G/ElBZppd5e0JanMWInGNDqWJ7C/oERGSW4rkLp4CBlPcwr5ixe+cRshANznpQZBEs3jEl7slYi1GySuq5KdnWUrWf3SOu5WsNFoU+drp2D7VzHXVY3X/vVB9osEk9T20+g+3oO5sLO88mpEfZvjfGboRv4yb7bObu4loVTw4jOKL1f8vjmSe+l6Ye7jAiJIgxkbKpWgMKWCIN/GOeA9+3joDNlalPxgDAv3jubF66ZS0enRFim1Cp/+MBP2PapPpRqXeoaNBXRbOGFDLxgAC8UwJ4pMys8XUMxbX549nkStu3XtNI6XsNBMjZ0IUNk3ESYhYEKp5de55HIEsZiPe3viRC896efA2TvKazIiP6iE6bXjyEULZmD4cZCkC/JksOywXaY+q5D3oliofokdp3x0+KoLY/ex8q8VJ8vpzqqipIry3JHUeRpSlHwIiHcoMbXH/sz8/Qp2eDVc9Jj4gbJ+CWYNICVSPny7A//7RK67qzz9e6zqAmDg6u7EJ7Hu3IvSdOgorTVrupUGbcjyvnFl8mrER7oOBC3XJGnO7+U++jJD5NU6/SqJYJ1i+Mv3UJon42VVHjp4Tls+HA//bESKcWk7AbJOAn6/lrkuI9swe5XePam+YRjLbJOjIValYydkFMYN9RWzq66aR9o0LrEIBVuMHJ+B/c9sIzciREGfzLJkisyjJzVwcDdRdQRj6wTo18rkFYlSS56fwvhwdZTekipJioe/VrRT8gvMaDnfG/W/0B2rIvw2RGKPB67kqMpG3QhxuwQRVcKiOa0pgjssikuldOXLrVMYkGd7OdipJ+v00opBO53yDhxmp5K4kGTwJTD+GUx5ukFlLpLcrTO8m2jFJ4JElhn0T9cpKNURfVcBvQcfX+vyUUQlNkSni6bi0q9yVhqJld3n4IAngwsQHVdPpZ/mp+N3s5fXv8+1w3dwrdG/0TXOfIPterLewEw8g4fWPUCZ5yygXlfzdMxUac5X8NOKjz5m8VE9rcxhMOQzwqdHp/98qyb2HpZn7yhWxZewJCnHEtOIrTxgmwiOo7PSnH4xjc/StaJk1TqzNezFH0uR1hIgnvNM/j8rb/nc2P3k1cj3NzzTnAclFxRnmIsm5m3bEIXEomYVEx2tHrpVqu82JgvlYudcYTtSH9NfxduQD7NvaDOdwfvoeWp1NyAzLvEZfvyHmp9BnMfyPH02cvaqtBp9IGwbLkpqpIJG7820866iCkN8k6UXrVOv1qiXyu0weJjToy8E+Vjf7uIRb8ugSLIKHEuT5/LnmAXCh6n1jYwU/GP6poqG6RC0NfIs9Lcwz0z1tByFZSuNGfc8wLHfVR6UmquH1E5qbDyvftIPGVSn6VTH9Sxe6X1fdKJklRcYlaDZT8Y5dDPDVNeFeS5O+dR6gr7+IQEG1odxNRGO6uj4gbp3V2i4081su+JsruzA124WKgs7J1i03Uz2PnjNKnXkqgt6QAAIABJREFU6nS9VAUX5t6Va2Ml+rQKRTdI330lavsZ1OYFGLMlBlUXct04COpugB4/l+OtvN4WG4fwlYSmp7HL6maOLhPDFxoT9GpFtrd6WGlUmKeVyG+OoriQXxKh6IRRhcuY3cGOj6aZWhFBrXn0PldiYWWKFgq9f6tgxwT9dxSZe3SWFUtGOemYLSw8NcsRFwxx+Dm7WfnOfaxZuYdjV28nssTmIxvvY6E5jqfKY63nw5wBvJDBuvQisloUXVe4bOYFfLD7A3yv/0z+2nEQJS1MulmmpyU1IVpl+neE8WPjbPxRL8OPd/LcX+ai73MonR5C0SXDQ/pByhSdCMuNSWqeDHy56cyb2XZRhywPfAKbVICG5CkhFpYQJCEQ1QapB7ej4BJXZLSe6ek4ntJO0Y6IFiuuG2V2c4prek+mHorKaL5QEGwbp7sDb3Yfo3YHYcUiY8dY7vstDg/tpO4FUEen2r0W0WjJU4OugePJ0kErEldMmW+iWCTVBlOnRog/0yRmVv+5j+B58vcxdNnArJtc0PMClp/SXXFDJJU6j9cXsd3qxkGQVmryZCVafPIvH2bxzb6wrVDGC+gUA3G+MPcCno8tQsXjp3tvY0FZNkrdRBhP1zhm6g0AngzI8euPnr6TlaFh8v4iq7pB8lMRDjp/hOBOi/U39uH0KNi+/KnuM08KL8OBp46y6JdZxt4bp3h7Ai8p6NVKOAhWBvdiCBmG7fqEuKRbZ9bnCjgxhd2fSFF0ImxuzmBAK0qJurB49tSFPHvLfAJ5G0+H6D1N0kqVAT3HmB2jsdcg/LrFKyfM+Sd7wJDVScwfJJiezpCdok8rvKVr9m0hALPQyNjSWNSrFRmxk21jVdENk9aqPNHopVcrsqAs59fBvhZdWrmNJii7QZ77wXxOO2MDigOxL9foyxaIr5VH9tjrLerLdCbPjlLsDVOMhunrKKKZLpGyTWNKIby1Ree9NVaWXub80kuMqQmeCi9ia1gCqL2AjlI1oWGyUe9jmTmOZ+hMuikm9W7+3rEMN6ih5qu4kRBeUEM0LB7e+F0ACudE2HFMD0mlTuftdVTTY+tp3Si4bZTl5lYPh4aGGLITPv6yg6BicdPpN3ORciH7XTOBFzSkl6XmyZq92pAy8nINNxVDAW485hiu+PtDEjCl53imPp8urYyDIPx6k64bq4ycl+TV9fOlwc0n2rs9KYTnIWomc/Qp1pkz6dcLkh2DioJLTGnIzJBGU56ELBsvZCCmShCV4TLTtu5DQ0NknQh5J8oLJ85n9s1rOb62mXuMg2UcoNnECxiyt2HoeEJwyf0PYnq6JMCrdepugKIbpt+Pw8vacboC42xtzeCSh89hv5+P+/2SIF4iBp6H3ZfC253hu91ncInyBGeWXuO6PbfyTHQxv+do9jZCHFXbwcboLCZT3XzmD3cx5sRwPIUeRZZjAafF4ZcMERpp8cZv+plaHWXWjTI8aszqYMWWvcSubTLwRJHqDIPdt6XZeNgMdJx22lhQWGT9pnvZkW7XsGIT/3mN1BsN1l87A7dLJei2iOFg+RtLxk4wS89TP8xg4+9msPzcMWL7migvg3WwRlhpsuSucTwBiXOrlERYQpjaI3Md07OIKQ1yTpQxnzf0Vl1vi40DD/q1Mlkn0tYKZJ04KbXaVn5aQiMiLOyiLBusuHzrc/QpMrZ0uCbn1ii8I0TnQ3X6H6zQmC//eJMfjpL/VoytrS6WGpOMWUkcBEN0ypR033D14EeOIJzKMRru4jBzF0cVN/Puylrsivw+0WYVNxlEcV1GQl0c29iObls0uxModTlFUeryuK1U61ATeMqbiQQPfHc1Rx/3OnZTYfCGCVqrdIxDbOqWTMMyfW5G1om0exNDrW7mGFPElAY/Pvl3XK6+j8Erd+J1JGSfIRjwJwbT4CILtyOKkq/ww3Pfw/fv+TUZJ9JWzHplwfwrcjR7NLZ8pRcu8Mn2SMWnMC1JZ4uGyDtR4qrk5E6nZuVc2fAUZgs3EZFj2ZCBMpGXm5fltJWmZTfoO4sluCiyqsm64AD/VlrL/aGlmNGgPCkFDJkaFgny8b/eR1wxmaUUCAiHkhsApckSLUfNVci7QZJKnSGrk28/fjb7/WTMDyLyZBaIoiAcRwKnDB0nFeUG+yhmOEUOqg6xuraLo7dvY4Mxg7mtSdZ9tJ9LLv9Lm+FjorcXff89JdKvNVh3TR9bVvXRRRnNcohOuZx6/noSa5vYCcHGz8yg/JEAo6EUXUoZ09Xp00oMWykM4dCl1tBxGfEUhu00857IsvjqMntP7mDs1ASWq2G6BkE/0jAoLBxFtGMoJ5fGePUHMzn48n0s+NokWx7pYdtEHwfdOkL5lCD2LI04b+o0gsL6p00kKKy2Z+atut4WpUpIaVHzNBTh0q1WiChNRlrSHj5ojFNzAwxoeWqejlORC7EYDmH5nM6I0iSxqc6KM0fpfKiOFZK/1tQBcjyVnRklKOQReqvVyUK/YaQKl3lani61zBJjgp88ezPfzfyZqhLg0eB+fL33XD7W+37WxeYA8NnMQxw//DyeqlANyKdISPdQCzXZZ/A8afoyJVoR15XHd/+KVqt887QLSP2pTmjMYvMnu9EVjzn6FLusNDknwnCrk7RSZ6GRoe7qzDGmpK7ETqILm9tOvp6tVy6QjBFFkU9q20EpVmTfY7qpm4iilOttotiAVsS2FPa/dJTIniavXT0TEffY8cGURDgoitQ4NFvy++XK/GzfO+hVS+ScSBuzCZBWGrKMq8qJkjAt+aQXgtxBnejClidFtUpMMQmLJt1qlfff/3F+HzuElFPjRG+nlK1Pazc8D1FvEldM//UhKp5OTGlheSrrmt0M2SlSiknNDXD5Q+9j8fUlOdkp13DDAQm7brZkfquvaBUtG8/Q+UHnqQwFuvEQ3BdZTq8ra8gDrh/lxFM3ceyXtjPjlhKJv9aJb5Rj8PRrDYonBAlO2hxzxTZWH7+H6BstYsNN1IrH9i928ujTg0x9OsJkOE6v35TM2AmKbhDL09CFTd4Js8PqJK3WmLthkuWXjdFYrrPx32eQ1BqYrsHywDiWp2F5moSvuwEm7RguCkUnQvbMBK2YSmJHk/BdFqf/fgNa1WX9pf1saM7E9DQmnajcpP2SqOibRIPKWxviA2+TjcPxHZPTeZQqHqvDO9uW9EEj6/cAFJSQPFKnW1KopXs2S382zmHn7CaUs9hyYzc7X+zCDgtm3i2PnFGzyQ4r4QeayIWcVJqoeEz43f/8tKxXCNk3CBp4AZ2xcBd/6FgDwISR5POlJ/jW+N0kmvLGazYcWZ+Hg7DPZ4cEDSlTnh6d+pepB0gVJhn4RolN4ZmYx0i26KjdQbcqae2DgXFqnk7FDVF0pbU65i+mLrWC6encfMov2fH+GE4qKpWVmip1HkEDUShLglujCQ2THx53Fv1qibqjsd+XJ+h9vsLm7/VSXhNijlbi6rNvk/mgli1LDp9h4qZiOJ/paCfH92klUmqdLrVGzg1J6XswgJuKydc48hTyw2/eSM6J+huNhDlLPUmIwRuKrE8tYEOwn/Myz6G7NvasboTtYvckueSBh9hrpaSr2ZManmG7AxWPWVqBfrVE3g3yiT9dyOB1U3KTCxh4to1aqOCG/RJO1+Tfw3Vl38NsUQ+E+cbMd1HWw5yibsQ8R95bExfHqPQGCT/ZZO5VeVZ9dh9dj9Xaf7PkIyaD35sk9WIda46C1a/SOFDnwfuWMXZJkkI4StaOt4OBk0qdFcF9/oJt4XgKSaVBRGnSekpl2QUZWl0qr940QDgqlc0LjUky/iJ3EL5RscgsPY8ubNI+KS5/SBgnKNjv2xliv2qQPTFCalmDQWPc58oq1NwAJd8hHfQxCknFbMcNvlXX22Lj0HBJKS1MTyfrxOQNqjTbtveia1D3JwNaUi5Eq6ggmi4LPztF34/LjJ8SZ90j/RROiGAnNcZulzWdBwS2WkREi6IrMxufacyj6AZ8JqhNr1omoTQxIhZuQMgOf6EspwShQLvzf3PvO7khcRQH1vdwZuE1qkqAZiDYNk2JWBQvqOMmwnIDikff5KoAlVCUy4pPYDgWP+4+iW8dfQ4/2nU8vVqRLrVBzpWsmIydpOhIJ2rdDTBqJ8n7yj/dP/recfZ17LggJt9bywKzKZWQqYRMAQ8F8DrieIUSXznhvaj/AfPvmWL7p7uonhcg70QpuhK2JManZA6In0MhGk2ZsWnLUWy3WmHElmPlvCMFbG46jpIrSmdtXbpY0aY3+glMVzZky/6TN6aY7U30ttnH0enWOKG6CbVYR1TqfOsPtzJoZOnWKrQ8lQGt2A43dpCJbaNOggsevoSFv8zIz9txZaO4K4UbD0tUQywsTy+NpvwMIkHZPLYdth81j+cemku1K8DMP5WwogqvXTEL8/YIm9bO4LGXFrPusT6yh8jT5J6Lkmx5vIeXX53FE88vZtsve8j1RqgGAyTVGlk7zjxjkpprkPWnPH1qnawTYdjq5IpbP8K17zyJrxx6OnP/lGPNhbupzTRYf2cfVpeGgUPNMzA9tZ14rguHfq1M8B8Sy3QhDYLlOfLh9r+4e+8ouaoz7fe3T6icuqqTutVSS60sRBBBgAEDBoPI0SZjwAQbMA5gM8YGDBhjY4ZgsBEeMgZsTBIgke0xmGBACIQCklootTpUV3flcNK+f+yjwp7vu2PPvdxvse5ZiwWqalTVVefs8+73fZ7fo9ckZtnjo292scFJs9lJs9FO+2NzlWE79ndK0e2Tqc/y+FciIENCiL8JIT7wIyB/4j8+RQjxth8B+XshRMB/POj/eb3/fO8/ew0XwTb/hMy5MdKaAgRXvaDCx7vxJq3aSqmKITpgsetZW+heXGDdZa3035IhkVGKyffqPWybH2fk4hgCaF9SplAI0W+1ExUOswKDuGhk9ErTrVmVBgaSsGHx/SVPULg3osawQqh+BSBdj6cTu/BvicMJS4ugZzO1OKBEWfWG0lnUbbS6ox7TxD8krM8fXcuelX7u6zqAgUAaNEHLGUV+esgJZN2wD31JNrkaQz4YRt3xx1UJ7EYYclSS/YvH/ZJ1Z/lekURMKUsNDXLj6s7ruIhQkC/nP2TBHRsZPjHGpm+10KU3cNHot9uwpcHxf/4QUVfGte1bHYIBhOf5KtcIUWFRlzoDTouKx3Q8nJ42JZhqWEhDx0tEiGgN0prD9MCwL+Ev06ZX+PHhp6n8GMflQzpZGermpMLbRBsVcBSjdUVjAimtSrteZnl9oopS8CvRdr3ExS+cyexf5dWCkfBFZKaB8DylBymoLaOMhPyKQyposuvxzRef5/arbqNtSpHVj7djpXTMssee3/mEkWxAGRjbYE1kAunlquIYXxjhk95WjIyCLXcZNQLCISjsJnbAkxq9gVF6/Ab9q9Vp/PDq87jviIPofXSQeEzjisKLTPv+KNXZAQrfD5MYb+BWVOPfxPWboakmvc1FsM4XeEWFRZte4536ZGItFnpdbe2kAFI0rQ3btU/d5jhRYTUjFlSAu/OZ8zj+lYqjARwopdwJ2Bk4VAixJ/Bz4GYp5XRgHDjH//lzgHEp5TTgZv/n/ttDxSOoHkdcqzHqms1tSt6N+mo5hVAzZ6oPYMqNY8T/1uD1X/bx3nmTqRNontiKHyFZ+502KlNNNBf2P3gdqWyFNVYHRU/BVNp0VSqmtBrrrA5cBAI1Gr1n9oP87Ml7+fbTT1Ceqb5QDAMZDVNpbUdHUtdMrs0tJhOyQdOa2gYvZKi9d7nWzEsBOKrwPn8J9vG0PhcAWa0jIiFkOMDVXzmTkhf2/Rdh5gYHiAqblNbwAUAVUnqVjF5uUq22OAl+eszDrL6sW+3ppUTqOrQkkUET4bgc5azm2yPP825sKsuvnUhFhvjYTjI9MERCq9OpF4jrNXUmaKKp40BKpKbxi62HYgrHH306RLVGEyRjbBvDyySQjoIP5eckCeAx5vNVdJTpL+eFEQXFU5XhIOgaiyYcRItb5eujf+aHf11CRDR8zma0ibnTffEZwCnPfpNZt46q7dT2Po5vhBNjBUVvD5hqe1JWilo0gUwnueC5pdjSYKPdqkBHiTCVOQEanTqpJVXmfXkQ+0GNmN1g9v1D+BU+ab3OVHOMETfGgJNiixMhIFwVs6BVqMiAn12scfPgl7n3uIUsOXoPHv7DjRw08h4XjrzEQx/dzD41lWEcW2Ex+ZxxZh8+zEE7fcy+R68j8+sKgTGHnYNbies13xMUQUOZBIfcJHkvwKzAIOW4X71KFdA9965Bcm6M9v8iZMy6cVw06t6nyEv3/xYb/P/s+KcLh1RH2f+j6f8jgQOBP/qP3w/4oAeO9v+M//yXxH+T3gTK5AbKJn1IROkfsm6CLqOgpOB4dBoFhpwk74Qn4UQFoX6Hj3/STu04Q6HvtRrrrHYOiWzGQyMkXFyh89a9vUgBoazDEQd/xP5Xf8wu125mwc/7qd0uSTxRpbIqQEb+o5Z/jdXGkJugXS9zwvmvAHDmtS8jLJsTh5W34erWIwm6FtdteIRQaxitZquJyuYRNZnw+yT4H9jKUDc39hytYgk0DVoSvudDWbvvOXBfrjn0K8r9qVnkvAj9dsavxFTjNCps8q6qAEzhMCswzJ2H3cO6s9tB15rJbFq1zrm5P/GNkVd4MzaDayccwzU/PKd5km2fHAw4LcwwR/jRUw838YWeH8+gjRepn5/CFC5RrcEaS42SLXTIjqu7veNBJoUXDfPzn97pf4+Bpi/Gljo/O+YkZCKqGpe1BgjBOq2NP2YWsLD8Ec6raqEZ8dkSGb3MjMBwU+14xuJvMuua9So/tlRRDWchVMRD0ETGfXu/7qtPdR1RqXHH8/dy5TMP02uOMdUcJaOXVePdzuBoOla7wYtPzMaZKJj/oy3M338zsx8epLKD+s7G3BBrLMWrbff7SwKJgeu/1xq3LNiXnx9/EmNnKbZqql5ien2I74y/wpGF5QjgteQsbulcyLL7JvLGQ728eusMtl2cAFOw+02b2WGfQVpvKyFsSVH6/Qlh06kXSetlAnhowiPxoWrarr+glaEjE7QsrhK3VaLc9husJdXIPOskmB4YIeskWNno+swFYP9qIJMOvAdMA+4A+oG8lH4U+acxj/B3EZBSSkcIUQAywOh/+TubEZBtXSZteoWNTgsFr0jOS9CmFxlzVaZbzo3Ra44x4saZtnQEoyJxIgL3NBUnOOSauAjmBQd5utxH60AJ8bzHbi9vJrzSxl+XMGqStt9V/u5dfAru8QzABRmAKSPjvJtRPI0RN8ZUU731YSfJL69/iLknDfNYfFdWxSZznX401w0+zsXrnubG9CFqNOrbuGUwwDFbXgOgIQyu7jkBWzNVQrQm1EleU1OM7aFIAIuOPYLrnnlAqf+kxoDTQlyr0ecHP3eZKne0x8wx5MTJ6BXuOOE/uFD7OjN+sw0jqHPZ2PPsV1zNUy27clfnQch8mfhHWTY7aULCZpIvCIprNYo+AFcUymAaaONFZCKqLtTxIgFcElqDjFal325TfZFICGrKqSvrDbRQkIxWo+I3n+vS9KMSq4ia8onISEhVAq4HrstDHV/kiPQy9vrRBla90IkXVf2duFbD1FwGnBbOfu5cZt0+jIjH8AIGsr0FMTyGiPhGtWgY4Xt5tFxRieJ0jW+/+BxRTZC3I7jUmmCd6YERes1RZEIQ3Oyg7+DR/1Qb1VcD7HzDViKDNsZKP3d2aY355gDvTOmhLz7KiB2nLg0kglvPP5nglnHMdsGU4hZmjm1kz8Yn7FLdCKgbxaPte3N/2xeRqKnRrH3Vc7rwGNPj1L8X4f1VUWbfOsSEm4rs9/J6KvcmCHXUeLcRwxQeGVEj54UJZB3anlPn7sYL0kz52xhdTxSZ+Po4ziEaQzLZnDAGhEunkWd5fSIZo0xKq/qU/s/u+Jeao1JKV0q5MyqVbQ9g9v/ux/x//8sRkFLK3aSUu7WkNfJekE69yEYn0GRlaj7BOaOXybpRdihsY7efbKY+WceoSgbeSpJzo2r+7hnkXgxz8ml/49gvfcAONw7iOBrl+QGciPiHNyGBgUMSbLk4yejCCI12Hc0BIUFvwLQ9R9j/tLX0vDHGHHOMUb/RlCqU6ft2jtokk6lvD3PJS0t46py9eLR1bw6srGGBuxkvFUPYDlGnxqVbFvON/H8C8F6kl7JrNDUXolxDy+a3fxifTkdctYhcuf/x/PagA5p76YBPz+q32wngKiju9u2cp3gND55wO7nT4vxs08PsU1zNovT+LGrZH2+8hMykQAjuP/QA2vUSGx0Vf5jRK814x+FDJjXxfTLgv9dEDBdBUrObKtROowANC6+9pbnYIQR53yrQpqvt2ZCd4kf9xyr8n6kjGrZqPNsOXkucM55+iS03pggOO6SurTUX/3a9jC11vv/cKcy+aZvqafiRDtpYCRIxJbBLRBGehxcJgOMhY2GuX/IQNy29n5IX5q16GxHfIWwKh5BmsaoxQRnOEkFkXmkltrkpug6uMbZ3BDcgGD1INUen/HacSUfmOHbn5czZb5ApXxqj9d0qbW9WuPON27jnk7t4ctWN3NZ/LxeO/4mZ9cHmBXV/eh/unXAg0lbTJjce4pZDjwDw+bUtfGB1Ysz0+Ouv+vjg9i6iay0Sx+T5eED3Obc6G50WbE9j+o+yCFvihqAWDNK/VxtWSqPr+YLP3dgeSVlnZaObkHDoNAoqTkE4TDLG/vmF/j84/kdTFSllHpVKvyeQEkJsr1j+PuaxGQHpP58E/tt37aLRb7U3Z+BpvYyLaHbmdaTCzF1dR6tINt6WwQsK9nhhM91GkQlvFdnx6EG+8PUNBIdcll/azdon2zB0j+RbDaq7B1h3YytORGAnfXHPC0XSr9dY/ZMOXnlzFuuWtuPfLGm06KTXV9j1jK20HJOnY626wGfekMUsu3x0ZyfDwSQ2Ovd9/VYyr+UozQnwraEXiFRKLKhtYNHGezgwv4KPIxMA2CySePEw0tAUmzMdVw7XekMtGp6nyviAiShXFek7FePh/XfnlwOHENfqBPDQfdet6jU46L51ve4ZRBZb/PVX1zDdGuJnrYfzJNPV1CURU1MI20GaBj859rSmPsMUnirhhcXtV9zeHGNquaLqz5hKeJf1oc+qEowh00mEq6YXIqyakVFh+xQ3tbfuNPOEv6EpG7vnqW2b4yI1waWP/x5TOCyf28PW81NMfSzH1MWjLKtPpN9u49TFFzLrlgG1iIWDfnyDnwMTDanPbfv0y5WMzW/h6iUPM+QmWGV1EtIstcABJTfcBC9H/K1KsSdEMO/gjarzIe8ZxN63KM4Psekk1dP62697+PiOdh5L7sUbYzOwsp9OyIoE+TjYyR/j87k2czh3dx5IzGvwfGonAGzdRFTVtkxqAr1Ub8rs1Yi2SkjYagui1akdYfLWQ70Esw7zzh2k3Sv49LY8Ux7M0fZihfpkg9pkNWGcEhlnfI8IsfctNvrbzZBwqHsme4b7SWsWWR+xoL7nz1YA9q9EQLYBtpQyL4QIAwehGp5/Ak4AHuV/jYA8E3jTf/5VP6Tpvz12Dm1lm5NsBjfvEZS811B7upwXJflxjcnPjrP+G61smddC60EVko/XiJVqTHl8jPpEg9yNCcaODVPdajLz5GGMosfqX7XjHWXgIXi/t4edzh3AjWp4GkTft/jCXp+w6WtpBn+YYFJYx3BcdENCHbZdECf9VJWpP1JlvVaWrH6gnfysCJ1akYo/G5cBjbXXtrHr8QP8oXgr5pDHJ8E2ft5yGFcOLwbAMQIq0T0aVqg9n9m5PRFNRoJ4QRN9cAyZjKkLzNCQsQiVi4L8uH4KFz73LD1mDgudXqPAkBthVX0i00uDLLhqI5nnq+R2jLDqF538x5oDmHl9v7LbR0KgOZAvIgAZMrFQ+IC8F2KyMU5VGgw4Lc2kNFxXbQNqDQbcZLMrH9dqar/senixIHpFKum4lNSlT5jXq5h+hYSug4bq41TryoxXKDf9J3XXZMMlGeLL6sz+wTCNToNji99izq2DShVr2apnUa7itbZA0FBOYU3Di4cQpQo3PHEPcc3mr7Ve2o0SbUaRqUaZdxudzRyY7WgAW6qeWH4HtedvW1liZL845YZJYk2NT07LYPmXxcM/2ZuPA50QFZDQ1KLqowS8eBg80Apl2rUql266l2WhSdyd3pdD8x+obVzUURVcS0JxYkNB2vVyU0iX0qpNQh0eVHYOsPnf00z9Ro6pvxnlrQv7iLxiMfWaHFu/lKTt/RLZA1RiX9YNE9mxRseLZcIlC61FYkmtSZH/2E+8t6WOLjwGnBS7/7OL8H9w/CsVxwTgT0KID4F3gJeklM8CPwC+K4RYj+ph3O3//N1Axn/8u8Dl/+wFBLJJ6d7uqHyzoTdP7qiw2Ok3AzhRjU/OUWX10MIYZsmj9/Ex1p3dxuqXO1hxQju1ms7ss4bRq5K3H+nlk8PaFKTHC+LsprPsyR6sOTqBkoeVUaX+lLvHWDBnI2ZdsSX+8vupeDFBx4NlCHy692qEDLYkMr6+JEzFCZBcUWenX2xlziXKQ2OMeKy7JsPmDxN07DtOXPpSYCGUqrRaVxeT7SCrNXUiWrZvL2+ok9OyEbUG+mgRYTtoo4oN8uuDD2FlYyK21FlptRPF4qBXPuLghWtIvVJj1fc7cBcncGdqPHD0r1n7A+VDwVCOU2EYihherPLzA4+izz+xCr5WZHpghIOfWY4MB/AyqWZMw6UPnk3FH43nPWWtF+Uqeq6kFg3Po//KYJMR60mNNq3KtWedpdSormJ34Ck154Vvqr6Pi1AwZSPOR4smUOwJ0nd2jkOuX6M+s+0munoDmUmhVWpKpRpVfQxcyY/fWMKIG6PfbiGqWbgIPKnxarWXXiOnbAtuwocbR/x4Co/GDuq77/toVAUg9XtoDXjsub1YeuX85rnf7ltlAAAgAElEQVQp4xFVLRl6s7G7vfrRcnlkJMRpo6+jIbml9WA8f4omNE2JAAOmmlAFTGTQ4NhXL8SSOlvsDCHhMOIqTuh2vYt1eIDxw8N0Lyoy/43N7PbtLRTnhVj9gw6CYx6BeS7teklVmXPVjUtfKRlylEu44gWpSJMhJ0nVCzLkpMho1abw8bM6/pWpyodSyl2klDtKKXeQUl7jP75BSrmHlHKalPJEKdUVIqWs+3+e5j+/4Z+/CUnRC5HQ6nho9BhFttktZLQamvAIDtoknq2z5bQU0YxF4o06s/5tBC8AXkww9q0w5aCimrdeWya1qcbKRZ0489RdxkXQpVdp02sUJoVZ+ftOPv5VG8WOEJpfwWkN0GzQq5IDDlxPYNBFr0jMQZfRXdUdIly0Ofio1ex80Vb2OHkjB+2yltlHDjPh7gLVPpNN30ohPEAXTLFKXPLSqwweqMx7bjKsFoXtUnQhkD6v00vFVH9DSiiUlJArEcVriSMLpU8T3oTgqeP34aYjj6frrwWmnJhj7sXDNHoMti7NUPlmkGVui6JcC5vbj7mX1f82UTUnt8NxfHaHF4vw/f2/CvjBzEIxRg+OrlbiL129Ty8ZZeo9m9GFR96NktEqZF0/eS1goo0XwXH5913/0EQ2hoRDQ+oENuXUxQN+FkmYU174a3Oca0ujqc9xkjpHfPV7uA3BtQOP0WIV1We1Hb5Ta6hxa6GE1AXfWvoc9yz5D0LCoSoVTbzHzNGpF4n7ClzT1zb0mDmybpQ2vcSIGyeh1Umm6pR2DBB+0eKF0jyeOlthE3OBxKfvWdNgrKCMfKWKUuZaNl5rUj1vGCTtMgeWV7M0viPZYAsi5LNmfQq9jEXUgmka6MUqO165VaUI+s7ZlFZtNv879QIb7RSF70XRapLJF+Sw2zXevquX9F/UgrR273Y2O2mSWoP+VjXJmV3MEhCuclebOQWJMnNYUqfPHEETytbwWR6fC5Ob6XtU1lgT6DQKrLMzxPUaeS+oIvyerSIkDH0lQfufS0w9bxSr12DoijiTzxmn6+oiQ7ckGF6eYM8/bGLVuZ2s37WDWdowA44KkS5JgxWNbnWHkzGGDksSOtymdUOZ8Fs2sbcaTHzWn7IIcOICrSrRbWh9T31pui3BhuRzdWrTTDYf3UJjF53SgSGcFp26Z9D5XInU4jreu6CXPNZ+p50Jr5bY9+jlzP3OOr71/YtJvrwWJrThhk3MYhUvHvJl3y4kYqpK8Dy0YgOScaRp4MbCaMUKu5X6OXX4L8w+c5Bap8Hyq7opnBZiYrDCFiuNJXXa9TIrrS6mB4a4b+Eizq5fwMw7hhRj1E9d16rq33GtTtaNM9UYI+tFWGN14C6y0S8Q/hZB9Tnqnql4pp4iTIlKTTWCHRfRsJq6hpIXYpvbwo03nURnfYOq1nzAD1IS12pktCquX1a7UqPLKHDsE99m5h9HuLLtaG7M/pFrsou5vOUMiqEQeqmKl44jahZeVxvf/MOTPrg3wWY7TVSz/PG1Mua16UXfTp5QDAx/9NxllOgzs9hSJ+dFWXLAjnz11nfpP7KLPqEqxrJr0OqnouF6eBPb0AsVCASgVFU9qEpdLWi6xhcKa9CRPN+yk9ri+baQKZUhzrReY5o9wqTqCFHPIuI10AB3rqCRMHDaNax5BqNzo2yY30pqtkqjK8dM3KBAb0hW3ddOvL1B39IslVkBrGk6k8QYHzS62al1CwBj40oFndKqTcNnWi9T8YKk9TpZN0z0/3To9P+JoyF1Rtw484JbsX2ieVovM+SkSOkVJi7JU5obJFapM+WbOaozA3z4uwkMRDIUL4iw4x0DjCyMsetzm3ATgtELo7QZRWypsdFu881HAV8xKhixW6l7Ju1GCTFdsGVqC+apLqERh3Ddoj7JJP1cFRkCO6xR6zT54MqJ2BM0ouEGc742THjIZuupKUZnqCTwOIqHsebQTna8YwABDHwrwfgstZc2/TvCzb+4nawbJ6NVuGbhV8F10cfKqnEohBIvbb9gNXXxhqwaC4qrOC77NjPrgwzrcW6LfIGXUnvjPODy07MeUxkobohuc5zNTgt95ggbrHbSepn7j/01X3MuZPoDY4q74XmKLWq7XL3n4Rz/5w99foNNtzHOWRP/ygNyfz8qMooYL7JTcICx7XEEvvxcGxkHXcftSDHkJuk1cqy0ulRj9IWtyvjmeYpn4kpufe5uxtxQE5cwyRhDEx4nPPIdZv12EKo11rdN5drYV7h6w6PcvOY/+PGE4xnWE2gj41zzxmJybpSMXiHvhf209ogPflKYSMWnVdLtnIgxLzDKOjtJVFgM+fb2G474CghBayXHV3mXL+dXsC2hRGdVMwSOj6YXoOdV0p1MRFWl6C+A242Mc5whcnqULfEO9h/9iANLKwE4pLgCF8GmYBuG9LA1g0dadsVxJO4XYWFoJZGBBqklNVofqTCLEarTTey9DMIvWAhPIjxYFp9M9/pxUu/V2XBpmrrPaNknvIUPQxnmMkSiXCeh1RlwWpgeGFFYTCQZvcw6O0PejdJnjnym1+znYuEwhOdPCRTdKKUr56opHGKFOukPqmz4epoZZ49STxu8uGgOnYkCca+GdYlG408GO102gLBg7THtBFK+TB2TSWaumcE55CaYbuZIaHWF2UeyrD6JuFYnpKk8ikbY5I1bp9L2rRKTbx+j85kSiXUNdv3xJjYdnWHjYRneuSfIF4/vZ/dzNvHqUzNp6ygx4KSUG3KOgwCsCTqbL0w3O/vb0Xu6UOIcWze486X7KHk65605leTpeaUi9TxIxAg6DfYormO/2jp2L/cTkg6DgRS3tB7MK6GZ2KkkUgiE7vHDw04jtCjPGRPepOSFSfuGq5BmY6MTEg43HXc/lyROY/Zt46oC0FW7U1g29/3waO64+VbWWB0EhKvK3J4WAgMFtEIZmYyxwprQBOT2mqOqeRuLKKFYueGPAm1mBQZZXp+ktlf5kqKJ54pMf3qYDXbaD95WwOIhJ84Fz5/NrPuyym0bCSPKVd7XJ/BvPSdx1cAT/PvAw1y+4BwOvP9N1lgTiGs1sm6cuFZjyInTphcpuu2MuHG2xypn3TidepFZgWE22AlCwuaSqy4is2xMTYGqBWQiRk5EeT05iyNL73NX6EAAzLCOJ3xwk65/GhLluMiggRB+BKQ/Vp5cy1LWgtyz5td0OEVymlqcno7vzN09X6YRCHLd6geIC4uH4guUdmeDQc/iMWWEwya+1WLoxSS7PfYJiQdUdVvdyST6gc3e2zag3+fhhgRvHDONydooVS/Iq40JTLHU96FFaE5Ntjgp2vWSglYLm/mBUYbdAkX5KYzqszg+Nya3qFBjpb1D2+jUi2S0qnIUfqgaQB1vlzAqLivvnUCks9GU0A7qSTYtSiuHbV3i7a4yJzr1ohLC6EUVPO0zCvJewH8szGSjqJiSRp5Z5ijKyiYxcalOC/LuzZP5y+/61JsUglm3DbPwkFXset4Wtn0xQSDrsOtlm3H9OIDZ+UH2uH4TEih8IUQw6Db9B5qQ6MJTiXXCRsNjmxMm54X54bQl/PQ/nyF5gMtR9mouH3iaR/tv54qRZ9mhuoWXYnP5Xt/pnD3lfF5I7oSdSipAcsRPhheCxqlBFp1wJG16kZTvpo2IBt26WriiWoNzvvAX1p6TwUtF1ThTCAiHiH+UZd32ACfPxEXjyrvvUWzTeARRqvJ6cQYVqcxcFRnAa1PNU68lRnFehrwXYaOjALyPH7V3c7SMlGDonNTydpNS1WMUWWN1KJfrbb7L1R9bykgIGTRZZXTy3alnYHa6/Ob925n+52F6/EU/pVXJugk8VEWZ0tW5ou7G6sKz0NjipLjgvVO57qhTyLw9ouhf8bCqhMaLSEPnkfgexNwGO9YV/zXu1FUzFz5V/RZKiLrCBwBqmxYNMc8bYkpjhMn2GGN6lB9NPYlz514IwJCeoKEHmnwTPMmpxbd4qP8OaFhNm8UKqwdzsqAlXSaywaHeazB8fIzwKvVagZtspiweZcPJrQQ7VHM6JGxsaZAsqd91OBpXeiY/OiKiqXO9Uy+T9zTW2u1NpfBnd81+Dg4brbkQrLCU10QJiUqIFerx6Aqb5Vd2U5gWbn5wdWnSZ+ZoTDLZ+tUUfb/NMeX2UdgLNnVk0PDI+Qatt+u97B3+hFVWB13GuEphc2NEhEpMr0uTDjlOWDi0+yh+F4G5h4sXhE37pxn6epxJL4yTebZC9xN5NBc6/1IiM6/C9Dk5YusbBMoutS6D8AcWY8si9LaoplQsXye8xqK7MM7EyhiV8SBuTmfSunFSH1WJrrd41L0NgEarziv6PF7TJ/NBejoeorlAiGqtOeUxBnKq+Wao4GZRbfDTw7/KFc/9ni69xLAbI++Fmw3BvaLrOOi4lZzZuIi++6qq2x9UuL57DjmAy15+hh4zR8XP6BW2qzwmqTj9x3div6po8FFhoWXzyFQc4UrOuvZpIkJFDupIyJcgGm42GS9Y+kIT0ORKjbwX4AevfpXZN34MHa3IoSz0TFC9HddTDchEhKOfeIG3R3vZ69xPmH/+Vvq/38rqsztY63XSFxhmqlFgHV7TPwI0pzpXHX06om4zVfhTDj8BT8U92pBUzuV+rYu/xmewb2G1+v+LY9iGH2lRbyAaLnS2Ih23CSwKtEQ5Z+OzHDX2HjYaK8LdXDbldETDJrI9MiIURIZNtFLFXzw1gsIj5taRkaDyu+gVppCldIPOzr8eYGiPOGsXtTMaj7PjQVuZ9o1Rev8yjhSweu/O5uJoCpfpwSEiObW4yBZ1Y8i5MdrMCp5UrNGEUKP0dr3EVPMfM3X/3x6fi4Vj+2q4vToYcpJN086M9cNIAWN7RBg7Q/ULEqJBBbPZSQ4JFy2q7hKBrEPfMaO49wo+mq5yM3Oe6nnUpc5Uc5Rt6xJMPLLEA5l9eOac3bnutIeYE1AZKw2pTG51adKpl1njdtDIbCVVqOFN1LG/HmDFWUlylRg9q8eZfskI0WyDlmVVhKtGt5Ft6uQ56LiPm79j9/1Fuu//X788K6MzOjdG/sthRudGacwziHXbpBnnMFkkUJK8feJslXbW2YJu2UoLoWnKXGY7OC0RjKLv4bAdrj/oOKQmuPal31PyQuwaHFCvJTXeqU/isVNv5pjUJcy6fcwfk3rIUJBfHHoMFy5dgi0N+vRxVl+UYs4vlSRehoL0+1jDISfuU7c8cD3ajCIeGuvsDJc+eDZT2nNIKZGmznce/6PPk9WbMZwnLv4Wc27YiOxoVRdVzwQlgLNsvNExjn+3nz3Dn5B1o6Q7q7zz8CR2uXQr024YpeXFKgO/HKMx1aTqN4LXWJ2k9Co/v/B0IutGVaWgKwBy0xfkx17qW0bANJXkP19EBIP8pusQFq1bREDCFHuUdcKPEnClqsx03Rfr2SSDkqvXP8AMa4inYjvT546iS0+ZC00JrtIeCdtGHy2qSRCA7TL+JRPzJZcfPPkHIlqD8Q8j7HN5P5FVNoPHJxi4PokR8OikQK4SZZrv0nBiGodf9BEDv0rx0Ze6yHsqNyizSknQR/piJGigC4+NdpqSF2ZecEC5qN0wui7Z4kTo/ewu2c/HwmEKl4oXJCdj6MJjkjGOi6DkhUh+VEdIGPlxHE2XfmfepuKa/n5ZJ++FSLvqPvzWI73MP3eAOccPEbjMZcMZreiabIqd8k6Yjzb3cFhtCclGman3buaee/ZFhgL8Yssj1NuDVKX6u2ypMS84CFJBhJY1epgeGFKLSqzA8M5xkgfVmPZAAyeh8dFDnQylk8y+dZCeJ/KsvbMVr2DQ+mQZJsD4/hHqCYNKPEApEcZK6rhJQUJXjtPNTpqEVicoCmQdNd/fIbyVnZ7brNCBBx6mfB6moUKQpFSxCGVLbSlqjaZLVlQtrtz3WK567SmybriJ8OsNjLLOaufqLz3OdYUTmXbPkDq5pVSLk9ToNXK4CH72pcd44KrdELoGoSA7hzZR8gJ4aHipKFpenbi95hh1P4VvyiPDyvxWqkIs7EOSIswJlFjmxjjzxfOYc+MWZDyqGoy2o6TtARMZCnL+8g/o1AvNkPEhJ04mVmHznWkKj4VZcN0ntCysse7SVtae2U5PsMD9Jx6CqFmEGcOLhRS8x5Ng2TidKYxsUUVWluuqQhMC4XqIkKqCcjWNRZMO5bsbF/PF4mrWxZWvw4tHoFBGRMNgCTopc922P9Bql7huwjG8KSZyfvF1Dq2sVFAi18WLql6CFwmy+qpWfrvvffSdNYyel+zXsRYAYUtm3pUjeWsZK2Xw6h0zqB9qNgHDeS/MLn/dggTG9gjzwa3dzP/GVnrOH8e9Gt4/dTKbrFYOWrWaRkZn+qRxNrlJUlqVtFZnk9PS3Hr2GAVKf5cs+Fkdn4uFw5GaysZEhQltdlqYGxjhnewU9v9kHY2kzvDcOENOkhnmCGvs1ibMeHu10t6uGqCZjjrLn+5mxuVZZl07QutzZQoHhgitdMmsKBPc5nKMtwKAy7JLWR2cwJJJe/I2PUhDJ5S1uPLIM5rQGU1Inhy6iY9C3ewe2uzLqQ30lR57Xf0JLe/UsFMari7on9rOjHiWUJ+L5sLHe3ahRTzcE3VsqTHgJpukaxOXnBPDxKXoCTa7aXYNbWFFo0t5SHyKd8kLEfdxeee//ArdRp6vPPktZv56WH14hv5ptEA4iNR1hKsCmxgv8JP9jwNPcv6rrwIQAdqMIiEvxMVHL+GWyEJm3jUGjovb2cKdCw/hgqUqTyStl1n3vWlMe2gcNHg8vzu7Rj+h0yigldQ4tzKzlSEnTkC4fP2p85jZGIBaAxyHU596lYoXBA022CEueuosZt85/Km/xbJxutJoVZsfLX6Y6WaNDXbIN8ipRSelVVVkBgGyxyR4fZ+pzP3REDN/msX5pcntmS8hYr4PXtPQxstKL+Oq5q2RLSpGRygIDUtt8zQNHAeCAbWgFCo837oLp275E5OdMeb5LAshJbSn8QyNdGGUnw08StixuDxzNKvjfQjH5T36OKa8nJ9c8hDbvpSiu5yHnWDX09Zw5z6bSWk1JAIDl7Bmgwfzj9tMcmWDbUcmaFwXgjhM1sfJehEqMkBlIEB6cRUvIPj4pk6KbRH+88EZ7PjtAaZclcMLa3SdOEbgHZfSvBBZGWrS4ra5cUzh0GcWWWl1+cFkMbo/Y8r556I56iHIeVHqntkME+q3WzjsTx+iuZJSl+JmTjLG2Ohk6NYLTeT/kJsk6yR4p3cyANYHGvFOm9WL2hg/Ikzm/Sp9vxyj89Ui1ckBPrkgzVOReQCEcJhhj3DFuse4b+NdtNYL6s5bKPsKT42JXp6gdFj5Ug/fWXAcDy/Yi9QOdXY/fAvah7Dhl2k23pomlHPZ5T+3kPPCbEKFFksL37sR5MNGN516kelGmaIXYsBpYVZgiDajSEYvNxeNBaEt2FKn324n70WYExyg11TqRrWPjXLzkQ9w9Ut/4PyXXsaNB5viMRkwFI2rpOzo3uROX7Fo8psTj+HV4hwCuESFxVRjjJnBbTxw1K/5+Ly0csXWlGL1zsMXEsBl52Cea499VAVC5Yp8+LXZRLWGyuL1re1X3nq3P7mxmXHPOE5HChmPcMlrr9BtjNOul+gx8py6+EJm/mpA6T4sG1Gt47UmceIBbn/uP+jSq6yxo+o8kCbTAyNEhdVUEoNylf7i5CM5c81Z3Ni+kEl2jt9se5ArBp9misir8bVpqG1P3YLRMbVdScb8jFrND4JSUn4cV/VqomG0Yo37MvsAcPzIW+rEHB5F1BpEsqNcM/AEKbvCWdefzsFvr+HbS5/hB688zawXN2O3acx5YMRHG6rttGG5dK4pUHvdxMh6iGGPjqeK6JYkNmjRf2eGP980k/GkUtyusCag4xHJWSw8ZRWaC+9eNInNnSpxsCNeYPntExnbJ8KUf8uReLBOdKNF4WB1c9muRq14QXr9SV5Kr6j0er8n+Fken4uKQxOSihds0p9adZtVVguBZ1zcsMDExZWaiiAUNmttBdJpM4rYno6Gxtw9RnAiGi2v1qjPNdntghHCH9oM7xWj3mXS/eI46b/WiAzbrBJdzde+p2UftmkJvlpdxs6VTaTcKqmEIF8CuWEzexvrAJhqZ7mz9C6T66OUtCAPpvbi6cQulO9JotfqPGjcxfqbu9l2UIQdituQAnrTORDKrNcXGFEcTU/9DhlTeRZSWo0BN4mLxvTAMB/bGcViMPLMMQtscsLEtQYFL6hyZbxAM0owqjX4zkO/J+fGeHjhvoqNAdg9rRiFGnquhNsSRx8t4KZjrDuhm6szZ3LDY3eT9SJNx+3SY2/i8MalzPjNgLqgdI0RVyleQ5qNLFcgnUIbK9FrjLOi0aUmIShYz/YLW+RLGBXF++w0SgpIIzyOf/Q7zHgkr3oFvgcGKdnj/g+YFMjxWm0qswKDtGlVNlqtTDLH2OKPtyOiQc6LcsehC5WCFAuZjPFqfQ5/C/VyTHk5x4y/x74ff8wbiRk8Ep7PukSPaia3JJVKNmyiFWtIH/CMlM2KcnvMA47LG4mZ1EdewhUaUWmxe0uRl2+K8OJ9v6VrcYGXfzOLMw56izQlto214HmCaS3DvH9OD3vcsInQjyzmZ1VfYv5NW+Gm//35ro9JOq8r8cUn15LdK07tkACp9iqyX7DjWQMEtrrUOkxyF0SZFRgm66oModZQieV3dLHgpM3Mum4ET4PqYQFSWk3lHgsV6rXOzjSRmBvt1qb/67M8xL/gP/v//Ji9Y1D+ZvEkJTFHkvUiMAb77bGeep8BFcF7r/c0EWg5f1Xfbr3Pu+oi2Pm7W+h4qYQTUaq7DT/P0Dg8SM4Lsz7bwX4vrKX1uTKpt2rNUmvITLLSnEBZC3J0WQX0VLUA7wd7yLhlZlrDCMADVgS7+UtyDn9KzqXmaOrkrDfwMim+OfwCh2aX8ZUdLuWcDUs5oPYxX+m9CIRg280hbp/3MKCcwAHUFCCiNRhykiS0OnGtzorGRKYHhtB9CllU2M3ftdcokPOCrGlMoC8w0hzLhYRN3otQcsPk3QhPDe2MdrKNiIQ/bQy6rn8nlmpLky/wvfdeZ6ZZ4NVqL3uGN7GiMYHvLzmFWbcNKXGYJ/nBy0/hSY26NLn1mGMRDYvLX3gCT2r84rDj8BJhzv7dYtr1Er844nhEvoSMR7ni+cd4ozqdL0bXcNLii5l9y+CnQGM/DuHMF/+TjF5mpllg1DWbsQue1FjTmMD04BA/uP48Ol4ZUEFNlo3bmlDRjbEIWqmiFrnRcSLpCMcOvM4xpfeJew2WhSfz59B03kjPoWKrqAdA/f4+lNlLxtTfEQ0jTZ3hvVL8+2WLmPftAdIvVNB9i1G9Wyc04GK1abhBjUDRRS/+4zUjBSBVY9w1QHeg1qrjmRrRQRtPBy8ksBM6oSEHa4KuVMg1iVGWSAGFmSFim+torrI/jD2aZuWCVBPcHBK2ErdpNtYanYMXfozbInjzvV7SeoMxL8RGu424VmuS4gecFuYGhhhwEgAcOnXV//jaFEK8J6Xc7b8+/rmoOGwf1trv322zboLZ7w2iuTAws4W+pVlilkU5EGCd1amChfyE+6wbb05X+k9spevpIkjJiie7ic9x2Wi3kNKqdGXyfHxKB2OnR3hqj125YeQJAByhM8ceJOZ+mksR9iwW1D5h2IgjgD/G5/NE256MZtrRcyWc1iTGcME3kBlohTLvhKdytHyHWdl+2vUaOT3WLOcnXGZzXeQ05er04TNDB7bzq+/fQadRoOSFsKVO7/acVKNI1g2z0cmQ1suUvBArrXba9RJzg9uoS6PZCBv2U796gnnWWe2c3v0WO7+9lawb5apLvk50Q15tC/z4ADQNkUry7wcfidQEFyx9oZmne9sR93Gx+Bqz7hqHXJ6fnnIGFz74R9r1EsKnmG8nSwGImk2vOaoqDsdFJmIc9Pgysm6C+eGNnLTkImbencdNxdAsB1FvcPqf36bXHKUiA0SFxXo7geUHYutI7h79AgNHRBDx3WmLjKtFo1JDJqJoBR9rCMr/ISUkYtTKFr/r2I+n0rtzZP59Dimt4Lu1l7k4/yrvRabwl3wvb4WmUIslwbLJ3x3iZzMepU2r4iEo1AOE/uIy4YoC4VV2c9EACA24SAH1HpPq5AB6SjIWCxMYceh8rUR4m4MXEVgZjdAWF81HzIZHXcDvk7mgVSSa/97dKTq1vE58Q735Oqk1n/730JfjbFwQI65ZxEWVZY0uUkYVXUjimoX2phIvGOOSwO89qicbPltUjWctqTc5NhudliZ687M8PhcLh1KJuqpbj0ankSf5UQ0pwN5foD0DzmqN+o4m+4Y3sNFJUsekLg3adIX8s6XOtN+N4Am1YjMuGfPUyZlzY/SZOfp9QFAx8CkB+onEfJaG54Kho9VqmLEgU80iN66+hw6nxLLwZH47eSHCdtBzJYUGrDvIYgmRTOAlIkghWJ9TZ1ufXmBGZRvL4lNVYFIwoPoHowVVofgk8M4/Zbnu9VPUft+yye3TxW3X/qoZorP9qHpBpps5VjQmUJcmFRkgo1VZY3VSN4qktBo5N0rIx/v16qOssTrQhce1t91Fp17h5Osvpf3tAjg23tAIWkdbk3Fx51GHc/wTr9FmFIlqDV455pccbF/KjEU2+idDZJ0EUa2BFwqguR6dRp41VodKlhdKL5DzQUduMswOoS1k3QTfXXIasxaNqcZk0MSLBLjm2SfQkU02Zl0o+IwmPP5t3fHEz3PwUjG0UAk3GUXP5lXzNBJEK1YVydy/+JzuNMamEdyuDLq/7ahqQR7u+xKP1vZjRnmA/QbeYb/GFvZ0+nHrgsqkAI0dTfIrQgxZCSojBhOWFpn14iBm0cOJaxR3CGIVNQIjHsMHR+l4qYLdqpNY1kB0CAYOjtP9YJH40gaNFp3K3gGcikZ8lZr+ba9F6m0aoayHldSQNne2UQEAACAASURBVJiWh2ap54sEGT4uTmK4ysSHihhVT6l4ATcEnS+WMM7yWHN9O9s6kiwIbWOTE1HIgnqNKYtyZHeLormSnW4b4M9HTycTqeD5W5K6NMGDdr3MZqeFkhdiViD7mV6zn4uFI4DrxwFkea/eQ29glM5VRSp9Abbu0sIcRkisrLFuTkfTTblTYJRR16TfbmNOYIjyG9C+tMLqC9vpeT7PDucP8toDfRR3UM1WF0G7XqLkhdTM/e8Od0IarVzHjYRwLZuxvEdNBIhJi6dadkUrKhK3TCdVZ75Sh9Y00gfeYOgURIgRM8EOYxtIuxXWa2llmdc03EgQkY43G3FePIQ+XkEGDdXUDAfJvDbAT/Y+UomqGjZUa3idGXI/tblrzkP0mVk2+yDmETem7tLCwhRKAFX6u/SwWYFhKtJQ9Gw3ylWX3k+7XmKt1cHvD90baRrqLm7oeJEAjx+1N2ga5zzzIqukyR+Pv5XjzEuYfavHY2cczNceepZzf/8Mdx+7kK89diF3n/gbCAZY/T2ld7j7iIMhO8o3lrxI1k1w1TMnMvuWLU0S+bVLfseQm2CD1U6PqUa9bboSi/34rK9j5OvELJWPqo2MI1OqLyOTMZXIJoQCEkmJrNWRLXH0XBnCIWUMtB0ImGw5spPbL/o1IWGzzWlhqlnkXauHrg/zhJ9z6PigSPrhCm31MtN9jYSnQb3DpDwvyPi0MKGMAzakR2q0v1yhNDXA8J4Jut/PE32hzqyl9ebiEBx30T+Q2HMDrP5aJ84RGm2DZbouKBLKepR7A6y8opNJ94+TKNYp9oXoXFyi9YMynX9VNzwnLJBBgfTA6dYIbnQp7Rkk9WaFBYds4oOfdbP18DBZN0Fcq2Fc7xIetll220RijQY7nbGN6U+M4J2hbipxUSPrJpqWg3a9pDAUbpRZn+E1+7lYOBpSZ7o5Skrz0H1AqBwEa5JB99QijU6dtj9VmH/6VvJegJBwWdZQpXtKrzDsxthx0VbsNo1N38ygnww9Xxlj31P62fCzVjYd0ULVMxlwWthm/xf2ouuhbR5GRFUG6s6NzVyWXYoUggomB+c+4J0Jk5U5TEqEp4RNolCCiNo7y3IVUnGGtDiTHAU7W5GeBpbqpGjbsgjTVKHOQqiSu2EhdA0vGVFCIdPA8/fwMmAiQkG0QoXW75r80Du5eaeVhs7oFzo5+weLMYXLmB+hYEudnBulXS+RdaMMOUl2D20hZ0fRhddUbl788guYwuGbD5/HtLu2oI9X8CIhtEqNew7cl1lPD3JwciU3LHyEy8VJzL5xgAeOOIDLX3iC0d3STL97hO6TyniJCA8v/DUXrjyZDuFxw/IX2OYk+d6S05jxQB4ZClCblOTS2x+kIgPNEfNaq4OfvHMks36YxWuJESiMgieVuG3LCF57C2LLMLI9A76CVCv5gdrVBiISRrMc3Dstzul5jV5zFFvqrLM6MYWL7U8X4lqNjXaaSeY463bsxEi6JMs1EsvrSAPKOwSop030ikTPe4Q32CSW19Ern/YvhIT4BovoSA6pg/DAM0EGhAIYGVCeYVKbFcCbJrC26iSvVUrV4rQgkRGLBeduRgqQGkQ/VFsJvSpxQgKjLjFq6vUqc03+dMkMdnxtgEkP5hk4I0FsRYPdLtpC/0CG/Dlh4m81mPFgljWnd+DtISjKIGO7hJl4Z57HT9iFiKGo/V2msg6ktDp5L0TFUzL/z/L4XCwcQkDWi7DBCdFrZnHRCBYcxqZFGfbixBfWmPi7AsP5BPW4ErN0+3F7tjSIjFdJv16l/7w2xswYie46A48nmPvNIWZckiXz+wqNwwy63HE+eHsS++XWN1/7hNJ7LLA3QUXQZhWY2sgyYKT4ft9JHDH4NoeVPiRsQjUQwk2EMCo1Ndoz/OQ024F0EqSkZISZXhthm5FkfaQTEfDHgsm4yh4xDWTQUNxM00DULfRaQ2EEhVBboGBACaJQwUgyHkYM5tRIsWEjYxFa3xhm8dELeMbZDaRk5IBurr7iXj90KkJcq9FrjrLSamfISTE3uJW6NEno9WZD9dqvPkzmlDLnP3Uu0x6tIF0XISWrT5/GyuBsfvz4g9x52D1coJ3N7JuGqHsmd119C5efcDZr7FZEuUZSa9B5QRkMnTVWB5e/dBLT/qBgOyc9+xpzg9tU4JBn4gmNs5ecy6xbR5ipl/CSMYUCrDcgnUTLV1SAlK4jWlsUvCfkb1GSUYK35vj2xJfIuTFSuhKebUcCZLQKc4IDfq/MaCafrWx0MXvrMHv/aj1dTxWROgyeliB7gQoe1/HIuqpx2GvkGHFjSFuQKNfY6bithEds3KDGwNFJpjwwTuWAACtv7yAadXA+EGjPSNqXl2l/vMSEB/7xwkys/7tGiVSLzvajNtUgPz3CJzu3kjswyry3Bui4o8QR560kt2OY7BeidD9QZP3drYgnBX0/yxHod+j8c4n6ZANxBU2gUv+pbex+6WaM9ySpvatN82ZAc8l7IbbZLUwPDLPK6vj/X8WBhOlGmS2urchG0kArSrSkp8JpFnYw6d48jec0UqfUSWnO/8Xde0fJVZ1r+s8+qXLoqq6OaqmVE0IgkokmCEQQQYAIBgwmG2ww0cbGGPvia2yyycEkYyyTDQaEBRhMzgIJ5dzqVnVXV8510vyxS8W9v3V/M/YMM+M1Zy0tdbdqtaTqs/f59ve97/OyyZIQ3S61QNcnRRQb1h2QYIZnGznHS2eszKozOvDUTGLvVhDvyr+qVymg/oeQpLBdZefyJgz3KyZjr5XjB5tfYL2/G8O1mV7YzMddM9CG8zhtIZRkGnRdBjb5PJIRGgliKhpex+TN2ExEvamI1FQpzXbclp/EDcgIRRxHYgQLkjFKMgVjumSj0Sctd0qpBgGf/FrIL4OeXLcZNm3j+A06Fm/kzrcPx/V7JLQHIFtg1U19LP7m7dRcFRxIu0EZBC2MVmLcHUc/hH6MhN3ecfyx4DiomQL/dtxp/PTp3/P7w+/m9PoF3LbvQZz+5nugKPSqeVyvjBrEY/Cr1xex4LkfMOWRImqmwE//9hwgXaojVkgejwI+pjVSUvWqqpIH4rqyCitWWlESm4+McMfpi1pBzRusGP1alkErLMOemmrS7QFEtqvgV0wqjk5UqTNgSS9TuWqw5y0bmPLACI4u2Hp6hOVn9yA6oU/LkzNlcvwqK8hkT5IRO0jF9TDbn2TzQIjgFpPh7weJP1hm/KNZBg8LM3R7hM1ugqhTJrFTmdpshS20UcXP8KNe9rhmM5sXtKG5Dk4/FHbxUYx4GHN9nlC5xvNPzmaykSQgLDlibW7yKyd0Y5+kozxp0nFnieAXVSyvYMzVWVa92Uk8VKLvj3lcD7z+0FSyqp8wNZbWxtI/dwTHA3suWc+qPeVR3kSl5hjSgSwi6MKhX0t/rUv2X2LjsFDZbMmy32ji6RxVoDkOpqtR2MlDeqqfSfeP8uTRu3BYeBMZO4guZPneWCGTrdQdbJanuzngiTXE7iszI2NhxhUKJ3lJeQJ0bS5ivqfTVv8qIkHBZWmgn/f1cXwSnUxPNc2M+hD7lNdwdOZjAE5Lv8XWaDfDelCSyX1e2SeoSSGTGw4gihXG1+S0YYkysSlCkrQtUalJ/0TDbOL7BUomjwhJC7ary16HiEVx0zmEriNMCzsWRClUcdoCKIUqoiA5pShCTkcsG7VuyvxUn0yrdyIyAlEBpl2X55JrT5GbF+AaOtnZUc7/6TPM8W4hZQewXQnT6VXzXPXM46yq9xBQ6jx2wiH88rATcH0GNz/5KJco3+bhBRHa7x9g0I6gZAtceel3uff1WznyqUuZ+lCWi/78XDO20eKqY85AmJKbKvyONMt5DRkF4bjYsSCz7vuSg8PLWz+LgFJvRUJUHL05kpZ9HFU4crOz/fTrOTK2l0wzjGjAijYjAGQfwLvUZIcrtuFbZ7F1YYQ1l3XQ01NiuBphijLMsB1sNhE15gXWsdmSEwe/qPN5o4tpr24DoDzeoKNSwlUgvKHGZ0Nj6e3LoginFdsYECaogplPb6M4xkPjRoPXrInSI9WceE3Q0ghcEqqsSpbWxzBRH6FHy+IVNjVXReiC9LeCbD4uTteiPFN+NYJ3m03PD/L4Bxu4AkQdetbmKE+VtLtpniGSapT8fj4SrxZZ9tPe1oSqSy/wUW0c04xtbGjybb7O6x/eOJrZKh8Dg67rzhdCjEeCimPAp8Bprus2hBAe4FFgFyANnOi67qb/3vd2mn7PsmuQc/wk1CJWRCFQMJvI/CQjFwWZfuEIO/51gJcOG88c7xa6VJtNlkE4XceMqox/Ls2BN6xFyzoU9vOw/Mxu2Adyih8Vl62ijaWHTucHq1/gkfg+nJ5+mwei+/JS9x4tMMtwtI3P1Ck8Xt2TsY1R7tr6KJOtUR5cfRcvxXbmgfHzqBea4cya0vSKVAjrFmPMLEXFy2D3OJRiVfpJihWctiBiWxqiIVwhUEfy2GM6UHOllgmqZXMPBXCbwUhKpYEollGam4QTC0m/hSKjGl0hwLZxIiHUXAkn4ENN5eRG4jUQlRpWVxS1WJdsDCD28ShPztuDJ4x9ZKTBzglO+dmLDCl19vJtpKhnCIgGVz37R65eu4DQ+WXuOWwez756KydmL+UHHc+wodFBfUoXoY+2csTzlzD10Rw/+LMcb1993dkkFm9AxOwmT1X2hezOKPs99DH7BFczZLYxw7ONTHNE2KMVWdVIULNl9ELKDtFApeh4KTue1qQg5wbo10epOFqLPyFp+Aa2UiNVDtF/R4apDwxT69BY/nAXW/aVakrbUphojOBvyr7HahmSdqSVs9ql5ik4XvyiTvfyAtUejb5f5ChO97D84h52u3Qzh5y4kk9+10dlmgxNUoVDytWw1mbo/7zBqp92kFRCzPFuaYG3vcJEEzY2UrCXskMyD8eO0KXm2WC1MUEfJdWMlggZNZwzNN4/oJ89Dt5Mx0tlXAErrulg7Mt5Zv44ib6Lw1BvhC/rY9jJu5n8rj7allQh7ZKLSCPhqkY3Ca1A0o4wy0j+o8v8H77+mYrjYmAlEG5+vj0CcpEQ4h5k9OPd/IcISCHESc3Xnfjf+8aiKeQq2j5qjs44LUstrEMG+jWp4a8cYtA3JceMm5NwCDiuIG0LCdsteIkWK0z+8SjlPQ0+vbwLbRcXG6XVB6kh6FXyBGpyXt7Qv1LSOUEvit2MJyiW5QL3GmyM9WMNqvw1NhvXtDki8xm7F9Zxa/shfKZOgnoTPiwEZ2TeQMFl0GhDmDZ2PNRSK4pqA2HouIBSa8iKoFiR1UiTRYEiKdqiUJYj22a+CR5DViS2zCZxvYZ8jeO2Jg1qtsklrdVl9VOpyVhE20FNN/NRmvZ7USi3NhU3EqTt7S28uGAPXF3jySaF3A36Wfn9CDceuIjEawVMV+WSMy9kwsZBLgycTf9faiy4dwk3LTmCew7/HW/sO51bDz8KUa7S7kuy8qrxPHPUbWyx2jCETaNpgEtoBcKiDnqWVY1OerUsRcfHkBVqpu+ZrG100aXlMF2VCVqGDc0AqahSYYsVo+h4v8oRdlVCSoOiUie4ocax539GYK1J8oQQyavDDAVkJaLgNGMbK60AqwErRs72t5CINqKppLXwLrPQbAel4vL5Lb0kpld5u3sie5y9id2P38zAVVHeP2E8/Z40OdtP+HV5Tw0eFsV0VFaYbTRclV49i42C5ar4kEK9uFLGRhBSZMh4nyZVsjk7wF7ezWywIgyYYcZ+lJMmRsAxYOoNKb68vJsZK5LErijz/kP9TPQMk7JDBGfJfkpweYPBvTQCosFEfYS0E8ArTNY3BwKT/4nF/j+6/tEktzHAEcAvkWRzgYyA/FbzJY8A1yI3jqObH4OMgLxDCCH+kYiEnmaIb8bxEu9XiX5UJWkHpXsWL5t+EWOHk5Ikfl1i9c86pez8oyL9r2TAgg+vHkf+DA/9RoG1ZryVO1p2PPRqEqmnVpswlqY8G10Fy8GJ+FGEkPEBzcZlsF7B41qMGBGe6NmLv5V25NLBv/Cr5FM8ZO7Ln+J74vo8zClv5LDycupCZaOvE1EooyCPBsK2WzCb7RoOt96QBipdw/UYOCEvSr4iF7PP0zr+uB5d6ktyRdxqFWX7GFlTW69DCCmfbsYIbN+EAGiTWbYuTYu5Ixu6FEq4kRAiX5Jxj6nMfz42WTYzfjnE724+WE4z6g08Wobq5ATnHvFX7tEP5sZ3DmXcYpt39p/CQeEvOeTl5YSUGmlbTnEG7UiTOSERkH6lji5s3qhMZTffBoxmxbDFjDPRGGaOJ8mQ5cOv1FGREZhrzfbmDSh/61CLKMJhspaWjl9hUHQMxi4dZerZKYSAgUfaWL9fnJQVpl8dxUagNqMoy65OVJWmuS41T83RUYSDX7FI2gEarkqXWcS3Rd4jK37YSXGSj2Q9St+OaV5/air7/GQd/T/NEn25iv3LIB+N9RNfUabUbWB2qswwslTcHBVHo+ZqpJ0AmpA/A9uV3JmyIx20XWqBVJNyHtAaLGt0EBmoMue6QeKvVahO0vCts/jb9VPZ8Q+DzP7FEJl5PjpeKbHbnzez9vgO2QieJZfWmPUZ8t/0MmhFiaslQkoN01VJWWFmebbHHn091z9acdwKXAmEmp/H+RojINt7DFJ2iLLjoUvL47gKxR3kzNtMqdTaZQj16B5Bhs4IM/bhHKkDg/gLDaZeNkIlohNImdR21YhrVfwCmXJvhYmqZVThsMWK4bgKc0//DG6Afc78En4D+31/BfucJnH827kOfqVOWNQJflCDE2HGLzZw27yVbDKjFC0PyStCfOf5tzjgkOW8f8F4jly4jMo4Hf9mk7GXJTn9xHcIKHX6tBybzJjE7zcp4oNWG2ObyeZOE2Ck4raeyhOMEULCZMgOkbMD9OlpGe3XROirQj49e9V8M41N6iG2WDGm6CMM2pEWOLhPK7Ci0UmXmsevmCStkDQQNjowhE1UrZBQi5RdAxUZ7BRSGiSbPYDt2a1f1sewt289fy7sxOun7I57jgsOHHPjEhafvg8fNma1jmaYlty4lOaGtp1H4bqIYgXXo/NXIeMHRLUupfCWLSuzWuOrPohly96MoUu1rVfGOrh+bwsB4Ooa++RXckVqMSNahKvHn8y2HwKREMKypYhsJNvsATUzWhTlqyoPwHF4uFaXdHJVJW4XeYx7ySp+Ln31XHhwBOJtiHwRp6ONOwsVDm1fxtnvv0n4gFG80Q4y1SANR+HWPffH7YwjkikZWRnwoeRLdKVKhNw698w/nCmFLezQGOIF7w6YwSA3vfIoA1aEwIY6+96zjrbnKri6YOPVMQb3jLDPERvp0gqseSxB40qVMc/nseIK428f5Ysje9khWudjf4SD1GHMjCal6SgyvQ6bDY0Opnm2sd6MM+sfXOz/yPWPBDLNB0Zc1/1ECLH/9i//Fy/9pyMggfsAxu8QdOOKbFg6rsIWM4YzQzCZFDOWJxk6MEKfliNj+9l4RYzIe1VmnzeIWncZ3SVI43oP/oPTdL+RZ3B2lDU1SZ/0CpOBZuWx3Va8nXjtbT7xdGyWmV1ElUpLyp5QKmQcL/4ldRwNMjv7KVnyKVHwGKy6cQI79w4w/u4MvYtzKCWX9d+LM+WWNKVZEtUPUGs2qtJ2gN7mHH2KPtIK5PErdWqO3mRWBOnXR0laEWrNQKOEJlPTGq5KQG1gCBulqbLNNdmiXmFRdLxM1FN0qiZpx8Tb9CnowiahFmigUrCkEC7n+AkoDQJKvaX/MF0Vr2KStCLoIkdANDj3hXOYet1aRFhCez55aByHRL/k/u8FOWePN3j10n24K3sYk8qjlCe18evb/kDZNejX8hz8/GVMv34Au6MNpVRFFOWodTtMp/XLtnHiYRlOBfK4tZ0p0hR1bf9cNExJ8NpeTQX9HJP5kHNHlrDK28PP244gr0XAljoaV9ek91uTGTbomkyAK9fkVCsv7feiXEUYMqjaCfvZa+tnALwVmAw1GyyJLKCpq8F2eKlvT94JT2FB7hOOyn1KwGlQETrHedfxQclisD0u/52qkLksGUk/n1QZ4ujqFxyUXc7L/bNo0ysY95l848WNRJfWsL2C4TNCDJ0Xpqvbpr62uTxrLh6vzYc39mP0rafjzhIaDgc8t5bl32rHq1jYYYVIsULN7SChFsnYQeJqmRnB1WywggSU/zAe/hquf6Ti2Bs4SghxOOBF9jhupRkB2aw6/qsIyK3/aASkJmySdgRdWIzTCjRcFX1XS0YUvOxQ2N9LRJGwGyXg8taFk5h30UpcHVb+qoPKeA+xbxTpfzLL8HdDGKrEwwdEAwcFpRmbuMlMEHLqQPY/4eJVXHIVP5GSTCWvhlU8rsmE59IU5niZ8MYokeU13E2CSLHKpOwowUIdV4CelXvi5NvSuAJ2vGSIRkTDCitUx+hUdqiQ3cHP6GQ/EW+NgiuDjbzCJO0EMF2tpbuIqRUSaplPan1M82xjRb2XyUaSQautlf6+nc/hb8GdYy2/ywCiCTfSMF1VBiOpFelnUeSo23Q1urQcXmGRtMP8OTuH1d+bjrAcaavPS13GNLGNkaOm8Og1NzFsB7nhwCP40QWnMOOWDfy9b3eOe+Sv7Otfy0LrEm476UGuPe7bqPkytfsc7jnsQaLzJaq/S8u3ZObXXHo2oc+TX2lVQgFEQ3p3HK8mJf3VmlTbdsVRMwUJLgKpY6nWQRGIcpXTzU85KfUu7/gncf3447CyZVnhdMQlfrBUQa03sBMRyQ5RRCu71hUCt97AjcvNTOSloA3LYW72CwA+iU+RN0ciLvkiuoYTCaCM5lGGMxTCIR7um8vTPftwy5qHaLcKnLNlCecAZWGwzt/NVjsAPoPdSusB+NXWPxF05AJetOlOPDiwDIozPXxyWR+lEwwK7T5qjkHYHaKrLBvaGX8Qx4WQVuPNH0xht56NjPtJlsS/FVk9P4EnYmH6VKyyiu0qvF2eyj6B1S0rwqZG+/95W73rulcBVwE0K47LXdc9RQjxJF9TBKTblCAHhMmAHSSqVojrdVIHh+j9a57K9V7erU0goRWoD+ocfc3n1HtV1LzDbqdsYdmDPQycG2HKd1JEH6vhOcum6HgZtKMy/s+VpdsszyA1R/6X3Q+aC/63I0y/bhil/v9xPCJLJ2PUJvphDccD9UkataiOPUHB+UIgXKh1q3i3yeolP9FLY4oGeQhm6kQ+qaL/Qd74jgGZKQHMHRU27x1ncL8oY0OZpiw8TMr2t9K8QAYTbw/RmainqLky28QrJOwoZYfQsVuRf4pwMHBAwIAZZ4ZnG5vMWPMMLxkaqxrdbKwn+ODsOahDTVFZvoRmD2P3dbSe8k7Qy83PP9gU5cW4/eSFrLnSzzOH38r3P7iI4Lo8vXqWe1L7M+mBQS4MfIc7n3yI3x5xJJ7zbW7Vj+HKvzxNXC2Ra45PB6wY37vhT63jT9HxceuPTia8dBhX11CTRTnCbip41WxRUsYTEdn/qcqsWEJ+jsx8zEnpd3kpvCN3ts/FNl2Ex8AJ+qQZz5SQHuoNGT2xnUgGONGQnGB1xKQQT5GhT6JSJ17OMMmSng7DQB6tfB7ZTK6bMsLT52m+vobrMyioAT4N9nNI9gu+03U6s5UUk4pbmV3fyszGAFrtK83Q9k0DkD8rwAwrDB8UInRGA2/YRncc7CakKrdCVqbeyQ3WmZ0ycErLseHkBNFlNaKLqux05iDL/tiNVnLIB31E1QrzQ8vI2F4GzDhdWpGJhsyV/Tqv/5Vt6IfAIiHEdcBn/OcIyN83IyAzwEn/w39EEx1oCq3ZQW+wrNHFtCO30f1MAfVli92O2kzONph5TRKl7rL4iZn4rAb7nrWOOScOsPqmBLX9DKbdmOSdfSbinWIS0ys4ruCT+jh2yW7E/b1gziIZYtPxt2Z5HBeM7OrHP2DiX99Aq0opsbCkj8AxBEZexgPaVYXSLgaxdyp4MyarftPBuqMS7D93LcGtDdKXB/jooH6m6COM2EFU1ya4uUFgeZ3w8hpty6vEXqjQ/XgRKyCoH+Lh80O7ie9fJGRUW6SmBioGNn61hukqpOxQK/+0Vy2QbmodJugZAorD0noHYaXGFruNuFpq9kUMrnrwDPoXDUqmaNAv81ejQZRGrcnQbOBGQxJokytz/kuLCSu1ZphRjDsPPwLX0Flzrp+75j3MT/ZZwI/efIS79j+IWUaS+xceyHlLXuWeww/lAuMMrn9hEVGlwm0HH84Nc48EwI4GueKpRS3FatKKMFbP0Ktl+eWN90oamrAkpR6H094+m2kXb0REQrgevZU543gMhOPwjcJqzku/wfv+idzZdgCOKYVxKIoMTnIcWT3YLm7Q24qfdH0SeNSio1m2HGmX5PFDeAz2YXMLtxAZ2obb3d8COrnhgIyjsLdH/ynSJyMEq7QujnY/IaqZvOeZyO65NfQ1MiT1CM937s4nbjc1oXNEYwULRj5Ax+HkiRcSmlviuvXPMOm3o9QWaaz5dQLlAIeQsNhgxtjjg42YYQVrgsJsfZDVZgcNV8UQNlsvjRJZVCXySY3+qzLoBZvOWIkPGhPIqBWm6iMktAIVR46y/6+CfFzXfQOZVk8z2nH3/+I1NWDhP/N9Je9CwStqlF0D25Yl95a925gwMU3nHUU+PTxC/9MZYm9UWf+zOOpEB7/SYPmzXUw9K8XM80cYOTRA2G+z61lb+OKP3Wzobsc31OCoe5fS/kQZxXIx+xTIwNCpQXoeK6FtcehaVcIJCLLzfCzfqYfd79yEqwq+fKGbdCyAZ9hkyusp2h6oMOZRSVcaPSBA8hthphqj6La0XoeeqjHtsGEGrCi9ah5dOCTHB8n2B0gfFuRA32Y+rYZovK0yY/E2ul8psNezGzFDCqVDPaw9J8GnY/uZaAyTc/yojkNIqWEjWFXvplfPMmBF0YVUeuYdDwOWl4e37U3tV29SLQAAIABJREFU7PBX0xshENU643yjX7l4DQ3FY0i1qxDyiVmusPLyDm45+HE5HrSDFJvKywcP/iZCmKw5L8Hj8+/kF/MWgk9Ce9xwgE1WBNfQ6VCLXLn4OX4z72iuqp/M88fewhWvvsCvTjkVpWah5svcfPCR4DisPb+XR0+4gy1WrDUhyTl+/KJOl1bEdBWu3f15Oj4q4hUmy2p99OhZTFflt9ecyB4vvcWPii+yzujgV/3HYukehGnLygFAVXBCgZbWRYAM0fZ7ZQN2u2IVsNsCqKUKItTEH9QbzEmuZasapdvOE3cq0pcU8EkHc1P+T8P5qrFq2SilCh/Ep9MYWcxRuU+ZWk/SbhW5f8xcnuncE3LSTIgQiG1fHY/rtsLGBV18MaWHqV+OErusyKwzt7HpZ218duo4+iujRP9aJXe4j5wIoLsOUaVCVKnSQGE0ESC3sw9v0mTM0/KezMU89OujbDFjDIhIq9cmH8b/53sc/9svy1WabEnJoig6OgG1QKdh8uH5/ex3xTom/CVN56+L5Hb1MfRtqRCsuTqNTpXXnpzC1LtGmHr3CFZQQR812XXBAJsPLDP+uTTCheGFQYa+GyH6cIWJv8vQ/QeppDMnqrx17ni8cxv4P2iw5yUbcRGs/H0Hg21RepUszgqF+JMVvJtM0nv4qHYZ9LyUZ9+566kc7MGzzWZoQYieZ4t89tZYzG9opJsJY0XHR5+eJqpUGLZ1IkaN9P5+1u7fyfAvw/B36HkpT8eLJXZ7aguTDh+leJGP0jQPa812crafgFJnmmdbSy377xuPwHOhgRP0oOQrUmruNCcUtiNhPV6PFLV5JX9THcni+jwoFakj2XhThBt2WkJUWUKfVmGDGWaaMcxlp56PPlxAYLLykh7+7dAnaaAiag3E722SVgRsuaE5IS/f+9X3uPmqu0HXmHpPiiM9P+CZw3/LTx5/lE+r/fz1+N3klGU0y6SHUvzigePZeEo3d3/7HkxXJdHMuDFdhaQdZm/fJgbtIAY2Uz1DFB0fu3kHuP3829hpySD2GIXFj81k9LYOQivSUoKP7IFgWrIisG1QNOnt8TQbrDRH0k2VrlKqy+ZtpS6/7jGY1BhhqX8cZl1jElkp7W9qaIRloxQqctMwLeqTOjCWD+C2hanWTN7yT+bA0ipKqpcfdi1kldOOW5PcDNdnSBe1/h+Wm+ty+cQlFB0fq2e2M/YFndj3i4y/Ngt+gXfQQi25rD0t0epnNbfHFme3NlsjvLJKYU8P4ffqkIRBq40OrUiHWiKkmKRsX9PG8Z8d4f+r17/ExuE2IwFtBKsaCTJ2kDneLbxeHceYozNU7tXpuSaPlndJ3uOnJgwSSpmk5aFXLbNW6aLv8jyfzetlwr+nib5XQ6m5THpilEpCZ+stEbZ1Rpl5yxDxZ+RZNzvHS+yTGssW9jBxcgblUovel/MUJ3tYd38cJeqy29Ob8T/WoG1ZlcoYnU03x0gtCGCisfmKGBN/mqLrxRK2T5A+10/i7TK73bmJD/fsJ6pUCSk1wo7c9UNKA9NVKLgeQkpNjmCFxuB+bRQO8PHyZe0c8IdVjH0kS+zFCiOHBBn9vo+LFl9I92sjsmRWZOK9VwPqJYTPkAzPTFFazw0d1yvl6sK0pLu0PSJHpeUKTneMW566j4qrsbbRyRxjlIyjssGUPpCr9j4W3ZcHQ2flRQluPvQxdGHx67nH4HoVvj/mRS5YfAbTRtag4rLhuDCTb9+IepXDNS8u4ufHnML0m4Y5rnExt8x/lP39q5nxwiC3HXIETiImF7mhM/7xJDf8/ihcXeOkP7/Bvr5NDNhBQkqNASvMJrOdyUaSjB2kT0+zoRrlG9/fhGsJlj40hll9W/nmLbdJ96uWlS5RO8gPPz2WSVdmcfMFSMRlbGPDBKcZJ6EqcjpTqkBbGDWZlr0Q2yFWzRF3yqyNjMEua+xWWi/5H9WGfC+FANfFiQQQlTqeTWkIBxhTHmaSOcKOtYHmzexyVv4d6qpOqeyl5OpsKXewTsRQzcZX97ymNrVFMUxXI+vxMHR7iNlnDTLuxxkEMHxEkIFpcfpEGrO5WYzXHT6oSZ5J+8wS3bUi28aFCb2XYvzvMpSOGyA1IcQX9V5meoZaUR9F28duX+Oa/ZdAB87Y0XAf/0snKVtOGQbNNvb3ryNp+6m5Oh0fFdjxxG00OlT+9t4Uws3yvej4KDueltjly3oPu3y+mWlnDqNWnVbOCTTnwQpYEQU961DY1UP44zpWh4I24mD7Bdm5PraNjdD7RY7ou1UUC4rjPRS+62PdMXEU3W2pFk1XY/LFw/S+mMcOKKBC5ig/nY+WePlPMxC7umTsID16lpQVbp43PXSpBSKKyaf1HnRh0a9nyNh+frXpcNTv+QjaVY5JfcgxuU8IOnWWRHfknp6DKTu6jCCsbydgOTLBfnv6fMSPOjgqhV3NTcP1eUDX0O4ucHznx0TVCoaw8St1+rUSa02Zun7TkcfJ6UXz/L/utDh3LHyAouPjgRPmo+TLXLzkJXq1AlcccQaiVOHMJW/Sp6e5dt5JIASnPP83VBwePWJ/nGiANacFueGwx4mqZQbMOH16mpvmH/vVKLbRnHD4PKAojOwV49c/uq8lJZ+glVjRaMNBYeJdKabeNMJbt01EP9pqoSJjaoUhK4KCPPJM0UeouRrjtCo5R2GoqQ361c++Tez9Zuh2o/n+NY9rTtiPqFvskF7Hjamn+Env8XTYJS5OLub8ntPYGJcQbFFvyI0v7GN2Zj3fzH7JXrX1ROxq6z6uCg2fa5FSg6TVIAG3QcSpEm6+ZnubVAFOnfhdjn/lHeJqqYWTLDheOtfm2enwIVwFVr3fSTImhXTbvSY520/R8dGrZVGX2uyxYAvlyVJBbKRtqmN11j2doKBKjMJ2husms50zp7zzT6/Nf2l04HavSlyp8GWjh128m1llthNXytRcHaeoIADPiM2urwzx8bweDGGTUIvUXF3qD3SLKX8dZuZlSepjVF773VS8yy32vHo9nrz8kQkH9Kz8OPyxLF+1Efm5WnFpf75COxVKEww2fidO5SgdZil8aXazv2+Id2udrYjBrqfy9L2QZ+XFnWQX+NjxO0MkFpWxDZj2XJLVu0rIjYFNVC232J26cBiwg/x67Tzar2j2GgI+VEdK3ku6we97D+S50M4sLH/K8aPvs3NxA7eNm89H7rivSnNdk9MCkJvG0HbHrtZSnsYeGOHKnsX/SWadUKUYrexIc9uthx2JKBVwQwFZaVwc4dlDbmWL1UbKCkndg6ZKx6WrwtAIROWxpugYkC9CVB4dVeFgdYTRclWm/2YLPy6dwu0nPtB0hJqc8OybPHH0fvL/0DBbTVslnaPz5RI3fHwSuRkh7rnuNj6ud+EXdSatTzHptyMMHhahZ0GZtWYbHWqJguuh6BhElQoNVDqEzEuVsRlgCId0Uxvz81/8ruWmVXH54c/PI/7+iByv5su4uTy+mA4pKHpDrHc6+B6C/Spr2NTWh6jUUL0acysrOGnwfbrMPBWh8746hs/ap3BK7j0qisGFY8/gvJHXOKbwGR8HJ3JX9yGYqk48O8IkkeXk0XeZWpcGugfX38fgzyMkzw9BDyTtCO1rikw5N4WrgmJC/UuN3N5+EqqU/evCxkQeOWquTjQi7wX/ugbrLm6nMVFl5veHid9fZs3ZncTVEl1aHhvBbt7NX+ua/ZfYOABSdoDJep7eZhhTQi3iFTa6KND+lzJmSFCZ7CH2gwITHzdI7hIioTbIOVXKjofY2xWmXzJMYbaHrXdEmXjvKJMeSVHv1Vh6dxelXT2EV1eJ/KnGuMdyZA71EltcIzfbx+hBAcphg9SkEO4OLvGobEDlbD/YsL9viLeqMvA4ZwfoeTvLtB8Pk93bx/rvttPjLbDs6W52OCdJ8NM6vS/kWP/zdvr0NDnHzxX3nEXfy2lcXUXJFsFxSdB8UinyzCwqNZxYSJbGtk3JE+Ahz76845nIpaOL+bcNi/irfzr3TJhPtSwrA5HJ40alJwZVxclkSc3r4+c/eo6aYxBVyyytjWGsnqHsGqStYMv38Yv5J4Pt4Po0eQYv1Vh9XoLHDr4LkFGK9+y+B8RdnJCM0ay5GnQncBsmaceHioPwenAzeVQh839ve/xuLp1/JgT9THxkhAuMs/nT8dK3ktAK3PDK7xmwovz2yKNkszLdjJKs1lGzReLvlvjJQdLaZN5l8tRl9+KEFT67to9S3cM0Y7hVZXgVk5QdJKaWSKjllmN1nRluKV/rNY1EsUgp6yVSrGDmNB7c+UacPQQjgTDZoJ9ovMJHT/bDnVDUfeSUCF/4+vhmeTWPmt/kG8YQ3137Eh1WgVXebn7XeQAfFMKYwTAzzSRdVoHfjDkKVwjujR9AxePnW6l3mFkZ4L7ofkysJfG5Jsv8fUysJ9FxeSM8nbl/XM64RRlGTggyMZKi64EiTkRh+R+7mXrOCD1P59m4d6JJ95e/crZNlz5KzdVIBqVtTLgwcEQbicllRl8MMObmHOq+LvpMGYWRdgKtiNWv6/qXOKpMnuVz/+3ZmV8BVs0EKSvELO8AUafCzjsNMnJokA0/jrPzcVvRsg6rHunEnq2yyYqz94YB4sdmMccorL8uTv/lWYKbGgyeGuHjK8aiBF1mGaPkHA3xhsPs04d444nJqLvZraNH0orSpeVaFCnJSqi1SsgOtUQDBf0Dhx3PGsTuU1j2RDeDPonzy9l+fv72fBafdyed9Ty3dBzCK+27yA0hEpAUK8fBrdVxehIoA0mpymzmfGz3qeDI2EE36JfUcL8Xw6xzcu4DTsh+QFb1c338ML70jsEN+nACHkTN4rvPPt8C/urCoux4SNlhJhvJ1tNqaW0cAaXO4/P2lj0Rn0dOC1SF1Rd2cueRD5Fo4hV/c9gCOaXJFfnRB0sA2ZS74cAjcEIBrn7+cQLC5CcHnoCrKrheD5f/+Ulqrk5CLXLtISdK2biuserCBA/Ovw+/Um+FcEfVMjcedyLKaF5qJfweiSnIF7G72xG2zUlb3+Q76bf4Zcd8xr6dol9PtYxi680Oao7Obr5NAKiuQ2aTD88ym44vi4SW14h8WcPI2v9/t91/edX6NQo7exGOS+LPZZZ2jmOn4c2sMzp4qGN/PuqchlKz5JTG0Dlz08scW/yME8ddQMUbkFMt22GXxmYu2vwXOu0iVaFTVj2s9PawZ2ktGi5XdJ/Iud95nd7Hc/g2mQgg9w0vn97Wh9LhMunKFJ2Liyz9vJciPhJquUUr3977IQX77r6Bco/O629NxStMQukaOx0yiDVW4a0nJpFXfK0j3F79G/7ptfkvfVRxmzzQhqvSpVYIKYNUdJ2c42dwRRu7lQZQ9hX4YxYfPtjPXt/ewMyTkrx/Sz89+2YJn5PHDChsOr+NaWeM4AYEH/x+HI19VDyO1fR3CFJ2gIj7FU3adDWiSlX6OvQ0KTvEoBljStOGXHN0Uk6YiXqKD2vjOfy1ZfRekqMyxuDj+/v47ppTGX9lSS7AcpVOn8tPxp3IA2vu46z0W/ytc2dMRZGsUceBcBA3GpQO2XgbznYaWHPhYdm4Aa/cYDQFpzuGUmlQC/p4JHAQ74an8MNtf+HfU89yQ/d83lJ24LQ/vExAqbc2L6kclf6QkFKl6HiJKxV04fDYj+YTXJVBKLK3IHJF7I421pwV5IX5t5CyA1JF6/jlEaS9DeGV7IdNZjvDZlQa90yL9Y0OompFuoDLdZSyDKMG2NDokEIyvweEYPotQ5xTO4+bjn2kdcTZZLbz82cf4encbixfMBa2ZCERA11HKVZoa5Q4OfMef2+bwVuJHREHlnADPs5/8WUAurQcTkmgvWIx5qU8vvcbePJyk3A0KE/1MDQ3TH2MTrCtzlp/B8G2Gt42k0rYQNRd9IKNkbcJF+roH1p0PlXCTChE3qniGZHfa/bwZmoxFX1hnT0OW8nzb+7BmKe2yPfPtplsjbLZm6DacMFwwJT09Y8jkzlr6oUclFvG2clXiVsl9i2tad17N2z7E/w72GFB4ZseAqtNou/XGPtslur5BuU5BvqTDp4tFuY4k7KrEVfLLdNeVKnT/kxTWTrPT5+Wo+LomO0qb109iYMvW8WkF0ZIHx+g8b8hd+1fYuOwm8rOmFoiZftooJJoquf6VucASM3082WjhzkTBvjwqXHsfM5W9r5gA9XZOr7NFp+f08Osy4fITAhQfcxPe1edlOOhX8+xtN7TWkwRvto4xmkFljUXANBMvWrgV+pEqTJiS8rYxlIc42SdscuyfOkfw8+do8lf2EZ/pQzVGniNlqN2S3svKT1Ewixy5sAS7uk8WGIC6w0cnyHP1M3YBGE5YOhSU5Au4gT9snln6LiGlGBjWuCLIEoV1mkdXNJ3Cle6L/CTDX9m2bc/Yq1IMGjGmpuEjw2WNDV1qQU2WXFqrs7Seh9PHrQrQb9MJnPDATlqjIbYsDDMk0fcRs1VKbsGDVvl/nlzET4H13FYeUUvGTtIVKlw/wXHYlRHcCNBxuoZvMKk+47NDJ+WwAn4OPWZC3ll4Y2ElBrX/uUxrp1/apNm5mHyw6NcqpzOY8fdgd703Gwy21kQ+YRDXlsm4xpct5WBclz6E3TX5pHgnlJ7EvDh+j08dOhB7J5fw069A8xbtQyt5lLp1EkfGqC8o8HgjCjlqQYBX4OAaJBqBks1XBVHEVSFTkypUXdVUk6IPq3ANidMvsdH51Or2XJRDK9rMe78NALZ+7I7FMY+kGfcvcs4cPxVZI7x8+m8sTjTFCYfto2PO/pxR/wtV7KwbEShgu26vNI2m32Kq4jUihQNP7PLm1nt7eaP0w5kwa/fIDHVpK4IRopepl6ZYtL1oySHQhTnSm9UY5tGcoxkd5gIetQKXmGTLXmY8pB8wBX38GC6CmXXkPEVxyYpPuih644i5QUeHFUh6XxF9v86rn+JjUMXNjVHJ0OwlUA1bAfp0wq4K6SCszxep19JsaLRhR632PSnOF3n5Gl/u4LlE8y+f4jknmHW3hOnHPTS4ZTI2EGKjuyiz9BH+bzRhdrs2htYLGt04KBguio1R6dXK/Cdv3+HKXc3UMsypX1yY5hLt77A+MZSXgnM5M74gTQMH6JmYnZF0NPyLbTaQ2jpEkq+wkpPDz57I8fkPuXv/imsCPfjRIOy0djkawjHQWRlBozSHLMqJakTcP1e1K0pyePwGqjDOdxIkB/8+RkydpAtjSidl7cx6/ohvIMm0WsqxFT5xO/VsoSUGg0U/KLOrYcdKTcuUZbHoWgIV1NQ8mVWXtbNi0feRKYpdY8qFX556EJQHAQK2A7XH7qIkFIlaUXRU2U53s2V6FRLrDY7OD3xDr/RjkPJl5h6V41PjuptwnY8nPHsYh6ePxcUFVGqMOWBFN/yXMCiI+9gppFkk9VG2gmgY/PDV5+j4ni4fe48wqrF/OxnvBGazmCoA1yXWC3P8SMfc2j+C/xOg0wmwEu+Hfl7z3QmLBmiy1NAFxZxpcxkLcNwM+Rpe8bw9kvFZbj5QCg7HlY1EkwzUph9sumoL7EZ//go1Uk6G+5vZ8y5OYKjdV5/ZRJjP8jR8WKJvjtzjL09R2GmB0/GYvr0bVzz2FMUHJnhCmAIm2vu+Ta9SzLguDiKQsCSY/jLY8fSdW+JtbFOTEZJmSFsj4J6u0NjjErPvQWMrbLxWa/o9GkZCTdyVVJ2GF1Y7HTDVjzD8l7e3NFOthEgqlaYYIyQtoMMXNRgxnnDWM8pVI+VBPyv8/qX2DiEcImqFXq0PKsandQUjbQdRBEO09NJzA6VqG6y1pTd+4BSZ5sSJlYvY+ugVSXwxB+vY2xz2DQhTFwtt26aDrXIu83zfVjIaUqXWiRm1Djsre8x7eq0bBSGA0zTq4hqg36ynLrtTfbJr2JUC/LTcSfykW88olCSlu2t29DpA1UBy0bLV+W0wHYY1UMorktaD/Lt/Htc5emRf2bZoFjS7VmtSw0BQLEsDV+WLceslZqEITefvpct/jNRpUrSDtOjZxkgzse/HYv9a8Hk36XoGi0weGcbSTfEULMJWXY8PHTCEShmSZq6mnhD6g2Uqsvac3u5Yd4fWqCc9Y1ODg00S+mRNG5XgvWnd7QQACGlKp2kVQVXU1ltdqALi4LjlXQxQ8ctV/jh2wu5e7/fE1NLdMBXo2GvBxTB9FuHOdn5Pjcd8Rh9Woaaq1F0fHSpZVbYQS597UWyO4cxXItF0T2I1/IsHPmIw0c/RcXhjchMlvimsczXhxUJIhoWy/eP4PZ2MO/x9/B6B1jW8BJWagREozW2l9TzBL1alk61hInSwjhUHI3aGI1GUGHS4ymqk3TWP5lgq7+N0o0G3zh6M5NuztC4W+fvJ00ili4xbnGO+MMljLRD4rUSW1+I4hwqCKjSjKkLm+vOf5jABXW6T8/gyzcYHI3DEDjxKGd2vETN1UnZIRJqkZQdIulEyVwZomiMMPV26ZkpBwz61ArjtAyfN8IERIPiO176Hs5RnGkQWGMSmlGl3SiRskNsaHQwx7uVgYMi9EzLM/3OYdYuSJCy/x+sOARuswtuMc0YJmP7ydl+omqZStaDHnIYsMKtxl3R8TH5kxF6PpJW9S3fjuIJWMQerbDHXzYzbe9hNhwWxz0cylGpnIurJRquyqAVZTIp7jpnX9KhODv7M1QVBSfspy2XZp/CKvarr2fHyhZKwsNjHfvybHgOZc0nuZ5aBJHJo4zvkw29cg1yRUTQL12ftk05q+B3TR6L7M25o28wwxlhhUhIsncqI+HDriv7BVWJ/Me0JKWraSn/yWvPkmqOF8uuwXpTTkRUHCYbSVJ2iPw1fjZ0woR/z9D1szyrrknQpeW57fjj5ASnIjeKFvPC50FYNmvO7+b+4+5tiYNMV+Mbvg2cd9S5iPwodCVA13jw5DspOF56tQJLytNlNVSpInzeFgek5uq44aAUnWka024uoewnDXc5V2Xhy+/xpxMORNRMUFTsSIApD+S4xPstHjnkPnK2n7haYsgK4RUmlZSHBeYnpA/yc9QnS5mX/wLFdXk1MJ0nwrsyFOluWeWVfFmK3noSKMMZ/vrNiSwJzcaOBvnNs7+j6BgMmHHZi2l6YQrNgOZpRhZVOFQcDzlXRc06qA05KHjzgcn4gw381AnvYLLyoi5m3Jxk2W97KJ7nI9DeYOTbIdZ9K84Ox20j9mWFXS8aoDzJIPn9EKkjAxjCpSi8eIVJTK3QEAr97cMwBEc/8ZaksSsVco6PpBWRjU21RtKKsP7iBO1/KxNfXmHChhTv7iL9T3GlQmWDxkEXraY+XsUJCUpTDaqGgeLK4LGQUiVl+4hqNTZ/L8bs7w3B8y59x/4/GI/gIuhS8xQdlaJjoAiHLj1HygqzW2UzbkiQUMsMWZEWoLjnWtn72Hp0hNU/66BPL/LZWWOY84dBQs9W2fnqQdyfQWGKl8oOOqnpIZx2QXSZ7Gfs7g5ywuZneTM0jYarMmnrCGPrMs5wix7jwTEH8WJwNoVIpGm0khJmUaqC1wOOg5KTdmxBCDsakHJux6EcjEAR3mibycLMBywcepNrp5yGUqnJUKem10Fs1zIYXkS9wcrLQtyy7yJ6tKzkTypVdGERQFqqt/NFurQcIaXGqkYns87bxoqRLmY8kGRa9wgXv3wOwjZR0gUJxfFKNyd1qYBc8aNunjr0NmwEPWqdiivYZEa58rizUFNZ3EioxTO1UZr0LIU/XXcobeX1iFAAVxF8WR/D2CaQd86fVvPp8ZMQho6oN1CF02rIzfJsJfTUS9x7xgK0XBUUUPIlZlxX5Mzy+Ty24E68wsIWFjVbZ9oft6FXHGLvVTjCXMpLiTk8GdiVYS2M6/XITBvHQana8r23HES1gRuLSCyiqqBsHeGqvY8FRWHtBX08cOLdGNh0aXk61RIZx0vO0SjaPlTVxStMZvx8G8JyURyIKyW22VEm66OYKCQvCBNbV2bWTUPYPYJVR3VJNIJmkTwsQvvnFVb8rJP+RRkmXpwm9kSFldd3EehtsL7RwY7uELaroDW1JH1Gmj6twKom4WyslkURLkXHoOJ4CGh17JjAMWDcb7KMzA2RjIfpzuXY9cwBBC5v3zKRAxauZf2pCQbMONOMbUzUR1jT6GyJCu1DwZyiMem+UZYf0/21rtmvv936P3FpODSaAqOUHZb+DNGgS8uDH/SqzdpGB3M8GWquzphXMvhXmNR6NZZe30tIrZOxvfQmiqy4qJNXX53KK89NZ+13E7gJiL1WYcdfDLHTRYP03y+BPidkPwTgm8VV7FLdSEoN8kfvTpw/5RzO7T+LJ3xzKIbCKDUTYcvEtu080O2AYdfvlUpOIWSoU6GMqNbxNqRGo1RyeC0yi13NQUKlnPRN1E2pvwj4sNvDuNEQmd3a+fHrz3HLvovwizo5W9KbZPi0giIcokpN8jW0At4mz8MrTN6tTmD9D+O81jObab8ZZv/UUul63Z7MLgSMZEBVWXlZD4/Mu6/VMNxgBdlkRlld70Ep1XHrdVkFFSvs/8dPAJopYGHaPs9IbmqzatmpKSgKKHXmhr7E9Xowu6Lgutx47AnNLNwcg1aUouPF9mnSLp/MSqiOz8OUB9J86y8XkLTDdKoN4skCE++TKIHCLC9/e2US7nt1Qk8VJBYRUDMFSU/3GvJ3vYljVBR5bBQCEm0S+uP3MvGPWX590NFctf5YFOGQcvwsrY2TZHS1wgQ9Q8crBbpeKLLmVAmACr0ofwYf1cZSMTX6VuUo7ubB7FSYfdkgx35zKbvsN8BOe21lzCJ5P41flGbt0Qm2nBUh9FmV3Q/dTNfjecZqaVxAFW5LNm66GqvMdnrVPGkryCYrzgaznZzjZ5qxjbbRCvH3KqSODqJWHSb/JEV0S4mpC0fQt9msf6CdyOoaigkbD5ebxogdwkYwxRjGbIoNUQTDJwcIrmhgr/16dRzGkVl0AAAgAElEQVT/EhWHhYLjKi1VnINC0ooQU0u4YYE26EjPgunFt9Jkh0u2IYC1N7YT8dZIKHVWm3EKjpeUHUbFoW92mtJOXrY6bfSpearDKhuG2xlXTtPzeoGbjLn85o5nub/zQJ4OzZH9BSFwfLI7ruTLKLlyiwyl5Ery45BsjLpeD6hCVg2qitD1Jpi4TsiqURMatd4O/j4wkeP5kL3+G3dvHiVXWe77f9491a65uqqr00M6aRISkkAgQIAYBGSeZZJJUUBUQAXRgx7FCeGgqCAgCIoiB0QEB+ZZEAFBEBIkISFzOun03NU1j3t47x/vTuFZv99V79J1F+vutbIaetXq6mHv532G7/P51jbzjLFYcUQDxN6nf/UAA+Y0vhSEhEdKa7YZqxZq8jDpxXGkwepGPxm9QtUPcVBkMzXfUCvwusmPjj8eMyXoyk1x+diTTM+MsSq+K8L1kbqF8Dw2XJDl9yd9n0FX0dQ2OlkGjBwFGeGJM9+HVilBPKZKJctkoT1MRquzptWtVrJ3YgADR7mxgOIdQT1kotHErNbbD7SHxh9r88joFdJ6hR/ecQtfPPIj+JmEErkF6taF39vBp/3zWOFczdJvltFrksnjI2y+uZNpL84Sc4TuzMtUn3yd7y4/WpVzXtAHCjxaMA213OZ6CCGQho6MhNraGT8aJnypx3cbJyFti/947AHmGEVqUmdTLc1h12ygttBk9KtJdlkxzayHppncK0rkYY89f7+jPZp1YwIvIbBGPBq7GlQX2xhVH7cgsDe67PU9xbLyDfBtyaKvjdN7XwHX1ogIl6qvelpxrd4GLnUbRWzNYUuri8WhHeS8KHv+eBjNl+Q+G6OwS4TdvjdB6rUaaIK3f9HD5j27OPz6dTRmGlj7Omx2usjq6kBR+EeH1c0kc6wJ8sdF6buqSPrROhzx73tm3xOBQ0qBh2C7m2a/0DAbnQ7mhKbY4nRCh0DP+SAlRsPl/Z9Vy0TVbpPqMouyH+Y1J0O3UVRddX2UITfdJnzlPGVClMrWIA1hy+cv+83m/Nyf4RaoSx3RVMtgoukEEGNfjVljEfA8tFwdP5NQfYNCVTUJQ1a7LyFtlaID+LEIiak6ZT2MVqyxIdnPWC7BAdXNPNW9H3Pv3MoZmdfQA/L2pBclo9WYDLrxqo8hmfDiJLQGi8wpHARzTGUm3W/mGHHjzNArfO+E05RgzHNxXclVPSdz/fCvuGL0ES50z6aUVnCedy7v5cZj7mJ1qxtQ4+955iRjXoyfHHE4mqZ+PnzQ8iVyH5jFPHMKS/jK1MeNt42gRKkCQpAJdicSosmYTKp+T6XRVoNeu+04vj3wICUZaqMYL3vyUW468ji1Zm7oSF3HDJvc9bU7yJSVJYFdc9nwzS4szScrSrxcH2C+Nc6WVhdfePlZMlqNK446Gz8ZQytWVMDQNNWADShhoqn8bgBlmLWzJDQNpKnz/TPPRp+uUF2Y5dvLf0Jkh8OqO3po6jo79k0y9+4ch5yxBc8SDB3SwfjRcVL7NajPMnijOsCJ336LGfdW0BOSld+dSWJrnT0vHG3bOmouaBXVL0m93VSkchu07LtQH5VNCnw0Jt0EB9iDbHHTJN5s0HNXiZEzkvwlPcBh5XcCOj688PhcsvNrLHpzhOTLDTZ/sZOyDBPVmtiaQ0S4bHM7aFFp70bpXT5TS2PMfmIabpTvIgH+xes9UaqAJKtX6Qqc560AiQewdW4Gs+hjjEi6vlfFHnRxIhrOAQYNLEq+zYA5FZgwO1Sl2l+Y8FQKGNWadBvFIHWeZshN0KcXafLumrGMRxDbRlX/AtTpaiuHNkIWMhpGK9dVPe16ELbxExH8bEoRyst1leI3VPCY05xgW7gLvyOGjNqsjfWzJLGNzz30IEelVlPwIm3xWbdeoeCHsfAC7YpGyVdTAVs4jHthJr0wZd8ioTXQhY8mfC4/6Ax821IBy1eBtRxL8Z3sccS8BheXX0Y0Hd65PMtDJ95ERq8wz5zEFg5deiVA9DdU4NM1tFINLcAGXnPVT9nipmlIPfAHCZqQdkjttOjv7kvk/AgD5pRqfu5cBLNMxMc0Cr5ie/gBkBlQKtOwhSyWiPs1vjN8P4eU1/Hz+DLGG0nGlyUoZqKktRZl3w7g0Q5pvULOixESHqc98oqa1kipLCPrypNGNFrIcqWt0EXTYGQCUW8qoyrfR4xPIxouXjJK/O1R5nxjmvWJPnZ0pzjg9G3MvVv5xNZnGax+o4eNP8lSP83kzd6ZoAn2iW1nw39l2XBjltAmhwOP2cKeF6r9E6MhGT8mxrpfdbHi8T5WXdlDeY6FQD349pDKXLpeVI3Kqh+iJXUWh0aZ9m2sYZf3fXor9W6T9ctmcPrpK5l1W5HiYhu9JQnlXMq+RedNVdyUxoqzZ9EdmDxZeKx3ukjrFVJaiwXmFNnAcNo7SSOyyYG33zW/+lev90Tg8NAp+Daa8FnZ7EUTfltJ2rW3InWlH6wy+7+nGTk9QSjvs3ZBD9NeDEt4VKVFVGsy7CWx8NpO3XPMKUzhYuFjC4eCb1PwooSE1643abQQ+RLebv1t6TdCQKMJlklPaZz3T67ihKm/8OGNT3PB6LN8dPpPnDr+KkdMvsmCTaswaxW8dBTqDaxGndmtHJu0DDsOi/OhX/2B2EUVImMO6ekKKb3W7k9MenGq0mDQ6SSutZj0I1h41NpcUpftbpq01qDqh+g1ilx/7Ml89+DjkY0m+lRRTTpCFl5HHByXLdkBfpVZzqHVdfQfOcG3PvAAhWASFRGKxZoMLBO/dfApiHoTN5tQ4+hYmNI+vYCCOA+5KfYJTXP6Sxfhx22kbSKjNn4mQc6LoSOVX60XYejkGchwSL3OMpEhk19MLldjRi/GdjeNJTy+9PTDiHqL7myIG965g/m1Ea7p+SAro3MYmM5x06yjiGhNVre6FNbfmmDai9BtFCl4UcrSJGuUuPGZuzjz2ddU4Gy2VEB3XEQ4rHpP0YjSy6QSyHBILQHqulLD+j5a02EhU/S6BUZJcMQJGxCrBKu+3cv0N+OEt7vwvNJ6ZLR6sAqRZthLYmo+lb1C+ClNbWBL8MKK7TLjqQryNcH0blGmz40y+HyW/B428m8O+r3OGyX9nRq69FhgTeJJAW/DB87YiFb28aNw2GUbMMoeg3ekefm+ObgxjYEHpvGfF3Q+X2XjBZ2IOESES1qvtAWOI24HY16UjU6GQacTX2psPLITXwN+/et/2zP7nihVwsGD5EidRdYYG51OoloTS3gML4jSa0zTf7uSeu84NkXvb0qEFrXI6iVl4KMXSesNTOERFw62yCkzIDy69QpjXoyqH1L9BF1j3IsR2akgtSy1odlw8ZNR4rkp3udt4qDCahY2RojL/0lOagods+H9j4jrojGYz/KX6FxGp2MY+Mz/zjDXHX0H/UYBf/dgH2ijIJFtUpARdKlYoCmtxQJrFA3JmJskpdXUpmlwQqe0GtvcDoadDm46/Biwgq/VkVBOblIibeUqh+8jHI/7u5azd3QrP/zNvbz+idnkUsrFfnWrS2UAUlNLbjGJqNQxx4tBGVLlvG+/BEC3UWaL08lGJ8zCb0y1ORQi8HBZYE3iSI1hV2lm/vviG/na0+eiTxRVE9hxGT0nS/wZ9XtWUOYGG1sz+NZ372P+aZMYSK5In8Qacxanl14HYMvr3Xz8gYt4+EM3APBEdSFL7G2KxC5ajLmKbLW62UNCb/Dlpx/gOx88C63WUI55dSXcw/Pw0zH0ySKi5eDPSKspmBlR2Yqhc3juLTwEHyi9w0ux3bil+yjyD6Qxqg1+ELqb3a8cRVsuKXQq2T4odfH0phhHnfUO0oOX75nDeDTB/rcN0v+MmvQtvHGcXX43xfZPd1D+oI3IQHkPi9imFnodpA4Lbh8nU6mw44wEA7dNsyj4PQmpMpdN13by1xNnErJdTDxyR0TIPlUm/UKF4q422y5Q07Vp38bCo4FGt15khl5no9NBwYswx5pQLnUzSpSX2iSfegquvvrf8sz+s4ZMg0AZ8ABXSrlUCJEG7gcGgEHgDCllPjBrugk4DqgB50kpV/69r+8DceHwVquLsl5jd2uCcgDmrWphWt069g6P52+Zw7y6Esa0MmoC0xvYHpR9k4IXYUyabVewqrRoeCaeVGPF1c0+xfSUOiU3BWxXP5/jssvoFs4qvsby+mZMfMaMJC/Fd2Oj7GBT5y5MtUyqmLQiUbRaA7vDJpWfYhetxK6VYXavDnF2/hWEj/KxzfvMZpqmNNgcy7IXI1gFhwkvgS5UBpTzYm2H9YjmsLs1RsEP4UiDMU8FEUt4fP3yj5NYOaKmOZrWDhZaUZG9RbmKTMTayMC1l/YyMi/B7qcMs/hbI/zxhnmk9Qa9Rp2NTpI1zcACx3HVdi4orYeUdJvq5h9xk/Qb05hCofe0cj0ga2nIZIwxL4qFhyU8GtJg0kuoBzOTUOQtU01RdhLMdu4CZd4us+85Q0wZSb7UeRJDHX2Iap35rQlGjSSFeIp5vyhykvg8133wnrYH6zxzimHNYZaRpypNVYLqJca8BJ996CFu23Eo4mLzXZCwaQROehEYn0IYuspMQgp+lPKrHFleg4bk5o7DeLzvfWp9fiSHH4vwg5kncMuWn1M/LIKzUlA1VF8i1aiz9MLt4MGa33QzMZDAEi5DP+lgy7YMMx4rMfuXecJDLvO/MoX8CkgDfA30gOMjPMWHyd5bJXuvyqg9UzB1bJS1p/QQer+DZ2gYnk9Gq1LybayTDKyHfGQZXrt1F2pWiC5RoSENWuiBe32RST9ESq8x6SUo+3a7Ed6zd4Hknaug1VIk5n/x+j8pVQ6VUi75m025LwPPSSnnAc8F/w9wLMptbh7KcOm2f/SFHakz7SvwiIcg54dY1+rGQ8PfCKFhVRumo1W0gK0RSTkqndeUtV5DGqT0mjI5ClCEtnCUM5jwGTDyLAntCOA5BTqD5l7SdPjq5GPcNnYPy+pbWRkd4HO9H+a8XT7FzenDeTK8iI3RPgpahEZPVk1WIja1lmAk0snPrtqP2BsVRt5J8OKf5qjOe0yw11dHmXv4JOZDLvM7VQ3cKpjoQhkf7VwSi4oWvUaRtc0eCgFqsOBHyLkxUlqdaz90NvENBfxUDAqKyu13JNRkJ2Ir9WlgMiSjNusv6eWGE+9GLoQdn02RerTOjDdKPFHZnbWtDIutEr/70CFtcyIZmBXJcIixm21SWo1evUy3XiLnRSn7FjKgZ8mdSlfHxUJZWhT8CGZQAslSRS3nBaZKMmpzzdXnktFqlH2b9HCFQz+1ASet8+YfexiKd7epWru6k2zUMohaE2nqzL9tnC88cU67efh6YxbdRpGcH2HMTSk/WATbnQw6km/MfoRvP3EPuB5+NKzsDOK2ssNMxFV/JqU0KhHh8P1tv8TA55Hw7jzeu0w1ui1TKXjrTbaHu7i990gOKG+ivF+cbx9+ChffdRGh77pYmz3+cNN8Bgc66TXymKj7U5stGftMkj+9PJc3/9BD7fQwrbSO5oLR4n9cAhU8pIBVV3Sz8p2ZrLqxD/cQjTGRUoHAKFKVqrfVekNNsyoHWGSW1knrFSa8GHGtFWTWRUyhDJhAjckdaTDkpsjqJfzFugoaa9b80w/837v+lR7HSSjrR4KPJ//N5++W6noV5b/yd9UnGpJqEClt4VDwIkS0Jlmtxh63jeKFBJ4N/b/Ik6+q6UPdMujWS22Hs0EnG8h3S8S1OqUgEO28xrwYk16UlKY0HxmhIv1HJ//IPrVt/DK0hE1mJ2HfYYPWqWr5VAxh6O/CdqYr6rSP2nz7mV9x0ZNPc8NB96nlOM1h1l8LGBXJ9HUJtt2eRo/C4stGyX5FvdccL4cjDXqNIrPMaRypt/co0npF2Rzg060X+d3J7+eKo85Gnywgag114qcV71OausoyTF0ZUJuGopGfl+CWk+4kE9S8g59MU8uY7HbLBMsjG9HwOe/o8xEVxSlFV9mLKFaQps4X5j/X7rXsDMQFP4I2lVe0MVABZzJHRHPoN9SiW9m3GXE6ECEr2JRtKKJ4wyHz53FaaBSnwiw5fxjpCAbvyhDq9rjo8ScR+RLJwjTdrQIbk7PAMtHHC6BpLLxxlP94/By6zQL72So7tINpWZ+RR0fSZ06j4TPidrDd7eDuZ+/icw89iCiU0epqmkKzhVZRFpu6Jvn61vvpbqnM6vfZfZWuxjYVTc0yVfY1leex5N78LnMAJxVWcvrEyyy78x1m//c0j3fszcgBKXw0MlqTjK6yAi+QFZjCY1N/Dy9/dxZvruijeECI+oDBhs9lqc6zWPODbnYck1B/eQnJV5pUdbXUttNnZ6iVYcxNqkPwlzVm/KhCK67jRHQKfoiCFwmyaNUTbKG3TcYmvTiLrHG69ZKih2kNti9Kqb/fihX//BP+d5/Zf+6SwDNCiBWBdSPADCnlKEDwsSv4fNsCMrj+1h6yfQkhPiWEeEMI8UYp7xLVmvQaRcqBy9k8c4rxjVFmPFJmx0dTDH4kQ/aRCmlHZQqlogogZV/JegfMSbr1EqbwGHIy2JrC+5V9m3XNXvoDJ7VJL0puOkrfZ1WJU9klxKdmnss96QPxdJWuqw69oywH49E2b1IaOl996jdc/NuHGfMULKbqK4ZozbXI3lihMtdi/eFpNh/RyXMP7srKL/fT9Zp679HtcTR8pgMkIqjO+qCTRhd+2/j46kNPVgZClRpeT1qhAQPXMUxD2QCEbcWvCKYL6z7byR0n3k5cq+OhkdAaJKItJi+Mkv5TDXuFwyP5fZThkqapk13X1YmfSSBaLgusUXQkOup7yWhNJt2EUpN6nmpEWib0dFHzTarSYk6wJasJRfPa6ZoGqJ6L6+E2BMd+Zg3mkMcrt82lMjfEhBenSy9TPHCAXZvjAGyyu9VkJKweIuoN5v93iUueOpcRL05Wq1H2w9hai7jWYoPTRUqrMWAW6Dem6dLLbHEteo0i577w54AyJtXXEwJpGly07QmWeGO8HpuLi8Z2vUPpcJqBc1zLQeoaJGLgS37WcRDPp3bn45VXuWLiMQDuiy3lvlMO5adHHU5D6mx2stiaorIDSkdk5pTa2Uvj2jr1pEnx82FeeXoXnNMMirdFmThE7Y/M+mMeOUjgvFdmXbOXxfYQCVFn/g8nWPS1cUofsKkeZpFY22TY7UAPCGcRrYmFEghOesr/N6uXWduagSYk6WAZsTLLgkTi/3rgOFBKuQ+qDPmMEOLgv/Paf9oCUkq5VEq5NNZhMux2sMXpbPuHbHM7mHvbFNKEyU/G2fCJLqQpiDwXoPMKor1r4aOpjcDAgfzo6CZWN/opBc7mKb3GS7W5igA9XOawMzcQe1Pljps/miVnJpCewt63UfZNdQOLUoWOewp86ckHufKZ+4kGsKG4Vg9OPZ+CH6bj8RqxDS3WXNxLVdjMNkpMkqR6ocnGH2QBWHzHCEsfGmZds0f5wCKxhBd4y3pcc+LZXPuhsxXEp9ZA+r7SjbQctEIZr7ujzcnEcdVp6kvWf3YmNx+nkr+V9V0oeBE04eNLwbqzunHSGv0/LLDl7F61cSuUq5lWrrb3bS565HFyXpRcELgVCCjM7VeeiihV8OPRdt8CXzE7oqJFwbcoBFuoxh11Vf6YOl4yDIYq65xlUTJv1Nj8gwzb9k0zQ2+10f333nA9u/o5ADZ5CfzAGxZQwbHaYMFNk3zq4U8yEqgjlcjJI6XVgr97QtHJIBh1a/QZeb78zIN8+vlnVXkZDbN3bZATS2/xQHJfijJEwYjQqqiNYaTiaLSDo2m0lxavSx3Jg90HsFtjlJJu09AU9kDqGpd/8HzuOngZ37z4E+weGgZUL2SnOnU4cIqXUgQZcZUxN840YV65dQ71AYV/XPqZ7RS8CAU/zGGR9fhljV0vn2LOTTnGT4ux4sf9jHYn0XI+ffo03XqpbWta8MOsbvbRb5TYx97BtBcjq5eUGtWL0G9Mk5Nx2Gef/7uBQ0o5EnycAB5E+amM7yxBgo8Twct3WkDuvP7WHvL/9xLAgDlFvzHdVowOjOTofyjPxrO7yGWizOipsOHjXXS+prrb9qjDHKOFhk9EKJBNt16kIU2aEva1B8noFRZbU2T1EvuFB5k3Osb80yawxl1evWGX9ptf9YffIGdk1I3j+fjJGDtOmslljzzINX9+hPNnvKQI3E6GkUKC3udK7HXTOIsuGOOUo97k0CUbWHbZIABLvz7IIQdupPeDOZZ/YzPdvyphTKoHobiHTed/lDjk3vVEtSYRrclso0Sv3uLao05RtoX5gMEhBKSTbXQ/pqFS+J0BwzSUjPxLfdxyys/RkfQbJQ6IbFJ9Ei9CXHMwYz6bL+gk80KN+Y0xVZ7UG0jbCgJUExnAerr0iurQB83HhjRJPb9FBQPbwE9FlQ2B7wfeLoYSMkkNH40vzHxG/U59H32qDK7HUdN/5dDCGrZ9sYOVR8/G1hx2uGG69RJxrcWIG+bgQ9+moIUpzehGK5TV0qDjtqnkwvNZ8MMRPvXoJ3GkgYbPpGeRCQzFFdbQZMxL4qOxujmzXTbEtQafefwxotM5Lht/mh1mB3eFlxKTTSq6DV0ZRLESMDSUXkX52vp4qZj6GApxX2oZAEmvzk923MWyLX9B+FI1q+0Q4R1lvnfsKVx3xIl8+9Vj6WtNE9ca7GsP4kkNW7iktBrTXoRJL4GHhm07/OE3C5Qnz9oW8ecbzDOL8JLP/sduo/+hPMOXJSn9IErdtEh21NEcCDVcCkEvbGemqixFQxR8q12ixIMx8urmTCzhwYIFsHXrP/PI/8PrHwYOIURUCBHf+d/AUcDbvGv1CP9fC8iPCXUtA4o7S5r/7TcRQF12lh1x4RD/SUOZIn2iBx+NFhre53XKcy0kMPutHOOeRk0qk2cnANHMM6cYchOqyerFWNfqwEEnNxlmj/NGES3JX3/TR+gAlXF06aozrU3lQQiaGYtzfvd7bv3cLdiaw2Yni3AlxYciHHXJWo49YC1zPzFF/IdV7B0uU7vHaKZN0GDbh1Ns/3Ca2kEWlXCIgSdyzLtiinlXTSGB+kEGEwdHWfRfY8x4sowvNc754uWcf+pFUCipmzZYRvMTESUoa7aU0VA0DNpO3J8Sfa2/uJOHTryJghehJXWq0mDMTQbyY+WpoQmfyY/FKGk2Z5ReV1lVNNwmjWGZ/OfDv8ZHY02rl4jmBKbWEbVQGECM9cki+lRJfT+lSnuPxhQ+Ua1JWq+o1xs6WqmGcD06yzkuHHuW1dFZXPTwJ5llTLMkNEKvUWdVs49hN0Fab5Cq1ClroXchRjMyKivygvJH3XwsuHGELzxxDmU/zLCbouCHyWjVgFFbJauXGHY6WGCNkg3Gp2NuEhOPWz/yS2a4JW7sOJxmMkVUtqgFdqAYqmSTiSheRxSaLSXsqzXVioChM7OizsVbZx5DQQ/zrdLTXDXyWxYOr1e/T0PDj9uEhcNjZ9/K8PIE5z77CdUjEhI3EPaNuUnmmhNqAugmkWmoLlJN54Mv30THJ/Psfs4YWPDC/fPY+LksDQzSeoWxiEIHytK7Sb0tHKp+iKjWJCpcpgPhY1xrkNWrFAKBXkvq0NEB+fy7Gd2/cP0z49gZwINqyooB3CulfEoI8TrwayHEBai55k73tidQo9hNqHHs+f/oDVypM2BOUQ4Uk6PNGLs+Mc7UUTHoVuVIQ5rUjBDyBz57nDRG7wNFnvziTFq6TkOadOsVqtJgyE0qGwB8hoMyJuy22OvCESLDLVb8op/IQo/ohCp5yr5F1Q9x1Z8fZeDMCaoyxLAWxRQeO6odDDw0zZ4/2UF0u0Mzq1M+O8zaI7so7BkhHa9i/EzS/3iBNy+Zyfhl8bYreFpr8FJrLvFtDZZfuIXQiEvvjyr4OjTTBku/sI3PX30WydQkfjw4+epNZKuF351BC1SssiOBmC4iImFlshT0Od65vIenTryejU5GGWxrTRpSV/LjYNSbEVVsXK740Ie5sOMPHD+9krDuURdC9W9MA3yPrF5ls5Mhq5eY9tSDqiMZc1NqtBpXnxP1ZnsvpyotdCnba/GTXpyoaKnXeD7Strh04nkM6XFDx+HQcmihs7rZQ7+ZI6E36AqIb53FEonFdXBUqdiWiBtKFSptJe9HShbeNMYXtbN56MSbqPlmmxznS3WffCCyiWEvxupWDwuscTThM12M0vHTKqVDQxzxszW8fcwuNDWTuN5UjeHAHtPLJtCnKwjPV8t4rgthG+pNYlIdNBtC3TzT+xFOKbzBacUV3Fi/n5XTfTyb2YtX04va9/QnK38m9RW4OX40d/XfjodQzX/NIaur5n3GqEAVPEvD18As+sSeazJ6aYKJz8TxTUHLN8gBKa1BvKWCYdGKIJABX1aNxDV84ppqjprCVXJzrUFcU6v6s4xpFTg8DyoViMf/iUf/f3/9w4xDSrlFSrlX8G93KeU1wedzUsrDpZTzgo/TweellPIzUsq5UsrFUso3/tF7RIRDRmu268G5r+UITXvkTwyT0mrBxEFpH5y9TAoHhLHyPku/uo2MpmTqBT9EQ6obycJHE5KUpjw05/94nM4VVdZ8t4fG/iYbnU62uspTpCFNrABQ7KITCbZym6+anHT8Kt731a34KY1XfzybR17ak3VXZiksixKJtZBPCva9ZjtTR0Ypfi5ERlfTkzXNmWx0Ouk1C/T0lbBHXHac2sEfXpxH/iNR9JyPaMHVUw8Rdevt1BghINOBNjIJhTJeSplCY4faNbgKGt08deIPGHRSxLUGBV95bVj4TLoJosKh5ofIeVGuOP6jiHKVFyPzsaTH8om3VekRnLLrLsuyptWNJTwSWoNIUKJk9TLXf/3DanGv1mgvt/kx5cFq4gU6FKPdJI5oTXrvm0LGIxw5+hr7V7dwZ/YQhjN9yFiE8x69KKCJJek18hT8MENOBqPoIxOCqx/7hQoU4ak/clwAACAASURBVJ0jZqeNWZRRu72TsuDHBU5+9HM0pMlsI8+0F2PMS6AjWd3qxhZOsGag0fBN3vfbrYTyHpsuyRLVmnz79/fRe2SOuFtXhPWS4sZqDQfhS/x4WAUNO4SbTSBti1ZY9X6sShVXN7l/4DDOXXAJt88+mpl+kS+NP8F979zAFaMq8RZI4o0yCRqYnofmSWbk65ibPWrPaMy6Oc+yC7dy3AFrSL7ZAKFGs0LAhk92kbfCbHfSpPQaOj5l30IUBVKAH1eZRlyrU/NDbc8VR0J/gFzwEAy5aXQCFTZBxgFQKPxz0eHvXO8J5WhD6mjALFPVhdYjLm5cY9WBfXSJMn16hTFPOb39tdmPfyks/cgQfb8r4Uc11nytm5YeYq6ZZ0uri5IMMUevUNMaVN82WXjLCMMnJNl44gzSVBgwp8mhTlGJoCX1gPMh8XzBLlfl6LqzQq3P4s+3DzB1mJqs7BzhVv0Qc38/wa6XTVHay2btTTMoizCWVBqNudY4Y24Ky/NI/2EcvS4Jf1DizdT4yJ8/TWd/gcvyz7K0spWfD/6Ur3I2m8I9SuauCeXYDggplXw6GAcjBOs/08P3j7yXta0Z9AYPjS0csnqZQmA3qQlVRoy5SRidRHZ3stbqYHwswcHFtTyX3EOVAtU69x57a1CahPEQmEh6jaJaO38735bg+4kwWt1B2zaG7FD7Kym91iao60jWNXv4aPZlbm8dw4XVV1lt9/FodC+lOK3WWXCLA8dDRq+wpaX2Kjw0QiWX5i7qVvTTcQXoCVmQL+L1pdGnyojxErI7C/mS+lpXTvKJ5qe49eQ7iGt11jV7mWtNqH6L1Jj2YtSChyv5QJ3SkhAz9nNZVUvgbNKZn5sgKpp8ZvvjRIWDXpVUpUE5FGOqHGWT0cnWehxZDuFHLKZd9TfJanW1Ie141I0QD5Rm8uDci1ngTXBIcS37VDYD6kQ+vrKa4yurIWgrpPZuEHTWkAKqu1hMnhYj9ac6Tr9OY7ZB9p4qc78xSfHGKHZolEkvTkqrKSVxTsGNo0aLgq/2nRq+SURr4qMx7MXIakobNObv9JjR2DtU5bVG4t3Akc9D/9+2If/Pr/dE4BACVjZ7caTOaCvJPk8PkTsiysxogaTW5KX6HBZYo8S1FnOsCUr72zQ7dbyYRv/dBTrG67zxg36GRIL97G0MuSm2uT5lz2b5N7bgJHW8a0KktBpZrUZNGmSDKB3TGuwgxaCTZU93hPD6FtbrPuMfjbHii/10JyrM06YZdFKUfJsJL8777tnCrKvy5PeMULkrRtM2yWrKHKoRpM9qLCpIPtyg2Wlw7nWXQkExRXNWkq/O/QhXb/gl+9W3cv3mu/jOrFP5c3oBot7CTUfQag5ixzgiEVddft/nncuz3Hnk7aT1Gr4UrGjMbis9dSQ5L0ZKr2JLl2X2Ni5dfgYiaUBQPrwU3Y2TCiuIuXWqvrJlWNfqYVFoWHnBSo2GNBhyE0REU4miIjZS1xU4GZCZDoTjEhEu416MXqOMiWStF2dZeBtbnDRnTr6C7Tvc0HOcGqeZhjJvdlwc9DayryotMnoFo+QxnYjgSJ3P/+633HTkcWq6kYyjT5WRURuh66ALJbUHSKeY/5MJLoyez3WH38diewhbKCsLNdYsMeklsDe3iKx1GPpgitDHKhz153H0xrs1/lH2KurJEOXxMDG3QazcwJRKs+Ih2FDs5cXQXF5JLaAldBZUd/DCxGxO8texuLqdq2efjmw5vGP38o7VQ7RjOb/bpEBJf4nMIXJ5nRl/KtP5dpVtF3cQSnkMdydp7G6yxuyjs1HmQ/evZOToJMPnJMnes4Xeh4u8delMEgN1MlqVMS/JPHOSzPoKtXkWk16COeYUg06a/ewhNgeZelarsbLZ3ybdp0ylw1nvqMb3/wgc/+L1nlhy0/FJ6VUiWpPFf9mBXpKMnRCn4EfwEWSNEjk/yqDbgY5PVQtRPc0mvN1hx2cTRJ9psuzkQTpXVdjoZOnWS6op9JcpUisaDF+aYn28Qy39BOO8sQBmk/eipLQaPSN5YmuamFWfDbd0svmqLHbMY9hLssVJk9AahPMtll+2hdnfyjN1RJTnfrEbm+IphafTWqqc0tS4doE1Sd9gga5nKzzi7o2YLLXtD6WtaOfXdRxJQ5g0dItvbP8NHxx7DdFy0LeNq2nCTt8VYN0lM7jnqB9TlRYF32bMSzBgTTLUUkiBYU+VXsOO+jkvOeJjqmkXaBiE4/JidDdMfJZXNiAjNuf+/kWWhIYoB2K5km8z26jhSU3pafIlZTbt+yrjAUUH0wRDbhIPwRYnzUv1gQDraBKeaHJs8S2ejS5kVCSCEaejtozDIW457ZSgzq+y2JrCQ+BJDQ2fNc0+olqTjz/9vFqYS6pNXOW9YikrCfnuarjXEWXhjdNc/sczmfTiTHpR+owCtlBl1KKJUQ744iAA/Y8USK2vM3FmnJU/mMm229RDtP7bM3j9hVkMrU9y9q6f5cRFX+YjCy7lyt5TuT+9DFO6XFh4kbsGb6eqhTi4vgGZTTGzNsnutR24qfC7DFk9gAkF1zY7y+i5SdbdMYMHX15C8fwIxVMjbF+aQYv7LLG3s8eLw2gOjH8gzlh3itzuEYSExbcPq8PAj2IKl8lWhOhah9zuUfayxhhz44Hth05NKt1Lua0rqjPXnFDNazxSWut/GjL9G5qj74nAUfMtHGkQ1ZqEn3dxoxqjy5P0GkVWNPrbCtHF1lQwdiyw9RMd+JYgOubw5p0zcUs6e5w2wh7fG2Y6r8Z9Az/M487Q2H5Gh7pRQzsYdDvY4HThBduxMa1BbLrJso8NIhxJZYHFC0csYLubbn9/tt9ixiMlDj1mI/3P5Bn8QgcrftRPKlajIU16jbzC0/shysGJV/Athi/upikNftexn5KHB36loqRS8XI4wSOJJcS9Om+FZ/GZsWc4qrhalSqGrgRUlRrrLunhFyfeiodGRqvyVl35mQ47HSyPbA5m9QVsrcVca4IfDx2ilJ6GrqYCjSbS0NmQmMm4mWC/8mbwFGujJENMugnG3CQLrDyvNXoDFEEBkjE1tjU0ZQ5lGohyre3+XvCiFLwIA9ZUMPp02PNno+jS576+Q9qbuzvtHkWtgXD9YI/IYKOTpOFbiKTEKnltmXS3UaCwZwZtIt+2iRT1loIEtRyFOwD0ShM/FmLRNWNc8tS5lP0wZd9mzVQ3e185xPxDxon81cGJaaz6XQ+vvTSLytURvFM1hg5N4VmC7hVlBoLs56xHX6TZHSfn27yamM/dnQdxSe85XLDLJ7lnxkHY0iHtVLll3e1EgmapOVrAjyu40E5Hvp3XQWetRRd+G5C9welivdNFXKuT82I0fIOBO6Zp9BuEDnBZZI3hHqKDgJm/KSCGfeaZOeJag771RYy6T2NPAx+CMtGg4IdUdgjYwmOuNU5Ca1CVFhYeuvDZ6GQY8xLvZho7M49/4XpPBA5D+AGsuE7X22VKu9ssjBUo+HabpRHRmvy12YWHYMyNU+u0qJwTJvVgnXCXw+ZnOpk+Ncr82yc5+ODN9H09T+RVh/EL4thhR9nnBXyInf8AZEuw6wWThMcdqgtCeAmNjFEho1dwWhpdD1bY9+gh5n4uR7NH5/mH5jF0SQcpq04q8JEdcTuwg+aiJzW2tLq4+4ADOW7DCp7o2JtCJKUI47qGjIbxg4acH7N5YMZyPDS2Rrt5IzaHS6efZR9nCKTEyyZZ98VZ/OqUm7GFS1S0SOsNZluTaPjsHhphdbMPS3isbfZQ9sJ4aBifjwZm1Dqi1mzvs+B6rI/0sas7ySG/fYvVzT4avskca4KUXuOPtQHmmpOMuUn+c8OHFBSnUEY4ngpCUbtddhT8CFmj1DbVtoXL9pEEHfdUeXivpYw7tgo0jqt+bl1Xo9WWw9fO+SSO1MloNeZZEzSTBnrJb/ucOtLg1mtvUq83dES1rjIvQ8ft6VAKz4DBoY/lkbEIu/24yOWPnEPij3VOOv4tZt2bZ/SMBK2szvQHovhLdRrCYqOToSENIrbLxMFxUk/V2dxM0a1XWGLv4Os/vZNLn3y8LcuXlsmISPBLbU8+NvMT5LUwc5oTHFx+h5DvgACt6agAG7LeBeUIaEmDqh9iu9tBVGsyy5im35jGQSehNeh6sExklcOqi/soCZtJP8LQohTCByR03VZlxI2T0er4jwp8HTYc1E0hYJM2fCUntwKp+Rank7jWUPJ3qTHmJQOCfImMVv1/L3AALLLGWVmZTeydJrndo2xzI9T8EF16pe1g3m0UqfohCn6Egh/hrYt7aHQYzL58mrVGN29+dyYvP7oL1QMten9RRgKh5x0yv60yuD2F5wsGW1ls4RDS1JSg57EisbdavHT9rtSiFr4rmPlSnn2+MsRhB2zggMsHsS2XV364C6sf7sVbqBENasjNjlKELrBGWed0MuHF+eZN5/HACe/jP/K/p6hH+FVmuWpQ2lZbui48T0nZfSiE46wMD3BQ4R2ujR7OoN3FFcMPkW0U2HBehDtOvB1Q0vpJL86QmyCqNRkwC8GIrxpoBXx6zTzXHn2qWjfWg6AhRJuRKnzJRidOT6vA3s2tzDUnmGfmqfkhxtwkA9YUw16SedYYyU8ruwjCdhtwJFpuW9fQpZeVWMw3yQVTjTk/yyEcGLhhFBmy3oXtBOWWKFWDssnDFB7b3Q6G3BQkQS8q6pmaFqhT+6tP/1a9t6EjpEQ0WhhDU0oSvnMNIHCk01oO1179a5Z+fAg3rrPygZmMfylBaMIjvyjCS7V5FLx3PVRzfoQNx3RhjXnMWFnGkRq+FJjCxUPwzT89zOYvW+1VA5mIUUp3ck3XCQA4wiAsHa4af5Cwr0jyYqdwD2X5oYakGn1GgYjWJOcrpzxHGogNPvO/NUl+3zD+mbJ9kLl7qEeyutRil9/kSE9UKHgWs57IUzgwQqvDaK87dBtF1jtdags8yHx3HmA+mlroNHJqB0r4/+8FDjsglx+0YwN6Q9JYrBpoBS9CLli4GnQ6GXE7yOhVHGlg4tHR2WDt1T1E1joc+OPNVP0QiT1bPH/LblRnmdS7TWLbW8y7fIpj3v8Oh79vA2dc/Aa7XTHBnGuVzDm9sk5pUYjdnhgju6pMx4o6+5+/jeRjdcqH2qy6o4dHHl5M9QSLqghR8KIMe0nKvo0flCcA3XqJH59wHD1/mOLs4mvMbU1y84yjKFtRpdFoKod20Wyph6dcRTguWqXBC/EFZN0ys4wKV/Wegub7XGA/x41H3s2EF2/vtZjCxQnUmtOeHYi9yswxp5hvTuBIpYEQvq82XkOWWps3DSX2AjbFZgKQXKMezrda3SwN1UgF3fhqsKFLK8jIDB2vM4nXmVCjYV8i8qqHtFPSvyA0QodTYeC+HLkTIrzcM0/V+rU6slBUqszApkHUGuhl1Yi1hMeYk6IWtzBLHo40AsS/E1C/FZRHRsNKlBUNID2er6htgeJTT0f58rYHOCP/Fx6P78W+n/sGtb0scpNqd0NmJLsXd7D78DADkzkmywlybpTYsQ3ciEb3PSU8BAU/HEwqLOLC4fb9f8F/PPkQTBcU4a3a4K3Ze3BX5iDC0sVBY5/yZr6/5W4y+QlEqYKXfte/xAvoPYXAoFv11hIcMDjEsvMG8W144bp5TBOn7NtERYvObhWkx5YkEK6k/1dFuv5UITrUYuiEDkzhUvbCSjGtNYkIpdtZZI0HcgSbiOagoRS1290OTOErA/V8XsGMYv+6x8p7InC4CKY9m+gaVTeG9lRqRFN4FLwoVT9El16m6ocYctMMmJOBxDhG8xiDjadkmXVzgdmPTfN6YzYLymNEtzts+ViGR59fzOqHu1nxtX7G3p+AUej5Q5HuB8vt948OOyTXNHBsnWqfxaY7O1m3socXr9uVkQ+kmBtS5O1uvYKttZTXiR9iP3uIuFbnvDfO4+tHnQW+zyGVdXxk4k/8PrqQV2YsVv0MW53SwlNsC9FQOH9F1bL4S3xXABY7o4xHMlxz5vF8YO0GDnpom9p09c120NjJGUnrDRJag2kvxrQXYdhLcv2xJyuRWL4UMCl0xeuo1nE74+D7bNJU76ZrTTn4mYqMeEpE5CHoNpRsH9NQQq5ICL1YVeDjv9kj2clBsQKwsvucjlGRbD0tw7LwZhBCmUcnA0d1x1XioyB4XHX06WT1Mkvs7WhJiVbw2Sc0xD6hCbY4aaYDNeyXnnhAlUvVOlq1rmhnmbhijCaiaDpcufk+Dmls5GfZQ/l5ZH/Ov+oV1l/Qy/JLlcnywv+c4LBlG1n0gXEWLxvl1D3/yhmL32SXs6apzzbofqxM/VWDqrSoSosxN8m4F2NDq5uCF+XKN55m5Mg0TE2j1Rzu7zqQQSuDic+gPYO+5jTXT/6GjpgGf+Nx7aO17xUPDZsWez0wTNfJefBg692dRGc32c3MBXoYg61mCl8Bypk6IIr9cJOOG+o0enWmTwyjC1XSpQIrSFtz6DdKauNbqweEfJ8uvaL2ibQmw25CgcDzeZVt/Bu4o++JcezORmV4tYMbEayflWVAK+AZSjo94nagizrdRoGGNCn7YRKBKg7AudagOGyz5Es7EDN8dEf99UqLbeaFJqnuFSK+xKFAlNVuH71GkdAPWyy8foI/3TuAfJ9GXGsx64xpQDJ1aJSocEn5wUzcSxDRmmx2MsHIVTESXq4PcP9x72dOeQzZl2XP0hYu3/Ywq8IzubnrKKXOjNgIx1MELUc9xAB+yEQr1RUrNJ5kxEyxa2OMdZ/q4OoTVlDYaBO7rkrniVUSEZcRL9Jevd/c6CKjVWlJHS0Qxn3/iBORiaAcCsDHWsttlypGoQaOSzmdpW6apN+uMUSHKlM8ZQjU8ExKvk2XXm6rNbVSTW3GNlQGsrMxutNiYbE1xaAbY/cnR3HSGvqBUnmqtBz0elNlPYEC1I9F0HIF1ex0XMa8BP1GgcGeDPvnKlTyBrUUaKjsaJaRZ8xLcM2fHuSKI89SQdHzEFVFXJemzqUjj7O0upVHOvZhYXWIj9VfxJIejecNts9IM58Jtp2eorJHiGbMxKx5pMo1/CmNyDst4qsdhISDztpC5X0hBj+YJnxyk5IfZs/QEC10Jr04P730JqxLfb560KntCZMP9DSnMfHpdMpcu/luLvjpOfBxdV9n9CpFzSZVqeE+pTPvzgk63qlT3d/iz9cPYMz0mWcUGXHD7GbmGPJi2JqLE9WxKw7Dx6VY8vVhooMVhq5OUbdCmKgArwzLavhS46/NXuaakwy5KWzh0JQ6VakOm6ofasOPWL8edtmpJPnXrvdExrETwGsOujR2MakKm6o0SGnKazOtVygHaWRca7Ql6ENuWp0SIZMXb92Vcn+IxeePEntA3dzNxQa+FO0TJBdYAe7IJ9n1jilyh0UILfeJay0GnTSWcNGQ+FJTm7e+qYyLjCJ+MKKca07iIVjX7OG+Ew5Ssuh4lOX5tfzXlvsYsVJc1XsKrYhKkzENRL6Ellcn/PzGKCfkV/KFbQ9z49AvuHPLT/jt6u/T7RRZXl7P6uu/ym4fmqASDxEa9+i6ucTGlmIp1PwQjtTpN3Osa/XgoEZxr9TmIcsVhQII3gcjgDELoTZgC2VkOMTGczspzg2jb1MqU1O49Bp5Uppyu99ZDyviu6d2N1oOFEptX1sspSzVkYy4YeL1BunnauSPiRAylTsaoLZ4i2VEvqSUmdU6fkb9LNI0uOSVD7PF6aRjbzUlabxlMRnQ3Te3uujUHVpSJ+dH8Drj7W1VUWsgGi3OGHqBowuryBsRPphfycLWKE8m9uLyrg9x2i6X8iNxOACDR3ay9sN9pM9wGf5wiupnI1S+GWbjvV38/q8L2X5mSgGFt/gs/soo7z90K7vfM0K+HiYqWuhI5d2KxhUvPqqUrUI9Op8auIBnkosBmOUVePqTtwCg+dD1owp7HDXK3kt2sP+XtmHXHYavS/HCL3cl1t9kzE3yUn02ab1BWRrU/BBx0cSsefgxCB/WQgJOQmPb6Sm69RK25jDPLDLtxRgI6EAZvULZt8l5MRJag4mAB5vR1BLgqmafKptWroR99/23PLPviYxDSoEjdbQi+CnBXHOSqrTwpdZ2ri94kTYvc6cJbzpI42uEiGcavHjvPN5/4SZ6Hyrh2YJKLIQhleQ250exccjqNXp+W8Is+Kz9bHe7XszoFZrSaLMoJr1o20B4J2Coz8jjSJ27Dj0wWMKqI+NRTiq/yacmnmO93cM3dvsIZS2CNpYLXuMxVytyWGkdB+1YR9ZVD3ZRC7Mp0cuOcCc1adIfn2TJ0HbKe4YITbjMWKFe1/ejEunHa+RPiLDj5BTNuQaDTpYuo9Q2in725L3w+yNotaYqTQApZdubVsuVVJPTl/zoQz9De8XH2OyTNUoqtQ3KDYAloRHOuvKLdKmFaPR8wP6QEkoV5UQHbQD0K7V5nPnH19HrkpETVNOuJXW4vYH4tA5JpUXx4iF0z1dfJ/jeFvxXkdZjOsaeKnWeuTbPyMFJWujMtSbY4YaZa+aoSoNL7/k1PzrwYETYRsYiHDCxmo/nXgSgrNn8NP1+nu9dCrVmsAgYbL8CD760Hwcf9g5DrtpM1YXPsNPBEnsHmvD56zdmEl/RxK44PPuj3dj3zu3Mu3KK7jvLrPpeLyyFjFZt613+83f30XlMATbARGc3P6wu5+dzDubmPf6bnkfeLYEB6v0m245K4x0q2LK4E12XQcDtUMHajzDkJgKryArVmonWgmbCRN6qgpNnC6QlqEqTlNbglXo/cb3OQ5V5HBjezLCbIK7X6DdzbUI+qN7hHGOaMSdFeJsDxaJarf83XO+JjEMTigCml3yaCVXrWXjtbUJbqAfbFuoEKvsKcTfidOCj0a2XsPDId0T5w90LaHbr6A3J/udtJzystj0zWpWUVuetZh/9DxcoLLYp7KUUnt1Gud2gVe71Rruf0G2oG2HY7eAzd1zEt045R3mQmP+LufeOkqws175/zw6VU1d1dVfH6emZnjwMwQGBIagIKCAoCoYjAsdRJJo4vh5RXjEhIoh4yAb0FTgCSgYli+TM5NzTsbqrq7py2PH749lTeL7v/b7DWi/rW+y1ZvXMmpla1b1rP89z3/d1XT+NtFXhRxN/4pzZx3nBv5Bv95xGpaWB5YDfx3Ilz4+yf+ZXE3/gpPlX2eVLc0X3R/n80Jc5ffEFXJI8hZ/HjuHCyz5N6PQGwoGJn8Z57fYB7nllDZv/vRsANyroua7M2g+PMXJejlW7xkl6mSA/+/DHEJYtTXGaKk8Eli0t33PzMpgmGsKdL1G8Tnb5i7Egetluezrqjp+a62OFf5pxK0ZqQ0V6WTz9h90Rls3VfZoM26Hpyp7AcZFNiPtcWmkV5xCFupfk9m+Dj8heS0sa37TZsmyYtgyoeFmp9SZX/vizvBLqp96vE9/YJKG0qHhN102tPoqOv32C+c7zj4DrcsrM81w6ex8ucF3mWL7SfyZPJlZDveUhNTWcaJCST576Vv5thq8/dxpbW730afMU7TCqkL2auuOnP1zizSv68Ocs9rtzgo23dfPkb0dQHIfDPr2Hw3+yh1ZL7rEVb6QvkFXhjq/qkO7g9a8MMf2LOIWDZBnz+nl9PLNnmMnfdDDz9Rg713S3F428HWFYnyOgmO309lEzTcUJEMnLU0RirMGyP85QWhcgMGujvinfb9Fj36aUGvsH9lJzNQa8vlTT0b3nyaHm+ggpFgUnQEYvEt4oS81368Txnlg4JCLPwVeyacZ0cnaMrB3HJyTvc4OXo6gIhz6tjOFKR+yIb8ZLQZIogdX+SaKRBsUlQRo9Gp2vVVlz3CTBa01qZZ28HWZ4ahb/BovJExKYruZ5OqLk7TCaV1snPLm4g0LFkc2yXx/xfpbePcWtG6/h5OwLfKr+GjfkbmdFfYJfdR7DDzMn03Jl9mfn7ASXTv+FqyZuZ9jMcUv6aE5f+XX+59DpPJFYTS6caiddbb2wl3tOugY7Lm9FqSA9CBlfiVdOHcL2C4yDdF55YZC95yZJ/b3GuhP2MHzxHJe9KEeDbiggJxfFSjtMGMfB7enErXusmK4UP19yJzYCLeGglR3qlo+wsCTo2Ohm3JKmOaXSlGYz24H5MkrdaI900TXcWJisLe3qW1tddL9cZvKIBGUlgI2gYEfk+A/axjQJRJLwK6Lh9pSl86U8KbVKfZWPwAYpDFvjk0yQZf6pNrio6fhomRrrfc9zTu4JFOCazPHc17kWp2nIEa1l4/p9khFTaVBruMxpERZVplh+ySw/efAUQkpLanRcta17eLaxmNzqGM99dxFdT9UYuTSPeyQ89sAyymeEiN9SZ+XZ0wQqRlvOrXjZVL8+9Fa+dO9D3HDqTXTrFqPfl83noafyDGh1slaUqMfIiSpNBrSiB+NSMV2VpuNlnzg6YWGgb/Lyde+qUXh/kM2Xy80j8IIcYSeUJoN6oT1WTigG41YcFccLhSrjw0EXNk1XbXtakhtrMqR41ap35Zl9TywcCi5ppYpWdrDicv4sDTqCmGgxos+RtyPsNrqouRo+YTNmJtG9k8jbY68AA1oZXXdwOwR33ncQxYODrPr5NEcetYslv5xl2d1yQlL6aJARPYeKg4nknAoZH8suM01arbR7K6pw+PmL95CZ2UvGKnP2zFOcnX2SDf4+zhk6iweSB2InIrg+nQ80t3ND7g4OMCb4depIvrDkXO6OHkSjLJOz9gmX7M44W7+c5KaTb6boBNC8TE+h4xHeYsTiDSpH+9H/alFL+xj9ZpKn/76Y6S9H6f9LkT9//kYObI3J3kPQ306ykgCisEQtBmXkoGgZjJqdNB0ftYgP4UKiJhfItYG9DOp5MmqZkJDTDzcclKzY3k6pv9A13HqznfB1iD9LTGmiTLnoBalozFpxinaYrBVv736AlL6HAiilGk48IhubQT9OOIgoyRyPymofQG6bBQAAIABJREFUkTGD3lKDJ+pD5O2wF3gjZBiyWWHtOWN8YvsL1ISPTb4e/hrbT7p2Pc2Ik4q9Lae2bNxYhB2BDIutWdxYmCU3zPC5P12IjWC1f4KMKgVn7w/uYrV/GuMMlcmvxMjcXmHJD2dJRqo8/70FbLwyQ+dLVQ48bZLIbBPD3QevkDL9qNIgLAxMoNovy5nE5iYbNks37qjZSdqDjb3R6qfX086AzIOJKg0CikneCeN70MYF6gt8PH/dMHafSj2j07dlnimrg1EzyWuNIUCGfKu4dKlVwsL0Rsp+DBS5KLkqRTssF6U3W7B69buScC6f2ffAZboquyppFMPFl5BlRcjLlXihMUzJO64O+2bJeSKhJb4ZCrYsNabsKCHFYrVeZ7PRzXwkDCVoDmjcff1BbL23i5kDYgxfkydxbQ1Hl4An50mH4LyB6WrUHQ0HgeMqpNQqBTtCaTbEimenOfT6UYZOmuOG+TsBmAkkuHDgX/jeyOc4priRL0/+FbVUY/3M4/zb9AOM+ZKcO3QWd2bWYRiyEejGwohmS+Z71pvs+EKUm0+8ua0+DZW9I2qizpCWJ6o0SKh15t8XIjxtUM4GGTU6seIqT39zCRf1n0FND/KjiT9x6uQzkrFiWpKSti/sx3WxO2M48TBff/xB1vgnGdDz+DtkWTZZSFB3dLYa3SSUOk1X44zvfwNh2fI9h4PyYU/F5KkhEZXBvzMFpmwfBipDm6UeZtfyLvq0eZqu3t6VS78LY/YkcIM+xHxZlieu2w5cRhWgKPz4iBMZPTwFQPlBhUG9QMUJklSr7DK6iDlNVn9tmtiTTbInRwi7BrfFD5EiM0syY51ouP0970s4Ey2DbZF++o0CHc0SKAojv5vjS/etp+gE0YVNwY54EZQyOPq5ry5i4sw4/b8tMXheiYBhMn9qiInfJ/FPmBx49ji+qsyzBVnaDmslGfJs+wgKeR9dFQ65aQ82CkP6XDvaECClNBg1Oz0vSqgdxLP2/nEWPTCH64c9f0gRTEgcqLmfSmiDSdkOkFKrHBXeiukhKd5o9VJ0gpRdT2NkdbQnjyouYaWFPacQfbkFxx//rj2z74nmqMAl4VnWm0Lzxk0SonRgcBTHVQgpEm5su0q7aQnQrVYZt/xUHJ0pK0BGLeHGQSvaDGp5bKFQ2C9M7jeC+YkgSz42i2Y5LLt6tv0a+8cnceIKvjF5TDzkqFF8ZQu99Dbrc35VkNzXOxi6ap6/RlaxPTaIMjfPEmOGpF3l24WHOaK8lXuT7+NGsT9OsFMe93VNfhXyIRENg+3n9PLHj/2KxXqTGVshJOo48wp2QDCvhwi48lhbsCMgG/b03zFP39A8/rLNQHOebLOT29KH89GZV1g//3e6lDo3RddhO44U+XjxgkpN4gb2IQUqTpD3KdLnvZ+WZbub8mb9HQQUg/RLhf86OrZthE/ySvBORW48SlQxMW2Vvs1FHBXi+0kF60rfFFk7hoLD9xbfzy/mT0FU6lI+rmswW0Dsyy9VXAlvclzEfi6tQZWhOwsUkmF6S0UytRIddp3BZwp0/L3J7i92kHipSXmZn9caQ3IhjgRQqqDUmzJq0DtpoKlgmDyvD3EmsK6yjQfUpbiREMuumeIc80v8+pOS3CGblXFCSouwZvDKdwap9WZZ+uMcqb1Vdl7ZyWsH99O4TmXk7Bz7nzeF6jWTR/QcJUdnzJIQpIOETGOvrPGTerCG+j8dmhGNsDAZszoY8WXJO0F6tXmSqrTLu1WX4I9MMreVcIHRszvQ+6Fp6qzxVZlfGWTob/MsbOYwdY2KE6Tp6gxpeUKKRdYOU3f8HBWc5rVWAh82IdGi6AQJiRaLH59FsYHTTnvXntn3xsIhoCPckMKXkmSOrPRPtXcuSfEyiSlNwkgjVNkJ0KcVGbfi7WT0lFpjl5nGGVAYqeWI5+rEem2eaQxzSGCU2c4QwXmLXRekmP5ijMBGi+TGGtqEAyXB4JgUNRUOCBHtMJjoiTO2PEl6/zKT4Q6GW3Nw1TzCU2ESDMCcScYuMtKc4cbMMfwlfpD80Aoh4/8aBk7SC8PVVLZ9sYOrT7yVohNiwrIkcU7YHLizQmtIo2iHGZifY/CvJZY/NkPwLdnUOvCaif/yM1tJtv17Fzg5/wpranu5pedDvNnoxEgnZanSMqgtzpBSqxTtECO+LErRawzGpZcipjQxhNpO8BK2LZusiuKVFAHU2XlPkyJl5PsmAYENJpXFAeb0GENqXkrP9QI5W+7oCIHbMnBTMZSZglyADBM3GUGpNlnYmGGdsZvMSVX0SRv/mM2R5+z6335Ohm+R96eW0bnm5D/yi7+eyC63Vy4epRrU6qBpCEWBWgM7nWBvRWM0kOao0mbuX7QWV5Ny9ZEfbuLM8Jf5w0euZ9KSI+KyFSelVikTYXp9HGNYY+TbOfY7eYrOc2tMfTnGph/1sPp/TNNKynF31stDyWglYkqTsVoHq5lidkWM+Ks5ko/VaX1cp+gEGdIL1B3ZxKw4QXyWRdfTFYa/VyA0aTB1cIzel8rs/Hg3g5QICJNtpp++/eSUJLa5SfX9kiczoBXJO0EmzTgqLk1XZ6cZIKCYZO23YVqOKxh8sEBzkUZg9er/00e1fb0nFg4dhxo+nJiCKLmsDYwx4zXYfNjk7Jg0Rak1slaSYX2OVb4Key2drBWXkwHXT4I6KbWKb3/5sMU2tKj1BEhrZWbsCI2irLvdNLgxQfUwP/EjTMquxpQVZ+6XESY9MZTupYIllarseNsBUo7M8Fj6r1NwrxRXDVIi6rS4Mf0B/tJ5CM7OUZSBXhACpeolWLkuomGw7dwubvrYzaSUOtvNLrnDKS3yVpjkhhqNlTpHnrWDrucqCAdawxqVY/wk766TOynM5AUJrjj3ExhNm5DqEFFMumoFhrUix2ZfY6iZ44d77qCiBHiiuJQ704cxp0W48Od3yLAfrSxl+yUvgi7sI6VUGTdTHBiYYNySPQLX75MuT8uCoB91riRLrXpTLii2Q69akSXiJpPKB6RD0/AqXymHT5BSJa9FiYTAsHDjUouh2wbHz77MKZPPscCal7qYUg/ZE6P03lshe06EPad3Ypgah5+2i0a3zsYf9bD8D7Mk7m1Al2DklhzX2b9lQk9yf2x/Hk4dQCualCWVEFAqozRDuAE/jydW8a/ZJ1k8P8auQLe8J5k0yy7bwxmtc7nixNsY8c2yuSXxP0P6nIxK+HCTZw8YZtH35xj6ZYHuP1QY+9ckYyclGLi/CEJyUFJKnZpXognFO5UNutS6fUQebDFzckzGIZghmo7OCn2K2BNN1vxqkvCbBsZClZf+OMj+35mktp8Psdil6ap0q1VKjp/CqiALgNSmGu6hMtF/0lXafhWfl7SfVhu83BxgQM+jC4cpK85gvkD8xSajFyRZ+C6R6uEd9jiEEAkhxF1CiK1CiC1CiEOFEEkhxKNCiB3e1w7v3wohxC+FEDuFEG8JIf7bwbHlOSLrMR2t5NCrCRRPX192Ap7oSqZX68Jic6uHF1spaq6Po0Oj1F0/abXcdlw6KwWuAuE3DCqeZV8XFgtrsh5PdFjYKN4YUmsfU8uuXzYPvcZVxQnKxpZW5sDAGPMet6JfL7Dl20k+MPc6PWaJeSXIG6EFHJl/C2VQImTccEDurAE/YqbA1q+mufrE3zOslSSdXtjsaGUIC4MlD8/gKzjEn2kR3dFkxzlp3ni4j5ceG+DeH+6P0aHihBR2Luim4I9TtxTm7ACjdoyXwou4Q1nDFwf/lWcjIzjATl+aE6ob+M3oTXyl+jSxQt3jpNRJq2UilSZ2TLDD7sFGYZkvy24zKen19Ua7wejuS1kP+CQOQNdkg7fepOAEUG0H35xNoVdCvpv71IqujwE9Lx8k0+uX6CpqqcxHzS38ZuK3XLT3QZp6gF+lPsS/DKznGwvP4L7L96c0HEB/3UFb6LD02hlEHbb8spvSASGadY3mQo3xB1I8/eIiNv+om/lghK/kn+B3u27g4/kXEWHJrRWxKK5fRylVeVhfRlXx85nKS7L/Y5jye0zGWXr9LN+6/7PUHTml2wcDT2tlik4Ap0Ow4epenrxrhPyaCIuunKPfY8TiwoKy5BRn1DrbjW78nllNUaB5pEbP62UUbNaKOTJvlDjipztYcXiWw9bvwc3Dth+nefyhJSjT4N9js/kcOUUpOgF2mJ2Mmp1UO/04foE5o2IghYgptUZMabLb6CJrxzBclZwtE+DGzRRTltwAgw8YCBcmTki8sxXhHV7vtDl6DfCI67rLgDXAFt5FBKTl2eZF3CVcNthjyvi3LrUimSlOiIRa48DAGAml7o2l6qSUBpuNFIf4s+jCJmsl5MMf1CmsDRF+xCCt1Fnhm6Hm+HG9yeSEN9/P2xGarsqwR1VLKE0Sak2SyY1OABxXISwMpqw4mqf1UIDbl9/AV6rPUlH8zGlRji5t5pvZh3BiQUTTeFt01Wyx7VvD/Ob4m+ViYXa0E8L0qsXC78xx4EWSxzH21QTPPTXEzMVRppYkCCg2A3oeK6Tib1j85kNHguqllMfCUs7daIKuYWsaP0scy5Q/SY9T4SuL1/NoZCUnzb3EB4/bTu99JWxXxh4qJZdWTKPfzlOb8bN7ppOkW+Gs185EaB5PxLLbPRrpL2nJxdC2JWNWrROpSIWuGnfaU5SwMLyfq85z9RFm1skQ5sHCJFfm/8wF4w+RVSJ8P3wM3+84gceiK5kPJhD1JvceeyD5j4VJvlRHecQmc3+FifUJCosjDOlFOjbVmVsV5o1WL76UQ/GzIYpvalw89Dn2ijjnTD3KLzffwgJTOmiV+QquYVDTgtyTXMvhle0scnJv298dF2FaLLliN2f85/m82hxqu1f3ib0kw6VJx9oGo7/r4Ml7FrP3tCSuIrEeKw/IcuwHthD8UoOPX/EWA7+Ui0rvzSXUaQdf3uawE/bStSzLYZ/cQ9/vi9SX67x2dT+vPjHA5Kc7UFyHlb+aprzUT+046XTNWTEcFEZ8MxSdEFZcgZJksyzzTcs+knAY9s2i4KB6NLecHWPEJwFXhq2QuaNCbbkPc+TdLS7+21cTQsSAI4EzAVzXNQBDCHEycLT3z24FngK+xT8hIIEXvNNKz/8XIsFyFXm6iASJlZuUXT+7jC5sFJb4sjIByYq18XAJtUZUMZj0MAjjtpy6pNQqMdGi5urMfTTC0ktnGd8Cc0vD0rjlmQLdiqDiBOjT5hk1OxnS5yQBzkq0OSFDvjlMV/VCeqRbt0tIIlvZCbDokjwhvcVGp4egsGVt7bqIlqzr0VSoN9h50TC/PeV6clZMju2UFhUriPGmzmnnv0pwysRIK5gphb+eswpVOIyQlSG8ToCE0iBQNXni8eWQ8Chzlo3rk793UgmUihyXtvxBrur6CFeO/5GTZl7g2sxxLLx+lp5vlFj51SylGwNYQ3MknmqgNOEDy3f+l/vwqvgJU74EO31d7BApXulbzUzOQOg6qGqbHeuGg+wyOyjkIhzMGNWonwGtRMtVKTpBlvlmKDoBhv2zXPnFGzDvCPLh0gaJiBA6K8wsq8wsyH44JirzepjdvjRqw8b1wfLvz2BFFGbXh1GFw+bpLpZNTeOcJVjmm0HHYbeVJKHUOePpp7j4I1/g8Pwmzp97jGvHfs/Nvcdwv38VxCK4wD3hNXxk/nW+ufseLuw4FSsYaqMihGmx+NdZLo+cxM0fvYVeTY5L614A9pCW92z3Cv41NhNrEnQ+XyWy08BKKUwvj9O9uUzgGYt4TZaBoaxJYE5uNE1HxT7Lx+yqMIUjQlhx7wHXc0xaMQ69bozQHpNnblmET3EIuwYj/jx1R6Ps+rFdhVZMI1Q2yKhlKk6Aoh1mtW+OrUYHFSdIQq3RdHTSqnT6RpUG3X8rE95usOOaTtJekPa7db2TZWgYyAG/FUKsAV4FLuL/hoAUQvx3CMj/14VDF7KP4Q5OEbjfJCXqZNVGW3q+zz+xTJ/DL6DgaISF5R3Zqu0b3KuVZGycFWLjsb0suWwW/Q4HLpWp0NlIlJVk8ZVszwNTRxEOW1s9DOoFUkoNXdjUXB85K8YiPcezjcWM+LKs8GXZVZMjw77JIqnH6uz5VpKBl+eZeyGBqwpAoMx7EYGGyWXP309A2GwyMizScxSdIBm1jvqEw8EX7MVMqGy5upsVX51h4qwO0lqZLrVC0Qlhe7N4XBfmBdWkF2rjGeaUSkNGEFbrsq4P+MFx2Bzo5YHQak6ovEXyP8qE72wRzMuTQXxLE2cnOBq0BjWyn4zixBQUR4rvXvrdCANWgcNqOzne2Qjlp9kW6uWp9CoeDaygonqsE6QMP+aJy9SEgyoUdByW6mV21sIo98ARD2yn89k6wpX5nbsC3ez0dVPSQ1QVqYAMOU3CqkNXY55FzSz9NxZRgOC0RXFhkMZ2P4G1JnpeTjHmMhHiwuLF5gBr/JO82eoj4Jth4NYJnv3CSjYG+rho7lHOnfobmXSJW7o+iGPaVP1hftn3Ub4/dieftd7i1uBRckSsqfKXrrHs+nm+ZK3n6hN/T9PVWenLYrqSHTNpddCnlnijNcAK/ySa4oAAPe8w+Yk4peODKMLFNAXpfJM51U+pGeRD63aw7XPd2GcIdhtdLPNlmbY6GNLyvNxcwPu2jBK9vsb0J6P0Hltjyg4xaUn7vIrr+ZM0nLggWJYRgPuyWjcbqbYGZF+g977g6Lqt0nNNmfpCnRePHWaBM/dO1oN3fL2ThUMDDgQucF33RSHENbxdlvzvrneEgPQYtF8C6OlTWe2fhP0E+m0Os7vCpBZWCQnr7SaPJjv1o2YnhwTGedPIUHN8ZDSpGsWBgh2iV6uQtyMMZgpMnJRg8R05Zs+NYKZU9gY7+YC2g8xchc1OLzsMGeM25Jsjo9YoOj5p29fyJHyz1B3dq3nlsTHuaS7C/zAwUgqvf26Qo17eTma4gMguxBVIoVTQz44zO8nZUUJKSyIeFIMNrX4GHyhw6NdGaS7Vee6WhSz/SRYzpDB3epiEWpeByFaULk2CqM0ZVWImlaBcMMp1mbfh06VuQ9cgHJSCJy8R/enQEk6ob+TwM/bgapA7LMr4RX5UHIYuKaA1oHS8j9e+sqDtrk2pNf7yp/1Y1sqyWyRZ3pomY5cYrmdZuneK9fyNkhpiUk2wO9BF+s4qtilvtRHXKNlBlJaDebvJ+28axT9tY4UFwoV/BBdzef/JWKqOqDXklOmf2C5u0CcXQkUQNBr8auWt9D1UITHW4MjTdjF7aIS5Y2R5Ge1oscHokT8bFAb0PBUnwOc6n+dy8+OUgnF+OHgqX5x9kk/kXiTZKPHTxZ/ErRu8ZHbxaGQFp889x069i2djS2XOhmW3R83Lrs3yNfcMbjr5ZnJ2GEU4BDDRsdllplGQvbd9H2izQ2HwgXmyx0e9/NciTyQGyGgl4i25yycrdSoiwHGhSe6tDTGg59llpjm0uJuFX5nD6VKY+G6CSUNO2NYGxhg1EzJJXqkzoBUxYiq+WZu64yejlsnb8iQWEBaTVkKqToXtJek1GX4yT3Srwd6rO/BrFlnr//8exwQw4brui96f70IuJP9HCMh/ZseGOnxkrSizK+WHY+GWAgmlQUp1eaExzLpACV3Y7bLixeYAvdo8YcVo50wmVckR3W0m8QmbXWYXU+fHUAyX7purVOwgx8R2UF3iR90gd6+o0pBJ2ML0ItpajBqdjFkdbDW6mbQ6OCiwlyE917Z6AwT2WGxbn2Eolqfu+BACDvzkdoQr5d9bz0lxwydvIuT5Lvq0MlN2iHWv7mDkGznKB/p5/LYlROtNeh4oU/hCmGpHoE33WhsYI2vFGVBbPPKZQwDYleiXD5cnzEJTZfamosiAHdfFV6txVuV5rpj7My4CBDx192L2/D5J/lNhRk/tZPO3MwBoDzmE6036Z+ZZfFOOJSfMcuvUb/l2/mFOrr6BH5tdWpqno8t4OrKMWTVKwq6z3Jjm+MoGFl2cZ8m/y12s7y9Fuu8qc/CxYxz4/XHKvQFGT0yi1Vw2nZvhh4OnYqm6nNiEJCx7XzJYO6PTcXCiIZpagOiogZlWwIW958aJ72yw4geybg+68vhvonr9B4Nuj7tz4SMPyWZupcFNmWP4TeeRHF3dyvrt90sqHnDtgpMQwLen72NFaRThunxj7hF+u/sGhGHiRIMsvXGO9Q99kZrrIyZa5OwoXWqVjFbkoIA8TJuuHMcWjw/S/0QRvWF70wwbw8NUlnwhHB0i1RbjVoIdls4y3zQ5K8ZgI0/fmUX0ss3GWzI0Y7JHJNWfPgp2REYcKiaTVoxWTEMv2x73RkMVDlmvtB7U5ml67tqmo6O6DslratQX6Gz9aDeL9BxRb9N7t67/9sThum5WCDEuhFjquu424EPAZu/XF4DL+X8iIM8XQtwBHMI7QUDiklJrVJYEsHVB802dyeMT1Nw6g3qeNw0fUcUgrZWZ9TreU1YHfdo83WoDB8jabxvWpqw4vb55ZhfGmDslzOLfzTL28Q72LouhrjTofbSI6SjEtCYBxZR2cuGQtUP06vMkVFmnOq4iid9CfriHdDmOdVR465O9dNgNBoXM8Kg7fhTdYeuXk/zsI7e1M0ZUXBRcBvaUGTgnT3NI5+UbFxCP1ll+zgx2WLDpzEwbrLR/YIIdZicBYfKBF77Cd6qPA7Az2os7XUaEgtBoYfV0oArh+T8MFls5Lp66lwVGnkeiq+n4TZFDPjXO8Ct5avsHmbEjlJ0Aiy25vscmmxx17E58OQvFhsKaEDd3HMnrnUsYt6OYgQA4rhSSKQooggG3yIV7H2B1fZzc2jD6kEPizgbp22t03V7DCcL2yzrBB0v+xxyNzwTZ9rVujC1xfBMSsSmahmTH1Ju48YiUyusqTiKCUmuSNMrEdrXYcV6KRbcUUEfh+acXsux7WTJ3VcmcW6L/8gjljwTJ2hHCQh7fK06QXq3ExMm99DxVQp2d508dh5BslvlE9Q2yzTT3DB6OW5Yy+4aic9nsPVymfwLPaSDzQgoVME2WXetygXMmv/jo78loJbYaGYb0OXaYadnY9rw4o8cnSd8+jv8Fix3ruunT5kmoNequn4BjoJhQ13WGtQIOgqRqE52fYODseaLbm7x8ywKmlsbBhj6tSNNrzEbVhoe67JAJ+4YJfiS4zANhpdQqj9ZWsCIwKfU/ep5FWpnWvYLYxhYbr8iQ9teYtOMyc/RdvN7pVOUC4I9CiLeA/YEfIxeMDwshdgAf9v4MEgG5G4mAvBk49797cQvJ81B8LpWlfno2l7zEa5WEUieqyLFqzooRU5rowm4rSN80MrzR6sVGzrUdz7eSteKEhUHukihWTOH939rDKlFGOcjFV3RYsCNP0ZFW/YR3WsnbEQ4LTNLn7WAJpUHd0Rn3qG+vN2QbpzIcoCdZRsFBE9JuFPdYpb876QYPiRgjrdbQhcWeRgepi8pYqsJLv16AmxB0/qFG9IUWo5ekiHa3yNoxb6Qsp0mKcBj+9yprynvY6++k2RJgy/6GGw2hTcrRsmgYHFLezpW7f0/YbvHvQ5/hmtQx2O/TaK3UiN5vUPAmBD5hE3ujiRlScF0IZC1KBwTY9fc0Rxz3Q+5Ov589TgLL8pAGqiLl4qUK2A4TzSD/NvBZrk8eTXJDneATsncigPyaELamsOR7c4z8+xzFgwP87XuL6dWL5L7akCNS05LToH0S/GIFYTsodcM7cQRYpJUAaH1AY+y8BP0PlQg8afHS6TKAxkipvO+8cZLX1sgolbaZTvFoZ1edfyNKTUKk0DVu6jmGF/xDrM89waLsPuCy4In4SgpKiB+N/yfdRhEUgVJrSO2Kp7x95JSfk1KrkmWsNpi1o9iuQsq71wDza+QpObKhxTJvejekz6HgEPNCm4jDa60B8k6Q0e1BRj6eI7alyYb/6GXuSDmBUoWD7pUeKaXelrTLKaKFXVIoRoNsMDKMGp1t4t4hoV0s0+dkKp6jo+UdFl+aI78qhP+TbjvR/59T+9+N653S6t/wyor9XNc9xXXd+XcTAQmQs2MklSa5lVEiG1qotsOAVvb+Tmrwo6q8EXXH347w04XFiG/2v5iqALrUCgNamclEnOkfJIhsMDB+3GDHBztxVeh/qPj2awmbPm0eVTjM2D42GBkqTlDOx71E6pwdY9k2b8y1XCXtkdJ1XCxXQRUuQrjtRq0M25Ez+f1vmSC6wWDTD3up9/kZ3DLPkp/myB8VYva0CK82h9CRoOes5wy+9dij6HDqrG5O8I/wiAywiUVlALEhOSWi0eKE8pt8N/8ge7Uk5y8+m9f8g1zx9J/Qhc3u45Ok3qghZpBxg69UiT/SRK87VD4TYH5dgOjGFiXLz+CdE4imgd0Rlg+3l2khbBdzYaY9osWyuTe1li2/6sI3Lx/aqY9EefMv/bz2TD+1Xh0cCG036HusSM6O8rNVd+H6dBl6VG9KW70nwQdk0FG5jjpXZkllAhvBJRefzvQ5cYorgxz4vXEGdVkWbVvfRf7kEPtfPUnHt2vsbaYkNkKtMW7K5vWXHvyrHBtbNm7D4Bfdx1MTfr4+9zc0S+osGq7ON/o/x5ZQP6tbk8TNGiG7iRuL4EZCnPfIw4xbMcbNFGlVjmiLdoiMVqT2TxtUZ6JGeaGf4AZTaicU00u9N4kU5cI6FU6QVkp03lbl4I/tRa047L4jTem4AEm12s7PqDsyAHurkWFYn2sH9+jCJlA20RNSSr6ff5Ips4OQkKXwC80FpNUGDgqB7zTQqza5q6NsddMklDp9WpEh/d1tjr4nTG4aMhui5PjJrwujlx0CL5jYrpDMS2CtfxLT1Zi0OhjWC+StSNtQVXQCOCiowmknj281esh6iVbGiT52/0uK/ptLDDw8z/yhIVL31wi4Bkm1zlaju52kHhB2m8sZVRoU7Ag11ydHqRtlnSwWQFyxSSl1mqiowkVn3/+XgSzjZko52z1cAAAgAElEQVS+zmST3mtKzJ0YZvL4ON1TJRacWaDZofPSTxZQQxqcVG/nXKbP8b0bzsDVNdaVt6Hi8nR6P5x4SGZkKAJVE+A4fKCymQumH+Hl6GK+1XMaRYI40YCUIlsJZtfKvE/tTYfuOyoc/Jm9CAvGv5Dg1R8O8uJPF+L6BL3flQYwNxqSwT3QRj9i2egzJdmEtaTcPKJY9P24jOWXD0/XE1Xi2+r4HrQJT5mMXxzHGlR53wXjHHLlKAEM2ZPxApsB6d1RFVy/jpuI4pYquD6dgdosM1qMZijCvBpmx5WdaGWbrptqOH7o3FNj21Vd7D4nRf/tJd53xV4KdoSEYmC40pOj4ND8g0RCuJEQJTXEtV0fZqSZ5cTCa4CLqypUWy6XZD7BnkCaoGtyw8StrGvu4HsP3tEOTg4oJrstH7NWjIRaJ2sl2icEgLdafbSWaug7HQa0orfQlMlaccQW+fkO+A0OO2sPq76TpbhfkPvv2o+xNR3kbHl/9nmwutUGMaVJrz7fNt3lrJhk9ZRs7Lji6TWkcc4nbIa1AgN6nqLjY8kjM/Q8VGHuqxGKIwH61BIOknezL+rx3Xtm3yNXQJgowmHqqA6skMLwQ3maR4eZslVsV2GvhyXs9c2TtcMs80/LhQPbCy1ptbUZipA3seL4GPcUdOOX9BKZbjHy/Tmyn42S/EedvieK7PpQF0v0WUatlOcQlQtVQmmRs8MMafn2SDa0WS4chUiQf9SHWRvYi+MKbFcwZ0dIu9V2lseIL0tUmISuk0Dh57+1kM6ZKiNn5tBbNn+7dTnBjHTmrg2MUbADHmDHR/9DOdRanVPmX2Gnv4uVuZ2cOfYYi60cSbOKhoMhVHTXZk6L8GB4Fa1YDByXPR+P4UOGD8dXN3AVWP3rScIvmdQHNYITFtnzotgIwr0tZi+I0vejEsv6p9jil6Cnto0+4GtnpKIqOJ0d+KtVLh27i7jdYNNN3aw+cwZ0WH3WFJZQqa7xMXVunF3ru+i/dJ6R6+ewJlRUn4IdlPBsYcgFpN0ctWzcrhSi1iDqGpQCUVxF4dznPsd1h/2R3Rd0sviqOeoLNMIbWpQJUrvYh9JwWPSbPKEBkz1npujT50kpdfJOiO8ufICf6qfJcbUQPJtcyRvVNzmt/DIgQFNwYxEM12VXIEPUbFDVQ1wyejf143Umz6+y+8MpXL8ciw/pOY+c5rT7KiBPrK0Oje5Khbhit/1VQ3qO7sfLuAIO+toEVkRh6odxtn+mk4SoM2tHSalVHFdp4zArXniUikPOjqIjIVVL9TxaycGKKdIBa3aQUOuElVa7jG7NaRz43Qkq+/l56qwRDlGn2GrIlLGtRvpdf17fEycOkC7XhGIwECsw9cE4qUdq7KnLEJSMVmHWjpJQ6+w2ukgoTUxXpWiHiCstaR8WUhyTd2TNmbPDdKsNVvunyNpxlgZneeUXg5TWBuj5XxXMhELmF2VsT2NQc/zoQjJRAUwvd3SrkWFtcDcDWgnfDvl3DVfWsVKAJmP+e7QyQkheR1QxKdgRyhM6g3fNM396mHCpxUGfGCeYNZn6dQetERncElJa7DBTKMJBweG7x38WTIsPKaP0WUUGjTwXFR5noZFjY2iAO7sO5U/Rg3CBptAJOy1+kP0LN269gUMr27nxMzcyZiVJqxVywQhmXCH8ksneUxMIFcrvDxDqtlmhy9So8c8myAcjfLbsDc08iTmOI7NDbKc9shTNFmeX/sHqxgSbf5Zhcl0Hti4oHRdEm3cITZvsOq+TKTvJjIix9QfdTH0rRu/9JS6M/xmxD9XgISmF7YDj4qQTbXxDhBZVWwMFll1eJaHU2bS+h/IqP/5pm9hbDYKWQd6JMvrdJLnjwmQuKxN41fAW3iC2qxBVmnztnrs9mbxDfH6OrIiSdOpe7oo8teGTpDtT05neGGLPL1MIYOSiOY4+ZCcj38wx8ESRQN7AdhXSagVdvA1UHPDlacV01JLDxmIHA2/kWXrVDAd/cIzM3VUQ8OZ5fTz99GJe+vQCco5EZ3Z5ma01V4rqEkqdiuOTKfae5QGgVytRMVS0ioOVUKSyWZNN+qIdJqCYxO0G6y7ejVa12XllJ72BIqNWBJ+wmbUlKjKstN7V5/U9sXAEhM02swsdlx1GN9bJCvq8g/9Zi4CwMV2ljQJY4Z+m4vjYZXTRpxXZa3VQdgLUXF874yBnRyk7AUqOTsWRZYbjCuyQwuu/62f3CSn0okN8c4s190y2SxGADUYPNgJFuCSUBsO+WSpOgBk7gjovp/cNL8TYREXDwUFQdvzsk6uMWzGSapWO2xsotsvEYJwjTt+FC2y6s4f8wSEZHIN0/erYTFkd/Oysf8HVNZZVxrlw/CEAnvMPc/7CMzm76/Nc0XMSvw8dTC9VBHDh4Oc5beXXubznJFxF4dLxu9n/a+PEWg02tXqJ/WcT37xDo1PDOFsnuMdi+gR5PH655en1wnC/bz/WlneRcctvc0tCAYz+pEwTA9ygn5V2llMKr3Bv7AAaJ/tQFZfqYj/koNnpxdbtcYgqDS9CsMHkVxLs+VaS457ewtkTj0q9hBCSP+I5hkXLi7XTNXTXxlD1tq2/W20Q9bd4+ZpBXB9oDeh5SPa+fKrDiz8dotGrs/TiHFrTIqHIWj9nRwkrLY768wZQFKJmleMrG5nQO1BwEdWGDHGuN6msDRJN19A1hwc+vB9PPjTCG7/to3BciKHH8wz9a4GjD97FBw7fzrLPzzB8wRzh7TIdfd2/7aLrb2UUEz6y/xbe/6m99F9XhG5wBOw4M83012PsjXRStEOk1KqU/QuHrPW2szWpNMmodTkC9hL8666fpqvSsaOJcGHPUJqaJwgr2jJaImvGWHxJjvDfDbZd1s384rD0qngg6rDSYkibf9eVo++JhaPlqhzoz5Jz/Iz4ZthyeDdWRKHrwSpFJ0DRCWK4Khm1zJQVJ29HqDt+Jr04eMf7Nlb4siQ9Cn1YabHVyLRPE2NWB2FhEAkavHV1LxMXxnGBgYuLDN5XaNevKbUqkQhWlKITJOyhFxNKA7Usd0VVOKQUCWcOCouWqyNwcV1B0Q7Lm+S6DNxbxIorrPnRFLVlPv5+12Lqy32Mmkk2tHrweQuGMaOx/Mlp4rkCa3Lb+Fn2T2g43Nh7DD9e8Vl2hnpl3qeqsK66jXWVbfwhfigTagcGOk/FVnBe+nTeuKifjvsaHPr5Pax+ZYK1392LmVRwUgL1fgdHBf0EyDmSkrdvZ3usV+ZQHpV9U45JFYGoNdDzNZygDoqCr1Lh65MPMKUl+E330eTtMCmlTmWVn8ibLUKTJtXFPlZcNYM7CmmtjI3CqNnJP85ezPznQ3yq8ipHN7bi6hpKtSUXj33jXp+OW65Q81TBotrArdX58mfOI6S0mBpI8srNg7jA0GV5Yq0GurDpTZR54/I+wnsMFv1ijrwTIq1WKNoyMm9deJtMGtPlwrYx0C+nYLqJsF0ufeIuDu3cjSLkhpNSqwRUi91HpNn2s24efWEZL9w2xNZ/72JqbQJRkhiPfVfoBQN/ycZVYfK8OM9cv4hHn1/G2IkdKC7MnBojo1UY8WXbJUmXWmkLthJKg16tRM4JMWrFvVIrTEJpEvU4Kb4N8qTr7ieb70NaHp+wpfnyunHSf6qx84JO5k6XgOq0ViapVlGEw5Cnpi56k7V363pPLBwOgt1mjFGzE9NV6QuXqX7Ez9Ajc9gFeexc5suRteVOXnf87B8Yw0GhV6vIlHKlQclDGfapJbJWgqQHpVGF02521VwfMa3Fnq+l2PyLbnBh+KICB5w+zvKXpoiKBkm1TkKtM+SxTPc1TtWGXDhCikHZlTkWTVT8wsQvbIRwpZM369JzUYXwuIFaccheEuO1OwbQ+yQTwyfstt+m6ej0vlVk+foZ9p94i+/P3IOGw2ORFdyjrEC4rnx4HRe1XOULpRfY40tzd6cUhim1BjgOVjRK7qIwm67LkHirwZr1kzRTGvPvD6LUHQb+Mk95XYAd0RSmqxJVGwzpBZquTr6hsTnQy5HVrRLxqCjt0GM1V0JU63zY2Ulfa57/SB+DYSvk7BidqklllR9/Sf58pq+OI3BZff0UKaXGgFpFFQ5Dvjl2Xppis7+H88YfJlmfl+PPiZyc1JiW/NoRp4pOtCUXXjriaMUGTVeXp5hD/MwcFkWfd1h7/l50R/KAu49qkvtkmKHfF9BmbMatJGmtjC6kYvKS+26Trw9sDWZwgcH6LD9/8Lf4kNxiF9mkXBccx3BVdGFJLKMfth6UYfPZvfzj54vZc38nW5/KMPsvERodKrc/sZbc0RGaXTpvXdRP8dggSqdD33+WKC4Koq8waXpN2y612jZpZu0YI75Zik6QKStOwY4waXbwQmMY09XIWlEqjmT0am9ZmBGF/IA8cevCYUifo+uuCkt+kWP61BjlrwdkGJOwSKs1BrSSFBTaIV5t9clQqHfxek8sHAqu1xSSwbRpxWJ2fRSt5tL/OxneUnR8KEhmxzJflqITIqOWeKGxwHPQBtvHvFFLdrb3Hfmajg9VSBzAvtBYG4XKKQH2fM070m02WPW5LCtOmiF0fYvmmO4JbWRzrOgEccJvq+nb7BBvLKfYDjjQc26R/Y+YYvB++b7/ftsi/vy5A8i6CXJWjAWalJWHhcEuM8UyX5abth0JwBcbL+F3TWa1GNcu+pgEFxkWSlMyW49s7qDfLPC/eo7EtV35MLjS7PaLv92K7SpYH9WYOzyMVneZOqoDs6mhmC76jMP4iXEW/CXPkitn2e/SScLfb5G+qcpqc4qXYiMsMueI1cu4AR3RNNoRglo0wKez/2BTqJ9XUktxYiEW6bO82OylsVrW6M1+lfGVHWz+dA/df65Q3eMj5/WNmq7OM8ZSfr7gFHyuxfnFp6S4LBmXJw6PASMcl/lAnLRVflsZ67r89JhTSHk76BvflQjL9FM1Oi6pYzuw2exk7PwOFMtl5BapksxaCbJWgv39UzJm7xgZd1CPyFJtcccsUx4rpUNpoOB6quTe9ucm6p1m93FYM5oEoRsoNFwdRUCfPo827WB2yZyMmuOn88ka0Y0t8l8OMW51UrAjZLQis55rWCbchak4PgxXxfBO3H36PCN+GdBUsCMk1ao09G1wqK70E9YMXm4MkXeC9D1ZYvm3ZQr62E8SbDV7UHGlAc4JsNnIMKLPUXP8ZLQSute7e7eu98RUxQWKTogR3yw5O8wGo4P6sJ/I8U2Gf5cn92XBbNRHQDHxYZN3Qu2Tx6BeoOwdw3RhM2p0MqgX0IWFgYoPG1U4rPDNYLuCcStOlyfw2tzqI3deBP8em757yuz8eCepXTWWXJ5jyeU56gt1Wqs1cqsiTKXjOD4BuMReb9L/6DxKwSGyo4VesAltMVAs6HyxRvb0GO4kpDbVaR7kY7Uy3ua/vtbqIqFIc92+kV7v3bJx1WuVqCs63xk4HaMkKfOursrkrFCQU8uvMqqneC6wGLdQhLQU9bg+jaarMqCVULIOqedrNDIaCx+Yozasoecc7KBg9cVSh+KoYEVVRMtFbzhcwX/SVOT7O4gpnqpKxKLTESNqVDl99nnSVoU3w0OcNvssBX8U/xaDzNJ5dizq4gAmMGIylc39Miy/PcvwbwpUfyR9FW80B4kqTTYcvIg/Fo/g7NmnWNmcZGN0gcwxdV3coA8rFWZnvZePVDaQVhrMOnJRdoN+wsJk1o7gLFHInxgi+dc6C26bRy/a7L4qyd7+TvpOKdHzxzKvnT/I6uQkUWFRcTXW+Kpctf63cDt87KJn4avgm3OoGgESgQYFJ0g3coGTORwhGaDs6gxoxTYRrVeT4UUFO8Ii4ekiXJeOTXUKJ8r+he6aDFxTxBhQmf+4RDBKBKSQD7YtY//SapmEhznNqC1MF3JWjLSX4p9QZWxE3VCJbWmw9/PJNhKj644KA5cUqC338dyvFtJQ/Ciuw2r/NDvMFCkhoyFyTkjCyV2B+k+WiXfjeo8sHIKAMKk4cvfyCRtoseO8NL2PlCnerPDGuf3EVBkzn1HL1FydXq3CM/VFLPNPSeCuHWZtYEzWi6ak0g/pcyQUme04ZUfJaBVytqSGD+lzlJ0Aj1y2is/NvsKie+fY/YMUm36ZoefhMrHXm0ReNlhyX44l5Nrvd+CRIgOPSAGZo4ATEJSWB4htbvLEc0uI+xsc8KFJWvtpUs3qKCTValsYVHRCdKlV0moFG0FrLTAmkYLf7f0kk3YYVOEF8Tq4yTiDM3tY3Jrluq5jsJJhNMuGlgm2TW2xTK7aZnax9vpRcGD6ijgLz8gT3SSbeI1uldkzo8wcHqWwIERdCZBWy1x73Eksa0zyweImjq5s4ZuTD9ATy7Ez1s/Hdt/PAbVR9mV6H1Pa8PZN+yg0ezRmP1iQFLS6y5BeYKo7ztSH4ix4OM9zly5kzO1kmX+KXUYXV/zgBq7a8Ck+nn+Jz84+w3fCAzghH0pD4hO0YoMdAfm9jDSz5ELD0DJxAz6uyn6YizKPYSN45dwFHPvwFiorfPQ+VCYy2+KZ60Ps/HSazN0V1jw5wfZTughrJYrO/8Xde4dHetb33p+nT68aaSStykqrXXn7uvcCGIwBg4kJkBAwNaaTYAzJAQ6BJPTiGGx6r06wSSim28EF47Jee71VK63aSCONZjS9PPX94340a97rvOck5+z7xtf7XJeva3a8mlnNPPd9/36/bwtQcmRSvnubLHkggeRA42gAa49C0h+MNzydrFylRoCs3CSlWCzZwS5vw/WxFMeTRbaP1CIyb6JXHbzdMhNakdDXW/QcbHDiE2kM3SXqitfeULuG1A4xSZhG5XzPjbwd9ysR4f2CUkeTHGFCdUBGNsHeI1O2g+y8eZlNt1RoXK7z0D+NYEQcJK9DQnZ4oLWZjFolKps82hwVm1Joiofbw+wN/LH15P/p9bRoVTqesADcSGLP2UnCcgd5p8falSG2fm2Fc6w5wfXAZdWJUHODNF2VXYEFFETQTUatMmOnONoZIKE0yPjMU1lyyTkRVp0oeVvQhsXswkaXHMLBDl+9+QLyl8QY/29F+r9fY/+rhzn6hT5+8rtd/OrhbTzw81Fyz4xjGxKHP9TL3T/awu2/OZP6ZQaNMQPzEg1JkTBVsVmoOYfckOhdB9QKS3aymywuYDiNpmtQP6DzwZ//EIBfRXdwWO4DWcJrtIRJj+uC53GpdRIXuM8YQ12piFmEZeMZOjd9+pu4nkRfpcLA9yrkr43RLGhigXhgJ2Dm7h6mX5mhMh5kMlhmu74ijI+kAA9rI3xk+FqqcoA1Ncorqw/ywcV/YaS9xr8lz8IBfhTbx9U7/oYXjr+D12+6ntlPpGjvUBn6rqCIh2dNKks6VTdA7QU6WtFFfkAICWtukGGthOvJdFyFH6bO5azmLFvMvCCcmZaYq6gys1aYlqRxVm1azFlcFyybtet7KTphyk4Id5tM9R0RoodNCm8IE37C5PKXniCfiNIc0Ej9uOlHhMaYMXsJSBYnfS5Dx9Xwu0sGVtYJyRZ1V0fy2+W8E6PtijCjWTvSrWbTcoOya5BVRJyDIYsBafpegVZM7emhMyuR/XCV/KVRTl6b5p7mVmpuUISN+Zuv5ee6biiSN15/XCuw11gUfA7fQ1eTHLb/YgVXg7ULQux9V45Nt1RYfmmUqS9nMMMqsuSyXRdt8YC6TlgyKbsG5wRniMktHE9ib2ARyzu9S/1psXFEfLac6SmsOlHBzUfmUGcTC29NolY9AreaaJKNi9wdMk1bGXREapUsubieTN5KMGksoSE8Q/OOYN65PqQbk9tCPWv2UXODhOQOvUqNczInOfqlPtb+LMz459e4/M+O0zsrTqliIkJ1IkjtGQZqx6N0SZiVHXHOmljCkhRf3uzieTCmlvDaoLQ9vARsN3KUHDGPSSsN5i0xuFMtl/CnTS57yTT+7JXdX11i4ZYoXtvH3DecqmyHczuzPBkdoWSpeIqMGzbE5iFJDCoV5u0k0k9A6XhY4zI735nHioivd+UlMSoEfZJckAOdXvJOmLRSF+lqlo2nq5iySsqu05FEVMSikWIq0o8C/EafwF0tYXoK85lhDl/bz/4vDjP93wXNWwL2vSbHPi8Hz1RwAhKjdxfJqhVkXEbUKjk7idxs89PMOZiSwjPXnxT5spqKvFJCLpQxTZc/hMa4qDGFYnbE/9c1JNOi5gYZVIVRzSNvGKCywyB+e5uZj6fQig7XvOxJarsNQveZJC2R/LfdyBGQbBKq0Jdokt3lYEy2VkjJNjG5g+0paJJDRqmRVcvknTCDSp1epU7BjvnwaYKDnYFuiykByR83aWzRCA+3GXhTBVeRWPxwgrIb4azAbDc8TPbzkTd4GpbPDA1IFoqfvGb5bnMb5lGa5xD5SZviOWE2v2Wd7J01Tv51im++7wIKsmC1Wp7CmqOxXa91NVcOslAOKy1KbsC3EXRO65p9WmwcHhJN12DJTrJVWxUDTrOHXrXKiTP6yF8bZfMXi6QP1zE9hVk7TdxniuadGFGfEDag1hjSioQl02fcVag5wW6cY9RndcqSy6BW8r0yhE5g2spgqzL3/d0YC59JkppusuWqApfdNgVVmLUyFPYK2m74AYtJfYXDVo8YSHoya444JZqeynpJTLCVuID4hCOTYBvu1hdJ3ttk+7V5zrtllqWrYpQmBGltORjiEzv/hTff/zs6u4a7yIaGy+b2KkfcNJdqy3x64Tti4q+pOLe2MZEp2DG23rVKfZPG0GfKlHYFURviBq/sCNCntAhLdhfKc32RoKereNEQu3KHSdl1bEnhdVtv4FN9V7GvOce1q3+gLanMxDYhhUO44SDyeo2Q3CEqt5H8pIpOSiF6pMPgDessEKeyI0jsoOBzxOQ2bU8WniumRbva4eHIOJdUjiC3TTHkDRjiv0SUf0/tJO60+G9LP+Lt8z+BFWEF+NF//HNydoyiHUHWIH9bAk+GoU9WeOSLQ7TjKn0/r6NYHt7Dsq+aDXCKrgUR2ex6aayVwlRchXVXmPAouCz5uSQbgUY5R5hhL9lJGq7ux3SERT6vAz2PNKg+L8Cmt1RJHm5y8uY0J3sz7DKWkSWXYXWdcW21a0EZlU1fXGnjenI3l1hIGzRSighVT8tNyn8IEszbpPc3yBys8/DHh3nyzQPsCua6DNO2p/FEZ5CDZowx1USRXOHf4gYFQcxHh8pPIZWdjutpsnGIk2BIK5Jz4piewlmBBSH0UcusfCCGlVLYemMB1bIZUkuU3ICggfsqwQUrzZSVRpecbvboI50su4wlGq7BE52hrrNWTOqwXVsTVHQ7Qc4PAG64BjuMAgdfMMAv7trO/OVJej9V47rLH+PKzx2CqEtt2GDwrjIzfjrXhv/Chh9p3onRp4n5h+nHOpSdMJWWTuQXHba+eJU9r1xCX3M49vkMx2/uw/AJUE3X8KsXi7d+4Qfc8K8/YfEFfWwuzqHhMtUzyr7iMc5oLxFbWgHL5qbRu9BxOat9kvQfGii2hxOSUTWXjRRG3+eIvBPBRCYqtxhRqyTkJp4sk7LqvL/4U2xJ4aiepaBE+U1wkp9GdrGls8qSlsAJirgEudHCTURQELqgDZhv/oVJJCDy2w67PrWEu1sicthkoZ3EQWLFidB0NeElYujcG5ygx6oxrq+LWY4riGFSq8MjxghFJczO5iKj7QL09XTjImtukIBsEZAsvFGZB78wirbqcNaHFln4ZpKFlwnDmnPfMsfI/WW/ZUmh+loiy5O720jT05myMmiSg4zHrG/Uk5BbNFyDsmsw6YvDMkoV11dgXxiYw/Zk5LYHMqiHHPrurrHyoRilZ4ZouDo1X3Q57b/+tNnrO3pp6JKAkQFqboCclezyj5bsKAou9ZzG+e8Uat76Tp39d23Cuk4h6h90C1baJ42J8PEJrcKMrfuxCOJ3PdNYoO2JnKLi/x/hWM/3UwhIFmHJZK8h0JW8HUXBoxozePTvh4kcNdlz6xI5O4GDTM5Odm/cMX0VBY9VnzXqeGIgmbNjTOh5Jg3BLXA9mWkrw2Grh6j/fsJFSuReHLV6BPQ2UOXxz21i/08GWb8wyPgtRS659CRqxyFzX50t/54n0LQxPZWgbNFxNSTJY0gtIwv5AMFZi7GfrnHZ3xzjvHPm2PmXebRVh+N/n+G3d0/Qeq6AK2X/CAz4fbMmOb7Ppcq33/opXv03DwAwK6eJKmKDUl2H+Y+J495BwnlcRvIgmLfJXRQntr9zaoHYBkXXQPMrDQeZFSfIm75+A0qpyhvXfo3hWpTlEOWggCuRZb6auRwPCNttgXwEROi0ZAp+hOvJwgcVqJ3jO8Pv1en/UpX1cBCl5XHG2hJlN0Tb08jZSY6/PwqtNo9nJgDYsXDsVIZLQAfbxlJ1/jl5LjG3TchqiQhL3/DnQ599Bbrk+GW+h3OWwqO3DqFOO4y/bI0Tr+7BDkrgwfArSux77wKxUgvbF0sm5VPkrVSqQUjqEJFMNMntsofbnkpY7lB2Q0xbyS7Dc0BdJ63UqbgaWttFbntYKYXMr5scubGPX73kDBQ8xvVVcnbCj/Soo+B1D8WM0iIkdQhLpmjLcRjV10jIbWpuENeCwLdtLnrODEbOoXWGyonbe1FGhNdt04e4A7JF01PJOzHOCc4ya0e693bBiaL5bOywZJFRGj7gcPqup8XG4XqC3Vl0IoyoVWZtsRn0+gQuB5n5K1IcfWEfm24ts+lIqUvf3cCnA5LFhFakV6kRk9tdP46yz5JMyO2uJ8F2PU9GqbFgxym7IcEMVRpYnsygUqHhGjQ8cTLMTmZ49NZhfvirvUy/M40TEnZ4u1+bZ/fOHD0P1gmdMNn6hQKyCRMvWWX3NTk8YMvX1xh/a5H0L5rUn2Nw4KuD3PHLvSz9eZyaFqTghBlQmnj+YRCVOt3TIufE/ehAhUhVzDyuv+PXOEEBhNmZOJ/d8z0GfM1D+iwmP3gAACAASURBVJDo4c2kzKZfr9PqU3F8p4FWQuuWyhtXSLbY/O0c46xzyfoRfhA/lwA2dcno0sJbrlhsvW6dpNYR1HBNxQ3pXBJcZkJfwYmJW6gRCVDdZ6AUhBgre48YTDdKhtic1TJppc6nzv0BXjhIMZSgpIaZaIvKyVMVEcQdDQsvDH0SC5let46MhxcQG9Pgvy6QVSooeMxYMTTJpnJ5kHu/O47Sdrn4uhnckMz6pUFOvi7F4A8qXH7ZcXZ9STjJz9iJbquyEo6hSC4tT8X0oz91yaHoRHzGpRCsTerLXQ3UqFqh7anE/yA+b7Xk8OjHh5h7Y4qo3CLnq2fPMVZxEO3gcatX6EUkkwU71k1iy6oV4ZEidbh3fYJ9P1zkoitPcs775mn3aUjAgbdtYt5NUfYzjFMblHVfCCdeM0FabvloXY2AZHW9bIpuqBucfjqvp8XGIYGYTcgdKq64yRNyi1k7jSbZxCQRXKR9yKPdo7LrHcsM1ksCblXXabsaU6awxNtASzYe65KDJtlMmb2kFTEjWfDhr41rRLX8m0Rl3haEsI3J9obRjzsqs/CWJMfvzrJ4aQInKLH4+jheVMIX1IrfRfYwR1TsuEx1m8H8z9I88ugQd39kGwuXJdkWXiUsmdScIFG5zTErjSQ4Taw2xEBu431nrR4WrDSSH+NhRlS27RXWda+7+cf+z/ey6kQIH27jITxoUCQCBZuVs0X14ExKHDUFQSgkWyxZSQ53+vGaLd5Q+C0dSeW3se3EnBZ5IykGsh2TQEhB9r+fi2YfFQzPdgep47Bga7Q9ldygaA2SJ5vsv2GYUM6mea5O1LcgsNdVGp7OITPbHRRKjst4cZ66EmDMLggSm1/RSJYIuup4MjktScg1uaZ1UAxxbUdk10qit6+6AabMLGm5SXO3wdSdvbS3auhFh+TvW5x8VZpHf7mJueekSf9QLPT+H1aQ/J3DHFL8StfB9UTVK/tzg7Krs2ClRbKbT9gbUivMrsfY/uZlQoviHjv+nV6mXtQr5ka+tUNUbrPiaP7PlMiqFYpOhAG11uWIROU2Oi6K6aB+y+ENz/sd/TdVsBIyR7/UgyR5VLcaGM+x6VVqmJ7S3XDCcoeY3GbM5zCNqus0fP3KhhtawzVI+GHYmk9PP53X02LjAI+ssuEwrhGSOzhIhPwT+LjVS1RuMxVOs/8zQ2gLLlvfsEazpVH0w2km9DwFJ9iFZieNZcpOqEs7Tyt1skqdUa2Mi0xGboqS15N50oz6N5At3Lv93lHG7c5QMmoVBZecE+fku1IoLQ9HVijvCGJtVvn59Bnsnx3i0Pf7eezzQyxfEcMo2cyckWRZFvT3sGSSc+LdUtj126nCuCg5Rh5b55DZS9vVyFlJJvUVsmoZo2Ph6hIjRg3D3xRdxPBvgyEbXhStibzmUt4RxFUldNmmmdU41DvIdiNH2Q1yuCOMfke1NYiG2dFYoCQHGeyUADgRyIIslKOButjEmrLGRGdFtBLBAMgIFSoym0fWMJMKiSebKFfaVHcYBJ481Q6c4a5Qc4IMqussWGmyagUvFGB3eYbhTpGY2wZdw01GoFiGjolUreMlY5TkMDXJ4PqVuxkyi9zw07t41/2/6m764lAQ84K8HedQdoBDt/fR2KSjlxwuf8YU0S+Z1G/UeegrwwBsur8MLngS6CdtDNOk4rdxDlLXILjt+4ZanoqLTKLeJH5Lg0svOUHiZ20cDcykQvN8g63aancAm1FqzJhiM99AMmJSh2G1RM3VxNwLk/rjBv0fqXDmZYvsft8SnV6VA18b5IE7NuO0FUInbEpvD3PAGqbohkU4tidzuD3oh3qFWLKj6JJD3omI1EGf/xGQLMKySNYzUZgys39UbZ6O62mxcciSxz3NCWbNHt+l2SRnJxjVyt2Sy/Uj7zrnaTz2sUHiD7XZe9MSWalOwYl23Z9CcoeiGxaGPL683fJUVp0osr+pJOQmU1YPhzqDDKrrXW1CwRGDqaITYd5OYqH4vafA2tue8I60dqgsvTjGyBdLaDWblqcxqFY5bgnFaUppUt4Zwig4LM0mGVbXu6Xixsa23VfH1twA1a2C+Ba+y6RXqXU3t2krzYKVxotJyKbHWlPvMgATSgPdv7FTcovAtLhJC1eF6XmoyfRLe0j/ocnK86OcGZrzUQKNXcYSWanKrX9/FWfIayh4rBsxtjZEKT9tR0X6eyZBPSg2tLasM+jV/BAjF6nZYUCp0XQNHEmmutMg8USLAbXFibdkMJYcHJ+eXwwHmNTzXZ5N0zU48d5A1/c+7HRgbR250kQKBfFcF6e/B09RBOy8A+S0xy2trxBaE0hO2Ql1Q8ifEZwT7mZKnXGtQFMK4IQkVi6OcuIlGSbuXGX3ZUtsvUV4rU7/dbp7313yphmefd5RevfXcFoytqlQdMJCSyR3GHKKGL+wueivp9lzfo5Nn6ggy+CqEuvPCIEk7t2NTWNDFTykFX19jYgqyDsxym4I64jMeTef5OJnzXDFC6fIfqmKOanw2DcGOXxHH+XLg7RdjeF/KtPcorH/WUPd1gQgIJucEzzJYauHjFIlKrd9y0ShaQnIFjGpw4Bvv+h6MmNqXXCa/r/OVZEkaRvwg6c8NQa8H/im//woMAv8qed565IkSYjkt6uBJnC953n7/6fvAUwaS8Qk4eB8sNNPVi2zYMcYUqvknbCw9tdKwnv0BVEO5AbZ+/EczQGN9k1CBNXwdApWzMfLhZV8yG9zwpJFzdOwXBGuNKyuM6kX2N/exJBWFGW80mDK7BWbiT9Ma3sKlqcKMxe1Qs6JEJXbrH8gTOa+OqEjFq1RmPWhZBAxDepF/mT73+ewxjR26cvUPI2qHaDqBrpwXNkJE/XNkNMHmnCfx9ELMlwYPMnBTj8JpYnkt6dy1aPmBYjRYdWOs9BOM6QV8b7godbESow+1MHaphKudvAk6LxWQ8ftKogdJNpthW9/5TbuCp4BQFM2uKBzkuOBLA1VBBRJtkM7FcFCJmU3aKMx0lyhrIao6EEe7wyy3Vim6WrkLkiy52M5DswEqV4ZpHaGQeiEOOEWwykUx6VXqTOolik6Yb59/pfZH9gGQNCzIBnr+n4ceV+G2y79Fnk7zsTrlqEBB768iX0vX+C8183x6HeH0MMCOcuqFWZsoYY92B5iWF0nJHcI1GycPTInPtTLkRuynPeDWaJ3iM94yyeKwsskrlC+NER8rk3ocQtwuGbfE1h9ClZQQa057MzbSI6IQMg9L46y5DF4f4XDN/cRf7hFUmqzZMe7iIjmI3pDShO1XGHq3gSjR9bIPlkhdrBNZMHEk6F5gc7B1/djP1fG9sOrXR+B2/LrOtGpDg99eoRtgQJzdpJxrcij7SEySo0p360u55PKFMllTFsTplVWGletEJI7ZJU6DU9lxhaVyoHOJk5f5PR/zOX8GMKgGEmSFCAH3MmpCMiPSJL0Hv/P7+aPIyDPQ0RAnvc/ew/Hk1iw0kzoeRwk9hpL5JyIryIMM2v2MKit47hyl8//8GtGSS812PzFEmqfy8JrkmSUFo5P9Cq7OjlLBNts1VdYdSL0KnWanoGFwqoTQXGF8K3taRxub2JAW6fmBii6YaJyG9eTaXqGCL2RLB7tDPqKWI1iGCr/EODC15+ERYs0daatDAHZpOyEyW4rU9+qk/pxk7nrUxR905UJbY0pq4e8E/MDpE6V9a1+lX1/u8iv75zkaCJDwj8lcqkEQ5RJ5tto+KiK5DCur7Lp39bZ+o8FrKCE1vIwqjaLNyQY/scyq2+OsNQXZ9WKiiR1K42MS78sTiRNV6AFimWy1VrlS4kr8CIhPElCXltHripU1BA9dp2OonHbwtf5fuJ8vmlcTkJpouEyoLY4fnUCPgZ9P60RerNN7m1xJt8oNtGB/jJrUoS8H0Nh+VWW1BID3xYquY9ofH/vV5iyehhUhU/phg9KjDb5XTFmPtvDxBsKnPWyBX73xS0MDdUpOGEcn8NyYXCGGTvFejPEuWtzLCXjNFyDyZEVZm7sQX+RydlX5ihtD5I63EK3HPr/rfZH96HS9lDmbAxOkcScsERpJETvPXUCBZva2QbZuQapb4vNYsfnl2iUDUZqJYJVG7OsEFtoE1g4JSqrDRp0dqksvT6OebXKY7FhBtV15q0UZ0kLyHjMOVF22QViH63SGNOoP1+n4yoUnQimp/CM0CwnLKEOz9txzgos0PZEheR6Enk70UUHq7bYVBcscbC4yAyq6/+rpf6fuv6zrcozgWnP8+YQUY/f8J//BvAi/3E3AtLzvAeBxEb+yv/TZXkqe41FXE8WvqJOhJhPzy7YMcb1VRqugY5DWqlTdkIM6mX+/b1bmb8yydCHymQ/WuXexuauW1jZCbErsEBarXOoMyjovZ7R1boAbNMqlH1fiTFjhYTSwPRUBhWxsNr+vKXtaYQlqzv7aHqGGEA9U6cxrqFVXCY/XiCjVpnU1rr5GvNXp+h9tE75RLA7PS+4IXTJoeoG/JQwp4vNP/72QYwVmytuOM6uTt4PcXZgp6gmpINu15Y/b8bY9OV1tr6jQO1cHQzxdypXBhj8dIXyriDNvwpTdCJkfXuAHcYiiuRS9zVB0iVi0+r1dRz3qqPiC1FlUEVm7EJAlPZVn5fgaQqsFonKLWbsFHnHoHdznfpenf47q7QdBeu5Ko4ufLaoi+zVhm95EJZMJrQK5751RrxV1uXW3d/h4fYwuuRwqDNAVhHzJOG1IsRhS8+Ic/wrGSJzHa780yPEDrf9lD9XBJGbWYbUMjtnc8gWNHbojGsFin4ZX/ZRkUhNEMBmXpnh3qnN/ObhCR775SAzn0/z6EObuP3JfRw4tol77tzCox8cYvVZEdJTDYyCjRmTCRyxSH2q3r13Rz6+zrZvrJD6TRP9uE2obVLfZfDEjQNMfTvDN39/Hj+/ZwfHbuuj9MoQ88kUGUUI2XYbOQ6ZWQ6bWTJKDf3DTeJzbf7wwc3Mu2nydkIocp0Qj5s93aHwbiNHwQkLvYzSRJNcJvUVQS5zhHO/MFIS9IMBdZ2UcsqZ/XRc/1mR28uA7/mPT1sEZFAWOPoGT1+TbNpo3fTzghNjTFuj7AbI23EGtHUCkkUmWGPptija+23GPl+kJ/8Yix9LUvIiPm/fRlGqXZFbRm6y5ERxXJmw3GHJEW7pwrBHGBcX5BYNT2NIqTPnCQHSuFak5upklSrTlqgENngnjWEdfd0h9fkG/VaVo+/JkFablN0QsVdUcG6TOPuLC/z+w5tpeLYPDTdJ+Bb7RSeM6YqvoXWGzuFP9rP9Hctkr1tn+uYUg5N1nBGw4jKBgzZ1VydJi0tum2Lkzgorz47gqBLRh8SCSPyijTWi8PsvjhJROkzIq5TdgE/BVxlTKxx2RKD2QEbANf1umcKzwrzgtscZVO8RC80JcaLTx/JbQ+y7B+aHBtg1syxmD1lRLms4fkuoUbw+wsg7SiR+2cK8WkNyhZhs601rPP69ATJqtcvSLTmnEC0zrlB2BR8lIFnsMJYo+/eA55/7oo8P0LzEgNslNr+6yNA1Rcw3S5TeHCKrVTlgDVNzdSKPi0qmtsug6RjdOUBEFq2TvuDgyWCiENUtrIzDiUQfk9tWqDghYl6bFaKMn1nCmpbovbuO5MD+24ZYuDKJ5anojkW81sSYdzgy3k8iIrgZZxpl5myNnG8INeemOENZ9mcwbWatRPeePtweZHsg1405TTzUou/rdZb/IkrxvAhZudLN/Ikp4sDaMNKetjKMawWOmlkSSpMpJ8K4tkrVz2MRbFSHtqcQkBxKTgj3KZXt6bj+wxWHJEk6cA3wz/+rv/o/eO5/GAEpSdIjkiQ9Uiq6/hzDI6XU2aWv4SIWd0CyGFJLLPhuXwAH20OEJVukV8kBHvngMMfelSH2ozbZvygz0Njw8DDQJFeQxZw4JZ8YFpY7LFjpLgFMzBwsCk6YqNIS/g2uQUpp+nEHCg1PFwHASIQl0x9OmchArT9A8fow276yyvlvmyXYNmm4BifTUWZfliJ+R5PmSY2aG2RCK/qB2UnyfrSk7QuQZMlFfSEc/Uof6pLLM19wDP3vO6wth2icpZO6r0HcE4tv5M4Ki6+IY6ybDPyshpWQBA1ahpkfpDH6HAKSjeYvOl1y6FPq1DyVuH/6yD0iB1Z24IE3jpNVy12Yc0xf5dnRg5wrzwFw9gVHkSSPK/70AG//0Z2CF+IbOjc8nQevGqW+WWfzLSUiT7SRbahuMQg/ZJL5hkCULE9mwU4gSx5JSZzatYmAgA6VJg4SCdn0TXRsPEQgeUAW31Pb0wjulrnzx3soPTfExGfW2PmCPM7PJYbUNfJ2guT9LTpphZn+XmpOkJgk9DllW8DrVlLGkyEqtSm7AaatDNv1PAc6m+jzZxU9B+r0/HmV7TfmWd8a5NGfbWLuyjS9So20UqcvUKWd0pnbnSYa7hCSOjQ9g8NWmLIbZPgpbYHliQjPGStF0zOY0ApoOFwZPtzNTnEaEgM3lmkPqTz2rk1M6KtdBnHYjxBNyIKvscFfkiWPCX2l68YvS273c9pgqALUXN0f1P7XoSrPBfZ7nrfi//m0RUDGUyoxqUNI7tB0DWb96IOCHfPhphhZpcqUmaXtaVwSmqLm6t1YSEWC6Rt6WfqnBIn9LS7/0ylCx0wxEHV12q6GhkPDNXAR7dB2Y5kVJ+K7jqkEJFuoZj2ZkNzpoiAT+gpFR5S5bVcMOR0kps3e7r8BCcp/F+H432bI3NVg/Oo1dj+xSNkNcff1k3iKxCUfniYqNVmwY0xb6S4JTQROic1AwWPWSpC7NMEv7trOylVRhr+8zkUXzmDM2gQXbSJ+CFJtUiP7wyrxh/0bwvFPZxu0X52Keliw474NgU7HUyg5oa4JEVXxM64EgzvXCfuEp5jcpukarJdDJB4SbMrQUbFpu/4ml7OTNFxDcB3kJiOBIktvjRM8bJG8UWxMjf8WoHRFkPGPrVE7YRD1qeJ5Owo1/713iPT5jfS8BTvWrUBsTyEg2dTcALIkWpI5O8RAb5knPrOJez83htxyOf+GOS66ZoaR768xfHeJhauSTAaWuy3auFZg892COr52pfguPSQScptRbY39nSHiVoPWzxUufvUMZ//JAqFDJo+/d5BHvjuMNi4OtKobIOqjbE3PIK3UGdKK9Pr8IBHT0PId8ztMamv0KacczIbUUpdbNG1lGPPp7H0fqROet3jiIwPIYZixehjw7Q8TcgtNsrm3NUZUbqFLDrLkcrAzyIKd6qKJS3ayi5xZnkLOTqLgUXYFAvVfqY59OafaFBBRj6/yH//fIyBfKYnrfP4DEZCmp4qKwE9Tcz2ZMW2NjCryKdJyg6ITZoe+xHmBWb8Es0nIZpfzoUk2R5/fy/5vDKGsu1z8wmnitzRRbLdL5bZQyCg15q0UGi4ppcleY4FBdR1DElb0aaXe9V9ouhp9iklAthhQarjILPl03h2+BmYDyr23vZml18e591vj6KbD1utW2f53y2wP5yi9O0Lfb2r03lmn4ek0XQMXiYITxUSh4/MS+pUak7pow6Q+j9zNCQ7+pp/ZN6VQmp6oDnz9SfSohdzxqJ1tcOCjgxz6ZRZXgk6/wvDH12HVo+xrXxqeTlpuYPrcjw0UYPjnJQEpeqDeLuwKBDmpRdUNcM7H5lGaolgMHxQb1LIdJ/SUHJhRbQ0TWRDV/kSmcGGI1LEmdkBi+rI0Jz+cwtMlznnjPGvrAeERodYIzInh4dykIKOJ2ZNYgIpvWh2TBaktLJkU7BhjaomGH3hlegrO1TLHftvHk5/IQgvOfd88chtSRxtkvlZHf9hioZykuawxdqtIvqtcGEACTEch/mQb+1sq1/7t4zz3/MOc/ZcL6Idsjt3Uy5P39bP+2iBtWafghLE8haxa64rHxEkvSFxVz2BcK5BVKt0h8CEzy8PtIQ5bPTRco5uhYnmy35IHWLAT9N5RY+e3l1m5PsLK+SK7JaNUmfOjH4tOGMtTGdXWRM6LZNF2hRHQhFYgpdRJKM0uXX7j8wnIpoiSlIWHjfFfQTmXJCmEiHm84ylPn7YISCT8flmEMM1bKTEx92TODCyiSU437UqXXGbMXo6aWdqewlZtlbIT7rostS7QWPh1D6vPjjL+ySI7r10mekzI6Sc0cfOM6musOJGu+jGjCL/ShNwhbycoORFmzYxY5J5E29WYs5NdWXpUsliwU0xo68IYBolRXYjmspc1+MlPdpL7szhj3y5y3iVzOHMetZ0G4x8oEj8p3L9ydkyU367Wta63fe/VhCy0DAUniqdKZB+poecdXP1Uz3f05Rl+eXCSB34wxoEXDZHvjVO5IIingNzy2PemRby2WHRLVpJ5O4XlKSxY6e5NFJyz6cQVzJTMjk8vo68Js5mAZHP2HfP0fLdB7lpReammBx6klIaAxlXxWZqe4msjbA5ZfUgJ0avaERmzrbCUSfLYbZsIz5rs+Ms8/XadGauHkM8sNXZbhOQOE6oQHG6U6BunpITQaOwylqn4G6GC1yXxoUqs/0mIn9+1nepmAysqE8qZTH5wlYtfepIX732cCy+eQav7gVfvKIANW76wxubnrXHx+6YxfmVSfHaY41/L8OSD/Rz/y14CEeFjG/MHuwB5O9qtHjaYvVVPSOQLTpS8n9E6pJbpVWpk1Qp5K0FCaXKmkRebjhtkzGeT9t5fY/imdeoXGhx49ybKfrvecA0ySq1LCdjIDQLhlBeWBcVgwwho0Od6NFyDQXWdVSdKQLKougGOdgZYsNI0vdPr2fUfjYBsep6X9jyv8pTnTlsEpI5NWmmICiCwyG4j1/2y2r6nRtX3esw5EaKK6OmyimANZtVy14tAkxzmEzEO/NMmWl/oQcs57L0mx+hni+TqAhbM23FkyeVopx8Nh1k7TtEN+/L3Fmcbec4JzpBV6iLFXmn4yIpJQLLoeIILctDsxfWkrmeq68k82B5Bjbos/0Ocx36zifVrQvR+u070yQ5y0+WC62bZc+88GbNGw9P/SHzU9oQxi+XJmEWZfR+aZ9czlgj8QVRMvnkVAPPvSlPTQ2TVGoOaiK9ce16YwKLDzDvSJB5rMfmqVarrATJqlVFtjQUrzZmBedyfiteobjNwIxLLe+IodZddb1siZjbRv24z+J4yKxdHOPwqAYg1JkVVZDhWl60Jgr0p5hcqw/eVSP+siatCYM1h101LDMnrrJ0fIf+JOMkHW6RurDHaKBCbFgfBlJ0lrdRZcGSySpWEf3LG5HbXPV6RXEqOiMBoe2JoPqaVWHKiLPnygX33LxI72SH/32P89v5JfnzfTh75whCVHQFkByq7fRLfgAoSFM8KM/+5JA/fM8RvHt3K0U/04T5TpaqKQXLJDXCwM4AsuV2Gcd6Od9vdhCyyYhVcyk7YbzlbmAg5viAytkirdXQcpqx4N/9nzk4ycLzMWW9eoDGuc/zzGVaVOBkf7RtUq4I05ojvNyE3BT3db9dAVBYC3i9SdA3GNSGKrLoB9hpLAi1U6uwNzJFQGt12+3RdTxPrQEFhHlUryMAfOkPIkuv7OCiiVXHDPtdjVbgoYbC/kxKtiie4Ab1Kreu0lVYa/PpZWdy7+rnggycZ+GSV9DeaHHztAOuvCKJEhPt2Wm51ZxVtT5jyHDYFazSsrne1BQm5ScGJskcvMmVHOCcwT9NV8ZC6PJS2p5FQGgwqQghVHA7T/phG4+066Z80mfiXVaInOpzxmgKeBLvGl2mkdJL+HGHr61ZpDapEZztoRa/72azuiVK6LoT5PIWxl68RPWZi5hUGk+sUnDBDapWaq7F8VZyxDxaJTrd59JNDnPnuRS577gme+MAAoeeKU1z5nc2O9whD3LnnpRj/5zViyTYnPpph618VSF7SRC14rDwjwuJnE4zmBBV98aoE244WSD7WYsFLIUsuvXKLVSdCVq0xcM86W29YQwKOvz1Dj96i98N1GimD8vsDFF8UpjwXYPun8jh5GdnfLy8KLvKIk0WTKoQlG/xSfoPcZCPmTlUfUTs/OEfJCTBrJXARlP16x2Dg4xXqm3QeuHoMzXPRshaJ77SIH2pz5C19HHtHny+KdDh3yxz5c2KsPjfaHXY3XIMFL9aNFY3KJimlzpha54QlzIpH9bWujMHyZI5bvd34zpTSJkWbpqtS9O+Zom+o3faEhCCmtEnITYLLHc54TR4vBCe/lmY62MuElidvx8koJmVXZUwt0fEUZq0UvUqNvBNjwUwTkC2eFZphfyeC5SpMu2IjTSv17nD7wdZIN+lQ8TzScpMnOoOndc0+LSjnHhLbtAr3NLew4EQ4LyDmDg1PJypZpJRT5WLJz9kMyx0ySo0hpU7Zb2vEVL6JhULOTqDhEO3t8PhnBznyg16a2zTO/ug8l11+gv7PV3HrEnknQtEN+/i3gCwTioBvF+xE99+44U495cuXRa+qYXoqFgrjWgFNsknLDfG8H1adUtoUemNMvzbDPb+Y4MmPZ3FVsOIKnX4FCQ/Hz2A1CjaJg220okc7q7L21xEeeGSUn96+i2Mv7+NkrIeVZwozoQs/PMOsmUbB47DZR8GJUkkEKb4iTO+ddVb3xHj09iHcGJz3xjk2X73Gpe+cYsf1eZojonqIaB1wPNQlB/1ukQ2iFDw6CYWl18QoBYS1AQBbBC8j9JCJdszuIlxuHXo/WGXba4VYrTpscOK1Gfa/boCp6zNs/kaJrW8v0GwrrL4lzNJ1MbJ/qGGmxK1XdwVhz/VkQpIwot7uDw0lH5AVyud1Jo1l8k6YvBNHkVwmtCIlJ8LmW4uEjlqceG8PE6ECYbvN2X8zz5bb1lh9eZiVv450TYM3BsMhudO17Zsys+T9qNANi7+yGyCtNNjf6SWjNLA8lZIjXictdyi6IfYaSwwqFfboeQ50BliwYxRdkVe8YKV9AqNIbttt5JBxyazUOO81cyhVjyNf7eNQZoBJG+4N1wAAIABJREFUfUVwXOQOBUc4gc3YKTTJZYe+StvTGFHXyWoVRrU1Fm2B3IypJSa0dcpOyD/4NCa0CgmlKdonO3YqKe6/mMfx/9pVc2UGNeGZWHL1bllXcEMUbDFw0iWHnJ1kr7HItJUWvhxqxc/2XOvasbWdiAhNUhqU3SADSo1H9m3m/O/NcfIPKXo+02TLR9cY+WKJ9ReHWH1+BHOvKnpvyYdq5ZavdGydEkDJDcpuCBmXWX9qHZRNgr4D9y59GUUSyEhAtsjZSWCdPYbQgSw5Udaui/Dvg1u54I0zGIdt5t6RpHJ2kN4f1giu2BT3hFl6e5SpC/vQZLGRTSh5EnKHWTuJ0SOO6tS9LS7+12ke/5NBEV+p2AwqFU68vof0txrsuWWR0s0Rfv1vk2y9Y4Utn1oj4mffRk6IRb/5o6KaYAkC8TLLfxajeG6IrR8tsO8VS6ycF6Vy0VOCfCTAgJ3vXGb2AymkX8CV/5xDq7h0xlX0GZvFmxP0huoEJIej7+2lldHY/fEl4vk2j3xiCHlULEy9JGYOc+04Rtxh2uql6lapuUFW/ApAwUXCo1eps+IIEeKMlcT0FDJKlYITJPZki82fK7L0whizz+ph09I6F9x4ktgDHabelqH8VwFmzD4CksWknmfV92/xPIkdugACNb/d2jg48nacMX2Vg51NXU+XhNJku15j1tZ5sD1CVi1z1MwIApbniiAnyWJAabLgRNhu5Aj7iFBWqeMgsW1qhdHrS6h1h+Nf6qG0PcwwJdpPUb5uxEJmlBpFX7wXljscNrMMquuCzKgKt3PHdxAb1cVGK1CUUwdfVG4xoVV4oDVEVGmd1vX6tNg4ZMmj5mnICGZkzdUFuoJMVql0DVECkiVSr5wwE9oaHX+jODOwyIIdI6vUWbATDKrr3S9hTK2gSCLZLe+EKO6LcPRrA1x6eBr5cw7Zb1bo/UqdzqDCyPPXWXxenPYZqh9obdHwjC4q4yBhegq9SpO43GHqKdaBWbVGxTWougEmtHXubY0yqJ3C86esnm4CnJ2G9ecH6b29zsT7ingSrJ0fZvpTPaxdEEaXXHYpK9RcjWkrQ81XorZdnYobYAhYOTvKpveWWRsOM3h+xc/sUJGzLrOvTTF+W5HgtTJ2Aoa+UUYruhSfH2Tmkh60OZe9t+Zo7dBQcg6lnSGOfaWPhir4LAtXpOj7To3d38rR9ylByx5/d0HMWFoQPGRzxktW8VRYviJGZ5PK5q+VmHlTCu9MRUgE1HXCskXlTQFmR1IMvrvMRVfNIFse+WeFMZoOyQfa7H1Xjoc+N8pQVFg+dlW/atWfcVjM2oIqv7H4iz5cuzof5dmvP4KZUXngb8cYuL3C3g/nwIblT8aZflEPbUfz2ZU2h8wBxn09kSq5LLsGs5b4tzpIzNpJNIQEveyEfOMeQfu3PIXDpmhtNujiW/UVqm6AQ3ZctBN2goBks2ClmdSXmbWTZJQaOTvG8INFtt5QwAop3Pv9cbSdQkvVhO7vllAaAnb2hOZF8WdnAcnyFckhJoy8qHwkk5TapuZqtF2NtNrCkpRuYltItlh1omLYrjTJKH9Mr/8/XrOn9dX+Ny/BtY+jS46f/RpjUi9QtEUbsYGhh2SLKbOXtqex4ohBpwih0fzAYYOUD6euOiLC8ZiVZn8n6zuMC28DTXJ4ZOcm5r+U4LcPbeXJj2UpbwmS/EqDPdcs8ZzLj3D+208y+oUSkw+u4pXpWgtOaGs0PJ0ZW/SeUdlCljzydpRZq4depc7jZpasWhFhUDUV8/cSZ399ngvfOcOWy1c59zkLZL9bo36mxsrFEZAgerRD9PEOq+U4VTdA0TVE2evDnhtRD5tUcSPnPxWhPaSy6w1LtI8pWAiIuuREWHx7gtaISvwN6+x9UQ694nD8axnu/cwEzktl2jepHJwb5Ht3nIMZ0fAyElVVsDVDcgct5LDw2iTf/83ZPPYZ0RtX9olhqGNIFM8Tj6denqH2Ap3NXyvRfJ7B6o0RpizBSjURQUOWpzJ1dYbDd/XhaRKyA5FZi/agaJd6769z8Sum6ayqTFsZQr4gMSBZBH3SUkapEvap/8KjxSFRa/OsNxxFa9jMvD7F8153iAv/9iTlySAP/myE379wMxYKS1aSqhPoOr1tcEQkRJzioD/HCvhMWED4WDwFck7IwgNk3kp1W5m2pxOVTSyUbszGmcYS01aGSX2ZghMlIYuQ9MwddSZftYo1oDD7ozTlMwTEul0XyJSFQlYto+AJLshT2oqma/hepW0RQO0GMD2FaauXghOk6IQZ1cocMrM4yN1WrObqTGhrmJ7CgB89eTqvp0XFsWGAUnZDNDydAXWdmqsRVVpklBolJ8KkXmDBjgkfCcTpn5KatD2Fg+2hrlGJSF0LMayWCMkWZTfAmFJixkqR86HWcwJz5GyBq4cSFide3MvxF2fprVbo/2WFwN0OqQMNsj8Vu/QoRepDOvUtBm5CIhWvocddliIxgr8RMNno14tMVFcJVU3S5Tqhqkl0toMxY3eNY5p9GuySmXt1Eud5Kvl0BBOF2ccttn5mlZGPrZP9YpX8C2LUr9EJnG1jSSpZpUrbE62UbjskqLESiVP4apTL/uQEZ79snie/3E9k0mb7L5eJ/lub4JxgXrYGNB7/135aaSEYKzkR4TMhdxjTV1F9O8FRn+0ohtFNwpKJLjmsbRWl/aPXjaB/SyzopqMz9v4iW79VwPs2LO6Ns/DJBJ4kBGdXh0+w5Oi0EfTqgOfSc2sTreay8hcRYvd16P9n8dnmnhOj/7c1rrh2it//42bmLxQpfMIYR0LzrQOicptRtSK8PJdcRv9sjdC8iTuosP2Dq7SGVQ59NEvhujAZtYXpCCbq3sC8b8wTIqNUCcnCtyQkW2KuIVvs0fNMWWIgPqSWaboiBLrmOeTsBDkEenRRcBZDgsNmkkljiVk/j7jpGvQqNaasJKPaWpdXtFhJcf4nZxj7VpG1C8Psv3WI/mSNYiuCrLrc20p2Z3kKHlNWDwPqOkNKhxlPIaO0mDZ7eaIzxLmBk4Kl6wq9lUi3F871IUlYRSxYac40Fk5RBzyNpmdw1Ax16Qyn63pabByqD3e1XQ1Nsbvxd+NaQQTmIiBKgW8L6XtAFtTavB1nb2Cemhtg1sqw11ik7Qk38ymz14fyImzTVim4oS45Jyx3TnlU6Kv8trmF7T0rHHtJP+3rNFJKndl8hrEjBQYPl4k82Sa60EGeclEqLnrNJc0pj4PJD4kS2IrISHGox3Rqmw2Wr4nR2KlT3RVgNRXrDulKToRLlBlxauyKcN9XomSfqDL6pSKbbi+jfMvD7FNI7GnR2qWS2NHEiUn0nxSIePxYi46rsfiGBJtuKbPvupzgcNhQ6zeYf0uCYk+YfR/IMfKPZe75yFYyWs03/2kwa/V0PwMXMSTesC2cMXuFXZ4TIYvQs4yoRabdDDN2L5PKEkR94Z0HwaRFvpnA0GxG9QIFV3hhDioVpq0Mu7+wyOD3K6y8OcrqTTEe60TZ854c/XfU2HSX2PClNYfLrj9B85w5Fl8fw+tX0OYcJBekJ1yitQ7yrMXm31WI391C9sWntaRG/m0p5BfLzJEWwVdOlIId6/pijGlVHmwLs6YRdR0PqDgBQnIHF1nA6sgMqSVmrRTD6jqHzSyj2hphn7sTkpvk/YT4mhvsCh4DkkPOFhaGGw7pWbVC8XdRXvz+x9AXHFZfHSH3Nwl69AY1V2dIK/rztw4ppUnAFZwQYUYV47etkS4ClFGrlHyT6YI/a3GQ6FXqIr9Y6vBAe1BAr8YiCdmlIjfJO3GqToA1O8aIvtYliJ22NXtaX+1/8zI9lbRSZ4e+yv2t0a7v44SeZ9pKE5PbFBzhghST22zX86w4EWQ/D1ZQtXsY1dYo+zuyJjmMams82Bpnb2COw/5mkfVPs7Ib6lqsleQWQ1qRg51+tut59neGSMhNdvTnmO3pYeWSmJ8bGkLDEa2UskSlEqS/VCWQszmyPQsxD0MTd3Tb0xhUKhTdkCgzlTYh12bG6uFsI0/JLVFwguQd4ecwpNRZ2hvi0VuGGWmvo//aIvgri74nqwR/KV5zjGL3Mzvv5XPdx44h4QQl1KZH6dIgJz7dQzMlStZH1oc5++Z5LmSG9Y+GmJNTJHwV5UbeR0g2u+a541oRSyuyTeuQsy32GeI9JcnFQWJ4do1978kRfMxi5qVp2Oax+e9LXPX8Q9z/D1toXaoRlsSg9on2AM/50hH6P1ml8MIwj/3VIIPUSOtNmrt0uAPu+8koifs6ZO+rkHikRehhi60Pn/o9Aa540YnuYw9wdYmTr04w/aoM8rD4rGU/5XXKzDKh59E0h6OdAYa0InlH3BMppU7NE16eYf8zGNdXsTwx09rw+Nhg0LY9tWscveojKnk7wYS+2uWPnGnkaXoGYYRkYotVIP6hFud/Y472iMrvvrOF4rkRMkoVy1W7NIMFO8U2bZWap1F0w2TVis/9aDKkloQNg89mjvk0d5Fu3/TvL5WCHSOtr3QJhDVXp+xKvmu7aLN6fA7P6b6eFhuHhEdUNpmy0gxq62iSCFPaiEwsOhECssl2I0fejjPke2hEpRaj6roYQvlBPfhlreUplNwQzwgdo+ZTyFNKnUPmgD9tLpCzY0TlFgm/etkwu4n6+gDLU9hlLDNjpbA80TI8+n+1d+6xkV33ff+cc++dJ2c45JC7s+RySe1DWj1oyVJkS44N24ndxIotp0CANm2QpDDSFE6Rl4vAboIGLtIGLQo7ieO6TVK4RZG6RhI3luU4TmHHresgsix5pdWuuKaW4i6X3FnOznAe5Dzu45z+cc49Wjl27HVWXq4xP4Ag587s8h7ee3/n9/j+vt/hEktBg0j6+FOKxtQExeMhh0Wb1fAAi16bnsoYXQw7dVuVIzbigs2lI6MTalvIC36Ltspzwc5oNOMJopxH8R0h8lEjMiW6Cv+8wmsrprf6HPyTHlffVaQ+OUl7ukD+xIjjfofOB32W/9Mm9/3wFq1fKvLMjx5i4901pNLc/6ENJrcH6I9Azw9Yzm3QTgqkkLJ6MsmC3+J8VCXSPk+OJMvZy2wmATNA1PN54AMXqf1+F10UfPEDx2m8o0hBhrx4zyyvfe+LvOWfrLDxoxWe+rlFJo4M+Hu//jyHPt5l450VvvKbR5jy+pRkQjPOU9CmfjFzeMj6z0zx4s9UWfB2qPxFnwO/vkvhckT7ZA5Vhda9ReYf75C/GHP50RJr759BVwQXwxke9C6wp32UxX8sBE3XiVjKNJj19qjHJTdq3lYFNBdoqwK3Z67YFv6AzSRjAGZJ4IYeA5EQKZ+mLnBfts0XBqZ1enZ0iLuylymKmHpiHHQjKnHoMx2OfaBB/kLMxZ+u8Nx75szkrBoRad+iYT3qyaSTRIgsTilBMFR5ql6XM+Ec92UvEQhFIy67EYGTmSushAep+W1TB5IhPZWxwuoBQwxkYGU0R05GnMyaWgsYR3MjbV84DommlRSoyD6hLWjlpBFQaidFinL0Mu3VelKgq3Lck2lyNjSV8IxI2E5KLGcuu5QETDdDIW3dJMcxyw+5GZctFmTAUHsUZExF9xlZwd+eytNVOTZjTSBiW5jKsBQ06Km8LUaa39FQJaa9Xeb9HdOGtBKW6Q2Y4lBmLUBtLZ50bGKpIyp5ZtitIg0Ctuob0FsznuCBqQ2a9+fZiKo0vQFr/2iWOb9DMzI0d11dYEPG8B747Fvu4vXvP0/tX3aZ/FCfjXdN8eJPVPnS/FEe/rU1lt+2xbO/OUf9dRZKTkI7KZNoSUlG1OMK80GLnIxYjarccdGAxW7/V9v4kaL59gJP/doRDte6NCKzCycPSj7/2O285ncvMPfRDoc/+QzJpMBva1befYC1X55xiNdGYoYO079d3bbOPctS1v6hIk89vMid/77Oyf9RR6zA9JeGjA5JXvy9Ks//YM1A0oWp0TRVnqoc0FBF5rwePZt6Pjky4XtfBVQ982D2VZY7bFcltlSUbVUgZ2dgjvgtmqrIvG82rwyKoVCEKmAjNgOOLZUjQdJKCuD1aYVFTvzZFY5++CrF1YjdYxm++rF5nn9gjgdzG4QWX5SzEcysZzRbFoImZTGirfOshIf4gcIajSTmor131q3Wz3J2i0ZSZKgDVsKDVDwDCchZuogzo3mWMg36Oktfw7S3Sy1oU5F9tuIpFvwWPZVjzr+xXZV94Tg0woXNZTEiE1ylbUP8ttULDawKWSAU9WSCqrfLM+GMk9QryyE1v8MV26dXSB7OtXliaIqgJRGxFh/A8zuGtdqGd33lcyacYylo0LT8pCcy22xFU0a7M1NnpD070lx0+I4TQZOS0KzG5t+shuaGlkI55i6DfDUapmmtZahMwXDDYlNqftsIGmtJ3460z/pdpr2haf1lO1bpXFGzjGEX42m6oQmr571dvjRYAoyoVf1khTOf2EX+H8HxDzW4/TcanPi3DZqvLXLlJ0pUP9vngZ+8xOF/0Cb7LyYY6YBJr0/Nb7MaVTnQ6nJspUHmVMLhv2iTW7Gp17LP6X8zR+5kwiRGWnDJb3I+muX54RyPlk/RfPcEcSiY/69dvLapgSz9aQu/r+BB2LknT++w+dtL27EoiBAh4fzuLAfO91CnBW/+q3NMfn6ITCAsSfyBIrOtyH02Qt0GwfHY7aQV2efJ4SIlOeR8eIDX5dfYSgrU/A5L/i6txOzC9XiSk5kGZ8OD3MkWE3KE9gwidDOucMQ3mJZ0UhpgPa6y4LfISDOhPev1TFqjAhbp0PqjLG/6j6sU1iJ6J7Kc+u15tt42SeAnhJHHFwdHXSpd8dtsxNNUbOpREX0uxlNUvV1m/S5Pj2rUvA7Hgibno6pNv2ed6NheknESC0t26jdRwm6wQ5can49mKUlDDXHUymsYQfeXOFBuhAmt/wZVxnfdTizn9e9/6jAZEkfbN7SKVyU5pGGHduqx0RrJCeOZI+2znL3M2fAgzXiCWb/LAasAv6cMS1dJDox4jSXQ2bwmGlgKrtJXWaQwnBULfpu2yrEWHuBoZtuEf7bYlRMJ69G0abOKiLNhzRVo20nB5ZEhhn8h/T0V2SdniZBLcsC0HDrnFmrPiQulswUGB3KVC3Zs3aRMPp5QJFo6zAGYvr5h5DZzEQe9kBci4yhTdfS95zMc/0yDmcf3KL1onOW1VzyNBAaLPn5bEXSUe6/+6jLqIZj7SJevfmie3bebv+mc37Ft8AwJgt16ljs/Vmf+ox3TOXl0gi/8/O3c8+wW1cf3OPD/dpGh+a1JURBNSXKXrLJaVaJ8QdBMXMEznPHoPZJj7ZFpvNdoduoFbv+DK8z/YQc5MuJPa2+r0nykSHumyP3ZOiuhiVIbcdn9Hef9NuvRjCERtuxvJTng9SfWuPyzZZq/UuLJ4aJhoJcmnUjb+T2Voyr3+Fp4EIAHchtIpdBPaEqPjzj0mS6ZZkJ00ufJdy/Aj2gCT9FMio5usmZTjHUbKfdUniW/ybOjeYY6Y7BJMnT3e2oVr896NMOxoGGlTQdsxAUHh2/YCdyuynEsaOChkUIToAwrW1ThRLZORRrOEVNU3eOtt61c97MphHhKa/19X39830QcqVNoxGWG0uSqBrYbu8GmBUuCcyascTJzhZxIWI2qVjLyAiGSli1seUKRkyHHgh02E6M6nj5wC36bzbjMKYsATMmIe9JAdWf9LhkSIuG5p2w9mnaQ5LXYCEcrLU2UYQtRaTicINwOlhOxoanXHo2kTKR9LkbTnMxeJqclk3JER2XJ+WY+QgrFlqU+bCcF3lo8R08FdHWWoQqumZ0xVXJDkJsnQXAumnR8ETmratc7nif3yxHnfvEgSUOyeLbJxOkR/mpC9Zk+ecuN6bU14VGP1qsLXH1zkda9RaIJn7nzHeY+YgrKeypLzesSxAmXz5WZ/8oOM5/uM/PlXYSGnbflufDPp+jflUXHgo3bprjwzirVuId8HnLPRRRWQyY6I7Qekt+M6d2dI39Is1HNMbrbQ73KY/XQDD1V4P7cJVbCWdrVAtGvetT/WZkjH28z8fiQe//1Fuo34OprJui/PYA3arz5hJwMnUPetGDArspxNLjKhlUAVAi6Ks+p0WHekF9jJZqhJE2reqgDMhhMRyAS7hRbzJzuEz8mWfzzFrkrMToH9TeXufL3SwRvVYR4RmFNxdT8HvUYqrJPIykSas+NthuWuYiyN6TM0Ak+5UREJDwqckDTNgEeym2yEk6hkFwcThtAnQg57A8s236HC3GZkow4NZqjr7LUrENPrWFpMT2LEbmRti8ijuPLBf2/Pj3NSniQQMQsZ7Z5ejRnmY6UGzEHg7Jrq4IL25U2UpA5GTJrKfvTvnioPQccKgrD3bEWHnDao9JOHBryE99xLBRFzIrdaTyhKIiRo2OLrMxezVLQV+WAPe2TsUK/KUdpzdtj3Y5Ug8GXNC0epa98pNA07MTitUQ+CcISwvQ5Hx1wlHDr0Sy3X6OVG2mPOatGlw57mfmaaRKrSjbt9ZmWMWdD0yY0U51904bUkoKM2NnMUXos5ORn6kw8YwqWyofO8TyD2QylxoDSSojKCbYfnsC7qqmu7hndVKB/LKD/jixnfqRGcDxhUo4MPaOWVuc1ZDlzlbWobNPPAbPenqkRYGZGSiLidHiIshw6saKKDKnbv0/6gKUtVqUlpReGlD814OCnd8mdN85vNOPRuSfHcDmgfncZvQwXZ6vUgo7hsrVkNz99919R/9kyK++puQ1rqAO6gxyHVjssnG3jnU6YPD0kcy5GRpBkBPU3lsk/Cq23ZHkhUyXCFDbNqL0pyKeSF2la+xKL18gxyaWRbEYk3BE0WbNzMpH2Oejt0rH3cDspMut33YZlKBUThirgZGaHtvIdw1dFDmirvOOYTX/HvN8mEIqteJJHjj533c/mN4s49oXjuPNVWf07n7wNMA9RSURciKfcg99OihwLGi6imPZ2behvHjilpSHE1Rmby15hqD1HsqKuYfUqy6EhfbWhYTrPEojE8DvKIUeDLq0k4KnhIsu5Dfoqy5zfo54U6dt2b05ELq2qygEbcYXQQuNTuDuYVmF6vmAEe5SWXIynHRagq7OshQdYzl4i0h7r0YzLjVNHkWqG9lTedWLaSZEHc1ucDU1kVo8rHAu22U5KTmG9IEZEeBz1W1xJJgy/peyzHs2ynN1EacFQ+xRkxOCSh/dVmHxuwOTKgFwrongpJGi9pHovpjTDOwJ278nSXs7Rvq1AyRtRtwXWY0HTCHlHU7wuv2aiKVsYNIRCRpYwZeCuyAGNxPBcJFoa2jw0kZY0VYGq7LOnAxpJ2RTPtYdCck+myTPhDCUxQJ2RLD7ZIv9cRPm5IcUXQie4rTyIy5Ko7OFXoF/2mfqiidb6r80QtiX5boTfUY60CMy/6S1nUcuS6FUB228o4JWhYSVFC3JERQ5NmoC2/C6Bu8ZpdNtXhvc0QRi2Oqsv07PqcNOeATEa1PFLBcyKHPClwXEeyK27mlxRRLRVnllvz3WSCjKirwIKMjJSqjY6T4mOhzqgl+RZCJq8Yen8dT+b+9pxHF0u6v/2qZpTkv9adMAhP1tJgWmvz2krnlSQI9erT3fmSTliLZ6mIg1JcPrQJgijBeuQg+ahrSeTrnsRiNiBsuZtASuNPFwrS2VMQc+mJAs22kjh1UU5ItHSdVpq3q7jEUnP5f5si404YDU8yKzfZU9luTuzTSMxLNwpydD5aIq7Mjuci0zbua0MW9SeRScaVGJixaM0i/4OW/bnlJW9EZcdHX4gEhf+lrwB92eu8nQ4w4Jv2sYe2k5xGmKh9IZP/z/D+xC613cE22zZmpMjltYBs16Pnsq5uhIYoNSs16VohwBTfE7F23O/K73mF+Mp5v02OZFwanSYpaBBIzGtyDTi6Kss6+EMJ7J116YvyyGLfpcLFgkshYI98M8qFp9v0b8cUOyFeB1NzjqIkiU07rwmZ6aUyx5R2UdWFMkJyfqdVa7OT1DxTbRYt+TDFdmna/lbzdBjn5Ww5iJYV1fSGQISy59hajlVOeD0aM5onviWQgAs7si0/lfCQ9T8jp2HMtc60v7LIud0CO++7AZNVWDWM6CyRlJ23KdLfpNpL2I1mnQKboFIeHDxJezPt2v72nHcvpzTH35syRHSpjdvesOknjxV8UqH39KwMM3rDYdnSCsxYJlFP+KJUZUAwyB20BvQUhmatr2VMpWnUULN69JWeRs57BFY+sC041MUoWOwTizmo5VMUPM6buitbCOfFAegLJdEIy5zd3YTaTsoezrDnsq67s6sG6aSLuo4mtl2Mw8bUdXscpZAOW1dZ2wu3kyKrqiWDvnlhJnQTUFDKXXiWniAmt9xnY10oCrVdj3it9x6Hso1eHo0bUWOyw4ifTK4SiPJc2Y0z0P5F3lyuMhScNWtr5lMmJqUiPCE5unhYcdilRMRbVUwkaI3YMFv00iKzhmV5ICiiGjayehpb5eqt8f5aJZ5f4dGUqbmdSjIyJHmzMq+k3IMhKKVFJzeaoq+rHlmzWmxPX2opFCURETLOj7jCLsv24RSx7inM47gOiUbTutigNtA5r0OXZ2l5u3RSnK01UvFzWZiAGHpWlMHUxaGBjMlSUqjsL7KshRcZTspMe+33ejEiUzdDtTVGVoQW6g9m/IZ56a0dLIKb1pave5n85s5jn0x5BbaC5Dmakast8tmPEXN27XQXqPAXZQjSnLAdlIyBUxb2Ey/t5Ic9WSSnEg4F+Udd0eCYCspULGDUym344nMtuPx2NOB4Tj19uipHGdHh1iPZtyA0FD73JfdNpBjMWLB7kIHvQEjy39QkCMn8zhUAc1kgiP+Dsu5DdajGVeTKYrQasSYgSelBevRNHNeSFMVCUTCqtXbSJCO9r4oQiTK3rjmoWkkhqXMQzt9jaIIadr2b83vuV3x9HCB5eyWC7U3oiq9xIiYR9mjAAAMEUlEQVQtz/tti5wssRFPcsTf4QuDORb8NjkZOYYqD82Z8ABSKO7LXaRtcQlG8DjHtJ1GrceTXEkmyAnNUnCVnsoz7xsI+92ZOiVvwLzXYc0WJ2ftbFJbFQiRrivRSMo0khJLwVUqtlPVVTmUNg9GK5l4WarQtziRnDSbQqQ9CmJEiJELSGxqaxxP8DIld4mpaSVIB8zajKZcqlGSQ3PviYSKxYekol6mpmN0e4xKfM7x4057uyRaIlEsBQ3q8aRr0QciMTSIwHpkZFCr0ky0HvB6nMhcsXifFpuWXvGu7CYVObIOZYLtpOQIkwF3b3RVjq14ykmH3ijbF44ja7sEofZoKgPuqicGhltPJuipHHcFHddiTbTkiOVWNMjPAXP+DpH2mbQpRSrEcyK46ng00+6DQtpdt8ep4WGKIrTdCsMg3VZGSX4haDIX7Bh1ODGirQqsRQZtuh5XuZKYUL2lMhRkzN3ZTZ4eLFGRZp4gwrO7v++KcGdG87STAttJyeiT2hTFUCB2+PxgkYDEOoABC55hfk9FpFIEYHrDhdqzXKg56kmZlfAgkZbkRGxwHoHRl2nEZaqyzwO5C9STCfoqy1o0Q8XbMze732POC/FQVLw+Vc+QG5vpUSOGdS29gIHvj9iMKw4R24jTaWWT2ilMbWkjLrAZm4GujXiaY4FhLgtICJFuUxha7s7lzFVayQRtK5twd2bLTYbWrQRnPZ50chVLftMUE1WB1fAgqZDVXcGedUh7bjPoK8uej2ItmnHq7k+PFhyh8EsIYkOJmK77ruwmGRu91rwubaszmxMRR/2WiaRs0ddA1XdQWvDl4W2sWj6N1Lndl7tERfZdveNsWGPPFr1rXpf1uMpaeIB6MkkzKfKGwipKC3Nt5B6tZIIzYc2NTnhCuUnd7aTEtGeY6jMiMYTGNtq7UbYvHIcU2qlSGfUuM/BmBKdNvvzkyNC0LfgtQ0eP5GSmYecMfEoioiIHnLUiNSkzdkYoDnqm4jzUAetRhUV/x7ZTBUXbAq1IkwIcCwxMOa1Qz9scez02UGwpFKeGiy7cNhwMCetRxTgDr29yXEsOk3KZpsXUWb/LUqbBAa9HpCUZlMvj+zZ1aauCQ1Sejcwsy+nRYVcp7+ssd2UvO2asDEYZLlWFT53IWniAogg5HxmgUT0pEyJdqN1OTCpQ8wzHydlo0oXfm3GFjBXgTqzqeSq+ncpIfKG/ZIbAEsMXUpAjFv0dciJ2E5xDbaKukhzw/TnzAO7Zv+O836WRlIyAtCqwEVcoSYNZSBDUvL6ZQREapYWbkm3aTaWVTNBTeSNMZHfsuWDHMXt9fjDnnMWZkYmcmqrIUqZBSUacCBqU5JD7sxvcndkitKjhplUS/OvBbcz5O9T8Nq1kggwvURzs6YA35i+7Wtmspy1fSIODXkjN20OiuRhP8VB+jaq367RN0uLvtfdJzW+7mk5P5QxHh4yoeR08oViPpmlaB72nM4Tac+eSpvaGWqLAEX+Hp4eH2YymXGq1Gs3e2Gf2hv5v36FpzC7WSEos+CbMTQliU/Uq00oc2J0lT19l6amAOb/DymjOeez7s1usjmqu6zLUHh1luhwLfotGUmYjNniHp4aLgJkGDfHcYNPTwyP0bJ75Z7t3O0LhWa/LUBk8yYLfZtGCsYaWOr/md6j5nZcpg6f8lWU5tDdIh4pNtU6NFuhqI43YVCbHX/Kb1PwOy5kus17PcTS8Ib9Gze+5QaiteJKnB0ts2eilKEcsZ7fcTESC2Z261iGng2BDS2uYaoIsBE3X+gMDHKt5ewb+badAAdqJKS6nDNoRHg/kNpjzelS8vsO0AGzE047qUdnWcE5G/N9hxo6DZ5i13yvS/NuK7Fv6gMA+iKY4WJZDWkmB7WTCwPYtw3dRjrgj2CYQMffnLhFp34zjkzDvtzk1POIKjQmCeRvllGz+fzqssR5PUY8nuRBPEQjFvL9jeT8NjUEtMGlVzdtl1nKvpBR9s96AtTjjpBWfHpmu2tnwIC9EZdoqw7nogHHYcYma13Wt0/VohkZScoJRRhrTyB40krIjJK55HVcvM7NSu47bFjBTuMmEK4SbjaRJW+WpeH0WgqZzNM144oY+s/vCcQC0kyK9JM/pcIYlv8NBqxch0Tw7WmDOPqRFEVKRA+dolBaOxRvgydE8J7NblOSA1+W26KkM63GVejxp8+SGKbiqgFrQpiQHnMzUTcU+mqVp273pQ3Zv/gJzfs8hCjPC6teqLGvxNLcH26xHMzZF8GzRTzgaw5IcshFXnEasUeSapqfyLGcvURYjB2HvWmUxgKdH0y5HDUTMXw8XGVowUag9KrLPQ/k1R5e/4Hc5PZpjzjdCPqncxEZU5dRwkVmvZ9IHLV2XZtPC6lPMQWCp8/rKd6xUKYryiL/jinR9nbUE0nnW4mnHP9HXWTPrY3d/aaUOUt3flAahaB1MiEfd8rr2VJ56UjZ1GVsQb1sS6VmbTpnfYf7GeyrLhXjKqLSpjKUTHNg0RRkuF9m3cyrSFSZTYF2ipZEjEIpQe2zGZWpen6q3y7zfdZ2uDIqNuGJYx1WG9WgGieL06BDKKtOlaUJZDpmzD3FfZSmIkXOgXW2+V71djma2KcgR92Y3uRhPAXAmnAPgWLBNxSoYprWOoi3g79mUN9GGv2YrmqLmt013C5O2ngkPULDpurLRZSuZYDl3rSrr3932RVdFCNEDzt3s83iFbAa48XPNN9/G67r17DtZ26LW+m/kOfsCcg6c+0Ytn+8FE0J85XtxbeN13Xp2I9e2b1KVsY1tbLeOjR3H2MY2tuu2/eI4fu9mn8AraN+raxuv69azG7a2fVEcHdvYxnZr2X6JOMY2trHdQjZ2HGMb29iu22664xBC/LAQ4pwQ4gUhxHtv9vlcjwkhFoQQfymEeF4IcUYI8Qv2+LQQ4n8LIVbt9yl7XAghfseu9VkhxP03dwV/uwkhPCHEV4UQj9vXtwkhnrDr+rgQImOPZ+3rF+z7SzfzvL+VCSEqQog/FkKs2Gv38PfCNRNC/JK9D58TQnxMCJF7pa7ZTXUcQggP+DDwNuAu4MeFEHfdzHO6TouB92it7wQeAn7Onv97gc9prU8An7OvwazzhP36p8BHvvunfF32C8Dz17z+d8AH7bp2gHfZ4+8CdrTWx4EP2s/tZ/tt4M+11ieBezFrvKWvmRBiHvh54Pu01vcAHvAPeaWumdb6pn0BDwOfveb1+4D33cxz+juu55PAWzEo2EP22CEMwA3gPwM/fs3n3ef22xdwGPMA/QDwOIbX+Crgf/21Az4LPGx/9u3nxM1ewzdZVxl48evP71a/ZsA8sAFM22vwOPBDr9Q1u9mpSrrY1C7ZY7ec2VDv1cATwEGt9WUA+/2A/dittN7fAn4FHJFDFWhrrS0X+cvO3a3Lvt+xn9+PdhRoAB+1adgfCCGK3OLXTGu9CfwH4CJwGXMNnuIVumY323GIb3DslusPCyEmgD8BflFr3f3bPvoNju279Qoh3g5sa62fuvbwN/io/jbe22/mA/cDH9FavxrY46W05BvZLbE2W5N5J3AbMAcUMWnW19sNuWY323FcAhaueX0Y2LpJ5/IdmRAiwDiNP9Raf8IeviKEOGTfPwRs2+O3ynq/H3hUCLEO/E9MuvJbQEUIkc43XXvubl32/Umg9d084euwS8AlrfUT9vUfYxzJrX7N3gK8qLVuaK0j4BPA63iFrtnNdhxPAids5TeDKeY8dpPP6ds2IYQA/gvwvNb6A9e89RjwU/bnn8LUPtLjP2kr9Q8BnTQ83k+mtX6f1vqw1noJc00+r7X+x8BfAj9mP/b160rX+2P28/tuVwbQWteBDSHEHfbQDwJnucWvGSZFeUgIUbD3ZbquV+aa7YOiziPA14DzwK/e7PO5znN/PSa8exY4Zb8eweSKnwNW7fdp+3mB6SKdB05jKuA3fR3fYo1vAh63Px8Fvgy8APwRkLXHc/b1C/b9ozf7vL/Fmu4DvmKv258CU98L1wx4P7ACPAf8dyD7Sl2zMeR8bGMb23XbzU5Vxja2sd2CNnYcYxvb2K7bxo5jbGMb23Xb2HGMbWxju24bO46xjW1s121jxzG2sY3tum3sOMY2trFdt/1/gwCB2yduRqYAAAAASUVORK5CYII=\n",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "#Lets detect Harris corners w/o duplicates\n",
+ "n_feats = 50\n",
+ "mr_size = 6.0 \n",
+ "nms = kornia.geometry.ConvSoftArgmax3d(kernel_size=(3,3,3), # nms windows size (scale, height, width)\n",
+ " stride=(1,1,1), # stride (scale, height, width)\n",
+ " padding=(1, 1, 1),\n",
+ " strict_maxima_bonus=10.) # nms windows size (scale, height, width)\n",
+ "\n",
+ "harris_local_detector = ScaleSpaceDetector(n_feats, \n",
+ " resp_module=harris,\n",
+ " nms_module=nms,\n",
+ " mr_size=mr_size)\n",
+ "\n",
+ "lafs, resps = harris_local_detector(timg)\n",
+ "visualize_LAF(timg,lafs)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now we are much better. But what about symmetrical responce functions, like Hessian or Difference of Gaussians,\n",
+ "where both minima and maxima are equally good points?\n",
+ "In that case we could pass **minima_are_also_good** flag to the ScaleSpaceDetector."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "resp = kornia.feature.responses.BlobHessian()\n",
+ "\n",
+ "hessian_local_detector = ScaleSpaceDetector(n_feats, \n",
+ " resp_module=resp,\n",
+ " nms_module=nms,\n",
+ " mr_size=mr_size, minima_are_also_good=True)\n",
+ "lafs, resps = hessian_local_detector(timg)\n",
+ "visualize_LAF(timg,lafs)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# Now Shi-Tomasi\n",
+ "gftt_local_detector = ScaleSpaceDetector(n_feats, \n",
+ " resp_module=kornia.feature.CornerGFTT(),\n",
+ " nms_module=nms,\n",
+ " mr_size=mr_size, minima_are_also_good=False)\n",
+ "\n",
+ "lafs, resps = gftt_local_detector(timg)\n",
+ "visualize_LAF(timg,lafs)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQAAAAD4CAYAAAADxDimAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOydeXgkV3X2f3VvVXX13lKrpZZ6pNForJnxjMcebxjbLAaMcQiOzZ4QCGtIgEA+IBBCErYkrAnLRwwhBMJOAiYkGAzYJmG3jRfsGc9Y4xnJmtFI01KrW713dW33+6NqOhDIQj474Fjv8/QfWrq6um6dc895z3tOaUopNrGJTTw0IX7eJ7CJTWzi54dNB7CJTTyEsekANrGJhzA2HcAmNvEQxqYD2MQmHsLQf94nADAyMqKmp6d/3qexiU38r8Xtt9++rpQq/Nvf/0I4gOnpaW677baf92lsYhP/a6Fp2rGf9vvNFGATm3gIY9MBbGITD2FsOoBNbOIhjE0HsIlNPISx6QA2sYmHMDYdwCY28RDGpgPYxCYewviF0AE8qNBswvw8rK6Gr7U18DyYmIBSKXxNTkIq9fM+001s4j/FpgP4r2BpCf7pn+BLX4JvfhNc9z/+f02Dc8+Fyy8PXxdcAPrmpd7ELx60X4SBIOedd576hVQCHjoEv/d78NWvhj/v2AFXXgkXXghjY//6EgJWVmB5OXwdOQI33AA33QRBALkcXHUVvPKVcOaZP9/vtImHJDRNu10pdd5P/H7TAfwUVKvw5jfDBz4QhvKvfjU84xmwc+fPdpyNDbjxRrjuOvj856HTgcc/PjzeZZeFkcImNvE/gH/PAaCU+rm/zj33XPULg+9+V6l8XikhlHrpS5WqVO6f49ZqSr3tbUqNjysFSp1xhlLXXnv/HHsTm/hPANymfortPSBVAE3TLtc07bCmaUc1TXvdA/EZDwi+9CW49FLI5+HOO+Hqq2Fk5P459tAQvO51sLgIH/94SBxecQU8+clw/Pj98xkPJMrl8Ho897lh9PKEJ8BLXgIf+xi0Wj/vs9vEfxc/zSv8/7wACcwDM4AJ3AXs/o/e8wsRAXz4w+Gu/7CH3X+7/n+Efj+MCOJxpZJJpd71LqUc5/47frOp1HXXKfXBDyr17ncr9YUvKDU//7MfZ2lJqWc9SylNCyOXUim8Ruedp1QuF/4ukVDqd39XqdVVpT7/eaWe+UylzjlHqS1blDr/fKWe+1ylrr9eKd+//77fJn4m8O9EAPc7B6Bp2oXAm5RST4h+/oPI0bzt33vPz8oB3Hl8klZgUvVTJEWfqp+ipG8wLGwCNFqBidACXCVJai4dZbDoFijIJkW9xemGwUm/xz93ZyjoTbJfs3nUy46ycUmcA1ePYyZ9Kn6aSb1OPbAAWHBGmTHXKMoOC+4wtjIoyCb1IMGkXgcgUBodZTCpd1nyEnSCGHnZwdACFtwR0qIHgETRUSZVL8V5a8cYe1OTwjc6NE+3uOn921DboOxlKRkbSBS2MpjQG8w5Y0wb69T8FD4aSc2ho0zSwgbAVZLR5RZj72lR+Gob2fvJtW3ss7j32aPUn2zRUgkAcqKLoyQBAlsZ5ESXhOgz/sUmpdfX0XxYfX6ahatGELsUw9LGVYID9jhTd9XY8blVCl/ogAZaAE5BsrE7jjYCuYqLtt/FqAe0ZmMc/fMRju4eIyc7WJo7uBYSxbI3RE52SGoOOdFj3i3QCUx2mKsse0M8Nl6m7ENLGT/yvoBWECctetjKYNkdYk9sBYmiHsQ52C9xrrWIrQxsZWBpLjnR4153lJK+QSeIAdBVMXKiS0eZAKSFTUbr01QxMlofHw1L86kGcQIVXqeE6JMTNt3AoBokKcgWZS87uIa2MugGMfbGVij7KSZki67SsTQfgFZgsr8/ybRRAWBUthGaoih95tzkYM3swGDaqLNrcuW/bCP/Fv9jJKCmaU8DLldKvSj6+TnABUqp3/k3//di4MUAU1NT5x479lPblX8qrl3Yi4GPrQzqfoIzY8t0lEE9SOArwahs4aORFg5HnFGkFpAWPXKih49GXvSZc0coyQbmCY9dTyzTnTY5+YUhlmWGspflfGuJeXcIqQX4SpAUfVwVlvKagYWp+Viai6W5pIXDrfZWinoDHw1fCXKySyuwkChmjBplP0lRdqgHJiYBMc2nryQA1SDBnm+skn9tC+kFfO8d20k80aHsZ5CE6zOhN6j4SVyl46ORE12GhU0lSBAowb1OkUuumWP7W9cRKFavTLP2pBTejKRrmugnfJLfczntH9dI3utSPS/BTW+ZQd8Z3owLziizsTJlL4eBy6OvPsr4+5pULkjx3bduZ2SmRVF2f+yaSC0g2epzxitOkvlWH8/SEK5i7p2jLD95iLKXY1/sBN2eZOirPabesYG57rH/D0uUfyODixw4r24QoxPEkFowMB4nuj7Ajzl6H0ErsEgLm4qXGRh/RtiD9aj4SepBgoJsYmkettKZd0Y53zrOIac4+Jyyl8USYVm3E8TYY65QD+JU/VDHkRY9XCSdIMaobGErA0FARtgYmj9wNI6SuEjOj1X5Tm+cpOiH71U6jpKD88/LNhLFFr3Hqm8y54wzbVRoBXEEATnZZcnNM2lUSWoe824eqQUUZIuHb138mWzx39jbT3UADwQH8NOo7Z/wMkqpv1ZKnaeUOq9Q+IlBJf8hfCVwkUgtYIe5Sj2IYysDgLxs46MhUbQCE0PzMDSPnOjhKsmhfonb+yVyostSL8eWl9dBaRx//zAHtSJjss2kUWXJywwWuRXdEGlhh8Ynu2zVN0iIPovuCGU/xaRRZVKvU5INkqJPoMJLa2geFT+OqyQrXpqccEgLl0qQ4F53lGrktO58bIkffGkr3jbJo196lMI720g/CL8vGgf6JSzNZcaokY7OqxIkqPkpCqLNU6++g11/tEb/XIMffH2Kb755J9YjFffkJwiGNYbP7tN8SYxbrpvm9rdOkpm3ecIzDrH1+1XyssOu2Ekkirxsc/5HjjH+vibLT8vw3b+dIbuth49g3h0aRAlSC6gupTjzGSukvtdn4S15vvP9Gernxdn96jW2fGWDkr5BKzDpmBaHrhjnhq/sonmJxb43L1P8RBNX6bhKUvcT5ESXnOzgK8Gan6YTxJg11hmVLUZli6qfYkqv0QnCHbkkG0gC8rKNi6SoNyjIDg6SOWcMQ/MYlm1aQXjtDc0nJ7vUAotZc42CbOKjkRB9JvUavhLsi52gHsSxNJdZc41Zcw1LuHSCGKbmkxM9ZowaJb3Jmp+m6icp+xk6yqQehN9hzk2yPdrRk1roWFwkrtIp6g0A0sLhsJtlzhknL9tYmocgGNzfhuYBcNApMipbSBRlL/sz2ch/FQ+EAzgBTP7Iz1uA/37s8lOw11xjl7HOrFHFR2NYdkkLm0m9TifaSepBgnqQQGoB0/oG9SDOmp9mX2xpYJznXL1E7oc95t+a5/iWYQQBd/QnmetPMCy7zDnj5ITNLnMVgEp0Y7YCi1U/RcVPk5Y9Loz1aAVx5t08HWWQEz2GZRdX6VhaeAPlozC7G+hUgxhWdHMUZAdLuCREn9ZEnJv/fpr5Z44w/YEal7zwKPa6zjnmOq6SHHGK2Epi4rPiDVHxMjhK0n+fTuH9bZafkeXuj42xPpHGEi71wKQYpSenMGG2WXh6gXuvG8Up6ex6/hpDXwlD32VviPGv1dn+jirLT8py+B1jDMW7rPnpwfl2ghi+EugNnyc+/25iJzxu+PDpiOcb6EOKQx8fo3pegh2/V+G0g1Wyok89SLDdqFLIt7jn6iLVSxPse/MyZ3xnmUWngKt0yn4WV+mU9I3wuuhNaoE1OK9pY516kGDaCL+Pg6AVGauBz5Kb51Z7K3U/TGtsZWDiM2PUWPaGcFW4YXSCGEtejrKXoyA75GQXW+mkRY+DTpG0sDnuDTPnjFEPLDJaP3QIRoVlP4tEccQt8EhrnSU3TyEy0D1mGR9BTtjYSmfRGWHNT7HmpynJBjnRY8UbohPEIgflc05siWZgRZtD6FxXvCFKep26n2CXuYqDpCBb5GT3/jShAR6IFEAH7gUeBywDtwLPUkod/Pfe87NyAJ8/ei67zTKH3dFBiFf2M4OceK+5TicQ3GJPM2uWcZUe7ZoBK14WS3NxK4JLH32Y1cvS3P6eKXwlsDSXepDA1Hwm9RpVP0km2vWHhc2Knx6EdAAZYeMoian5jMk2rSgKWXBGmTSq5ESfI24BR4U7lInPojvChLFBRuvzxeY5PCo192PfzVU6dT/Bls9tcPFb5ulNGRz+dIHuaIxKM83E1xts/3qFzDEbWVH4CQ3zpE9zt8XNH9yKmIRiFAUd6Jd4YmKJW/tZSnqTA/0JinoDS3NxkLTrMR71m0dJ7Xe45RNb2ZhMctnl9+CeJvnOp2dom2FuPSFbHPOGGJZt6n4CzVVc8IJFMrfaHPpEkRMPGwLCHHbeLZCpdbn4KQvIIGDxxhHMNHSVZNnL0FUxEk6fC6+6j1jN43vXbSM/1mPFyzKhNwiURkJ43NDZxcOdo+i3BcRrLs1OnFjJZe30NFYpXKdTKcB2o8Kil49y5XWagcWk3iAtAg45QxT1FmUvTU52Q0eAIiv6HHKK0To5lP0kOWEz54xR0jdYcvMkRJ8Je4PVhRyF5SZySbGtVcM2JZ4p0SyFtBR3T04gzvTJpGy6QYyE6NMNYqSFzbKXi9IBm0AJhBYwIfvc5YyQE12Smsuyn8XAH6REIXflYCuDjjIH3MJV2+/6WUzxx/A/KgTSNO2JwHsJKwIfVUr92X/0/z+rA5hbmuDO6GbOaH3WIjLQR9ANYoMQ6lReVfcT7IqdpBVYg3DurLefYOIjDW6+YRp9e0DZz+ArwS6zwiFnjJ3GGn0lqQfxwecOyy5pzeMup8isUcFWElvpJDWXebdAUvQxNI+86JIWLmU/wbCwOeKOhISXFlDxMhiaT162yYkec06RnOzio3GWuc4t9gR52aajTLb+oMruF5XxRiQLvzHMaX9Zxdzw6W+RbOxJ0MmYbP1SDREohAtKg8ZT4hx71RBqi2DBHWFC36Dmp9iqb3BXv8SkUSUtHGp+gpzo0ajFuOBpx9DXfZx9OtYtLvNfKzA/VWBYtil7WZKiT1JzGJMhiRl7V48t72+w/53jdJ9hktQ8WoHJcW+YPWaZjtKxbnc562krLD8vy9obM+zvl8jJLtNGDVtJtENw3pXHOfnLGY6+J0wBAyXIqS5jX2uT/UiX5J0OWvCT69/eZ7L+whSdJ8VYURkKsjNw7DnRox7EmdBbtAIDW+ksuXlysktBtrCVjkQNSOJhYVMLrME1yZzsYX7LZ+a7VYxbPGJV/8c+W2mg/RSTCXRo74rRPdtg7TFpGo+2WPJHGJZtuipG3U9Q1BvkRLjWp+5VHw07MCnoTQqiO7jnqn4KQ/Mo6g3KXpZWEOc5szf/l23k3+J/lRLwH+fPoqTXWfKGuchaZc5NktH6CE2REx5lP4ZJwKKXRxAMdvai3iBQgomNBrOPWGPt8hRff/se9lknWPGyA+M97g2RETbL3hB52SYtelT9FBlhD4jGup8YhGW7zFUWvSFyojv4u6n5+Gi4SscODCaNKobmk9Zc+kqy5qfoqhjDso2rJJbmYisDXwnysoMbRRn6rR7n/foSwoXG7hhLbxhi7fw0DjoXX71E+t1tbrtmEj+vMf7ZJls+1kABd79+nM5vmNRVkpzoIrSAnHCo+RbL3hCTRhVXSSb1LhsLgjMvW0H24fhrcxz+7TFm9Aa32JMYmk9S9EmIMBRO3N1n75Vlalcm+P67ZgDYbayz6scpyB7f601zcXyReXeIvW9cYeLTDW79pynMswJaQZgrF2WTehBn+9vX2fbhKj/46laWTxti7LYG+/7gBMn7XNrbTIKrDPafO8bw1i7repLSSoPY7S7Dn+6SOObSvdhk5T05bsptY9KosuCMsju2jEno0CFMWWbNNRbcEZq+xajeou4nmI3SumUvx8iRNiOfbzPxrQaZ+T4A/aKkcXGc8rYM9qSOmgJzq8/R1CgNJ8GFYoGs41NpGehzAekf9hm+s0PyLgfZUbS2mRx7Xp72U01q8RQJ0UcSkNTcQWXBVjqG5lP2M5Rkg+Pe0CDVyssOFT+NoyTTRg2JYu/Uif+2jf2vcgB3HJviuDeEqfkMy3ZIhMkWhhZQ8ZNhvo0gqXlYms/t/RLTxjplL4up+Uy/Y53T/2aVu26YID0bsOSnqPkpJvUaB/sTmJqPoflMG+tU/HQYgvkZWn6cYdkmLzscccYo6M1wAb3sILQ+9f8VP03LjzNtrLPsDZGMDMhWBlU/xd7YMhU/yYRsccAJWWM7Ii0DBDPGOnUvxtmvWSH7Dz18S8NJ69z3mTwHpyfI1Lpc+pjDVB+dYOWvhljxsjQDi61r60y/foPxbzVZvyLBwjvztGNxmoHFqGzRUSYVL8Mus8yan8JWBlOyxs5Hr5I87nLvH45w7IV5OkGMveYarahsdYe9haKoc/GV9xFUNL73tW3oQwF2YFDSm4PyWDOwyMluGAK3u5z/qCVa58X4zodmSWh9crIbcifCxq7qPP4xh1l/eAJ/m2T8w026W0wO/v443uUac/7EwPGcCqMXnFHSWpfxv2txzluXcJOSo38/wsq27CASOBUB2sqg5ceZNVexlT4oF6aFw4lelsL1HbZ/qsLIDzoEJtQfFqd9SYzFi/M0Zi18JFP6Botent3mKnNOIaoohZULE3/AL0waVZbcPEnf5szrlxn9aIvkXS79jOTu353g8LPHSEiHkl6no0xcFVYWcrJLRuuzv18a3M9hNcOjowwMzQ8rJMrkipkD/20b+5+sAjzgEJoasNFhrhWGpqcM6rg3xKI7whG3wJ39ifDm0Vzysg2BYuaL66xcmuXW0gxdJWkFFjPGOmU/M9ghCnoTiRpUFNLCJi1Dsu9AfwsXWEvhDRZYBEqw5Oap+SmKsklS80hqDobmkxV9inodR0magYWheRRkk1Zg0gritJTBdqOCpblMGlUApvUqNT/BGR9bI/sPPY6+aoRv/+N2dHx2/Noa9qLOBZ87gewq7nzlJEtejlmjiqt0tBIc/Wie46/Jkf9yl+kXbFB0mlEk4wzY8OPeEF0VkpG1b6ZIHndpnhZj5v9WmW7WyQibFT/Bkpfj+71tCC1g7EstYgc9Dv3BGF5WUvNT4XcITGoR4SW1gFZgkRB97LTJ2gtSFL7RIXXQpqQ3meuPY+DTCiwy+T73/eowozd0mPjrJuVfS/PPX54lfoWHL8Ug+ijqDc4xQ7Xh3tgKHSzWnpXm1i9OoSnF9mevs3FfkkBpUdXHH/A+M+YaVT+JofmseWm8hkB/t89jH30vF7xikdRKn+XXZfnit/fxjb89ndpvpvB2SiaNBlP6xmBXvtWeYlS2mNFrzPUnmNbbQOhkZsw1fAQXWEvMJGpsXJnkji9u4duf207zLItz/2SJS158L6WNOq2I9DtgTw6Mv+xnONdaoqA3SYo+zcAiIbyIVHQoyA4tP/7TjeH/15YekKM+wEhrHkXZYFqvYmge9SCBrXSqfopaYJEUYRjXCWLsMleZ1OvcYk9T9nKM3tnCqvgsXp5nNlam4ocCjpqfIKk5gxDMPZWLeSnudUexA2OwQ+8yT3JHf4JpPRTqTBvrTBuVQY55xC1gK4OKl+aIO0JRdsO6s+yG2gHhDkpEp/JAV+lU/DRlLxdyGof7DL2jTfnxaY6/bIj2rMWRz44SOPCrv307sU/1aDzCorEtEbLgUT38UL9EwbA5+pJRDrxznMLNbcae38Tse1T8UFwSph06s0YFS7js/cwJ7BGdhffmkR1F/z3hTt4JYiQ1h/OtY1wkTjDz3nV6u3X6v6ITIHCUpKA3I6a6SUnfoOql8JXggD0ZVgxeYOKmBLs/epJqEGefdQKpBUgUzY7F2C0tNGDjcRarb8tipT0WvSFaQTys+SvBgjPKLf2hiKwL6/NF2cTZKbnxb3ch2wGXveYQa05ykHKlRQ9Lc0NHI2wKvs0jP3OEix5zH2e87ySNHXH+5a92cOBb4yz8Vp7xscbA6VuaG4l7EmSEja2M0IkjCdAoGTUqfig2y8kOtjJwleQup0g9iHGvO4qLQXC+xvIncxx+U4Gxm1qc9UvLzNxURaJ4fPIeyl6WZT9LWvRoBSau0pnrT9BVMRbcYTJan26g4yox2BzubzwoHUAtMDGiHBtC5rwou4NSkaH5ZIRNUvRZ9jKseFmGI2Z87IYmgQHOY0PWf9kbGtRYbWVgaB77rOO4kUPZE1uhpG9Q1FvsNsu0gjgJ4VLQwzpyM1IKGpqPEd3YgiAkcIxGqE7zU4NdL6m52NHNlRPdQQjpRMzvmbElLOGy7W1VVFJj7q2j2JgUZZO56SInPjyMPOYTX/VZflp24AAn9SajssVF8fs45Iyx5qepPS3JXe8qkb+pS/4Pe4yJFq6SFGWfkr5BPYgxtdGg8C9t1p+cpL4nwcmnZ9j9mZNwAqQWDL5f/R8E8eMe+19VoqxyAEzpNezAIPcjeomSsUFRbwxeJ1NJ1q9MMv71Jtt6TW7tTZPUHBLK5uGvXiR1wKG73cBc8FnycqQjMU9BtnAibmTaWGdCb1COhFCBElSDBGnh4O/ROPSWIrk7bC66eompG6sU/r7NyEc7pG+wGV1u4n9NMHbpBtvfXKW6I8nN127l7o+PM/XEJhUydIIYaeGQEzbLXoZ6kCAhIk4muscszaUguix7IVnso2ESUJRNWoEV3hdaKPY5JdYKUxefjeclmL+2QHfIYPJ5NUZvbrLoDQ30AmEVKxtqPGSPncYaPhpCU/zA3kZHGQMR2v2NB6UDOJVDLbojSBSTeo1vdk/D0nzyokNG6zMs2wNFWdnLst2oEgQaI9d3qF8YR8vCSkTyuUpnzU/TDKyBZNRWBjnZ4WB/gqqfouInaSmDWbNMNzDIaH2WvNyAGExrLmUvjdACpiKJqaF5dIMYbiSzLckGc04xigAchBZQjLQLGWGTEH3W/DTqDo3Rb7c59qJh3LxOM7BY9nLkRJevnbmH7gWhXDV2o0dJhgZXDWIRoZQkoYURkInP4lV55n5nlNO+UMH9qCAtbL7T2xrm6qKP/kUX4YH/zLCEeezlQxDArk+vYkRqx47SKX2yQWe7if9YjaqXinLzU9GXJB9VQIqyzaF+CUPzBpLl/VduQdoKrg2NqhlYbHlng9zXe9zyumkqz0mRvM/FXPSp+SnqfhJL86n4GZKij4NkxcuS1BwKsjUgVAOlke+2Saw5eCmNzPs6nPFbZc59/RKn/8kqe35zlbMeeZJHvmQeraNY/MgQ3/vkduq7wxLiYTdP3Q/LvtUgjq0kRb0Vpi8RCStRFGQYGXQjI3SjSsLNvRmOOGOh8lN0yckuAYJZs4yvQpa/4sfpBjHu3j7B/r8v0Z022fXiNfT9wUDGveSFGpQVLw2EUue0sFl0h8mIUIT1YBICPeBwlWRC7zFrrpGNwv1dsRWWvBwOknm3EIXwCSzNZULfoBrEmT62TnzRo3pZMtRom2UMzSMteuQj8qXqpyjIDnYQet0d5iqjskUrCBey5qc42C9x0JkYePqE6LMS5b9WxOrmZZuibPLI+AIAs0YVW+lMG+vkhB3KifHJR05qxmiGZTDZZeYjVdys4NhzwlC4qDfYY64htIC9sePoiwGN7TG2f7nKxHsaFERY3+4ok7zoIaPa2XJElFZemWT5MVnOetsy8p6ApOjTVTEWvSHiN7q0d5pUTwtzzBNjedYvSzL7uTWcjqSrYhT2d8jv77Ly7Axp6bLXWmLBGWXeLTBtrANQ8eORACvGrFlmSt8YqNs29sXpThvkr+2wK7bC5Pc2OO2v11n+9Qz2b0oOXTQOQOybPgnRp6A3cZVgl3lyUC4ryiZ2ZIA7jR5tJ0biAw4Pu+gYs29bx96qo4Dlp2X48jf3cPS1I/gmeJZGf1iSXHMxPheQa4WVm4Loh/0cepOE6FPzU7hK0g0MJmWY37f8OHf0pln2hqgGSWylk5NdkqJPK7C4KDEfajoi590KLHwlWHTDDlJLc6P3hb0B/ZzOoU+M4WUEj33hYar3JsmLXqgHEH06ymRKr0XnFwrJ0rL3Y/zQ/Y0HpQMwNJ8lL4FBgNQUi+4IyUiXb2kuJX1jIK80NZ8gUmiJUzqKh2vYyuCImw8JIyS+EpFkOAzzABKRii0tHIZlm4LsUJAtLOEOZKsGPhUvDCMrXoZuEEYPaeFgK516YNLuW6zckyL+VYf8tW2Mr7tsn1sHT9FRBgGCW+0JmoFFrZFkyz9vsHJFlslci7ToIQmo+HHswCA4KrGWPQ4+Z5zlp2cp/d8mwfUKH0FBdFnyctQjAZMlHBKiT0VluevtJdy0ZOfvr9Hqh9FJrtclf1uH+qPiLHp5INTc3/bsrciGYvTaFgmtT/BZ8OIa4umCVmCSF31EJMNd8UIRUDVIMqVvUPVTDP+IZFqiyMg+Jx+bIf4DF3FScdprKrRPM1l/QxpTCxibbdLdYrDr5pMArLhDLPtZOsrE0lwWnREMLYgiM53b7hjm0U85yq53rtK4IM7Xrjmdb39pB+tPTFL8aouL3jDPae9cx77Q5Mi3x7jp1mkqr08z/o0GF/z6InrL57Abft9/VWQ2WfaGcJAc8zLU/BQ52eXZ2QPkZZsZvUY9kl5bmkvVT9EKTEzCKClQIuoB6bDXPElJD49nRGrEU1L1XtHk1o9PIZXiCa+9h/n+MIbm4aswQjwVsR7zhqK1V1Ek9cCY6oNyUJ2ludT9sNtuUm9Q0jdYjqSkrtJJiD5N32LWWOf7vRkmjSoVP8m++WUCU6MzbTKp16j4afJRBaHsZdlrnqQWWMw7o5wZW2bRy0elO0lO2JT91KAhxVGSorEeCkui0tApRdmMsU4rMOkf0TntMxXO/ocl9OZPllunE1WaF1isPL3HiccOkTO6JL/hIG3F3b9UInBhUq9zp72FPbEVTM0ndVcY8aydl0H+WkD8bpcdr13jwHUTHC6MUpQNZowaFT8+aJrxlaAzbHHsTUPMvmKdsz51grkXFJm4qY5woXlJjKJsDPLdiYsbtLbF2PblKllzExEAACAASURBVPWnx9l6wwbrj06SPubTuM/F6tucmTiB2BnQnIyFRKi+wbKXoag36Cp9IKxKij4F2cJ7tEB+VHH2HyxhVn3m/maMDTNOTtgseTlK59TJ3GaTEzaB3qCjQuMyCTg/fh/1SD5tfdXlolfdh5uWfPcvZ9Cf5GOpkFfRdoG8TpH9vs2JN+dY+40UdZXAR2P5t7LcOzvChS9e5NzfWuLOT25hxqpFzTwmaKEjn9JrdJBM6A0W3BEWXAtX6axGub3UXNLRju8qOZBJZ6LSoKH5rPqpQTq5XVYo+0l8NAqRSKk8neWeP+6x91UnOf2aMid/LWxI6kROwtJcTC1sdivKJotenmGt/YDY0oPSAdT9BHnZYdnLseRlyQibtLAx8TnuDbNV32ApyLLkZTk/vkgrMElqLt49gvaMyZwqUlIbGJrHEbcQVhSMdVb9FBN6i4PKpOxnsDSXNS8ddRbaLDoFzo8vsugOD0iZXKT570ZtpZIAw/OZ+uAGk+/bAE1j5QkZTj4qy/DpXWQCGm2T9hGLHXetkrzeYe9LT7J7bJX5Vw6TusXByUvMCxzQNFwlODO2PEg1Ju6pE1ga+Z0tHF3npvdu4/KrDlH83Rbtz5is+WnKfnYQzaSja+MqSedXYpy4JscZV6+g/SrkftglkNA91xy0syZEnwWvQO6Xu2z9wAbjn2hgrvsU/qWD/Fqb0WgNJgk1+aeXVpm/qoD+YsVkrsExb4id+jqJ1XXKixkSnoPM+zTOsPB1GPp2jxMvzHLf6SPkaVOLtPurOzOMfWkFdwPIhO24tgrbbJOaQzOwKH2ozvnvWqJ+tsW/fGAH2TGblOaw4uS44N33MfJXHQIdahcmCV5gYXsGQguwgxiuEsQf47H49iFmXl1j6hNVjr1ghLSwBzLykrGBQ5j7GwQUZJOEcIEuDhJD8wakqKW5HHeHOddaYtnLUA2SAzHPtFGLFIn2IG0pyiaukqFTMCrUr7Jof85k+p01jj9+GGvEZd4Z5eHxYxxyxsjJDSzlUg/i+EoMIq37Gw9KB3BKgZcUffKiOxC0zBrrFPUGB5zxQasnwHZjg2U/xen39qicn2LaWCdQAoliWLZDzXUQ9qSveGmmjCpp0aMeJCgZIaEXKMF2c4205g0WsRV5eQg79up+gpRvM/o7TQrXd1h5YoblN+Uo5zNhw4sWphZ50cE806P8tBzijQGdbxic8Vcn2fG69VCQck4cS3rkRJ9WYGKjUfHDxp8dByv0T9eROqRFH3+H4MCbJtj3+8u0P2BSf2mSYdkOJceyNWgYyokuaBpzvz9G6Ul1Yld7pO7t0z3NJJvwSFFl0c1hCZdh2Wb1cWmm/3KDHW9ZRwHVJyaoPDZFc8biRCzPRKsOdyu23Vhl99VlnE9L7nvpELsWy5RuqBOr+OyhPFizQAIKlIDbXjCFp3R8wkqMoyTGmaF4Z+gem+rD0uREHxuDaRlGFns+ssLsu9apPCnJ4T8vMBJrU5RdTrYSXPzKecaub1N+VhoRBOS/1OUWu4Cva5Rkm3KkDExqDp0n66Sv7TP97g1Wn5TBHQvTPxuDCX1joPBciRq/ltwYadkjLzpM6nUqfpjTH3eHyevtQefhqGxxu72VolEflFttZTAsuzQ9CwQc6Ye9B1U/iSVcbnnDNI/5lXvZ++4V5t46xq7YSVa8NLvNVY5EjUZ1PxGK2CJl4/2NByUHAAwUbU0VDt1Iij5SU2S0PjkR1t3zepuc7DLnjqA1FPGTLtndLnnRH+zqwGC3TIg+Qgvw0Vhy80gUFS8zIOAKskNL6UzpNepBnGVviEAJCrIT5t1aj8lX1ilc3+HEG7Pce/Uoy8M5fCUQhGlCQbaoBwkO9Lcw54xxWI3RuDTOwS8UOfSnowgHcrf2GPtUi7pvYmle1IrcY4exRvyYQ3sm7JDz0Vhxh+g+3aB8RZod71vj3P0nKMk2ednGJGBYtgfE0qI7THNnnOqTE8x+fI3kARt7j8Gilw3DYEKCVd/w2feWMB8PDKidl+C2P59m9ZeznNiRp7C9SbAPVn8ty9onMlx/zS58Kdj51nWmP1elf4HBwbcU+cHHt/K9z27j++/fRuXKFCIAEcDlT72H3d9axoxmOkgtQJsJ04/eohHpJUIN/rKXYfiTXWbftk7rSRZ3v3uCVNyj7OU4fiLDmc9cYfSGNnf/UZEjfzpC/eEJZFfROBhGFmU/LAvPGtVIpeiw/w0TiJ5iyyfrHPeGCRCkRY9uEKOkN8kJB4kiJ0Nm/9SgEINgwPifGVvGj+rzOdkNIyi9ybS+QS7SILhK5057SzRLQrLXWiJADEja+OkuzWclKFzTpr1u0Q1iOEpiRw1L3SCGIODm3nZ2R2Tr/Y0HpQOo+OkBY94KrME8gJpvhTVTJHnRZVrfwCRgUq+TWgtz5/WJGEteBh/BnfYUGa1PUnM54hTDHT0wmNY3mDVXcSKJ5wGniCSg7KeoBxZWpPRL/ojDmDSqjPx9m61f2eAHr9zK/t/YQiuwQoIo2ukkATU/xYTeYELf4CJrZVCqrAYpgtPC5WjuttjxxxWmX7vBkV4hZPK9DDHfw1rz6BVDo3GV4KL4Epbw2Xhbkt6ESeEVDY40h+kok6YKW5fvtKcwNZ+SXuecWBnv/yQQjsKqBtR2JKLZCRYr3hBDToftz6+iH/RYPz+BcKF2UTjwYlh2mTSqoYDFG8JRkvmVEc5743Gsmos9IxEerD0yxeqzM/QfJTEv9BFXBLgNnVN9VV5SsOdFqxT/oomFQ1JzuDs3jtJAPxlwqF9iwR3BxKd0U53z33KMjcfFueUvphiKhZ2Duw+vcPFTFkgt9PneX23n3ucVKeg2K+eEUd+WH4ZtxcveEBU/zSFnLBRn+UncrTobj0sw/ndN/H5I3kFI+oaDREKRT8XLRAx+KEN2CTmNGb1LPYiTFH3qfuLHmsw6Sg93+EisFjbz5AY9/YmosSonbDrK5PtP3YZ0FRdcdyzUDgiXmp8YVFBcpfPw+DyVKMW8v/GgdAAQLhZASUYafC9DWjh0ghgF2eJed5ROVKYre2nyvZDs66XCFsuSbLPPOk7Zz3DcGxp0i+VlB2AwiSctHCb1WiQSCg3xeFQW2mmsseIOYStJctVl5s+q1C5MEH+FG6nDdEp6M6wjRyIhgJqfwEXyrd4k1YhVToo+rcXQQhbem+fAyyaYvKbORa9YIO70Od9agjWFFoA3IZjQN0JJqTNC2c/QSMUo/0UG64TPOR9cYiba9Xcb68yYa1GFxGfBzVDZGqNxfpTLFl2a0eSivbETZN7WZ/yuJvvfO0HnTBMN6I2ZFPUGi+4wac3l3Ngy240Ks94ql75ojuxCj8MfHeW7X9vOxsVxtr2pSm/RGIic/KOCLd+oc/yyMI89/sYhas9MMPOXVfJ/0eW4N8xYoomXF4yuhVFbUTZoHY+x8+WrtGYsjrxvhHUR1slzt3fZ+cxQfnv9Z3eTeIJDQTap+RbdCRN3SJCb60VS2i6zRnXA81T9FGUvyz2/WsSoBkzfEqZ7ZS8Xdg2KHunIWadFj4TWp6N0WoHFgjuCq3T+ubc10qLoZITNtB6Jn2STbhDDEi5VP4nQgnAqkd7E0Dym9A3yohcKf7x0WC06s0djj0XqczY50aMVycUDBMOyS1GvU/WTtCLu4f7Gg9IBlGSDpObhKDnIjc6xjlOPvHA3iA2afwwtCDur6mFIWE2kyIsOd/YnsJWOrQzysk1CC+vCy16OI26BpooxpW/QDQzqQZy9ZtiuaYlQLpzUHA444wzTIndjl6kXVJFtRfI+m9PPK3PpE+Z4xIuOUPrzOsGtGnUnDEVPEXN50WF37OSgnFgPEoyuNFEarI1nuPN3J5l7wyiTN9Q566XL3NYq0aqEu4AzElI3DpJdxvogfL3rnC00nhpn9K/b1OYsKl6G79tbByOvlr0MhuZRDeJUHxnmqd0jJnvMtbAUdVhj9hMVTjw7y3cfs4N+EPIbXkey5OZpBXEWvGGORCW03Nt6ZA/a3PH+SQ49cgKla8y9cxQUXHD1IjuMNcp+lvG/a6J0OPas0AHI9YDFtw9z6GlFdl69xlnfOoGPoF/Q0U96zF6zytaX17j08sMY9QBd+mz/oyq7v7hC+ZtpLnjBIk5B8oMvTFE8q0knmhFYDxLkZI/+lE7qxL82EbnR9e0GsXAkl6Y4dN44gakx+/21aNDIOknRZ84pAoT8hHAp6U0W3ZFoyEsbQ/N4bPwYBj6OkuGmE6kTDS0gIfpktD4u/0r4SYJINBVnycthK52ylx0oQe95apH4QZf4QWcw0CYUBmVJC4eS3mQmmiZ0f+NB6QCW/Sx39rew3agOduYD/dKg025MtgmUICNs7rCnMLQAtxkajZUOd+dzYisMRxyApXl0VajYy8kuiWgKzO321mgAps4hJ00jiDGp1wedfTu/VuYRly+w60UVMgf7uCMC+6IY5cvSNLZbmOWAoQ90ePQz5rniEQcYel8HVQvz7FBqKql4mTA8lw1ETeHmJEEsDDVXnpfjzj8pMfwvPS77kzmydhjF9OPh0JCk5vDN7mm0gjhlL0sniLH/98fx4xqnv3EVNxDsMVcoRfMFLOFGTsimmgsd4vQPNqgGMY44RWb/pkIQ11h81TC7YivkTnZQAiYWG7QCiz3mSqia9NI4RyUzn6py4jlZOo8zI6Kxx0YxxfIzsuS/1GGtlsIIXErX1mlcYjG9LyxlaSdhLUhz95vHae6MMf3HVdyKQK/6ZL7TZ+/rTjL2zRayp2jss7DHdFLf7XPma0/yhOfeg2bCoU+NES+5VIMErgrVkgXZCoU3kzrWibATtOqnqEe59Y8y+PlUh87DTJLf7Q+6JE9VWha84UGp+VTvwam5AgCH3XDN9phr4eyDSDG55OVChaqXp+ql6AaxcGyYl2PeLYTyXgIMzWdPbIWD/S1khI33ZA0lIP/17mDjygibWaPKgjvCkpdDPkDPkHlQOgBX6eRkh8WoNNIKLAqyGTavRJNeAO51igzLkKmdsEMPupFIhBJdJVnwhgfHPCXGkFHuteINcUVqnppvhQw6IdNvK4npeZTeUOfsly+jmYqF5w6jAXd+cAvfeOdO7ntrnsUPDfOdr2xn/x0lfvjeLfT2Gpz2nioPv3iR0rvqVNtxLM0f6N19NKyehxsPR0ANyzYJ0efQMyc49rIh8n/XYfjz4Xl4MTkogz48fh8J0Wd37CR52cYeMTj8mjFGbu6w5yvhgMuyn6DiZSjKTrRTWkz0w+4683aXdjnG2Rwn81Wbk7+cYT2TRqJIHPFws4LYPR7nWMeZd8MhIXtiK2Q+0UfpcNNLtjMp21F4HTLkzlMMNBd2fW+V029dJbbqc+yqYfbro7gJgVbRqAcJhuJd5l5fJH7S45LHHyW25uPmBHd+YAKtH1B+fJo7rpnk5r+d4fCHR/HiGoGlIWqK0h82MTr+QMa9y4wmKAcmtbEksTWPbhBWhnxEODwmKonui60gCFjbmyIx7+I6YiAzTor+oAEpL9vkRZei3uBOeyvbjbVwYlM0jehme+tgGEpW9CP5d+gMMtJmQm9gRX0jU3otTCH9zIDgTEbvSQx5OLM65v5QOr4ntoKDpBrEmNRrodLU2+wGHGBYtgcs6ymd9ikd9k6jGk1R7TEVtcgW9Qa5XhgG59Lh0I6DTjESEtUYFiERdQoZYVOQTe7oD4flvUhSbGg+KMXkqxps/eQGCy/K8+1/mmWk0cXNC9pnxwb/1wriFGSL262teFcJvvqhM7jhq7tYfHyerR/Y4OLH34d3vWDKqIWEk5/G7wpkPGBMOgRKYEZTYo+/OsfSFTlGrwl30IYZZzGaMlTxk5S9LN0gFI1IFPufXqJ1Voxdf7bK0vpwmAvLLotujrQI89tmN0wnRADj1zVJHHYw2gGVS1IECJK+TXLRwd5ikLnXphDJUZfcPHPOOKd9Y43uJTH8gsYBJ1QHuFFXoLZX4JsawX5IfaWPl9Q4fMkYk3qdIK6RdnoDQ8vpHZQGoqdonRujN26y5bMNgrjgh2/ewqJXYPSeJjufu4Y7Irn5hq388C1bKH6nydaX1MgFHaaN9XAMe9S8YyY9RE9hBzoL3jB50aPuh4IgQwso+wnysk11OoXmQWGlTdkPp0GfGg23O3YSQ/NxELhKMm1WqAbJKOwPc/WkODUu3GPJyw4m/iZEnxljnRUvy5KbH8xJaAUWRb3OvJvHVjq7zMhpK52TezOk99vYgU49iLPihvxJ1Q/lwgnxnzyQ9r+JB6UOoBuEM9wRDCb1nFq8I244u67sJ9iqb7Dip7EDg1VpkaPF4dY4haEWpuYPFqnih63DlnAGE31OjWJ2owUv+1km9RqjH2oycW2D/a+aoPsKA8/TiH/b4cQjh6iqNNP6OvXI+G2lMxkNLp01V1maHSa4WueOX9/Czjeuct5vHmflRWm+9codnJk6ieW5YMAd/dFICRZ2xR1xxnDfqpO/pU1izUOrhQTVqGyz7GfZF1thwR0O1WeBwXRsndvePMklTz7KpR87xMprc9iEgzvmnAJ52Ub1NAIJnW0m4//c4HgmjIacnaERb5xIoPnQnTTIHOhT25BMDvf5h8tO44KNOeINjw+Jx/LFK85B64fOU5kGWtdGJSw+Evsw7knJ0J0Nyhdm0C3FipfldOskfk9Q9VJcdGKB7S+u4mQlRiegFzdI1fpkD9oc/aMR4uMu21bW2PPCk5CGY3+Xpzseo/KsDAWzzZbX1Wn8dZvay8K5BefEVmgFcTqx0LmdrdrcqNKU/dCpjYo25ajhxtR8Rk4LCd/xLzdJVfsMH+6SPmojegqBwhsTbJyewLlE59bLt5JPtQfPIagHMbYbFQ70S0gCzrFO0A10lv2wCiH51+rQqecI5GV7MAREoiIdSpeKn8Q5U2JeE2CtuPhbxGCISVL0WfSGkCj2PQC29KCMALbqG8y7o+REj4ywmdBbg5l7pWi22rCwWfCGqXgZcrKLSIUM/Pn+InU/QSLq5ivI8L0FvRn2+xPO67MDM6rxh+PAql4K97hk8t0Nar8U57YXb6Xip0lV+hi1AHF22NlX8dMDzXoymgB0R28aHw1HSZb9FGvnp/nmF2c59pwhJv6mxeXPOUSvIvAsAX0GstJwKkzIwNfjSU78n7AN95wPL7HdCCfV5EWHbhD68ZK+wfaI8U/tc6g9KcHYx1p0KgZJEX7fP/3T5/LWxz2ZvBY+yOP4xcNkb7XpV0PCbzWV5YhTZHo9rCL0p8JjaysB9UBwWX0/T2qETRWVBmiOizJ0gmz0IAvTCJ+I7EDnxjixEz437j+LggyZ8MDSiPU9tmpVii9v4MQkh182inAVohFgrXrYk5KvP30PCbvPw377OGbb57oPnMHSeG4wuvzLV+6lfFmarVfX0Gs+Bb1JIwgfoGJYYYh9RyM9CLMNzcNHi3okXGr3JUh9LKwkjb+7yczn1pF2wNpj0iw9Y4hjzximc5pJ9o4eU6/Z4EmPvJvRj7WoesnBbj7vFkiLHudYJ1h0c5T9TMgRaeFGUpKNwQTqU9OKW0GcaT0SnyljMMswOCtM8vP7OxSjZqSi7IZybj8+mHJ0f+NBGQG0lBE9IEJj3hllrj/ObKzMtKzSCkIypxXEMfCZjIjCZWuIWdZptUKDOqXlPvXkHYOwKzCIxk2fmszSUWYYEos+296zjtJg6Y+H2BUrh91kC+Fi1bfHo7kETZb9LFU/RSdqTrooMY+rBNPG+mDW32iizcE3TXDsnDyP+IN5Tn/6Ks4ZOkFXGzzQIhwYGT7woigbtHaFJFb25j7L3w5YOHuUmdQ6gdLCGrMZMtAOgrKfYe1laS7/8iEqTywwl5ok12+Rb+6HoRy2pSM8CC4C+XHFTDUUmpTcDQKpEVsLjcjZHj0MZcUiu9sB3+fUYx5UKgFe2EGgNTqoZByrscFTuneRd5p0rVBctBYkOFMLh6AErsb/Y++9oySv6rz/1/2m+lbs6qqujtMzPaGZDEMeEBBBJIiCYARzXAwYHt01rK6rGHcNmFdlEcWALroiKCBRch4YJvaEnu7pWF3VlcM33d8f99s1+jy/3/O4v4PnPJyz95w+3VPTXelb93M/4R3qRoQVNxZI7Wyz49v9FLQkMEN8wUFvSJ753AAbE4cZfm+Z2LMO274/hNgoQ6UfHV+a9JpVdnxwgLNv34t9g8fcO01cofopRks99654g0UR7xiHmCKAWcnar8yR+U2jo8S/9/Ic2z62jDWJBSoyQlprUQps9sse0qJB9yNN0t9qsuGf5+j5U52Hrl7JUHIxVISKcsBVhB4kTHtdaAS40mCZ4THfVozKdZEZxWo0Skx6MWJauyMl1wgiPDq8knXM03u4xiHZTdFPANWwYdzuNCCf6/W8zADG3R4qgU1ceBxvH+o42pSCKHWppLZWmcWOoUcrMLGSKoIONatUApukcKkGigWX06sMhg0gR+poBCEn3AzFKSqsq0/T97sqE6/r5mBvT0c/IH5Ypb/6iKRPr4VCFa1QEKNKXDhqg/opXKnzWHNVKKVlqxLlwi7u+dEokQWf5J0tzJqPKTziwmW3M0CAxn63VwmgpNTlcrIaw58scbqxmydby9nr9nYYaRnd5T2fvZJvv+AMvvWWM7k7sZ6XLTzO2fltXJR/FNYsR6bi/GrxeADmNyUJdBB5tR2sA57Syi+qjV8YVid7fMFRTVNN67i89Pg1MA3cgTRBVxypC6xMjDdUHsGWHnqgNuKzF6wMeylRjFZAOtag/9+qlI62yZ8fJ9kI1YYLHn5UsPu8ftZcvcDAHyrs+1gP5RdHO7Lqo2YZVxoMG0XWbaqwuCnK0J2l0ILNxxYeelO9ln1ar6J2SxNbOnAtHHvOFN2/bXDg8iyP/G6FunarAlJRJRvfCCKUAptpt5uCn2DM7Wdha5zyTxMc+nQ3uXtrnP6BfSSDdigCow6OpR6SRkCAxryX4mknhS4C+vVyWM8nKAWKxNaSJsuNReX+4/SyJj1HYMBcIcWkm1Vwbj/ZEbcZtY7Aqp/L9bwMAFb4pux2+igEMXJ6nSFjkT69puCZRoltbSWvHYTzXCupmijTlSTrrDyTXhfzXjIc32SY9Lo6GnRZvd4Zz+X9FPudXuJ/cNA8mHpFOpSIUg5Aoqq2g+iCfKBQda7UGdTbjLsZcnpT6QNodUpBjA2RKdVMBAVd1lr4Jwl236AaaWY9YGhikR3OIDqBkt0Km3vtXrUpF8+OkTzoYP9YbdZevcp1l57Lly56NVe88HJ67zwMPd3IbJqfDpyJKX2WOwXQBFqxiqjUifxeXfqU3qK2JoK14BEYIP+kqQBVV9lGPBOKi7Q9BZ0O3Yo8NNZXJwgSNno97AHoOqJ1pFkV9dTf/uN5/wGoKYreDHBrOrFxl8Ib4hSDJJn9daQOugOVTRGO++Mhln2jzMSr0ux/aw8p0Q5Hcl1Me0rqPSY8xrwEiyfEiO1wMKXPtKu0IDPtBr4t6DVqjDm9JBeabLp8li2fPkxhc5xtty2j/M8xzGyYyZhQCmLsdxX7c9SodWy/lngjh/wuCm9OcPAzGTJ3NVl+dYlGEPkLwJgugg7a7yT7IH4IE1esvgYbrFniwmHELOGGGJZ6yCZ1hIGf0uhvlJV+Y5g9Fv2E8pEMx5HP9XpeBoBRM086TOuyWoMxpxdNKFcfF51qoNL8ljTV6Y9POa7GKMlai2kvSd5PcZQ1F3rJqa70rNfVYYeBqts0AobMRbrualEftvA2q7QclAGHrKnabZ/V0xHl0JHK+EFvUA2Ul1wlsDHxsYSvbLX8RAeeGhcOh9d2U7hCnbYb3zrL6uYsGb1Gv1Fm1FTilIVYAi8uaEQtpk7uYv335+hy6nz5vItBA21hEalrBOkEotGCIGDWi/LH7DEMOovqRPY8ZDJG0QrJJTOC6nobe69P7YwI62+axWh5DPsKSmt3q2AlWqqxhRAgBA1hclLzIPFKBeH6iEYbfbGK5ahNP2l2k/PVqNELO+lZv45ekxhFdZ+zZ6XI6RWy9zQIkup9bG/UWf2xBRaOj/OeJ95CC4sJr/svDDdTodeCToC7TMNoSvYsqKlOv1GiK+/i5JQo6Pqnpzj2wilS21ps/+IAd167lvqIxcPNVbiNEAIcV2SerF4jozc44MXoN0oMGYudYF3wE4x7WaYuT5O/OE76e3Xih1odpedqYDHldtMb9qOW/CTyvpocjHtdVEOlqWr4+YmFYrXrrBmlJZGy8Mpah2C2pG8x5Sq+wt9iPS8DwKyfIBKmX/OhgcIS6qsVKKKMUuX10ERATHPRBiRSAzGuzD2zeo1xtwdHKjZYNYh2gEXKiqlOzqgAMKhX6d7ZwD1OJ6U5rIvMEBcedWlQaUWRGqywVdNsaaa/Ljw5nJD8oYeIxExILllSCl6qTwM0xo9XnXhzwmfTe+dIySbbW8PsDCGoo+YCXr9Odq7Bs+8bxMr7LPtZCYRgpDnPp2q3s7I5D4CMRlQQaLX5efJEBJKE3wJNQ1Tq5E0VAFJzTUobo1hzPjOvTmLmA0avncdvqw1Zi6s6PuY4VIMo6OojU9VsYtLlZY1nEJU6Mmoh41EurSh5951WP0Z4Ojro+AgmDmcQEiJNn+aAyVBvE+NRSdfOFiLUS0jd7SAFYEq+OvUztm1dwb+95BzyoVZfn14jo7cYMkqK4m2onko2qLE1epCk5uAcljQHDbybdDa8bh6isPc3vYy9so8To0pbf5U1j6irx3SjypGnGkSZ9rrUJAjl4lMNbDJBkxV7Flhz7xwjv11EHqvKoM1fmaYS2BT8BDHNZchcDLH+XqcPNWwoGPhUmJ20QtQiKPxKPogxaCjfSpkSxCqOghRLgymvW5mCRg90hEue6/W8bAImtRaHQvOOljTpDa2TNluzlAKLHe1BtrWWM2Ip0cWiHyMdbdIaNMhM1Ok3yuR9pd83YpaY9ePoBEx5qmabKFwTWwAAIABJREFUdpVxRkZr8aSXJln2iEz7zKy3MUXAhKukunQCTknuQwQw1egiG1OGHlNed4cRtsQJAEJ1lxhayAY7MTLFmNuNi1IjYqV6ffMXJOj/XY3ubzbJva/SsSmf8xP0rioTHXNxTtEpbbVZ/sNFPnv/z/jVC07mlOoYv7E2olUa4HogBDIeZT6wWdATZPw6RtLGDQQLofiHNe1jHBVu1KzJ1HldrP3mPPVXqhNstqXGZmgoG7Swrm8bFg/EjuKy+ft5cMVqJhsWp81t46LKNgAakQSoKRs136Zfb2DMh+WDp+H16OxrpDjhsxP4CYFeU88hdshlx1f72PihOXpo0N/dBM/nxktOB9dj/Q2HeFl6W8cevaeksgw/CZNemkGjjDXtI/olWz9wkMXjouy/JgtdGjlZYYfTS0prKcRnXpUu45kMEZTx6k6nj5xeoT2paMOb7p4hut1Fb/+vgi6ZW5q8eM9uFl8epfLWGHbcDcE+cXa3B9lsT+JLxTo9PTpOPogw6WbRhMSVBquMIvc112CLQ9iai28JDCfo2JwNmosd6vCSWMtzvZ6XGcBSJNUIOiSgtN7gsdawEvLQXNJ6oyO2mdPr1KVJe6VB13ibdIjnX23mKfp2x3izNwQYDZqLHWWXUWuWvZMKcdhcZrLD6VfNG00JjxrheNGr6CHYRCOr1zBDRV2dgHkvyQpD1fWzXldHb3BPaP2c1hqU/DgHsz24GQ0ZFUxenGbdN+boebDKAbcnpDk3KayNEz/osNHP03ibTXTWo3a7TZBW5YNMJ5CGjrQtdVqbBtLQmTaVseULGmOIZptyYFGKRkmMtdnRozT56ocj7P5cH86wQfxG1ZjTS+r1zVkK6KKWAAnfzp1NU7P4zOFf8arCI3yscgd7I30AJGWrc70cDLa1B9Emwk0UA833OeGfJkk/26LWZ+F2qY/iofO6aVxkHbnYfqBeixCgaex+1XK+fMElSirM7YEdgvYKHT+ilKCmy0kiMx7JJx2Kp8d46rplVJMxpjw1Qs3qNTQRsL01THBIPWb/SmXksq01wPL7Cqx93TwvPmMvG/9lFs2RzL8+wbavD/LMbwbZf0+Oh+4YYe/HezpvxfBXy6x+YZ7e31UZc/pDqnmTop9Q3Amnnz1uVjFTzQItqcRF7muuYcgsUg0U2jRS83CTyhQmprV5sjmCLgIm3Swmf2lR9lyt52UAWGfNERNtVpuLbIxMUQ1n9spAQllKL430fASFIEpaa1MfiaAfCNjZVg23JRRXNlR0nfVT6EgslNuPJgIOOL2saKr0PkgK1llzzPsJYiHho5JUzbKjavPKsjzk/ef9uFKb9RPoQvJ0e4hRa1ap6WpuKFZa7ugH5owK/WaF6voI8Z0OE59L01xtctJHJ1jRWmC308+8nyCywUME0N4Lsy9K0Ooz2HzDNOv/fh8AolBBuB7C9ZBmOMNvO5TMJK7QeNn0Q6CpzTQue7B2+LQGVM2ZnmkylKuy//oevLT6aBz9L1Pq/2IKRoyUgARNUNQT/CBzBjmvxtuKf2JftJ/PrXwlAHGn2blePXoVW3MY2VPAjwjq/RapfW3Sv2hy4G0ZUgfb6I0AqcHil2N8/E3vOHKxDR3h+SAEotlG6hoEAZ8771X8/ILT6X+wQuHkOKbwGDVqrP3RPEJC+egIj35vBW3b6szQ7VDMBeDU6AGGpsv4luCh1AirHlzgvEt3ccJbJkmOt9j+wQHuvnuUJ347zNMfX4Z7sUH0+ICdw300V1nU32zjm4L5FyUZuzlHe7nB2ivznPzvB5TzUmSGY6xZ0lqD06OH0AiY8ruY9bp4sjnS6VfEhUKhzvtJjEpANWEz7mboN8qMWAvsbg+yJXK443XxXK/nZQA44PYwHEphVwI79GZvqrpLio5GWyswWRVq14+5OdordYxawJpynlkvTTWwmfC6mfcT5PRKx4111u/qADdOjU6SL6sO7Gy0i+3tIRoywohZIqvVaS4PFYEOidD4Ues4w2pCiZKus2Y40Z7sWJO5Ume3M8ABtyeEnqrontZa1DZFSOxtk5cp7r7qKMwZn+4vN1hnKdzBk6PLARBPSTQTdl3aT/ZPdU5qKfXhoLcbGbHwc12IRgsRquAiBDXNZqM7y4hVBSnZH+0nvschGW/hJTQy+TrTXpJDvVke/oDy/eu7TZ36uWtrLP+XIi+u7sSWHlm3yncO/jsfyd+Kg0ZFjzLanOGdE7cBYPouXpi2xoTLsFEi8rSHm9XJ3tVAc2D323spbIojAhAulDZFaSQtzMUjwUO0lDSaqNSRiSh+NgFhYDuzuB2r7vPNRy+kHkRYeFCw8mqlnrvt68uQlsYKQ83r11n5jkOQhU8xsNHGAtrLDM7/yE42vmEWu+TyzOcH2XtfH9UrbcrDaowchNqKeT/KiLHIvJ/ksJ6msc4i8Wyb3ev72H1DL8ULoxz1xTybbz6sxGSCCFNeN3c1VnUIZEsbeWmStSSvriPRqwGpdJtRc4FqYPPSWJl1kemORPnfYj0vA4AjdVy0juvrUn0UFw5jbja0VnJZZc0z7Stb6BMisxRXqDS5vU+n3yiR1ZRTz7BRxkdjUC9SO2ATvdtl1Q0LDP64ROvnAd3PqE007BbZEjnMsFFk3E1TCmKUl6sMIDioMe7mOhbl06Fa0KhZUB73foLjIvNk9BrDRoWcUelwGra1B6kGttIJ2KqjOdD3ZIXlp5QovCnOyp8U0Z5Ugh69q8s0+w0SDzlMemmaFxkICYnHVcotAoloO2glBczBMvEzquFXExYtYfCy+ccRns/e+BBGOyCxo4UX1/AaqhfhSB19pQpKe9+qnHsjjsfg949QUpN+k5pm8+2Bc3nD5g/yxu7L+VXXiRzfHAfgmNZkp9m14n1Fhi8s0vVYC3vao70iRC6mG6y+eaGDK5g7K8lVExfCwmLncWTERBo6QSYJgURfVNJmEafF66qPcsDK8ZQ5xC9ffiZr363YjE6PjlypbMLaUmfWSzPtKdn2op9Q+n54pB5tYU+45G6vMfehJPfcNkr7MoO99GEKvzMZWEIS2sJjKrQjT2otqiM2scMuG8wFdslBnvjaMNXjLdb/0yzetNpaWyLTnGyPKwl5qeFKIzSxPeJZsdvpJ0kDoxZQiMdCReAWc36z4zr036rAf7biWrujlLukupPRXaY9g7yXYpU1z4ON1Wy2J5WMV2CpsdwmtZGT29q4JxsUghgtaTI/HWPzj2aI39pm66GJ/8/HXfPmAvnj4tRfbBE5x6W2wma+O4Gb0sjtrzIUWoUt6QW0pMlsmEnkvZRypTUXlBw5PgecXnKGstTK6U3e+JEP0//IIW40vkn0Po/9p2YpfijK1lsOMvC5Kk/cMEzGqJM/OUnv/VVsHJxRnfYqg/Rj6tQUzTb+QBKt3EDaJqLmo7VdaLaQmsY9XZt4UXEH/zZwDk97/UgBow/kkVFItB2ldqS1KfaGNmKLqpP3wE9WYfb5fPf0F/IP1TtIyRZ/v/xyhOvh23H0pM+1kbP5Q+8J/Gjsu9S1CKmgiQDMhQAxCAIY/1A3B96bY92b58j9e5VYLUDqoPkwf2KK4J0xdOtIBoCmIVyPIGkjgkCd/p7PW+oPMeiW8RDohuDjh36DEXj4EZ38qYkOXySpuWyJHGY83FSDxiJ+UzD89yXMWkBt2GLHj/tpjlgEgcrGkmE2WQjiHWj4mNPPiLmg/BSlq7r2XRKj6vO008/GyDQ+gh1fGeCkcw4x9P0SB/6ph6Kv4aA8KmKiHcqS1bFDgdFsqN842p5BSJCpJbKbzyFPUZ3r0uqULs/1el5mAEsMv0kv03ljtrV7QzVcleJtsSfw0UKYbFppuWcTtFYaLH9CSWDbgcPR357i9LP2k7mmTmvEZN9ne3jihmEeum8FP3ngJO69dzW7vqd6BuWtEcxSwKrPFTn6zBk2vWqagd9XyG+Ok3hSIQf3ur2d9D+j1xT6y48R19osNxaZ9Lqo+krC7GR7nFZgMVPr4p+3XkjmiWlaeoRnYyMMPaBOwWbc5ND7M/Q9UWXDn2aVxfepMeyCx7LdZVwMFs6J07UzbLp5Pvp0gSAZU1MAXVNptB0BCfcaq4lKl+PL+yibCfZ0LSN2rwO2UIy8UEZc6w+URNeE+r5mqEzFiFLK9dMwbIQfIPwAaZnoCxVotRH1JiEviAkrSz0R4Y8H1vLw+Ar2vrAPKeDRV6/EkToHP5LBKAXoDtQGTQJLYB3nIjwfb+gITRspodVGX6ggHBf8gJe1nuHi+UfZbQ8gheCN+fvYVJ9k7r1dREo+1TOUYeyEl+Gx1jD3NdZg4isT16kMx7xqmqHfqRHv+NXddK1WilKDRvnPskmvo/jTkiYxrc1UaBS6RBn34noHuZkM2Xql4RjzFyQZ/I8Kds1lNiQHpbUGw39mmbZkEuNLBVSLHlB9iugqvwMwKoSO1Ut//7dYz8sAAMo/PSaUQcXSqTtoLJLTKyQ1h0IQV8gwL8s6ay5E6BmUT7QxHneJNBw2vXuWVV8rMH1mmt/fuomnfzTEvsty2Ft9akM22f46i0NxmmdbSAOKm+I8/PuV3HHvUYx/LIM+H3Dy+w/R93SNxB6HZZWiEiRFEoS1fa9epd8oM2iUiYRIw3RoFlqVJlftuoDdZw5y/fQPWRZUCGI2j4shcjvr9E5VCdCYelWa5ohB35cqHGh3o71YYRoiv3dJa03ypyrBTYDD70yBZaLVW4img4xaahN5isr8jDVEWY9yWnU3Utd4kiGST7aRbUldVx90S/g0TJvmCpPYuEtrtcGTcoCk1kKUax0wEG0H4fnIiIXMdBFkksiICsiuZhB3lBtxyY+x/oEZihtjdPfWFahllcSPhD2CvEftRJO3/ej9SNNAL/yZBr7rgWUSpBMYpsY78nfxnvHfc3/iKJ42BxESXrnwMLte1U8jPAzaZ5hsbw3TCCKKmmvN029UGT6wyMtf/Qz2AZf8KXGcbp0dG4aY9hRpaNrrYtrrohpE2e9mO07Dw0aJXr3KOmsmDBJKP0A6AhkRDBslDriZ0HOxwtOvWoZRC/D/pHcakJXAZtLrUo5VITW56CeIa202R6Zo7VSTj8JRNpoI2O9mGTGLHb5K/b81AY+sgpdgykujh022nF4PHVsUys5HdIhAtnDZ4fSTWbJ0OsHGWgxY+XdF0n9ssv9TWXZ+q5/K8mjnpC6Hwg79oZafb2o4K3RiB1w0AuSwYPZdSa7/w1Z2X5Oj1hdBAEe9NE/0LnUSmMJjZ3uAljSZ9ropBTaPtZYrwQypU/ASfPqCyxj4sGpyAUhdQ6s3uaf/WAByv6uS06t02032vLeP6B6PZQ8sciidYXZrit5batQDk9jxXqeO/tD6P4KudxplYk6dIGqMJvDtCA8nRzm5cQBT+tyV3oQIwCwG1CKK5TbhZug3SpQ3RDGLPqWNUTJ6TenSRSyE95fMNNFqIzVNwYC10LBVM9AciXQER0/l6Xqyxfz5SapBFB9B/7erGE31rI2WxNwXcMkvHkGr/U8nXcREt3RetPgs35n4EZcWHuWm5BY+P3IpQlcCLm6/TuUTFv03VSlsiVPNRRiNzLIlMslqs4AlfLq2txi5tIBsC+67fhXpvU1KZ0QZtZU1+5IIZ0avEdfapLRWx9A1qfmhEGpaiYaGG7hZMXESCnlqC5dZP8J+N0vzWJPAgsxTdWzhkg5xBwoqnGazNU/eT6ERkNbaFP0YI/sL+FFBc0j5Xqp+RayjQfDfSMA/W6dGDyhap1CCljHhd9x/lqDBAVpHcHPJWz2tNRg7VqXzufsa7P1IjqffOIytucS0Nlm9RjpM9Sx85v1EaFBhUFgVJ7lHocWyWoO8nyQXqVI6O8bYzT34ETBrPi98xz5WfKBAqqxop47UlVuPUWO1Nd/RGvjpG89HlKpqo4boOq3aACnJVyQ7o0PwQ8VgKwU27ZfrtHoNeq9RNfn8SxMkxh36n61xONZFe1h1igMpkIYObUfRcntCQwldAwnCD7g/tY643+bYyn4OmxnKx9rotYBkvEm/XuPoyBRJzYERieZDe7WBFc6hg4SN1MKPjWmoExpAFxAEiKaqARpCnWiZhTr80kFqULk0Qk6vsKy0yIprizRXGPi2QAqQQvDZQzfwk+lr+NjErzvX+u+mbueGfd/go4d+g/R8/rH/Er4zfD6y3GCtM4cAHv3nFQRTguTeNouX2B2ZuEIQY3t7kMzuOoOXL+IldLbdOISNj1kIWDgzTkVGmPWVBJdGQFK4ynpc6p3rN+srbwBL+IwYZUbMolL9rVSgC3a0l5HT6zQCpSPZG6tSWWszsmcx/KzEO7DeU+1DuKiJUa9eoxRE0ESAscenMWrSEpZqOuJ3nIZd9I4I7nO9npcBIAi59ZNulpTWIh8s2VOVOxztJcJORm+w2Z6kFI4LrSEFNXWyGgffoVhXKdFmxCyy3+nFlVqnCaSMR5RBSPm4KIlxh6HFIvMhMSOj1yj5MSbMHg6f1U1gwcyVSXpurrP+xXOM3L9AS5p0aW2KgYJ2xrU215z1Ik6beIqc4SA1rTOvR9eQlonMprkrtpbR0gze42qsuZ8+am+y6b+vwtqD86Qv9vBiguSPVL/BXaECQExzeOcttyGabbVBQ74+mqZ6AqbB034PdS3Cqd44wvP5zblb0HxolizG3BzjXpZprwsRfjpqRiTsnPtqg2uaYgUauurSx6MIL1CPKdVJmu9Tgae1z6D3VzVKZ9jUe5UjcfKHbfSWxMnoCB8WXhDnNca7+MLQRTwbW8ZKufgX1/teew2fGHwl79z8Pp6IjiDaLomsxfrGYaSAxLkOq39TQBow91JlAOJKnZxe56iJGTa8YQYZFRRu6GJ2qItVNy3gW4JnTl9GSrRJhvZwvXqNQ143ZphZNoII1SCKFdJ7k1qTqfDau1LHOuBTWxHBEh6TXpqCn2Cv20slsPFyOn4Rlhleh1gEMOaq98WROoUQcmwLF3uPR3ut2TGzWcqUFBmsSkr8dwDorLwfx0VnJERMDerKWdUUdFx+gU7qnfeTYSrXZOSmIkKC5kCKFlmtSUZXaftyU23uJUXXvJ/qGIXWtqoaLPGwYgvaQvnRFcMPROklUcwFSe00myd/O0w7a3DsWw6z5TuT7GnnKAU2vXqVz7/4ErqCJv80858c05wAQ+sw7KRpKBBPrcEdfcdT1yxqr1MnqSN1Hrx0JYEO1q89JmIJpi/tov/mCu15A31AXcq46zJsFAm6U+p+TUOl/82W6gWUq7iWzcPJUU5d3I0wNO67UWnN5LbXyGllVpkLZPQazkGF5u+ZVJ3qDhjFV6QiAExDzeiFQKbiEDbR1p1/EIBlvylhzAUsvF1BirfPD7DiJ0Xmz09gTflorqTyehvPMPmTHOaLuZfyjqOuAOC6gTM5b91H+cbKi3kisxZRqqmgU6ny+gN3YAo1QSiUo3Tf0GDuJUkOJY/g7efmE2x86ywI2PuzHH/qXUmPXyXz2walc6Ks7smHOo+qd1CREUp+rCMimtOrmMIjEmo3AqHYh81cM0l03KG5xuy4S2X1WseM1ktrmCWfu5qDKgsNbKa8bnr1GuNuOtR4UAdIfMbBXvCYGO0mZ1TU/xkltkSmFaNVah1y0XO9npcBYMnqykFn3O1hp9NNyY+z3ekJ1XhM5ePm28x6XQwbpY4LUPw2l3ZOx6gGpB9r4koNWwgOhBoDS1JgS2QixSi0OLQui58UpO5rdUQ94lqbUWuOim9Te4mFm9BI/LzFvqN6eeLXw+y/sIeRry7ygnfvJ9Nq8JWzLuClpadYEYQnnGWgVRpqvAWIWgNpGsiYTbstuS25mdOcg1x90aUcZc0R7XWonGrTf3MFXwoW3hRHdyTHXD/FeFadHJWZCC1pcNXvfqyAQC0HaZudQCAHepARi8e6R0kFLVbkD5JbnAMUDr/3fuXXV27YDNxfxh3Q6L63ybCuxDWF4yL8AAy9QyyS8Sii1VagozAwdGcb+FFB3+1VisfHePjElex1+jnhZ4cwawHiygiRRQ8/Jnjvt96FtCOqd9FqsySBK1queu6u9xeZTG/E42XNpyiui4GAoV+WMasBu94+0CFwlVs2J773ENasz33fHeXwigwxrY13h4G5GDB/iToUZv1Ux5V3CfylbM4VtbtXr9KW6rCxhUdGcyj6CXr219B8JaG2hDx1pB42oqt4gUagCY6PTOFKHUfqZPUa+91cKAyqyGRxrU3sPlU2tU8zlOORmyHvpygFqhxIag6DRvVvspeelwHA1lxyepOxdj9ZvcaQUSGr1xTIgqBDtlkXKuXubA8orXZPJ/tYnfwLE/i2IHNrg7o0eTK0aG6Ezb9GEGHeT3bcf/qNEgmrxdSL0gz+scyyoBGmaApqPGIt0IhGKLwiRu8tNZKlJtlEk11f62PHJ/vpvauGfowkEZG8t3AnR1fH1QtptvG74khLnUAyEUPUm0hdJ4jZ/C5xNALJ6w7/iSdaIwAsviyGPeGRfabO1Mpu8hfGyV1TQ7NCrHhFpY+zfupII9ALlkR80Mp1KJbZFSgs+6ZIhRW1aQCcZRpD/1hhsR4jcauLWQ7Ye0EvkWmfvkfrqg+gaarTL0HaJn5vdwdajGkQhKAjw5C0MwZGQzLxoTRZo86L5B5WXFtk9qwkk2XlOlTbYEG9pe7DMgl6utXzBWTEQCvVOsEGgCDgQrEHAqgfb4GENdcuMHtikoXNiY6c1vFfmCDzSJMDX84gjpfh/L3B5p9MUe+zeGLrcnwEq4wiFRnp1NjDZoF+oxragSlk6F63F4uAurQYc7uVNuTDakOWT1QWcTqSuNbGCqdS0YqLn9LY73ZjC49qEFVsSmDEzDPlK+k1VxrE73Fo9RnIdbDOmglLV9V01YUiqe12cs/lFuqs/2MAEEIMCyHuFkLsEkLsEEK8P7w9I4T4oxBiLPzeHd4uhBDfEELsE0I8I4Q47rl+0rNeF4+1ljMamcUUPvc11jDldVPwEuihqouOZNztYdQssy5UUzFnfcxawPSWLqZP7yJ7a51+UWeTVSCptVhnzRJIRQNdmiYA5P0UI2aJxkUGVinAvM8hrTUo+omOAEg9iDD5um50R7L6PxZCZiFMvrmbbd8cYk0wzxcP/vQvX4jvq9NfhrvT0MMRXhNp6szKOH/oOY4LCk/yxEXrMYXPzrMUeCdyj6orZz6cQjgw8JA6+ZLtVseHcM9VGXA9VZsLVFMQoDvFnNVFXkuwsTHJRrOMM6Tz+BeWk5hoc+w3J1n9ywXqwxbuhzTchAa/kOr9kBICCUGANr+IPltQtGMRNh/Dx3BmNKLTLlJA9WhbjWt/4hEp+Ry8IsOaf8kjgV9ppxKkYkhdBykR4WkPIByvs/GF6yECSTQiuXTxAaYuSEMKCBSjcc97+sJrFSd3Z5XlPykx+bY0pYvjJLWW4ng87ZF9uMHVJ72En7z23FAMpotAKhGUtK6MOmZD1GA9hHQvN4pMeN3oKG5INbDJPtigsdKka5nLkLEY2oqlOpwNvRhQ74qo+5FWZyKV1JpKxVproBPQ8gwyDzSYOy1JRUY7NndxoejX/boqCZYYpc/1+msyAA/4H1LK9cBW4D1CiA3AR4E7pZSjwJ3hvwHOB0bDr3cC332un7TyuVNpdMmPsTV6gBPtCfrNktJZD/X81llz3NMYoRDEqMgIrQVVT/tZnelz05jzAdXHDYqBEcp5H2Hw5fQqWU0xCh2pM+ZmqZ1u43VpWDe2yegNpULs9FEPu7+ldTEKp8RYdU0Bu6Uu9ohZYvH8ODv/vZ9e1CZdYnb5uS6koSHqR5BvQTxKEI+iFysE2TQ/S56Eh8abZu7mnY+/gXbawtlokH64iSk8FpYnOXBZltTjKo1MOm0CNFqByedP/LXq/rfDUaOuK+XeMI1/1h5kU2OSDfVJZo5NYZ/uU7wsxqrvF+h/uMLC6+KUYzFmL0qx4g+LBHMCGTnCzJOpBDIeRUYshdRz3M5Is/+GKm5SQ0jI3VkDKRn8WYXyCTbRBZeux1ugQ/JgG9FyEUGAjNkqKLZCNJFYKgUcpKamDCcM7kOvSRbeHsdqKmJU4awYmRep92O4WGLdP8xR2RDhqQ8tY9LLdNh5Qz8oU7UjPLF9JVq9yedOPheAQaPaEYddbhTJ6nVcadAbIgA1EYR1fJTRyCyRlkP3Iw0WTo0rVKfwSWsOBS+h2H6+QWKsTXuN3oGbN4IITzeXM+7mOgY2OaNC9zMNrLJP+Qxb8VvCzv8SwnVJnGbp8/5cr/9jAJBSzkgpnwx/rgK7gCHgIuC68NeuAy4Of74I+LFU62EgLYQYeC6f9LBRpBLYjDs9ylEVjW3twVDIo9FR7Bl3M6yLzJALm3ZmKHS5/oFZ0tsbSAFrPzpP9mNVMlc14JqAkfsL5KbqtAKDeqg+c5Q5T1prIC3BwVdk6f5Dg/aMEvkcteZwpUFLGqwyyky8vxtrwSd5vdKMmwyFLJqnWxz+garTT62HzD0/QGu6CrMP4Plo9aZS2g1vK5pJbsycyIuqu3jlB3egETB3UoLsk3USTotKYDP14TSttOpL1JqK/bbkmDx56TKCXFqVADJQwcb1QEp2xJfT49fpCer8ZM1WZv0UN/79sXhxgQQeXTtCWmsx/44E+JIV315UASVsWnY2vGmgz5WQEQurrIJcZNHjvm+vxhnQyf6uTuKJNrFxl4MXZNnwqTnK623K0SjRlhITCSImOAoJ2MmI9CNpv2i2CVIx3jl9B4sbo4gtgtSDKm0vfyJGNbBoBBF6P15Bq0sOf6ObgXiFY6xZ4sJjzd4Fhm9Z5H57He9auItht4iwI3z9vAspBRZjTh+NUKsv7yc7kwHlOZigGkQ7ohyZOxvoDcmzLxlSSs9emsday8kaNXw0eqZqGHVJY51FIYh1yodT4mMdQ1ll7mqw/P4iUkD9dIvJPyOLZXTlVp3WlHeiw9+GEPRf6gEIIUbGCjZCAAAgAElEQVSAY4FHgD4p5QyoIAH0hr82BEz+2Z8dDm/7n+/rnUKIx4UQj+fz+f/Sk65Li5TWYrlZZMRcIKe1WWfNsbs9QFprdZhXtnCxPB/vZsGmy2Z54RVjAKSvb7Lm53l8SxA74NJ3a43VP1lg82dm2PLmKdadNsepJ4+z4cpZVvy8wOx0ilkvzZSXpvZWE+FD14/bbG8rB+CTbaUMkw8i7Du+j8IpMTb9YJqgKkLHmQrLjCbbThwGIOurOlVfrCOqDbWRUGmun06oAKCFDTfP5xe9pzFhZXj/7K1cd/YZzB6bQncky/bVWG4sUonbHH6FGi/13V9lbShPXg8ifPmKa1QqHW4mGbPVSatp7Iioy+IhePqXwwwbJTbePY1Rl7S7DS55zzbk7ZLGCovDr06z/BdFhg6PLTX6VVNuCXNgGsSjAR+fvwWAyYu6aJwaIX9hguy9dYauK+PFNAYfL2Es+uz/1yzttklUeIimg9Z2kXFbBb6lsagfIBtNvIFuZCLGl7727+SerdF4hUXtJovYHhc0aK6xqAQ2Q/cu0nV7i11X9lNZE2G3M8B0aO81/YFu6rrNA+m1vKS2g4xX7zzOpy+4jEFzMVSDqpPWGgzqqgcA0K9XOp6QrjRYdlOZdp+Odopi9K02C6p218voBAw8o4JgYb0qEetSsVLd0G26P/SDTIs6vX+osnBMgj3xAYUS1Rok9SazXrJTWi4hS/8W66++VyFEArgR+ICUsvK/+9X/l9v+FzkVKeX3pZQnSClPyOX+aw2OtNbCR5DRG0qjXRpsbw+R1hsU/VhHzXf59iJrzs1zwnsmMcZ9Fi5XBJc/fXI1u/f2M/bNHCKAXZ/tY3xvL7c8tJFHfr6CPZ/ppXGqReLRNqs/UeD8F+zgvDfsYNXPF/DSOrMvTjL683nODvZhCo/DXpQg1L2zNYftHx7EKvj0f72KjyDvpzjgJTqCGnOnqJHY1sYYMmISRNWIMYjb6KUauB5aqOkndQ3PCfh63/nkvApXVO/jh986H4DCmKIzx4WDMaCym9guD++LytduozWrTrKZvOrOS44EAsvkcPcAEshbXVSyvUzuS3PSpw5RPDbKrb9dT2PUZMu7pjjms7P479DxYxofcR5ACwKlCRKxwA8Qns+Ji7v51s4fsNpVwdw91iCtNXjichX0VtxepLXaoPf3dcbe10t9Q4QFI0Wvp6jJotlGmyuqcWK4MaWpI6I2eqXFa397D12/ayEFHDouzYmfOkQrZyA1eKQ1wnStm+M/O0F5lc3YW3LKzcfMoyO5/otncMaevfysayvpproGA60FaDShVAHP5wuveB39eoVqYKlei9tDwU9gCZ9SEGXULFAI4oj5gPg9DvMvS9IfqXX0AGPCoxQoA9jU3U3ctCA22KI2F2FXdZBJr4tBvUpWazLrxxkxi0S2eyT3OsxcmmLI/MsUf8k8pBiWCktTrOd6/VUBQAhhojb/T6WUSzCtuaXUPvw+H95+GBj+sz9fBkw/N09XLVv4nBypUwps+o0qs16SETNPVq+RC+u3VT9bYP0lc5iNgKe/Pcgf71nLjo8OEGgwUipQxaJ2doTWoMHQ9WXy0sbN6ew6boDKG23Grs5x+wPr2HVHH/uu7CGy4HH0J6fZsnUKzZToi5KFb0U65h85vUo61CRsbTE5/Oo0Iz8qkNyt+Aq5PyNzaBtVPDzVOcRJtf1otZDJF0jVSLPC0Zeuqwae57OLHn6WOYWXFJ/m2OIYUoPkgRaTbpZ5P4m1oAJAcWuUVd8psvXq/RR8Zfs9/Yb1YBhHMPxhs+288QcQwKIWpbu8wJlX7EUK2H11P/aQxz3XjzL/+gTJaxsMXFKmdFyUdc1pjmrPohOwfGGCCypP86W5X/GZ4s14geCzAxd3XqcrDXpHqlSOs9E8SGx3mL4wxRN/t5wrnrmcKauboXYRpERWqshkXDVFi6XO+4GUiEqd4+1JMvfVWdwQ5eiPzWB6AdNnp0BAv1HmzBt2k5hwmP9Mku6o6t2Muzne/uu38cVrf8nhSIab+08mJlV/IapLZFcSkYgjYxFEy+Vjr3gL8yFmxBYuQ0aJjK6u2xKQZ+P1MwhPcviytNr4Tpv4Iy2S32xw/NsOccyZU/T8ZwOzJDn25Glefsp23rHlfk4/cz/Zd1Sp/cokWW9R9GNkf9nAiwgqL48wYii5c1N4ZLV6B1/Sb5Q7Je3fYv01UwABXAPsklJ+9c/+6ybgTeHPbwJ++2e3vzGcBmwFykulwnO1djs5Hm/HsPCJh2SLtNYOO/IaG/5zhqM+madwZoxdt/Vx8Nwe+q0qDTtCa9Qkul0BM3xdY+HyOD0P1YmMKU/2IXORbUuOwpgcWplh/P1ZHrl9OU/8dhnF82Lk7lCnyLHfmyR4THZAIlMhWMbWXGb+IYWf0lj50QLSFTSk0enkLgTq4jYGDT5YvpU4qgSQQhwh7+gaLBSV+YauUHw/7T+ThxNreEf+HspEic64jFqzauoxperyw1ekmH5NilXfLrLxylm8ksZPP/QVBd75s6aalTZ5dfMpyppNt9fgyzO/JDLh8ex3BvGHBQEa2VSDZz49xOO/Hqa+1SJ7v9oMWb/OitYCP5j5MVfO3EqmXeW7y87litF3sC9kv8nQtKUVGESn1abzkoKHPr+SnFll+ENNDkey9Pg1EoaPSCYUEtLQCEbCllHLQdoRvnz/f9CsaSSfahMpe8T2O2z/zgCyW72e1V6B4e+XqJ9mMX5qhkYQwdZcPnXLq/jCVb+hzy3ztd7z8FoeS3RF4Xtg6ASpGNpcMQQ3BXx8+yuYD8unHe1Bpr0u0lqT3W4PXa0GfT+tMv+iOOyBo66c5/Tj93PMa2dY/q8l4lMOlVwUAex9RY7Jq9IUr0qx+L44rWMM0tubnPLhcY4+ZZrY99sM/a7E9LlpjK6AMTdLTGuHxqNqyqSFTekAjbyffC63UGf9NRnAC4A3AGcJIbaFXxcAXwTOEUKMAeeE/wb4PXAA2Af8AHj3c/2k03ojpGiqjaN89JT9c2K6zfAnFmmcavHEt4ZxUgqosT/svi5ujJF6pkVO1Jj1uph5dReBCT0/rTNq5lllKBWWMaeXzdYsvaHXQAuL9tEme7/Sy8P3jzBxWRrhw/GvPsxpnxynMWdihQSiuHAop6McuKqHrqdbbPn6JONuT2fWvISoW7g8QcprcmZ8t3phAghUai1Ng2D5wJFGmGlAo8WXll/MIT1NV9Bk9v4sLgp8kphQ92lY8PBVK9n/kR56fl/npLMPYV/fxjblkWZaJsm7x24m49WZ01P0e2WyXo3L3vF3PHvSUMfhdomH7h+rsec7fTz+yDCfGnolhy1F190V6ed/DLyat6+9gpuMDbRTccbevwwAX2qszs+x4a2zRA4HIfhKsuYHC+x3+qDRZJeuRndHlw4o1Z+2i2g66LOLndf8gVvUudK8M4LmQ2zK5aGrVtE83cSRBiDQrvMxFwIeec8IpdAs9a2//jte+6WHuGjxCW5KH89Oa1DJiS2VWxErzIR8ZDKusq2pOZZ/0utIt6f0Vvg+qJJy2b+ViJR8so82OOWKcTL3Nxh/WZZnvj/InY+Pcscf1hHkwE1rTHw+zcOvWcWdr1nDne9dy4NXr2LbA4M8dMMIlWNstn7xEGYlwL9IhL4BFaa9bnypkQ9dlnWC0PquTL/+v6u6//+vv2YKcL+UUkgpj5ZSbgm/fi+lLEgpz5ZSjobfi+HvSynle6SUq6WUm6WUjz/XT1oxrBpMe13sd7sxhceUl6boJ0h9QaXTD35xBM2Gop9gyutmyFhkgzXHzAtSRIo+zpO64hFkkuQvSND/HxUqNZM9bpa4cEnrdVqh1/uSsCgolJjWK5n7fIqx1/YgJMRuaHLaOQfo/3mZZ5qDlIIoeS/F/vNyHHxNlpX/VmT0wTnyIaw4kKHkdi7CgQ9k2TKheqbC8eCQ0uCTsQh6uQ6FkpqTFxeREYtWM+Cjq95AWxhsmR1n3W9mSTsNYruOyEb3GxWK74kxfksP7RGD0U8scHJpjOVukXcX7uJLe67j3Mp2JHCUO48APrnslZRvVxnMAae3A4/NanUlZCpNgozgMXOYd/W9nmt7zmC0Pc+n527iXfN3sqVxiMGD+7l+5HsArP7iAi88Zx/ZB1XW8OhXh8lfEueYb04hTtUgFmW30UtDWBzbPNRB+yElQY/KIvCVj4K50+WUzyjJs4NfzlB9VaTjmgOSZdeUmN+aQNsaENfa/PNdF3P6t/fx0blbGLdzXJs7gyBmq9JqqeHqhfgIPwDL5A35P/Hjyg0QBPzgxS/CFooI5CMwDgYc975JVn6jiAQqp9k8+6N+bn5wMwe+kOXQ2Rm6e1qU5mP0/bHKzCtSzOtpVpt5+o0SmyMzJLUWOcNh5vg0T163jNaogln3/aDKvnofpSDasRRTMuNt4iHZ7YDbg/PfbMAjyyKgEMQVuEQEJDWHEbNItlml77Yq46/JUBu0MUN1lxFT+d6ZSIpnxZEGJG51Ohd47LIcZi2g+5fNv3ic2VAr0EEnkIKpUIpcjYlcip+M0xrWaQxYVNdF2PCJOV7++u3kDlXJ6DXmvSTP/OMQ5aNsNr13hhUH1fNYKhla0qT+rgi1ZQqfcPh1ccRAr5qFO57aFMk4Wr4EQ/1QWIRWm1pgcsjOUdcijH54gbXvnGPJPVr5ysfZ7+aYWZdk1429lP+zByelHvOcynaOaU3S0ExuS23m68tfCkA0cBCOmpwkdSVpnvdStKTJiFkkqal+g0zE8GNRfhk7jitXv4Un4iNcWHicL8z/muvmf8y6y1QryGgEHHpFhsPnpfHigtRWl/1fzrJ4bpR3Fe/hQwu3YYqAJ5MrOa2yByNpqywnYkGIBDz7lTsY+voiR718HqMW0OwycF4T6XAxBBICiM65HHpjNxvMOlfc8Sa2/Os0/zhxI7qQfGboEtp6REGV600FNwZAKASmoSNKVSKBS9JvQiAJknE+9dG3s6ywyMZPzXDyS8bJ3KYC2W3fXc/e7/VSOzOCZ+iYwienVykEMS78xbMK3Xi5zag1R0T4HYJZ0U/wZHuQjF5D7tSwxzwWXxIl9rDLab8cCyXqi6E5TZOkcDubXkmJ/V8wBvy/ZS0RI3ShrJqLfoy8H2fw/jLCgenz0iFlUzXolC9djHwQQXRJFl8QZfUtedquqssPH9tN+USbld8rkHCalIJoyAXwKQUxqoFNSxpk9Rq28EL3oDhuTOepzw2TOOwwuybFU18aIrGvzaYLZ1l9c56NkWm0WMBT1yxDRmHj2xUiUROqoZTTa7R0g1Kowf+D2evYfWUPQbdy9pGpuGqERW1Evanq5LA8iAYO2+xhfp47le77jnSIh1thna7XmPK6mfR6OHiszaO/Xc70OSls6fF4YjWvWfN+vtl/Hk8IlbL3NYogRMdkpeAnsDVVBpRCk9Rhs4CoNZQduCY4YPTwhVWv5LI17+Ojw6/l6z3nsP/qLHd/7SgeeXg541dl6HuqwuIpMQ6KLGPBAJdNfZDr+07nrPKz/OjwNfhuQHfQ4MziMwjHJV6rcEJxDwBDP6yw9ht58uclKK+O0thgdfQT48KhFVhKITmrY74k4MQ/fIBN3y3zqZn/ZLWX58srLmZaS6kyqlTBz6SQptpIwveP2Jqnk2qcCSAleqvFm+69la1njTPwiwqll0YJBMxcnKL3/Bq72wOq7xIChEYNF2dRJ31tnenzUsyuUj6Q036SdZGZDqEsrdeJC4dTvj+OE9eZ/HI3tRdGWPO1BeyWy6yXZNgsUApiFAObrNZmtVkgHfoe/i3W8zIA+CGf2g+pu3VpsdmqEOxTL6ewOa7Sd7cHUygpKBOfop9Q+vuv6SEy7WPf7hMTbY6y8jz9gWVE5zzMHyvP9lIQo+gniORdhu9b/H/Ye88guaqzbffasXfnNDkojQYJCQkhgrABk4OIIjmAsTEGEw22ARNsMMlgMJiMSQZMzsYEk3POEqA4CqMZzUzP9HRP57Dj+bFaw/udU3Xq/DD1fao6+4+KqpGQdvda61nPc9/Xzcyns3Q+PYH/nTqVEV+jAWlx7fn782JkPrMfHkMy4M3nerHmKPSeNc7W56WJWhWSU6osu6cTX0E0LBMVsUhVSSC48r1iA2h5rMjvt3uetT8O4sbDghdgWniyhNURB0nCaYoglSqEnBplxeC12HxcmKTrJH+RY8fjB5h/xRCzbkux8PKN9ByZZtc9N9D6TpG7mvfkT+2HY5sOkmVTkUX1YRiyoAYBzUoZRXLpUCfQEESfr2vdrDdb8AwfbjgoQKOKjFysUnI1vmzaipcDc8kfFmDikACFFj/OBhlj0GF4VxGB3abmIFvgwej3+G33T/k60M2uVSGKOjv1Iv/ZdBNP9d/M5cNPTX7WXz/XxpqbWvCVbNwWiWQDs9ahVolZZfCg77AWDn/ht8z7W4aL1j7G9pV+rm87kE+0qcKwVDMh1ohC2zwG1TRxtVJlQTlq/Ntnlob4W+oRThl9ndKOOm+8NBN7SAG/RN/5zWTcAPN9Q2iSTYc6gY7Lp/Uo0+7NohY9xs8SiPKAbJFzglRcH50NAGxSrlDrUwk9XyP7swCZSIjVJzSjFl263i8QlEUG4ma69Of1TvqsZixP5eva/xys/feeLXIDACajmTeHJr5R6aI9m8cKyyyIijI0qZQYtJI4SFgNJVVSKZHeJ4jZpbDowfUNrbaGvotF5nsBFt45QD7ro+mhEnsdspr9dl7NguOHaDk7z6xz0mz9szEO/P5y5h8wxKfbzWDf2ioWF75itdHGVr8Zw1+x+OThKaR+HSb0WJU5x4wyOBqlOldj5d2i6RV7VmwAeddHUDKZaLjQ1IrHHs+s4pbD7mX1CWEh2Gkw/dRcFc/vQ8mWCIZUEnaZITXKKYMvYkoqP205iZV/bGXTSVHCo1WaHi0z//phpjw9gVeDb85p5503erjt3u/hOULP7/l0qlXxxfe7Jl4kyDnXn4zRaAJankKqkV/fq6eEycrzRDltOeI0dV2cRAipVKX/hig51z/JsZvzsXAZGnuKptoFl/0KLxTAC/jok5Jc3nUkx/WcysMtuwDwha+bu9r25q17evlkRTef9k8hsK34rPWiQyWkE5OrtKk50o6OMughAX+KHMlO16/nqvUPsXNpLTd3HsCriW1FY7Fx50dTkWsmUkU0SyVbsA0k2xXiI9dF9RxuGn2Q6b4Uq29upu++ZhZ9nKblsxKr/tCKr80m44RYbnZMWo7HnBDh4Rqz7h4lf6BBZWuddWYLWSfAImOYlB1l0I5heQpjToi5d6ZwfRKVkwxMT6GwyC+IzG9LOMjs4u+ffOedDcRd2RVAku/i2SKpwAqeKFVlk6QsmnMaDnnXT4Iy/XZIBIU0dAFZJ0CzUiTnBBhzwuxoDDFwfJyZV4wT/rBO5Xs6YdmkdI6f5JEVdt67H1/WoTjXx/gFIZbPa8Nrk0g7YRZMDGJ/IdP2coGTJ96m3DhBb+o8kMs3PMLsQ9Icc/svuOrsf5Gf5af3d2l2OWo9q+5tYXC7BNuQojG5JPh1neLRBhFFlPClbXWmP5Ahc1KAGxY/wNmVn9N7f6ZRBWymc1SY4RNz8rhmsePERm5t25eJSBO/++ePOfftF8mdF6C/nmRbaQDXkHE8mU61QJwaD3bdx9nacUKtJUu44SDVUY1AIYekFWl/2aLvN0kydghHlVAkrzFlEX53L+BDKteQc0WxQUkScsUEReG8uS8LpDieCE79xsOOygx0RXE8mabPssLUkxWbDabFhOfn/ubdmVIYYVGtn+JVPqJ7iffhelBroLSpeJh+BctTJhtlcwZG8ICuJ7KcP/o8SafMXzoO5c2m+cjFqiAhJ6IgSbiGily1vpWkOUJyLBUrRAMe3/PWo+Eysk+EVVe2MBEJ0bNmFP/lBSZ285M/2mDMjjBXT6FJbqPCTBCU68z4cwYZWHFBK6vr7cz2jZCyo2y0bXr10clUouCmGvGnK2w8Ls5QPIziuYzIMSqdGr6UEG81yxU6tQmG7ThhWRCawvoYaSf4naylLbIC2Hz6azhk3CDhhkfbawa16BGq1xvmDXF/TdlRsk6IloYSL+36GD02RLlNZ+7VI9QclaKrsyIrnHb6hMM3t7bx6bNTWHtykuguNVLdEZI9JQZ3iPPe8b38pPxrftv+Y0qSGCsdkvmcP7UdQdCpcffJD3L1AUeybnEzax9twihZbPejIYz14s45skSUo93354n+sYpaEjtCekkQ/4hN4DUR+33X0Xew6tR4o4ytI9XE6bWgtAEHOGzsE74wpvBCYL4gC/l9lD2dsFxlYWAj8UCNoGQybMeR8Ri0Y4w6IcyOqBgJ1ky8gI+qrBNQPcH7K5bpVPIokoeGM0nANSSLpFwRbj9dEws4MyFUe41TtkUVXoxVZhsyHsE1JvmtDCw0Xi1sI1yDdROnJSqqB0kYfLBs/jb1MAaMJnY5fR3yaw5La10MOVHqniJAnH4Zo2YTlk1yboAeLYPbLyMBfxt6BA2Xc6cfx1vBWaJpWq1BwI/r14RzsVj7X3gFnq6BT6fXHuOB7M20lydwNVh5ayv1qIZRrjPjlCxuWOLzv3aT84K0KEXKnooheaQd8d+d7+Rof6nA+tOTjLZH2SPQj+uJhN+y6yPjBFEkl4BcZ8rfc3gKDJwUn9SELDIG8ZIS4az4zg47YZqVMm2KyGDIuT6GGxXBd/FskRvAZiCIIVtMUyfIuT7a1DzVrkas8jrxssqeTptSplvLEJZFc29nY4iYbBIM2IyfGyT8VZ15Lw4jrfTY/4zlmNMUJA+aVpcpI8wh/VaCHi0tOHGSxVzfEOgaK0PdPJFcBMABuWUcUPyay9qX0OHkuHr9g9x/0D6Mbhfm7Ud68YBdfi5GWTQ0HbndDHofStNzniiZMwuD2HGZKS9lJ9OF7jvoDlaf0izm1K6HGvRxUGEZMrDa18bl3UfiqgqepuAFDW7bd//JMIk1VksjHblO3VNIymUcJC6+5x7h5mvMxCuKD7/s4Bk6XjxCyokwzzdESyOefLN+YZXZhpwR82ipUkOKhCc791JdpNoONgQtX9fbCK+pU9xKqOpWHNY5uXkoozlcXWwAbjiI5LhUVD/ptw3qU1Tm/3KEnf+4gcSGssh6lByIQLhYR8aj1O/j/ZN6CNfF3+v9yGx+NftUVkWn4AV8uC1x8Bt4ho4ylhd+i3IVpyk62eyTLJvvV/v4W/ZRbE1h+NAoriaTccO0yQV2OG+Q0MY6K29qxW5WGm5Rp/EeRPhrIeNj5nlpSjN1+k+MM0WdYNgWKK9OdQILhYonPsfYigrTHs+w/idNVNp8k1fXPiuOVPSoBHXBmPBkUnZ4kkehIIRmqUYV8d9+tswrgOQyYCeYombpt+NMUydYbsbp/J7YNYMfmYxsHW34vSNCGqxlSTWoQc1KkaJrUDxMI3ZvldZLCkSaathhhXcfncm8K4doub1I4tAy+ekBYkqFPrOV2XoKB4mLDj4OKZPDCwdxG+C8ZwPbcGjxK9bJCS7tPJKLhp7mur77uPD7RzA8bTozH72Jjh/lABd/WZxCqw9qpXK2xp5LRCNsh8M2UdpKJ/5KFXsCrKRCTK5x1UEPc+vQwRxzz8ccUficqFNltd7KH7t+SM0CyTVRqnVxKksSZ7xxHNfv+QgxuUK/1USbmqfgicW+2Ws+ySGUJBwkFM/Fk2XkYpluNUfaCTayDb71V0zTxhtjOkcYdXzat9juaBATmR4tTdnT8EZBLbp4sxsfmueB4032NZRibXI05/l9rPlFkhWxLtY90cqeN6xmq3+OIj8BlTkahZkGUtkj8I7J9B+kmbtxuFGXwBPB7bgnshteHSTPbqgdPVEBaCpeqYwUDeOpCsqY0FIA7LPdcqa/+S7Z7fy89/eZbHe30GIUHR8dV+ZpeanE+gsTbNwpieWp5FwB5uxWxKZTdjUWXrgJNevy1p0zaKoXcZfKRFdWia2voKZcjFEbfcxBqdmoJTGy7Hp+graPC5QTPqq9Kutmt6CNOozPDNGjpal5quAuuJuzDFV6tAz9dvw7WUtbZAXgeDJBuU5UrpOUy6yzBPv//UQP9WkKgTfNhqfaPzkpSDt+Ko2mW7pRZlmyxqd/mYqSd4muqfHxhdMItJisurAVz5DY+k+jhKVGmpBSZcwJcfXQYlxDxW2Ji+5yo6v8aPvufBmYyomF91kfaOPCjqOJUOfG0UfZYXA5p51xIj/b90wAQq+IL1G7WmDKwhLrNrbyzZntpBaHCaw1Uasuh+y0nO13GmDarhmO3uFL3r32Mk7NvknUqZBX/JzbejQV1RBSYVnCi4aQJgp4ssScP6cm8dZtal7ALuQaKTtKm1JgjdlK3wktYsGP5/G7FlVUYUBSFE779VkNV1yt0T8pI+OScwN45Qpk83gB49vQznKV6XdvQMflq3onCblGok+8t8pWGr949US8aAgvHBD37lIVqS6sxF44gOS43H3EHSzwDaIbDp9cMI133+9h9dktWM0Ksc+qyGUPLefwUWAmf2/ai7ub9wTgham7iIUe8AlRj2khlau4m2nIbU2TYh/PthnfX2x809/MkjvIzycPTcPfYqJILuCx972raLm3xNjxIZaf0E6zUiQgifI85wRYbUVYUe+k/dY8La+UyM3xs9uZa1m4YIgdfjLI3MtSND1XJjhk4iQkUrtGqM/TkR3I7+ojv6+fUpePYLlO9+M59r5gNf60TccHeQJ/r5PPGyTkmhBASS5dapWM66dT+TaW7b/5bJEbwOborWX1TgxJ3JeH7Sgd6gQDhyRoeb+Ef5NJQinhIhOWTRINSaXpCbptyg4jSy7yHI96I+DTkExMFJxmhVW/ayXxfoWZ/8kK92Fj0yn/SHTiBWBDhs0c+2KZm1v2xefZHDH6ASuVVn671QnkZYM/b3qMY0ffwXxHdHL1rCglx+wgywFI4fEAACAASURBVMw2sp6PNWe20v/3BC+8OheA7M4BUntHqC1UGT00zJpLm1jzs2YMz+bu+A+w9MYCrJsCJVYo4yZjuOEAXsDgqiU/JihtTryZQEOo5MKyRac2wc1H3YOcyYGuEXDrVGQfniKuBYHBEqvMVtKOYNKvs5IYDaWRpOsQDQmEV12Ih9xokF83v0FAtunUJlhhtmGtEwstN93P1jflxM8WK6IE9xqmpwZY5KLXnmpEcQUwZJM2Nc9EMsiG05K8c89Mvni/m5ErokgePGHtwr8TO+A01JSVuoQXMJBLAivmJEVpjSKJhmOhLCoj2+E3773BqeveAaA+T+W9v80g6K+LisgTAaVTr55g5KAIX/yhi2a1NGnDjSkVukZybH1PiqMP+pxZ1wlRV3h9nWqvxlfndvDZvd089/48Xvl8Np/9Zwpf3ddJ8TIf+hqbwnwfqQfjfHVlJ0vv6GLTc0k++Hoa6y5KAiBHPWZfPcbee65B/4eJ4Zqss5KstqI0yxVq/xuJQP/HPYrkYja81ZtJrpMprj/RBSjy4dwk4GGV2UraDVDzFJKNGXebWqTmaiyvdqCP2ZhNMgv/sImutQIQmf2pn8I2PuKXldmQSdKm5llV7xAnmd8nylmfDiExwvPiUYaNJj4MzGSf0gqkeo2hss6ZM37Bm4FZHDfxATePPgLAVz4hvmn/uIDjyWQcoWrMOiHCM+rUOlXyUT9DV8Xou6GZNZe3UI4Z9D6QZvSQELf8YR+8ckXMsUN+pEyuMZMvI5dr4HpItssFS47H8hTSTphl9U5qrk6flSQoCbOJF/TjGTp+16RCgxSUyeEpEtO0cbrVAi7yJCJ7MzRTshsjQJ/eyO5zqHgqtUaH3pBNog2HYzBhiVm77YgKIJvHTUaQKjWcZJizn30SQ7JpbnjkLU+l32qatE4LNp/OEYXfYCOz58Q3IEmTrr6KI08Sg6SaibJuBM+nIw2NiZ6DT8eTJM5+8Rmm3ZWl5V3x5y4/oA1VFUKyhFzF+UhBsTzGDw7w+bVdrLdbCUo2dl1ixr/HWXj0INvsOkL7FQVC6+uYSZnVjzbz5CcLGbsnRuk0HwO7Jam1aARlCx3xztQbXHxjDusvSTLoRkU/QKmQdvxoqktwtYkTkPjk+Sm8+e9eilv76L1snFmnjNFdz1LzNNbbCXJu4DtZS1vmBoD3LbrbjlB0/XSqE4TlKv0tzaQPCDH9wQykPWZo42yljeF6cgP6KdJZmmUbRXJpz+ZRyx7pE0I4fonukyfQixYoEm9f0osvbbPwhgHCksXT+ywUZhqfhlwsQ+NLByAVSqDIvBedTdypMKM8DJpKXda5ZuZRXNJxOP7G/G/b2iYAWp4pE9tYpuL56FRzmJ5Cv9lEvVelfaBAq1LFqcm0/7XAdmdtYmK7AO/8uZdHDr+FlZcIPr6cynxr9a2b4q7daHTJYxPIkuADLjQ2iTxEyWr8anP6Sy9ilEsoeFRlHa8B5ZRL9YYRSGGhL4uM4CN2a5kGENQTcNFGpoFUqfF5bRr9VoIxOywatCULxy9x/pLjkScaFZPtIEmSoP36fUiWw7a6aCrWGmk4mmTT1rDGJpUys7QqJ/3nRJIPl/nMP429s19hlEuYkjgRlYS4lkiuhxv047UnxcKPRfBqdX7+0ptc+twDRJ6uM/vqMSpzxe8LqzUico1sIUDbmXmmfDOBq8Jnf5vCiJRgm9wmQpdX2Xnnfrb6XRol7fHVSe3U22ScqMwnT01laKc42wWHqHkKHWqVNiXPbH2UmFzFkGxaVuTZ+r4UmaMDfDpnButMsakEG5DQwXyc5hdKpA8O4fM5hLat88Z9s9hwWYLEGxWmH5+lm4nJdOLv4tkiNwBNsmlWitQ8jV59jJhSFpglPGRc1v2uCaXmMvvmUYbtKJrk4loQHa+gD9jMWTfEwFc+jEGT9pSYqafbwgz+PYE2YLPDaQNIdRdjoUX2Z0GmPDDBe/fM4N7UPzm88Jkw6SiKKC83E33DATAtVoeFYmt6xMVJhkW3vG7zUa2JE1t/hvU/XrniOcxfPMIXr3Wj5wVdZoGxiUpMQ0p75G/U2HmPfmbdNsbo0SG+eqiDss9H0TV4fvGNrDotgdPeJO7Afh8E/OJeLUmiH5CI8s8D9qTmagzbYvTQrJSpeRpDThQFj4AsvlgVVVCCJNNCqtS4ZmAxFVcQkyNyjW31cTJOSDALGnJkTxZsgfHdOunRR6l5Gp2aSDqu5TTMsCoszrU6TiwkrM6qOjkNOO/px1ht+Sl4vkkPfptSICbXaFVKZJwgxy3+JbNvz4Ek8UTXD0h6FY6sLqWoiFj2aD4nriWuK2LRs0Wkap2RA9q5+MMXxYL8qMqOF/QzvijIwBLRGzBki3yfnyU/Xkb0uSrlHXQ8XSKYMjn48mXs8oP1TLs3y9jOYT68fxobHksw9ZUJlLLHR/dOY7wrTFiuiZMcl/VWhJQTJeP6KXsaY6UQW581Sj2hsvS8ToJyne2NfpbWu1huttGh5ln0ykaUsseKw9sZtBNYnkJYqbHy2HaW/7WNxKcVjOsttvcNiRHsd/BskVOAnBuYhCcAk6o1XXKYracpTleZ2DdA+0MFQivXomZcthm0+H+TU8++NIU9R2F8+yAtH5RZ8IthPvvHFL7+fTsL3xvkR5d+Sow6PdVR8FtiwasKDIkPRqrbeDEf+bK4K0eqBZSxnPg520GKRaibFod2nEZXwOKutXeQkwO0WgWuOOU5QPjlPU9CLblIwMLrBpnYyc/665P0L2oSCHJ5nKJr0G/HuevAu/mVdRK9D4FcqovOviKDIgm4RrUO1RqXXnACV119B0G5zop6O/N8wwzZEVqUEqde+Qr8BFLhpkkOgZsIw28kBh4Xi3/IjjNgJ+hUJ8Sib4SBiKhui6svuUNASSRHnGw29BbSjOUiSHIWKegXEeWSNNk8jN81yoCVYErDADNbT7G03s00bZywXKPo6Zz+5In01lI4TWHU0RrLtVbe9m/FjzIfcU/bXgC0uQXSSituKIBk2dgdCf7x5N/5rN6Gg8TqgRaWnLGMYpfBF7d3M+0ZcXcPvmay33Ursf0y39zXRserBQJLTXbZaz3IMHZ0mLFTwmS7AwQ21ek9Jo087vHhP6djzVcJUmfIjgmvSaO3VHM1LFlUpttcNUxwvcXn93cRb6oRYXSyiiq6BjVLJnlrmfzWBoGda+Ah5MNugLLro3Skj8G3YvTeneadE3vIhwL81/HabKEbQFIuU3ANYV21mujV0mRcP9URjdCjWaY9VMbIiM0h9HWd9J5Bhg+MQjuUDR9ln06bWmC8EEIpOSy4Zgg7rmDVFKIbhAot9KHJD7ZZS/77BuN7B5nWnwWHSXQ3sgxpAZakBJ6hI6dz+DSxy5iqiMxyfRqy5+G5MpKm4vl0zLrwu98X+z4/Kn2O7to8E92O1nqeyj4qB63+GmPI5vX/zMJqV3A8mbnaGEVXI9cQQGWdEN2+HI8cfjM/kX7N7JvLQjFo6NAgDXuxMBg6sY+ExdiQLDRFdJezjZ7J9DUC4bXB34pUdYSox7LxDB9T1CxyIygl4wRJOxFhTqo0zEeeN1kBzdZHWVFvp0ObwJAsouUqKTmO15bE1VVxDQDx3uomRzV/Nmm5naGPUfB8fN+/gX4rhoPET18+ha3vToGuoY7mJ8eNt3UvZmb//RwzKpp5c8qb+CreheQ4jH+vmbMueJyPax0E5Trj9TAHnLMCteTy9f3tRGIVAp83wJ4fV6ns52PpH9ppf61A9LEq2JD9aZAvT+0i1il0I8oyj4UnDeHWJQb+meDK844Az+Oi15+mjOD1NcsVsgiGf83TmP7WOF0P5Rn8ZYz0LmFwaLhWa+ScAC4yxlMOwX6TpXd0kHODVDzfZHbBmC2oRKVf1VCe82h+tozvuO/GDLRFbgCtSpWwLLqkCaWEW4f5t40Qu7WMZENhb4OlB3WhazYLz9iE1azyze866G3ksePBGrdlUuKa/WiCyPIazz4yn4BSp3M4R/vVBbr+kyfyRZ34e9+67X5grCT6YIHf/+FUfPkSlMQHI5UqYETorInFNhpqwvVpKPkyniyJMdVoVmwgm6PAPLinbS8uGniKYTXO05Ed4CuJKakc23RtItZVacRCBRhyQtRcjaQixDG9+igpO0yLUuL+w27jF/XTmXnPmCjhs0WR1pMRpbMXCvCXxUdx/otPNoJPVGbooi/S1FemYBhkXQM3ISYcYrwp+gg5J0DKjrK9MUi/HRdQDVkGRcZJhFBKdUxPIecadDS4dpan8GVuKt1yXkhyG8hvN+hDyRQ5+nWBiBizw+xoDLDCbKNZLTBsh0kqZY568QzmXD0i0oJMS0wMKlXcQIx8yeWPzUu4OvUkYafO4vxS/h1ewHkvP4PRAMMk5Tof1aay+92riX5cY+CKOE3Ly7SeXSS+UjQnxw8MsPL0dhacvonwN3XKHRpG1mLTn+PkzCBF20/vy6PMOTdFKebjnOCxbLxmCsRdlOEMzxcW8IPQKtHQcwNUXB/dao7RVIje36cpzdbZeG58MqbOkGxWmW3M0MeoFHR6bxijPE/H2k8hSJ1OuUDNU4TrVBWswY1zEkxPZJixMscn/0+u7n/l2SJ7AH1WnNTm5NRNMlMPzpC4oUz6wBCfvdnNyD1xcof60Q7xGDgxTteDebZ5fIhl9U5M5MmMtoAsvrwbD03gG3GIvlJjmj5BuiuCe4efDy+ejlLxKC7wsfZYcXfURl22//4gj9tXcMmfnsH3ywbOy+/D8/tY6Ihm22qlFblm4sQFbUZO5/DamxobhRCjIMt8GJxJWg2xuPi1mCpUa0y1J1i+sZ20ExbY70ag5GYpc1AyKXu6iJt2BLH4+qPupe+EFiHQiQTF6RwNCytxqQKyxB/OOblhkVYns+rk1R7yNkKOK5fr3/5bNBVZEqPDKVqWITtCs1IUJppGhaCO5pDyJdrUIs1yhRlqiU5FoLEZVAhaVdywX/xdNAU5Vyb5UHYy+aZTmyDtBuhUJ0jZUUxP4ajXTheLv1QWVxpJEp59vyGuEZrKUPsUTm87lg16M631PI8P3UTP2ePwD4/ONwvYr3jsfN86uq7PUWtS6Lo0x+xzxwjUTdaeIhKR8v4AuyxZjzbi8NEt08gtNkCW+LQ6jWa7wPaXbGTe6SP0uW2cqh3P+SPP8cP+t4jkchxUW8HBu3zDHrv1sfvMtewxfS377LSSjqMm2PmHG9AKDl9c342pa3SoVQKyxZATRZZc+q0muq/NEUhZfHrRVAzZxUEm5/omg2gcT6ZTyWPIFrVOFYa+m9MfttAKoOL5SMglmoaKLDq2Hz3vsPIfrdj7qCgeDNthDNliyI6QO08n0Gcy4+IMpWk+0juHSSqlyZfdpubxHeRQvl5j9+vW8PHeUwk6ddZvCBHbvcI3V7Qx57IUncPiSuH4wNVlgitMFp24kW1bREf/4gee4NinfssBf/uCLwPTKNQA2UEu1kQYh6oKyIdPx2uEkSLLuLbLy5F5HJP9kLhaRzJcOs0sL/h7+de+u+KOZznry09wPZl+J8lCX2ry7hlscBDDchUXmbuOvoMT/L9i9q1pKJQgLDYCNxlDLlcJr8xy7dABHNy0DIBONUtkTY2JgwNI71rguLhhv5ip101yToCkUm5k2Vkk5booW2zhpbc6E2ipPOutJhJKCaiw2mrhyfQO/Nj7jJBbF9Jhz0OqWYzv0sqZzS8wQ8uSc/WGnsNmyI4QkWuc/ObxbH31uFj0ybjw6zegoOgaUs3EiQZRhjOU/CG+/KCdKbtmcMISsTcqND9V/l++Jx5ghxUGDkswcbCfzLwQ3W8I2XXPU+OMHhxm4vIAetxBWibhIfGfR7bhur+sZmp9gqeiO3Bvy+6YsTCdGzPsNrGc49Lv4vNshrUY4zsGkTs9yrKPaKZK5NUqxriDJ8E2943Qf36cFZEk3WoODYekUkL9wmXmA2lWH9MKO3qsMlsnuQI5J8BsPYWiFDEb4S6BqkWu3f+/Hwv+f9KTUEpUTZ0FZ21CLbosfbiD6t7iVNUkd/LnkkqZPredpTd2Up2mMfekFPGllQYgxE/OCbDebOEjawbrT0oS2miy+05r2X3+WvbYZy0L9h5mmz+msAIKek7swuUpGpLtYbUqrLsygdcAbU77YYZXv7qMhFuhfo+ATEiWLUryuvmtAMYQ4y/xl1VwEiE+is5GBhZk+tg79zUAn81YiDeRQ5rSwc177sspD51MwTHot0NM07JE5BpJuYwm2ULxpxQwJItnDruBvhNaxIZjO3iqguQ4ovlWMyme0UpEEbPo8Io6Wt4lMz/I7GeGhbOvJEpWybK5c2R3FDwcT2bMDjPkhCalvEzkUfuGyXyvjYJjUHF9ZBud/Myp7ZRlg6BTE/6CgAGuyxnnP0GzUuSj6lSKrkGuAXIBOPXNnzHn4kHQVOyWqMgZjPhFEKmu4Rk6bsBALtdYcWk3177xMNObJljzx2aMtMPwKVHe+3AGX/6rgy/PE+XyN39q55VX55C/yM/Y/AjKlx6zzhdW8eUntrH8pnZWhVspeD6+eWo6asXlqUtvJ2JXubjzKO5q3wfHcpk9vBYdh62sMd4NzeL0tmM4ofdUDo9dzJpzW6idq7NpmzjGuMPGI2Ks/nkrsacqzDowTXxViXJDlRopVNn5txuotWs4F8ik7QgxpUy3miWhlNAkhwE7zhqzlfVmC7prIw17lNp9/3846P98FFymPpAlvqzKqitaGJ8bxkRm0I5R9lRMT2HQSrK8gWAqhQzGHophJlUW/HwT2lKnIQmOsH1+gMW//YZ5F6bwFFDLHsX5Ou9eNYMVN7Sy6Y8xxncP4WriVUX6LCqdGuGVdSKv1+k7VZSUctUl+UoFs0nG9Kuc/9xjHPfyu7jRoAj6UGQh0KkIoQ4ApSrKxlE2WCGKso8FpX6WFJfyRWAqG9UkUiKOJ0m40RDTn8rx6MG7oSPuuW1KgZqnTc6c11nNZNwg660mbj7qHlb+fopY9KYlZLdjWaGYG89z1357E1MqtL5SxJNhdK8Q+0aX4waMyauM5/dROSXJmBMippRJqiWSclWMFzUVmhNIPp1fX/wEPfoYbUoByxNZAFK5RslTRWBmvYxkWlz88hNsbwyyzmpGlxzKrkB7FVyD058+USz+huVZHS+C66KMF4Q6UVUaScd1fvn8qzy4zx2sMNsoexq5Y/zUFhtMvSrHlKezTGwTYPa/R6nPUBg/NkTGDlF0DdreKrDvcatwGsnDE7sLYc3j++1CZn6E/bKiKno5PI+TZpzIJ6EeJMtmHmNcM/wYEvBWYBbXxfZhfaAd19BpenMQHQfrfYkFfxpkYjc//VcnGb44yttPzkT2XHb86SDSOg/Hg5nnjuNLOfTd0kQ+KJrYzUqZnOsXI0C5Sq82To8+JmLDvqigVVxGtosw2KAK/befLXIDsFyFngfTTOzkZ9OBcRTJxfVkYnKFtBOeFAaJDMEcSaXEZ4luvnqkHTOmssvP1+O+JzH3q01M22+cjtfzLD+jjdWft9J/WoLwVyZzHkvhn+Pw1S86WXF9GyMPNHDXCoTXmrgyNL9epvtZ0fjyjbsUe3Qkz2OPI/rovXaMqF3mvKcf45Z3HmHj0e24AZ9AXw8JNBi6htecwNV1NujN7FhZT9Iu8XDTLmIxuK5AV42MCTWd43LZ/keTsqN8XpuKLLnEZJOap9KsFkjKZWZo48i4/O3AB1l9UgKvUhObTywsmnGRIF5BnCZNr5TJ72hgJVW61RzVqWERJpoVXXdPlWlTi5MhlWVPxWkT0lXsbzHj5UY8myy5PDGxI5LtkIq3AdBVz+JVaoRlk7QTJCjXSSilhoDL4KzXf0rP40UBCgn6RblfrX1rF25MTpAkjnzuw8YYzc9C37Bg/9vN3PeXHek/OMGUv+bYYb9B/Kts1v06SVSv0awWSDxXZvuTByj2+Nj4Z0E07j+7A/98j39uuIMlxS95OzSLc9p/xI0dB1KOx5FMi87sAH/a+AQpLUodhXQ0Kaqfag0lW8ALGEQGasw/bZjqVI2Vt7RgKmI8XZpnsP5RMbrd+tej7HT7BpKvVlhzfjMbtxXv0JAs1ltNAnKiVMS7bljda55G4vkKji6R39Og/39XOvD/ic/UlRP4+h3KR/sYazTBzIYyMCiZNKvidNzWNyQWh1Jljp7C3+Xw5cNd2G0K3z9+PQt+MowdUXj3uR4q5+isCrXSd04zX97YRXhDnWn7j7Pw1AGaXizxda4DgKF9ItS2VpEbVXz8C9E4GzwoxrIXOvjwtRkMLYnSeWuBvQ9dQ3h1ldVWkguPf4ybnrmTVVckkVq//TClTSN4hk7IrpJwKjwWX8RytR1PkfCqNaSaieT3i9OwMYK8fckhPLVkVyxPYbnZQrARPmk0dBGdaoGwXOX+w25jzXk9SNW6uI7UTAEWaUly/24/ILy6zui+YsNcZbZy7o0PiJy+ZAzJcfF0lT6zhW41S871U3RFCS7VTKRqHS9gMM83REwR04pmucLKn0zHjQbpk0Vl1GuOcvqH7wI0AJkqnWqBecYgv3z2V2x93TjK0PjkZuLFwsJeXBP5iFKpyoGPfchFb/yLZrUgriRI9Fli4+/QJsAnMXxjhKVXdxLaJD6PnivG6Tp9gj1PW8O2Zw1Ra9L4YmA60VPEFeenY+/RWx3h2fgOnNR9Ald1LmG50iqcisMZpGKRc6vvYksyF0UXi+tRzRIkpVAAT9eIyHWMH4l3/uXdXaSCccJyDUOysTwVZYbE8is6iKyoM+NvE2w4JEn6F0Ex/kRBllxq7mZmpU7KDpN1QpRdH5F0lc4ncgwsTtARK5JUS9/JWtoiNwB9rVh9mxbEaFPzzPMNYUgWHWpxkqduegqjjUnBoB1hox2n30qQ7Qiy6q5mkCVky8PdWqKyzEfo/hoz/5mm5x9pfEMWa09oorKHTtMHZbY7fYiDTlgOQNfLBXx9NtL/Leys+4Uc7bcVscsKr1w5lw/+MR0p77Hd4ZswnhZJwUvrHdz5vfv53UMiP2/8xwax9jDnDPybGXaGmqTyQHRnPEVGrph4bUlx902EcWOhSay1VKlBrsC1R/yQf2W2x0Se5MavMltZWu+iQykSlCz+ecRtrDqnG2zh95dMC09X2a28BoBle3YL8oyaw/JU5FxJJPXqGvJEiR4tTdE1Ggm4VUHWVRUhcHLdSdxVxg0y7ISRbAe5UGFMCZOTDH649ydoOPRZzcz2DROTK6yzkhzz9K+Zfd2g6FOYYkMBoG7iRoWtubhVjKvefZJWLYcmOY2xrUrZ9RFTKmiS0ENsb/Qz4CYZ/V4YyYah/aPkFgWIfV4h8koNCZBTLvNqm8ipoudwR3Q3ftZzKndHd2U42iYqs1hYvKdQgN3ZxKzaCHck9iCd7ASkyYpEsh1itQLXrH+QrtEJPr19CvEZdQJSfdIvEZMr9FlJmiIl0YwMyNjXqySUOjG5KiK/GuEfm+PsLRRmaFkW+oaZcssEsuWx/NftjSvfd+MG3CKnAE6jgu5PJDE8q5HeUuHrertg/Nk+mlXRFFPwCGZN/B+bqJ85KKs8Wr4oIltiBYdfqrP4peX/n//frgRmi0qpQyf5ZYX0fkGUPo/k2go9N2XouSlDcf5G8vsY9F3SROudJfY6dw3rVyV565ytiMgqbk2cdud+8QqR/hqSCUNKhLLqxw4EkOoWdtgQ4aGOK+7wjiNORMsW5Xc4iFSuMXqIwaWho/j1qy9hekrDE2HycW0abWqeZqXIQ4feyk+tM9jq3gxoKv6JHEsKX/KFbwrx6aJzvrzeRaeW5bw3n+MvBxwpBD6GxhHvnsqVi/5FQimhyN/y8zxdZdMhzZRdX0O+W+HKvQ/HU+VJj8Dq2BRmLxtAkVy21VKst4X8+KzXf8rs+/OivNdUJMMQo75yFac9gTJe4OevvE1MrpCQRVAHQME1cJDYUG/B9WTm+YZFgKanE5TrzH9lGMmD9RcmuO30Jdw+9nfGVIPzWo5ivLUDOVNgrpvi2k2Psi45BRcJGv8exnNIhg+nKYqSL3NIcSkbfU282bpwknhEI7ewycrz14GHSbgVLu46il13/IYRS2WOPsp6S1wxNMmm9d06XSdP4LTKqKMu4ymDpil18q4Qd6XdAG1qnmErTliv0atlsDwZ8wOXeQ9l2XBskrHuCAHXnMxp+G8/W2QFMBZoYJYrZYEGk2wybpAFvmFkXDQswiurtF9TYM5+I8xZmGL6qVk6HiwQSJsoNY/S9jpv/20mK09rwfZL2BGJz6/oYvnXbTyydAdWftXGN++18/F/prLu8SaWXSSuANWFGtUmjcRXFSQHWl4so9cs6j1CODO+QwBHhs7r82xz+ijNy8o4usSMf2T42U4fsd+OK9luXyEWin5SZXivGK/8ZzbRthqRPSq4IQMcB3UsL8rwxvTAjYfFjN/vE131xiOFhdX1xiMO574RAddcbzUxWx8hLFepeSoF1+DaJQ/Q9/Mk2A6L7VXEnTIPduzOdfsfiuWpzPVtQsOh32yClFAHSpU6sy+bYHf/IJ1qgeX1LnEH1lTkYpVnTr+GNjVP0TUouz7RrDMtoflXJJqOyxBZWyOarzLohNAkh1+88UvmXDMm4JyeaIp6Qb9YZLpGaVqQ0157hWnaOIZs8Z/yViJbUTGZpo0TkyvsHlxFm5on5YQaJbfIM7A/VNikxbnqF0dw7rqn8XkOl8QPJBNOIheEZNtraDDkqvVtsrEkQSyMmwijpHPE5Tpz6iO8npiHZ1pQLDeAJi5hp8pVA4/S7hR4qnkRywJTma2NM2TFqXkKiYaHoemNMjuctJHqdJ3PrhT+kOAKi8/rnWTcID1ammQjgnzz7ym6GvkJnZlnj1OeqrPqvFbm+b41cX0Xzxa5AcS6xIfZOZJnmpZGkxwcT+brbCtd9+XYc/8+tj9wiCm3T1BPqmz4fYLVT7XwVSOvFQAAIABJREFUwGeLGDoshuRB/w1JvMNh4twgK15sozpdZ/s/bqLltBI9hVEmwn68bpmxWWE+WNBD7SBRLA0eEefLZ7p59+se1twk7rluQEYdFKdU02cVVNPli4c6efPeXlZd2EL2hwFyWxuoRY96UGHoRGHMWXFJOx9cP4NIvUZoyCS3p5+j73+V015/lcwuHXgFIbzxAob4AnqeMOxUanghPxTLQmhkWeBC7aQo5/zxtEkLLTDZF+hQJ7jrqDvo/1WYo1Pv86V/CiudJFK5ys177iuyFSWXHn2Mrd8siYUcEBSht6vdpJ0gU7QMILIFPUNnyAmRtiNoks1fjz9WXFEaCsJTn/w37C8jedDzQo6ia/Dzl37FnEuGxIkLYuHrGlLdxPP7CD9Y5MwrHyUs19BxKboG2xv9wiJsh0T6smRT9nQ0yRa0YFxuSe3NtYceRfTNKt9o7RyY+5KF1Y3c2bY3Q5EOMYZ1XdxE+FuxU6NSwaeL60c6A46HGwsz0xSjwm+MLvDpuF3NIEnosstfNj5MmyXK8fG6xl6F5Zx27in06GMUXZ20Eybx7wqzThmjuJXB5w91Y/WKdxLONaLGXB/9dpKM6yfrhJinT2DIFqWqztxTUhhpmy+v6yIRLqPgoeBRcL/d9P+bzxZ5BcjOD+DJ4H/Pom9hK1Pr40y9PUvn/Xn0vENhgY81VzSTO8DPplhCZAe4PlqkIp2f5MhvZVDoMtBxiMp13midzcYnxpjzUIqp12aJ71dh/QlJhn4VJRktk7Yj+CaNRzbrzBa2NzaiL1EwL1Jwtld465legm/VmX/1MKEVFtsfM8T4bgGWntVN9qQgUblO6c4yXX/OMzweBYqUVAPLU5l5ZxrHJ5HaO8xc3xAF1+CmK24me2mIASvJM3tsA60JpLqJ69eRJAlsV6jj+kfwmhJIoxkkVSHxbo1rDjmKy194UOj3vQgztPHJcI8nR24h4VT4c8sPcONhPFVGrtnkXB9JuULB87F/9GtW+GdNIrT3Dwzxbk149KViBac5hlyu0aaUyTkBcm4Afe0I+MW8XzJtkkqJ9VsnSG5dxHi8ypmh45n1UEm4FvMliIVFozNgIGdynP76q2g4BOU6DjJlT8PxZPrMVgzZIiLVKXgCejpDzbPejnLTMUcL6bLtEDJqRNwaw4Emjs1+yLLQVP4T2VaIsByBMJNzJTy9ET2uC5ipVBOEYkmKC2iJZZOsisnOqBoV76dQRfI89swtx+dZ3Brbg9/k3qBJqXPMyFuMvemnWSkyaMaZfeMoc25NUVqks+7OJqSIB8J/REnzkbJj7GRsmIyPc5D4wmzCcSR2Om8j8Y+q9N+YoLadhoFNzvVPita+i2eL3ACGY3HGF47T8VKO+kyFniszGCmb4f0ivH/8TIxF5uRMukMW4Q3NithNfRscJrYNUHCNyQjmBcZGLE+lcoLB6sWthC6vs9Vtabr+nuOWvfdnh+tXU2ikEdU8lV6fQEN/Wu/k4K4s7qhEW7BMfrGPl/ady/w7NzHjugzJ9yvs8+5qMnsFGLk0ylcndOGkZHr/Ib4RcaVM55sTtD5XYt2ZSZQmDxOFaVqOfitGWK4SlOuc/cHrGJLFz586na3uGRcnqNKI+Y6E8XIF3GlteIqEMl5EKpS56IBjwHG4/NXHGLRj1Fyd1m/yzLlhhPR+QZ5asi2zb8sh58t4fh9X7nYwZ739KhXPxzw9xaqTw8y5LIuXjLHCMhi24nSqOZzmmBhNWjYrzFbCcpUz7j+Z6clMg/Qjc/JTz4suOB6lH/roujTPfreuYSNR0d+Y3oaSq8C6QY76bF3DQiw4jQA1VxPWYjXHoJ1Ak2zeqsxitm+EM588gd47R/BkCdUtCp+FTydWFe90RmmYuFvl0o69BCSlUhOVVDgkxonlxvjGEz0gNxoSfRWYnGxIuYb33vWQCxXm2iPo2ODBha1HUHDEfTz7Ax2egZNufRulAlv9fjXR52sMHR1l5M8RTE0VwZ/9okFrdclspafwSQ4pO0qvPkrNU9Ftm6ZzKnQ8W2Dlua2sPqiVFqlIQLKpSTZ46mSg7H/72SKvAGXXx9jBIQJrbOaeOUo1ofHW472M3RWBHUUHVpx6AfqtJpabHay3RLmulh2UiENSKTNNG280koTu3UGi3qaRuTFISotSlTV+/9rz7LTtAM5+oqR++abt+PlbJ/J1vYN5vhHqsoLqOGy04wRki4Lr55uTO3nn0V6sJhlXhdh7FWbvl2LGP9KMXBBiYlfxRQ9/VGP3s/rIzzFY/atWyq7wxVdcle4GFGNnYyOOJ9NvNfPc0ddx60v3ctl7zyCVa8KTr2uQjCHVLdTRvDjRwiJSXKpbXLTfjwlKJruYm9jprI1YzQrD10R5ePFt9P0sIUQ9jWvGZeef0FhsM7llv/sF97Bc5YSHT2eaPk5MNpFLVaSaxYo/NNPcmDzMuGOd0A6YFvs+/AltSp6cG6BVKXGI8VssZA7MfD7JLVDH8kiWzZ++foftjY2UXR99ZithuSaatnKdousn5URoVgr0m828smQhN++3mJ4HJxrS4gb8pOFG1G1xR97GTrE0PI3VVnzyZ6RQsCFu0kETPy/VG4izxuL3NBW3KYqna2Qi4rvS4hTYJ7uMvww8igdkFxmceMLbXLSvmOIcv/YDABLXlJm6aJzICzXGdwtQ3l4l8IGJb5WFV4WW94vYPhlpG8FjGLSjBOQ6GSdIqF6n55Rxep4d59PfTGXjyXF6tAwZN0hfI9kqLH9rRvtvP1tkBdA0XmDGIyKptdKq8fHTU0gaVdJOkLBcxUGm6Ors4EuxzGyi5np0qBOss5L0Bkfx8hJ9Zivf9w+ywkxiDJlM/1eG6DtVAqtM9LKLBzjI9GtJyorBnsWVAJw1+jLu+RJPBxdxv7onD629hS+iM7l9aDcunPI8OxoDZF0DdoQvnu9i/pkpAh+Z1DpkZl85Ru5TP0tP7GSP99bR8VSBeo/Kl//sxPHLmJ7cYM9vZhRa5FyBi+7VUww3MuJjcpWzX36WoGRy2aIDkHy66GY3FoSnKALwqalINZNrDj6SC4b+zW6lMZ57YD5mUAUbHv3hjRwVPYM5f0mB4xJZOiaMKNoEMu7kbH7mHYNkjg4RlquTxKHH9v47RdegV8vjRUKTJ+qigCAcNysFDnztTObcNsIbiXkcmP2S5wLz2WT7Oem9DybJRDnXT0wpE2s0xEwUck5AXAU8mT8f8hMAvKCCNJpFUmThEDQtiIZwdRVlosh4vBk2QZNd4pHgLg0JtICEIklCC1HxRL8E0ceQDBc34EMuVBoboUtLYYxIaw02wl/HHxQ038bT/lGJ9o9KNHCEGGvFn9X0aRkkcFVoerdC07vfwjs8CZCg3qIQvrdO/05JOrfLs44moiMVpp46QfybCvkrIxjH2iiOR8oJ0ankybgBck6AHm2CdOOz/28/W94GkM2y2/Hr0DfZDJ8YofPuAjs+NsynP+2i4vno1dKUPZWcE+CNSgv/F3vvGR5nda1h3/st05s06rJs2XI3xgZseu/NYEIIEEpCCaGFHkI5AUIJnWBKTO8tdEILzdTQbAMG4y5ZVh2V6X3e9v3YY5GcnMJJTq7vy7m+/ceWZjR6Z7T3ftde61n3M8s9QK9Ti4qDRxjkJrnxrTGY7+llU8LPnBv7aH4qg7AcUnO9DB8e5KV123Ps0g8IWCWazDQeI86IGqDekmKMc4f+xJlCYYO7kahdoKC5cR9t8RtnAda4erBt8uMDnHTtC2x8oIFtbt3ElHtHsDwQfqvIbu90AiCA3iMiuOpsZqqjrDLqSNnSxajTqB/z52vSZBIta3uZ546RsDUiSpG45efUj/+M4Wj88s2jmf77JFi27NYbTUBrI6oK5/a8xG65Vdw/bm9C8xO06XESVoBvyy28sv8iFqbPY+rifoRpcfcee3De+38ia3tZe56X6ddI8nGrlqTk6DgBL0o6T8GW59nTnziFDjGC49H5zUuPouLI63r1JGbe1IdTrvCQd1t2UtZwenwJ+W8V6rUSvWZIPrfaP1CrVFhv1NCupzj1wdNpf3JQ0ocCQrYUqwp1ukFLrpsWK8244ghNG7O4rAqWy4XoK2MjQ9qZxgDuVIWYGmLAE6W/oYWyI52BxFC1e9PnwVEVbJfKfpet4IfvLaP+gxzeTSZsko1EWs4hN1mn7/gIU64eJXWIlw8vmsys5ABT9hnFCKloJYvEPC/f3t2CXSsYyNawdbqH4cEA44eTRB4qEFkm7+CTbxhlMqOYAYUJ0+J411QQwuGbu1rI7eumURQpOTpxM0BK8RNRpTV7zAyPuUf9b49/rQ3AtuHww/F2G3zzYDOpHbx4Ok0iv81R3lanaXqaTiNKwXaTt910uIaJW36m6cOM2BLEkNvBTfu1Cda862Lry/oI9Jbp+XENmdM8fNvQwnTXEK/sPotD1KV4bIN3gzP5xNfBcelPqC/meN2/BX8KzGIncxN7plcCcOjIUg5lKWnVy0CihqziprJaw3pDIWgX0WyBiYpekudPp9qvVBqvMuHhJOkTvKzXapikJVhVaaJNS9Guj5KyvXiEhV+YxG0FnyjzfnEC9WqGdj1Fr+mu0pA0LtrrZUL7FMnYXp46+0C8hok7keCS3Ftsm+vikabdeJaZOIdJ09ErP3oRgG6zhusOe5yLnWOY/EgchODm/Q7h0jef4/adnuAO72FgORKj7iiIwVGstgYytod6NcOk59KIcoUzXn2FbqOOiFLg1gMPYZonJYlBHhcp02LVpU1se9UmVr/WQOIgP3ErQFQfplVLMWIFuXl4L7p+MgFRKDHR6pG4cMdmy0w3Ow9+yY6Vburt77r9KqgMuiKUFR1RKkrkoFDRHYttk+vYy/7mu3nTDQNKkE2H1tG0Rxpuh4Mv+pwzO18n+lwB308NbJegsKNObHaA+rfzYIJadug6qo6hY0NMuXaUjcF6DEfFf5c8j7uy8u85emGAdMSLbltE/AW6/HW0jE9jfqwQ+rJE7PAgS66dzhbpftT3LdruSxFcXkYAlkcQ/FMJexysmNbEbFeMlJqh34zQpklfQL9SJm+7/ylL6l9rA7j3XnjvPVZd20zv9rWojsPn10xgr4PXsvepq/n6+RbUiI0uLHbxdfJpcQLj9QSfldqp12SzSt+CMONvTDDv1B4sr8IXT4xj07w6fKJMg8iyvtIga+8AOGCYfB6eynJtHMenP+HI7DJ8ToVFHQvZN7WCL30TeC6wNePNBK35IVrUEhGjgBsT1bbIaj6GtBBfhCaxyt1KU2GEUxKSZuPpkRPokWt24adXSrlsydHxCAsLQcyMjElfQbZB16sZRqyQJBur6Wo/QIGZ1SPCTHWQ9t8/jL+zTOPZOTpiI9wW3p3XfdvIMNe2cUyTX+97FK2PDXFU3adEtAKLj7iHk0MnMe3BImo6x/lrfsRP2z9hZF6Ehg+G6DUjKNg49bXgyHP6v61bSE3ZYHD/VvyiQlAr8dNXfs6MsgSiUq5QmNPKJbc9RJ8ZYcbzMSZdEWf5bD/tE0bpt8LceNZxePuyCMvB0WTvf0Q1OGrTa+xeXEfEKlBGZVloMk8FJtIbqCcWKzPS1D7mlygME6s2wOWrHmen/HoejezIXb/anedn3kGuy0Wop4h7hcU2b2/ClZW7785ndCGA0Vl+YjcE6N6+jsnXjzL+pSSJrX0su3EcW1wZY4sbBinN0BEVhxlvD7Llc33oGfl3K7bpBNYZtF2Twj+hQrLDh7aDxYat6nF/VmHCKQkKk1x8/m/ttOlxCl06s+8Ywd9tEP+xj/V719H+VpK2l1JMfMEmumOR4gUaI3OCNKhZEpaHBjX7T80DCMdx/vtn/ZPHvHnznGXLlv3XTyqVoLUV5szh0wc6QQhpdKGl0ZbabHVMH7nZbpY92sb4QHYMn/WXFNxuo465Wj9t247iHrHYcGMdqSN8ZG0PPUYt23s3sarSyN2HH8x9q39Pg5FhSWAGt0X3ljVrx+GI2EeclPiQTlc97ZVRzppyIl2lgDTmSGVxSiVEOIQd8iFyRXkOzxa+U71VDGqMHE/03TP21uKqnxtaFvBVWHagYdv03ODj93MfHzMyKTk6TWqajO2h4LjHAJprqjSdmBlhumuQYkKndVGKSY/FMb0Ka29uYHifEDfsd6i8lqrkdvP7wTA56uUPaNWTRJQiRz53FlPvHoZMjhs/e4m8o3HFfkcxtEcDv/vVYq7f5UDyD7q4bvJzXLXHQhyfh3NefpERK8Sv/3QE0++KS+KRbXPZm89SQcV2FOl4u97g4B9/gxFROalyPMnGZpREVgpySmXcVoUflL7hh1mJSftzeDof1G/BF2YjhXAYMZSAuhpp9JktjbU7D+7dyN2/XETD/RkmXZXE9AtWPd3EpulR2rUk6416hOEw+8E+2n8XRzPAqFFQCw5K2cGsE1ACtejw2S/ayZ7hwqOZNGbytB0Wx9Njjhm6WmGBmpZrxvKCWoR0hxutbOPvk8cLMyhQCg7l8RrrHm+g4OhMu3GE2hcLlFo1vr6uhaEdQ7SqaTqNetoLw9Q9XqD1wRSuEZu+H0T45PyJdLSOUqsarKlIIMz+k1b93WtMCLHccZx5//77/zoRwMsvQyIBF11El/FvY1Jfj7Do2qoO9Rabub/oZ84J/Sy9ewKNkRx6VTRScnRKtkuepZ/S8YxYlKMq469LsmnLWnIdHlr1JJ8WJ9CgZeWk/IvheNzSRadQ4pmGHdk3u5KOygjPR7ahy67BagogDAuhaxCoxbHtMQ89szaAoqoo+aIUpJgWSVeQg2ZcyO8776fJSFFj5bm+9ym6R+r5zDuJpYEOlF9P4PrCoVXZrY7j97DLI8s5MPg1MUuhXs0ybAWoOBIpNWNNP7VvFml7LImWsRk6OkjfeWGcqELFUjn19TdoULNcdMapePuz3ynj3C6eWrArF73xvNQJHL6IH+hnM2ORzZGLz+eOU+7C8blpXDKEcaGKEwlyw5THyNoeHJ+H1ReGGLFCXP7yEcy4tRfH58Gq9fObJx6UEl1RIY+KhcKfW6bwod7BtT1/5Cr9j1zkLCRfG0UkM+xg9XJG/B2iVp6PwtN5UN+a3vFTJFLNpcg8gM9LdnKYq393DwkrgOUoeJQKlqMwYNagz7aBJJamMOuYGNnfeSjtoTKrb5BxpybwrzFIzXETWVEme4iHUlylYUkebfQ7hsTcR3opfqphRxVcvTbuTeZfwWRNTaHvxCATHkjRc2ItE+9MMHp9kMR4Hw0vZGi+L4trRP6AaSq03Jam9kWJLR85I8Dw6UHSXi+q4+AWlgTbhhVWnDIO6wQN/XaDtnuTHLrkaz69ZSL9u4WpV7P/tCTgv04EcOKJchOIxVjaNwmQ8I8uo442LUHecTH5j6O0npciO8vNpodryde4MByVbqOeJi1FzAhz+P5fYvhVNi6qYdaRQ1CBzhvq+HD3qUTUAiVH54k9t+Oe4cdkBOCbxm1NB+DoGmG7wFm9r7JTsRMLwdvh2fyu6QB5165UWfe5gsRzGyZ2TQBRMqR81nakj0BOZtIdv5d9sis5v/8VABaHd2WnShczSwNojk1BuPjSO55udz1xxc+oHmTUV0OlbBOxi9SU0qjTfBzc/ilT3xvCFbNwFBjZJcDyC9pwz5K15vmeXrrN8NjHmLW9TNOHWfjo+XQ8lUCkc7JFWFOI7VzLtefdT8b2cNGfjmLG9b2c/f5bANy6/8Fc9OYLXHvY0Zz73LMs2vcgKJa45M+vcfxLpzP1wRSiUCZzh+Cmqc9IWi6CiFLkRx/9nCm3VCTSK55injbCFX3P0eVt5Fp9Z3YqbOBk80vWe5pYHNyFVdGOqhLRw8JnP6RBk70GirDHIBqGo6FgY6ASVEqERJm8rTFn7wE8iolpKvi6DdJz3QRWl8GBUkTHP/zXklpHgUKdjuK20JMOat75m0YvqLqKCxAO2Coolszw//vnlrbQWHF8K7VLckx+I45wILeti6U3TmCoJcRs1yCbzBpq1ZzMVTkudOSGkbAC+JQy2nqb3c5eT2B9mWXnjUc/y2bE8rPPxDXff1H9u/GvHwFs3AjTpoGqjlkud1fq0YVJVvEQVEqsPLiZDZ56djlrAxMPjrNpcQ1DW4QJKkWytpedO7vwbTT45JpxaB0Wq15oYtqpw0w/dZimHTOMHB9geNdANTwGcMClMcFJsufwSg5OfomGxb21uzGONLsnv2VxZDdKHh92JIBSKOOEg4hSGbs2iDBt2eRSqmAHPFJ0U6kgdB1hmPxZn8g5CFQcvqydykv69vgrBeYWe9ja7GPrdCc7FDb852KNT6H4mc7n/g4+aZrMZ9Hp5Dc5ZB9o5uwbnqJFT0rjTxxiZpi87WaKO0ZEsXngmDtZf0QTU1wxfvbAmUx8uIemj+C2dxaw4Qo/V+33LJcbR/C7hYdz8vOv4QTkcUpJSyMTKgZXfvxHjnz2bKYvHqTn8BZu/Pn95G03irA5YcmJzLi0B8JBpheGsSNBGBrFntjCsmyIq5oP5YLYa9xbfA4Nm4/2nET6Dg876J0cpi0nbgUoOTqhqqWb4SjS7VlLUXJ0dGHSpmXoMmqlcAj53Pgv/Uw8LcHQCQFya0zqP8lTtQvFlbWwdai6nJGb6qLiVvD3G7iHZRRgBiA33YM2bBPoqWC7pGXY8F5+XIaFf5ksE//lqDSp9B0VJj/eRejTMttc1oNadhjYM0Sgu0JgRRnXqAktYCC5FWvKzUTUAk1amlXlVsktUHN06Eli0318/NwkZl08wPybe+jUonT9rO6fsqz+dSKAefOgvh5ef533uqcQEmUqKHiExYAZxkIwRY/Ta4YIfS0hDe5Rg87L64gdHcRAZ8JDcTqujPPBx5NIN8q2zaFCiHlPbmLa/cN4hwxsDQxLw+3IQ19FqLgcmZT7KDiNRxt2pc9bz7z4Gq4efI6LW4/gS1+7lLfW1yCyBQnlrDbFKNkijqZih7yosWSVpW9JSaym8oe1txK2ihzTchI5l58JVpIOY4RoMYXbquBWbAJOGb9ZooJKWvWyKdxClx2h3xMlo/uxqh1tSjwjuwZrw7L+raqIXAHH56H3sCYeOu1WYpZ0S65Vc7iwyDuuaihtcOoXxzLxwmrfecXg2o+e4wfPnsO0RX0c+MYK+ss1fHzJdnh7s5z94guc/vpPmXFDP7949y0qjkpUzXHmTWfS8qcBmXC0LFmL39zrryo4Pjf9v4E/zLmPtp8mCL0ncxKD+wbpObsWa6Zc6JJ1WJIYdGGNGYfoQtKcNn+9+YjXb9QyXo8TUQp0XDxM41OyYmCrkJvrwrPBwpW2xmr4Ro0CQUGu1c1QawhzhqB/mwjRLXKkhI9JagrfDQWa75THQaNOYc3ZjeSP1qj/sEDHCXHSc9341lXQC85YNGC7ILnQR/Y0H4mJXpIjHnZauBFU+PqNZnJub/XoatJvhYkZkbHjLEBIKY3leRTLYvvzu2l6Jcs3tzQx+9zBv3uN/cMRgBBCBZYB/Y7jHCyEmAg8BdQCXwDHOY5TEUK4gUeAbYA4cKTjON1/95VvHm1tsE72sBdsNy7FIm77iSrSudanGCQsDy1qlvQcNx+9NImtzutlyqWjRN4ssvqaRtybTKygoNDgwnA0gkqRWm+BkZMDrDymhWnLh2j9NEVocYnNRZeYGuK56HZ85ptEyhXEDnpQMkXWeSXxpr08ypfhyQiXDlXlmdO5CSa3Iwpl7LAfJVNATeSwGmpQKiaOKhCmTaCSR7dNHOC3oy8yrpJA5bsNuSJUKkKjokjL6FpTypnJyRJXt6uOJcGZvJudzEi4AdwurBo/SkF2uIlCCTsaQskWGf9kD5c9/cOxCofj97D2XB+P7novBhrdlTpu3+pJjDclUu3uPffk4t2O4LF37+QnxTOJqn/mpTP34oh7/8TLx+zKGS+fwIxb+vjV+6/Qa0R5fOGeYFq0FLqlWWmpjB0JsO7YCHf/4B6a1BzxKvrKchSsuwSh98p0XVhDxvQxe/EAzW9myezoZuTEIOk9PYBArx7A/aIi8eOWn5A+Ik1ehVlFi+WY4ouztDQed6KC7/MyDlJnIWwILa+Qm+Hi6wtb0Q6ziLlDVTdgxj7vuBWQC1GxKZk6Q5aXrd6Ik5+m8/VlLUz+XZzZvx4k8wc3yf3lzSP8VXlsQzEjCkrJQS06+N+pMFoXoHCcjr+5QvqWII1HJok+XECcKug1a1GqZq2z3P3EbRnRpiw/EbVAVM1jWCqGqrH65iY8MZPpVwzDUYPQ3PwPL6W/HN87AhBCnAfMA0LVDeBp4HnHcZ4SQtwFrHAcZ7EQ4nRgS8dxThVCHAUc5jjOkf/Va3+vCODyy+Hqq6Gvj9eK+1CrSnb6TD3PsrL8QFu1DEtLEyR73XYzSYlTfkBl1k0DOIogMdlHaKjEsk/G023UVxVoBSwUElaAJjWNhWD+pF5KQsNUNZZ62rl10qGIYkW253pcKLkCnqDOMytv4mX/ljw5bndymg9TUWWiT1FwvC4J/3QcGQ343IiyScDIs1NyDbsU1jG31ItW9d1b6p9Ep6eRLjXKhtA4RooadkBCN4TtQLmCEvbTMtxDi7dCWzbGDqWNzCr2YQPfuFp5smlXVqhygjjFEkKXME1h2ZIhgBTACMOUDj9/+fc1LRy3i9xtFldOfgmAvONi0XFH4mgKG47ViKzQ8SwYYnhNPZcf8Cx+pcL9h+6H7XOhFA2Gd4xy/cX3jGkTPMJgnFbk41IrrVoSo9qaXLsszy7HdDK4d4jOxVF0xZbViz+kaH04gz9WoVSnkdvKzehcP2wN3VNrybs9tPoT+BWLbrOGZMHHzOEBKpt0fH0V2jcmCfyhhFaQi9vwKwgctLxDeYJC14J6BnaLMDA1DF5Bhz5MyvbJkmv1TuxXyrSoWQpfasxf2EP3r2vomxKhfW2C6GsFPF8Zf3Xu7z0vTO9+NYSnV9iQr2XyRyM5ctHsAAAgAElEQVS0PpMh/HYRRxX07R+h52c1zLw+hn9Tma8/bKEkpNIzbgVIWAHmunuxEHQa9cx1D6DisN6IjlW5GjammXvgANpxJ8B9932P1fq34z+LAL7XBiCEGAc8DFwDnAcsAEaAJsdxTCHEDsAVjuPsJ4R4o/r/T4QQGhAD6p3/4hd9rw1g7VqYPh2uvZaPj7qHlO2jRUuTsHz4lDIlR6dgu6uegRoeYTJiBVGwifblmH7JMME/yx27a3EtX+w5AY8qS2lZ20OtWiBmBpmiJ2mZEKcspK/dJk89q/Rmxhtxmo0UEatA2Cqg8bdvJ6u4SekB+vQaOl0NbNDq+Do4kYLbx+TSEEeMfMxO2XVo2MREgBF3mNmlft70z+CW1gXS1dYwpX49m8epCSFKFcy6IGqyisYuSMw4mgqGSZOVZs/Ut+yb/pomI83bkdncF96ZtPCMtebaPg8oYPnd6N1DssU15EMUynJTU6v1dNOSFlvlitwQcgWMaa0ccNcHPN2zNcOdURy3TXCtTnRlha1/+wUHRlagC4sRMzR2Po8qBSoo+IVJ3tEkMcgKEFEL+DNlZu87iOOFT19sxwypUuqsj5Cy3WiGTfTNHP63DUIrigQ3Vv7qM3YEOG4wXSp61vqrxWhroJhg6YLstm7eenAGU8Uw4RcKhF8qEfm4OJbEy3e4yTa60estEgE/ti0IOUUqJZ3GRBb1Wwv38F/z+AtNOtlt3GgZm9o/FzCDCrGLQowcFaDTbACogj6zsMlh3CMpGv+QQ8k55GbrBL4xWPZKG5mZXr4ptTHf20XK9hFRJN0oZXvHjj6bnZjq1QyqsJl5UYzWV02IxSAQ+K/Xyn8w/tEN4FngWiAIXAD8FPjUcZzJ1cfbgNcdx9lCCLES2N9xnL7qY53Ado7jjP5nr/+9NgCA/faDzz7j/TfqcDeZY/bfHmEQVEoYjpzwGdtDk5al26gdO1NFlSzNF2eZ/Ad5Gam5HtKn+RjcO4ChaHQb9YwfHKXj3TgtV6YQzncZXkeBwgQXpYkaTr0gF3VTcHRmLh5i8KAg1rYqdhq0URvviIGy1iG0sYRwwNLADiroSRsjoNBzZA2FQ3UGvBH2PnANigHvfjyZUqPcvCJKhZjlq04EOfl7qz4APlGm4LjHkppT9BE6jSg2CuPNOMHby0y5ZxgroNB3ZQ2jC/wSv12dZB5hMGwFxxh+m5l0fqXMV6UJzHL3jyGq6tUsMSvE5/kOlh49i5HtoiTmyA/E05blmCnLeOvCXfGtHZa8AtNClMqSmrNZSKWqYxwDYVo42RxHmyv5SfLPnN14FOv8rTI6CvhAERIEaiM7+Nw6DA4TrAswPdvLODOJ2zLQy0VcPh2XWSFThli4mSHby2C0hSvXP4GPCs1mhstaf8jnflktErkCOA5hj8PM0gBTjGEmFWJEnBKRSg6/U8ZGYAsFQ6gkVT8hq0DUzPFg4x50BZrocjWQsWVDmKgYjLeSnD7yDnOKPaz0tHJjaC9++MkXY/kVQFqGpdzMe3gU/a4cWsEhsZWXzH0BemuDGI5GvZonXuUtRpQCEaVMrxkZg5wAWAjCnxbZ8uhBeP55OOyw/36t/Lvxd+cAhBAHA8OO4ywXQuy++dv/wVOd7/HYX77uKcApAOPHj//vLkOO22+HLbdk+sXDrLq7CZ+rjGULhq2gFJoohrzjqzl6zQguYZGyfWNlwqFjg0z+wyh9C8M0LM8R+XmChtYMuelu5g324F1V7QwTYOtgexQKO7r46JZJlF0SQuEXFSJKEesZ+Ta/PakFc45Cg5rj20oLUTVHRCnQ9Faaxhuy+DcYiLQMSa2AwBoviAs/e/5oLYoB6b280KTgQRqcrjei5G03HqUythj7jRpa9STtegqfcPi41Mps1yBrjQZ8okzMDLNBbSB6fo7SoSoTL0ow8RdxcikXpWM1SraOotrELIlOK9huFGw6tAxxITfR2Z5eVGzOvfIM6j4bxXFJ6s/uf/yGA575jNtePRCtuYD/PT8ZK8gH187HY+S4ZsnTxKwQedvNw4M7Yp4alG21mzcB25a5iYAXn2OwcNNyPgtNYV1gnMxXpAuScagqiKwlOxkdB5EtYFs2OVtnaWQqyyqG1EN4XVLDYNtjEZMV9hMtpegwR/nEM4lmM8O3wfE4ugulUMJuqEFJ50m5XXysB/g404Jo9GC01KAPpmRXpUeX/INqkvbswdfZrtjF8+FtZNSl6oiKzK3YAR/dWoArwz/i4vXPMK+0iduMp/nigzbE7iXa1BybzBBdZi2RUIH3zxiH+wcV9ti5k8iKIqHdS+Qu0Og7OkyMgES7qwa9RhRdj1NydNo06VodswIy+TmruoS6ur7fWvme4/skAXcCDhFCHAh4gBBwKxARQmiO45jAOGCg+vw+oA3oqx4BwkDi37+o4zj3APeAjAC+19VOnQo330zjmWeS+7Wb9HUe/KLCbO8AMUv604GEdoyYIXxKmREzNHbH9M0okZ+oE95QYs3F9bTfkSS4qoy338QRkJvhYvAnQSZekcD2CYQO6ZAHv7fCUCXCdp5uusxadMdk6ksj5Jtc+OaUyQs3bmGxtbuXlaub2O7qjUQ/KlCJqvT9MMzodn58Awa1b+WZevkoUxjFUcH0K6y4pgWfUmbArKFdizNsBtnS3c+aShMz9VEKwkR3D9CiFlhRaaJFSxJRCnxRbmO+p4eU7aLguGlS06yrNFI/Lc9bj8xgp190MvvXg3zltKIfbeHCGqPoBJUiMTPC/k+ezNS7B6QbUEbeJevcw4hCiUs/eJmgUuGifX7M2tMa6HihwO53f8Z7i7bnB6d9xkP2Hty08FEu3etIHF3jujce4+SWD/C8bJCwArToSeqVAge+dTYzrx1BjafYX6wnbJd4KrItdsgnwaceN47PjZIrodslahKDhPwKNU6GsJ7BSg8SD0ZJ2W7iFR9ZLYwd9OJoCmoih+33oo6kaFHlFLMVhZLQyNsaSjZf5RNWIxHblsec+lrEqIR+OKkMIuCXjxkm5Is4QT9pT5BQtogmHMxwQEYqVfVktJJhWnqAeblO5pU2AbJzdI8T1rPh5DoyF3pQdJuo+M7E1hWQN5fYz4O4VthscfkgE16IM3BbDa/WzWZ7b2dV/h2uUpjd6MIiqhT4ttKC5R9lhqJIMdz/4vhvNwDHcS4GLgaoRgAXOI5zjBDiGeCHyErAT4CXqj/yx+rXn1QfX/Jfnf//x+OMM+hfdQkdvx9lk1HDyqubGRDmWAttvSLNGqe7Bukxa9nG040uLPqNGrbWB8ls5aH5+Sxbnh6j3KDS84sIxhwN7X2b1pdTTLkoLjPIloNqgG/AYKAiZbZDVgAdC+NTjcaPsqy8oJlKUWPGx8MUPtRoeyvJzNjAWAjkiluMezbNuGf/lugqLFh5ahNKo4MLmzYtgSIcmrQ0FRRmugfZZIbGSMcrKtKBZ5IuqTlRdRCfcPjGiDLTFaPLrKXdNUrMDBL151hxZwvamX3MvawfQ1M5etLPmHxlQcp0hcDxupgy2IlTVyN9CwM+hndt5KZL7sZXtRy76MDjWfOLGh46+C5++/gxvPuLHTno3nexHYWpDyX4pXMcz7xzK5ccdBwXHfQTRCaP/pjBFeP/SI9ZQ0QpsWj3x5myzygDZoBdd+lkaNsgb+62DeOf6QXTYoKnxPzUWubnuphV6kfD/pvPir84PJYUnVXeVr4MTmSF3kpnsgZbUdFtucAyug9PwcRTLlK2BI5PB0smYvG4cVyKPKr4vGijOYhGcISQ7ABdwwm6cDw6ne5GNGymZHpZHW5HaCo7plZzWGIpWxT7/uYSay2prJx83yjFNzQ+eKQDe4JCRC1gOCrhLqnlj88OMHJBgPqXc0y/bIhJB4xwwJVfM/qDwBj0wyMsYpaUCpccjSmuGPkBt4ymxo37OxfOfzz+ESHQr4CnhBBXA18C91e/fz/wqBBiA/LOf9Q/dol/Oz48ZzKztEFm3zZIZGORN26cycTJo8SsEH4hPe0iaoEOfUTWiU2NPV5ZS+Pvsnj6TEyvQCjQ90QNmybVElGKdO5Wj3lZP+X3YMapQ2Pc/7qP8hy+45ck5/jIzvKQr3MxY3EMI6LQsDzDtDuH0Iv2WB04P0FneM8ABZ+bULJIzRcF/Gtl5rg0TkVJObhycpLPuXWAlTOaSOwVIGX58AiDDj1J3HaTsj1VM8kIIaVEt1lPmx7nm3IrUTXHN5U6mvQ0U1zDGChYjoLhqHToSX47uD8Dp4zDnclyhf8lZl/axy4T+4g5Eom9OQFIJISjq6w7byKLDnuQJjXDiBXk9AdOpf3JQTacFOWhgxdz/d4L+fFrb/DUIbtRr2V5Ys/tuO7PD3PxHkfyQ+Vs7nv5Hk545yRmXpWncpKPS5Qf031EI/eedAd+RZ6v9bU27gGL7Dlu/m3BE4yPJtj6rh68G+TCXR9u5gXPNvRpNaR8YVKanzQeVMuglhI1yWFqXSZNSo45yS5Oir0LQFa4We6fyGfBycBYsYNJIsVqrQ5RLKPoGk5NSLZKZ3I4oQBmnQ9tMCm5gIaJHQ0hirKMq+RKfBGYSEWo7JlbzWh9I7/c8AJbFnoYcNXwcHRnvnKNI+S2+E33MwBcN34hBx/xGZMfG8Hba7LPPmv5alErqQP8rCk3s+C9FXKOzIc8bvIL3JTnaUw+d4QZ5w8TW1okfnWAoNthrREmquTJOzqGo9GmZqhdWmUMzJr1v7qW/nWEQH8x+vua+aZSw8Q/xem4cATFguz5AV788UzqPTkm6Qmytk7MCtG8Js3kX48Q+aJEaraHvnMiGB2CLQ4bwvEJ3rp/OmIKNKmZMf7anrPWYXsF666tp/WTLE4OlC9sQl2lv0lwbK43b/73rx5TIDPHQ2InL56IRfSuHEreYf3V9RQ2uNj6rj4cBZY8NQ1lm++yvxG1QMryEVKk+KfXiBJUirTrCQxHoduoo+ToPNC7E+4zXNgBaevt+DxYQTfYDtpoFkfXqC8muav3QdZ7mvjVpOOq5T6NTZdp/H6rJ4hbgTE9/RWrF9B0voGoGKw+r5VbD3yEuw45CEyLS994lmv2P4KzXnuF2w44iMveeIZuo46Hf7Q/a08J8fyBt5Fx3Jx/1WnULU9KCbQQEE+y8YxpvGxfy9QrR1h3XR2ND+QIrytR2kJj049rGN0tQLbJg6va9Ra3/ISUEu/np/Pu8duipvNQ5fo5fi8ogppsnDnlfuZmu9ipvJGgXZKGIZ5G2kujLIlswe01e8rQX4gxb0TK1Tu934vIFbBqQ6ipnLxWw8QJeMfs287OvsteyW8oqm4Ux+b+2l15o3YutiYbvOaqI1zb/QQAp487nuM/ep+s4abj7lEm3pwAB+IX+vnk2Insu9dqktN8xB4Pk7B8UtWoZlAtG/8NFabdPUxyZy9L75jAkC+Mik1QLWI4GquKrZz+83ep7a+XOQDlfw7y+oeqAP/s8T/dAJZsnEajmsNGUOhTmXR5nPq38xQm6PSfGSa90EvW8jDpllHG35ekElEZviTIN4e2oKvyFuH9xmD+iZtQizbLLphA8RidQRFBFxYLt/wK4YUPlk1m2AoyL9FD46UZAm/LEK00XqM0T8P3qYF7wKI0VaN7p1pqa4qkPW7SzV6KE11U2hUmDKRoujpN4IMKuWkuOm+PEp8cpOKodDw+zJTL4lgewcq3m8m3uuk3a4ioedq1NDHLx/pKk6xyqEVuPv1YPN1JhGHKM3Q6L400GmvlHX1zz4HjICqGnCgVg/2c9ZzT9xq3Nh1A7i2FnQNrGTBqmOSS9NuEFeC2Qw4dWyxrTqvhlv0f54LPj2DapXHu/uAJuswA183fk5uXv8L5B50Ats0pf3ydix87nkmPDrDmF0387uBHcAmL5+Lz6PtZm9RBVBfWb7qfYktrEK9lkJ+gs/ScduwF0G3V4xHGWEdjRM3jF9+V/irVyo5LWFQclQ9y0/ny0PYxjBm6hsuqsFthHT/re5OQXcJE1v/PnnA8GwKtOIoyRjlWklm5kQR90gvA7QJNxY4EZFm0YmAHfCjxFDPsYW6OPY0hVM6uO4JuLYoTCiBMC2ybuaVerh2UEcBpE07gxPffGTMuia7IsfVRfagVh+wWLoIrKyx5aiqxrWVtf/P72oy13+K5ASZdOkpuipu1T9aTCvnHuJbj3k4x/mdJuOEG+OUv/6419n9qA+jua6bX9BEzI3iUCh4qtCxJ03ZritC3ZcpNKo4DniGLnh9FGLwkRI+/Do9SGcviZxw3zbEs0fOz1H1coNisM7ggRG57F7NPHsTyKqy8vYnpd4/g/lyG8EZQofO6KENKmJ0u6kKYDr3X1vDx/h1YVcV+q5YkY7mp+yTHnAcGCL5XxggqDJ0fpO/YMF12I9NdMWpVg24zwPb7deNebzKwZ5ild0+gXU8QM4NcuOhntL7SL1uIN8e1hilBGfmivBNW226FZUs/vaAfO+yTFNtq56HjdSOE4Ima2/CvLvPVp60Ir6BerfBFuQkFm7sO3F8mwCyb9ae3cccR95G1vTyw3x4gBDcseZITvj2e6KU6V7/wED+7/myaPohz5+sPMGK7uWKfH2FH/Kw7LsBDC+5iTbmFbTzd/Hq/oxGFEg0egwfWL0bgcH90N15s3J5fv/bUmNlFydbHyL/rDFlPb9dHx6IggLjtp6kKymhQs6RsH7Vqjl4jyvXr96P+pAwzfRlu7nyUja46JlZGMVG4s2U/1okoW5V7mVweYkJxBJ9TwedUsIVCFhdZzUe/L0q3GmWjVsfq4HhKBtzU9ziTrAQex+Sj0DSum3AYZsmSoi7TZqvUBq7tfxqA01uO44APv8QvKmMKxYbONFsdMICwoDJJYeUbLeQ1F7qwxshJm9/ft+VWtv20k9mnDJKb4abr8ToSPj/aoMn2h23Cigq8KwpjTMP/6fg/tQEs2ThtrNNMFzYlR5XILMvDzNsHmHbHCMKW5bzszh669oyS3N3H6Lggs92DrKo0Uq9m6DdraNdG0N5xGPdoioaPsmNn/78clbDCxhOi9J0cpuGWArMfGCA9y8NrN8/GO7nMXPcwnxZamLJ6mKZXs9S+msc7YFKMaiR/4uObo1vQo/aYBrxUhZB6hEXk7gLtv5WZ3dNajmVjoEX27RdKUpRTkqUpkcpK7HaxhFMrcdVYDkq+iO33oqRzsvvQqtJuPRqVGg/X3XsXKcvHlOUjdPxolO4ba4kdEUTF4eJjT0EfSGLVBlBjSdaeO57fLHiGJi3FRdecQt3yFMlrDa6b9jw37r0AR1P57ZtPUnI0rtrxQAYPm8S9Fy7ixBU/ofWkIairZc1ZUf508C0MmEEytofMUi+HHPs1EavIi/Xzuat+b+mSXHVMjjyc4qzmt1lXaayy9b1VdaZgTbmFei3DXPcw3WZgDKO92Q5dxZHJxqquYZKeof74BO7lBou33Z1fvP3uX/0dh/QQG71NZBU3BXQURRCs5IlUsrQ6GeoNqfs3UejXwkwwk9xXvzumBacm3mOtt4Wbxy1gk6ceJV9krj04dgQ4rf0EFrzz+Xel4nKRuutzNDz4naff4L4hvr6thRn+FO8XJ2A4KvVaBh2LEStEuz5C69tp2k+NU9jezfs3TmaX4zbgGzL48g+tzD+w53+0rv5y/J/aAL7YNJ6M45Z4JlFBF7KpZcLTCdovSZCf6uKby1to/ihN/R9z+HukoKLYrtG3VQ3WHIGYDcNTA3iC5ljYZmYVGt/LsvUve1ANyLa76bk8wtBuYdzlCh3nxGl6I0vnMVHSp7mp7SmT+9pF4zKZpFHTDpYuyO3iJn6wn/SBXlxemyErQGelgfu6d6L2NANKZUncLZtsk9nANQPPYgNP+Lbh8eY9oGqUgZDob1QVFIHtd6OkC1Lnb1pSzquqMjtcfe7ojo3cdPlieo0o9WqGVeVWdvet5fNiO0cdvBQnKPjDU/N56cD5kplfpeL+6u0X6ao0EFELvJqYw8APwjjhAOe//BweYXDNfj/Ejvg59QlpE3b93gsBOPvNV8naXu495lBERb7WuhPC3HbwQwS7S+x4WBe2T8ETM7mmZSEf1syEkSQ01OKoAiWZkx2SPi/W/SbXTHwBw5FGr91GHTPd0kVpc2I3ZoYJKSWCijzzu7BRhEPK9hBRSuRWudhhQRdWSMWVkLu5pYFqQucRUY6JnE/NkgSOKt2WsaQEWhTLBMtZOkSKuZV+Dkkux+vIefOtu4UuVwO75tcQsMt86usgbOb5ODKdU4blJnNax8mc+M6bOH3gf6XC5IdHcA9arD2mngkfJ3Es8PaYxPfzse72Btwu6XO4uZ/Fp0inYJ8oU/N0ge0u3oQRlv0FXz/SQmAHiylt/y82A/1/aSwvTWC+txsVBwWHXjPMlo8N0HJ5mswuHtYvrqPPXYt7e4tV5zQzrjdJ/ft5wh+WafsgiecFOVGnMYwZUSi3acQagtTlcgS/KI+1iw4f5Kfyqc6sJQNEXi3iSlgUmzTGv5xEf/y7clVpokbvvhEqO2iU99aJB308ProDXadOR49lEeksTtBPDfJ87oQCsu5uWqQ12VgSU8PMUuTEtJtrUbIlueg9LpRSBVEooQiBVeNHTRdl7T6Rxa71oCSyrDuzjTsPv28spPQIg6iaZ66nh7jtY0tPH8NHB5l69Qhf7zkBvAJRMbBqA2z4cRAVm4hawCfK9B/fDAHoOiqK4WjELUn9VWNSg+AXlbHOvtM/P4ZF2z7FdU/fxyUHHYejKUy/dYCL8kfz+SNX4CiCby9sZJvz+jnops/54PotUPxeKJSknFnXwOeBUhnlTD+XlX7E6nMaeWrBHUxxxbAdRZKCq0zHKfooWUfHcFR6TNkK3KBl8Slluow66mszGBEVz6hFz14RvDua1F2ToxJRmPRsnHcnXca7t0zDM1t2Eq4vN/H8pfsS/HqYrBNgef04ujItHJn4lGdqtyOtSG7DguxX5ISLdZ4mtilsxIPF9OHY2By4uecRxPY23picW6Pz/ay6NYK5ncr6WzRm3zbI6gsamXHTEFueNcj6O+qY4C4yXA5SQcWyBU1qmp5KDZPFCI4KWtpm429qSM73Y9r/PxR0bLTqSWJmEI9ikLU9TH8lRsvlaUb28VO5O0AaH+3KaBU5XcTb4bChvQ7jeI1aJY930GToiyBtPQn0XovgphITPkug5Rwc9bvf03FnAkeR2VwcmfzLT3RjjlMoTtGITQqzqaOW1pYU51x1BvX3jOA8oqNki1hhP5pdkrZXjoMd8spFDTILXZXHhnNSkDLqDlFj5kBTUUfS2DVBlEwBRQhEuSqXHRpFNSOQziKCfpyQn5teeoCSoxKzQqTs7yoHm2vK3UYdEbVAp9nIOw/P4nHuYe/iau71NOB4XGw4OsjFB75IRCnTbbi5d/+9EMUsCMH9xz49xiUEQFXwCIOvSlK5KQyLqVdkaX0jjSIcLnvlSa486Cgcr5s7r3kET8Hkq4daCWSrSb1awbnPP8fvFh4u3XoURb5y1SrMrPGhJWHGjf385sbDcNw6Z/3pNdq0FBFXiTWVRr6pNBNRZEnMdhSiWm6MmajYFjN+PoSet0lt56ZtSYpVBzWRfdJD2xkJEOAasNjviFX0XBohebwfj8dg7s33MWwFsR2FFj3J28/OhF/CUnUcX7VtwXPDWzJdSfCD/BfsFF+FiZwkXZ5GppbkJmA3CjLb+uiZ4Sa1h5fkRD+9RpTpzgBsIz8/sbXD6l83MuOqIZpOz/DlbW3YmsSlNahZ3N+WOOiKlQSXV0jO8+LvLxN5qkzLTzIkHO//9jIC/kU3gM2AiKztIfJlgY4L4sTmB+m8LUoBNxGliE+YBLUsayr1EglWlVd2mzU0NWcY2DdMgztPd1eA7U/tRi04rDuvnoHTQ2QdD21GivR6N9ue1INWsem5v5bP5kxkpnuQw586l6mLNmI1RVFyRVAU6pVR2USTyYHbhZrIjLnJ2jX1skyna3Ih2zaksjiRIONKcjKnhYcmIwUjCay2JtRkVrLtM3nJFwCIhKTMNhrhjD/+EZB9AnnbTZOWQseSuQVsmvQ8A2aQiqNx7957yDCXEqv945hV6sfxull3Yi1/OPw2apUKKypN/DkzRUpd62pQ0jnytuw7+Pk7P2WmEcMO+rEQtLtG6Dq2iUmPxXDcLuK2D8tRUIWNURdgwer32T2/lvub9+Sq3AEsSV9bvX4Hj2JwwvOvE1EKLNprf/l9RYFyBTVdku/PXT2a6Bq3HXAQCMEpr74h3Y6VAi5h022GadPjsonG8jFihpjx7AB1X+VZe1M9mw6oZduTNzHjlzFW3tHMO29MZZtbe6l7LI+jwsTLk9S8UyR/hwuCMumYsAKERJmfCGn4cfjTS7lgyscsK9dyxic/ZvWVLYzTtuGE4ufslFlLe0maqC5q3p8p7/eOKU51YWJX/RXiVoDaBskmKI64WHlcKy5h0nFlnK3O7SV2Z4jSUo3p9wwReaeEEVVYe2M9ycO9RF8uMOXsUXhJJ3uo65+ylv4lN4DNYphoPscW5w5SaVDZcF8dpkfFgzGmouo3w2Rtryy7WCrdZg1BpUSvWYvtKCQ+8rDzGZ1gwdcPthDfJVClzmRIr/Ww83FdxPQwv9H2o+fySWCYoKpMzW3Cro+glKp3tkQaakI4+SJ2Ko0ysW3MmQfHQVgWdtXa2/ZoKLkyNNSCYbJdfgO9Wg0uyySjeqUsVRVSrGM5OJthGrrKxiObuOfYxQDEzDBG1TIqqBTxCBNDaGNn5a/K0s34haN3R/irPQ4eF2u1Bg5LL6fnyBC3HPoII1aQmCVo0ZJsOHsa2uhGRFM9G05tI6SUiFlhZtyckBFJOo+/2up76zH3c/uD+4GicPL7J7B410eJKAUuX3w/W2w5xEpPK8/4t2b6ohFu33Y/fseTlPMaTWoeV3WjOm/Ja9yy98FSped2Iar8Q5EvSshqXpqFYNncu8tOoOus/jPjYdwAACAASURBVFUr9x5wH35RqcJe5Tm/SU3Sdm+K9FwP1sEqLW+kcXUI7K8Fs08bZEbjEIVJLjbuHaWxJ4NvrUH4gxLb79JN/PIAyw4YR8BTpt8KU4fKFEbRHZsNhrQkf3yn+1DetBkwa8iuV+AASPl9NOSzHDv8IR9/MRFjG9nuvLmJxyWkajNky/cxSoB2fYSun9bhShu0LcoQnZ9Hj9tUalT6zw3z7XHNjAaCtIgk+sIyhUU66hNl9IX/gULyf2H8S24AHfoww1aQpusy+PorfPrkREb9QWxLQameZUuORquaJmX5iZlhVGFX+9RVFGzmL9lIx1lxCm06G+6rY2B8DTomUSWPf0OFKYeMkFCDXBI9kmElKO9SqirLci79O6imS4eakDzL1oZRwrJO7IBM5Nm2VJgNjSJqwii2LctI+RJ1RoYtC70827QD8zOdxG2PvOsbFkquhKMIrLogVz15PwNmDT5Rltw4USaklIgohTH2XqdRzzbufpaW2oiqeR7edzdpvJnPgu3IcqBls8bbgp5eyiMz70TTHWxHUHI0frPXEWjeEjREIZ1l0ZGvjLH/EQIlnhmz1o5bUrbqeN2IZIYZNwoqu6isKTdz8CMrqbXyXFN7wFiy0l/VT1hxlfXtIf4f6t4zOs7qbNs+7jq9SKMyqpYlyw0bbGJCL6H3FhwgEAKhg+klAZ4HCIEAIdQQSiiht5geiikBQodg3HBFtmz1GY2mt7u+P/Ygkn/ftx7yw7MWC/BaIM3Mvfe+9nWd53GmrCDT9TGSVphfLnlfZAkcdNh/KPVAAEulam2T9ftwFZmZ96S57dZDAZjzwmame0eZ6x1AXu8S2VRheP8w3buO401ZWH6J3AwvgS0GnjEbv2vgMw30dO3K4ZVQsw7xi3MccPUaMnv7yezkw/KIka42YCH3ABSxkbBdhW5tnLxcO433tuFVCPnLHHrsKtacGke+yCEaqDBh+6m4moB8bBYbQHtmguhtFfwfG4SXiuuglnIYPizEpptjLJemMNs7hN+uMmzWEfOU8RzpI357jvWbm5j3/9Ez9//ntVVmA3oli1Kfh85n0yRPCjK+ICBADqq4TwsjkEnCDtKoCMhDTBYgyYwdYNbLI0w7d5ziNhorn28h0+WfvFdKm1x6fp7E1lUUx+K4ic/EyV/z6culijCjZLICumHZwrsvSTh+j5jZ2wIEIhVKYFrCgNLbITBZrisEMh6dn098iovEPwKz6SqNsd4Tx2oKg+3ie7TAWW8s4ZInnsas0W9GrQi2K5yHFVcjIlexkSYFI3lHY3HiR1y9+1Fiw0qkcEIBoR0oVXACPl69dA4A/mUma41mZEnkDjghH1bEC5JEdZsOOtQMiuSIBqBtC7ZhWST0dmgpDLfGOmyqA8flzcy2tBYzRO4tkdwnwDfRqeIK5NXJS4Kv9PCSvYjJRWKqGI11aCl28Q5RcTXOfeN1MvMaxESgUhXJvVVDbLCKLD47ELLdgA8Mk5XH9vDCgTtw0a/Po/Vz4bdofStHaRudNx+ZxfNL5/PV852s/6KZTb+oR0s4lHo89D3fwDfXxcns6Ae5lgJUdIm8V6b3ynFmXZLABbqvnCB2TQHjMZXy2x4612YZGokgGeJO/1119u2iBiaO8TP7gVF+fNhm1Jcs3Bcleu8fY6/L1rHdlUO4wKxrEsTvyWE5MmvPb+abt5uZ2MNH8xsFoksrxDXxHgJylZAiRtz5PTxILizYsPm/spa2ygqgQTH5yQNrcTSJFWe1krTCtKppMrafkuPBL1fJ11xyjUqOvOMj46psp6fIPAUzfp0ks4uX5fe3IweF5TamZvAOGsw4MYlkwsjLAeIH5Sd5dpJpic63qojTPxTCbo6Kxp43jFSpIrn65Knl+j1CjQe4qoIynsNuigpcl2kxtTLG/rlVvB7ZjpZ8AgWXlb4Oznn0eXq1JKN2kIwdoE3NoOCiKXnaFPGA+GVLiGCsCCYKs7VxllZbueGiUwisSSLpNTWgpiHlizihAPi9rDsjwi0HPk35RpXotwJIGZUtrthzIZLXRHFdkGVufOg+ijWiz3fKSVfXkCpVGuUS+VpyL44jcN2WzeZj43QfPI6ad/jiwi5+M+dFbtpxPySPTs4STbOZb6U4YdtzufdQYRtJ1mzEMaWAjcwtN97D/RfuReoE5XucWbY4KXqSylWRfSgzqZVAVahbOQ4viO9p2dWt5E/xEqDKhCnQ4UkpSN81DZTm68z43wT+Uwyyvw/y9cNt2AMKc+8fpvXZLFreoThfY+0ezcx+ZhRfwqDtGYOOSmby2ZtCavKfm18Rd/vZNyYm/8zfZzLnglHmIJqD1WYZtehQ6tFYe3kz1Z1UCEuT3MORuyLstLCf6eckyDzvJdsdqCUlu5iuzJZ4E9NJ4hu0fvB1BFtpBdBf9NP4RpHxIwJE4hV69VEUyaFDzTJTH6VNzUw2Y5J2mIQVEifk6w6zrxhlfHc/qx6OYwdE6q7hKiRH/cz4eQJvwWTT4zFGeiMgS+A6/wa8EE0+V1NF9HSujJTNTwI4ATHm8wsCsBOtyUYlSXDyyiYYJj6zxK+HXiGn+HgqsiO7SZsxQzL7f7CCGVqCtUazgF/KVQasevyyxYQdJOP4MJBJ2j661QIOMho2i/Pb8fDeuxP4Ni3uz5qK69VxTRPX60FyXdb8uo5nDrtb6P7rZKSsmK2fdeCvxKZVqiBVTKSKsCYn7RBDVh3n3neOuJ9XqrjhIElHBKkk7RCrr2nGCYsxpqsqtL2UJbWbH2e2RKNc4qf/XAmqQi4QBaC+mGbGPUnOev1XAsXlyuiSzYAZI64UKToeFsXf5ejXPsMN+IRLsVKd5AWgKqI3YjniPYYDuH4vC1Of0W5mcIErH/0Zv9/3aJ6d2JGZ+ujkFckrmYwdGWbt680YUxUaF2VZcMoAMbdA5qYAnyzpwmhQ8H9tMu++IdL7+ZBNGDkpxOpbm/js0i6WXdDO6kub2HRyPQC5OeIqML6zn00X1bPhygaWX9ZKtVs8CxPnBhj5aQTZhC9u7mJ43yiEpZoYTCNhhwhGq2x4uAE02O7UEYL5CprkoEkWQ1aYbkVsOOO2/7+ylrbKCqDp0wJq0SF5YJCUHcArm2TsADG5RM710K0W6DMFYWWuZ5zVRozA5xWmn5cks62PT//cjamq9CpJco6XOqvI3LNH8I5ZrHyyheTs0GRaLS5i0Qd84NHFnb5Uwa1Uxb/7fbXqoNaxD/mR0jncgI/4xCg7FPqYJk0wrTBMs5nF71T5btI4FKznjh2eoOnlAtnj/DgemZKrElczJO0ws/UxRu0Aw1ZosrGUtENo2IzZFh1qhrMuupDQ6hQEED+/ZpZhPIMUDkGlyoaz2/n7PreRcTzElRzlsIY/V8V0RVKQq6mihwFc8O6bk1oCBZfOxcPgusI0k87XriM2UbnMkn3u5MJbTsb1eegtDeMbMBlYFKFNybLRqieuZXBVhSI+xuQQPZaYlMy6dZhF5incf+QDhOQKOdnLRrOeqFxCx6FNS3Ph66/wRHJnUgtDQptfLAvA6mhKTClqFUKgkOeY5Kds9DTSXU0SyqfIdHbRd1iMK8Mn8O1v/Tyx40P0mw10aeMUpuisej5O8BGDGbcn2P6AQdacFqf+7ArvvdnLrj/dRGCgSusTeVyg7S952vjPoJhyq/isRraLEF6VZOiiKJu2b6BNzTBkRcmf6mHWlWPE/lykTiqSPDrAyLZRuuRxbCT6rRitapqKoxOVDfpbo5j3Kuxw/ADdV4/zxW1TJ6+ug+ujzGIUtfO/0wTcKisA32qxGLSdXDKOX5BmkYjIJjo2q4wYneqEOF0sP/qQycyzE+Tavbx+3xy6ImnqlQJFV6VLTTHtf8epX1pi/S2NTMwXPPq848UKCasoXg+S44qTqBY5LXk9YuRXrv0Z4AZ9+J0qR7jruGvTIzy65QEWTfyDnTLryXhD/CO8DStauwBIzAmi7WDQ+EoR2QL/O1UaXi1SU/JiuMrkwjdchahcxnAVISeWhYjl8t2OIfTRRvF7yRJOozhpkSSIBHG9OquvaOEvC++nz4zhlSwyjg8zrKBkXR7ee3fhL/DVNrZyFUVyyNUwYhnbjxP0YjeEkfMlXF0j7/gYMGOM2mFWG81IVRMn5GWPwjosZMoH6PRbMUBsINe+/RxIEuv8rcwoD+P6vTihANPvT3LGq6dTdHV0yaZbm2DIqmPUFnLfqFLimIZ/cfEHbyK5rqjASmIEKmeFXkIqVdkvuZSQU+X9wEwAmqMqkmkLX4Tfw7RrSly7/7E8ut8eNfBrlZLsRTpd5st3OxnZP8yce0bo2S3J7KdGyP9IR3Zq0g9FyMktj8Sy61rZ8GgDH13eQ7lF6PGnPyXGgFLBJaYUaFYMEVXndUgcGMRRhUXcnpCRDYeiKyqGkFxGxyGqFNlgxvDKJoUFPjadH6P9lSwdL09QL1eouBrbvj6I5ZFI/ei/UwFslRuAd9TEiCgkvAHiapa840OXbJK1BFWvZE5aZtWqzbyzh5BM2PBgA9mIn1E7SL/RwMpKB+GHy7T9LcvGc+vJHuajXhHsvHqlREQvC7WaJZp632X7udGQKPtBTAa8Og3lNGeMvcvj6/7EWSMiTeehhj05Zfo5HNd9Lsfc9SumnzTE/OF+hn8eZuOr9Wy6I4brh+TsAEZEYf4Fg8y6LEmpIhZF0dWZsL8HReQdH11qlhuPPI6bDv2Z+Pl14VrUtVgQUrkqFkvVZM15Ue7c5wlGrYjoSNeyEuWoS36dH9fnwfV5RJ6AZTP/VdFoitcgJPVKATlbRElmxTXAElShqFIkZQXp1cQCUMYy7JFfy1LfFM753UW0qmkalTwyDnnHyyVvvszaYDtxM0vEKEyyA2f8OcGvXjiLRiVPyRGVD4BdyxIMyxUalSKnvvgGF7//xmTg6HfTCCfkZ3tzkEGtjncb5gGwTUmARpAkJNf9fpRo2dxx7DGcdcApXHjHWZjI+FssvrhjKp+9MoXCPI3O27K0vpCnOEPDiMpU61SqnQpK1WW7a4aJfFjBOlZi803iClCcIzaC2ZeNIi91WWXECCYMpl05zqwzEuRmeVl9cTPx9/McctkqJqoB+k2hSzGQicplQnJlks+4+ex6cgs8bH/tAJXNMi3rszQsLpI4LERLrPxfWUtb5RVAqfkX1lZbmefdwgQg4whduGzjdS0MRcFBpuW3ORq+KdL3QAOZLj9d7jgKgrzT9kmaqTdMMLpviH8u6mVXeTOGK6NJNqYro9ToNE59SGQDDiYg6BdjtVAAJAlvJs1Pq0tZOP4ZqmPzQWgmL/q2pc/fgqtrXL3kb0xU/Wx39SAdz2XpP6qed66aRbebZNYDo6hZl/Eng4zNDNJxV4aeu1LMTQ+TeDBEBp9AQys52lULTRrjnIVno5SLYiMKBwQ7LxJEzuRB18RfjsOaS9u5eZ+ncZAno9INV6FRLeP3WZg1WKf4QEWXfd/QN3glk2ErgozDumrr936BqgGOQ8XRBT5bMyi6Kk7IR0chR7OV4+mm3Qh/PkBMrvJVtY0eLTmZ4rROFS6/GYVBvgz0gC0Yf9MfnmCh7zxu2e9pKq5Gl5YUTjknwBQ1x3IjTlttunPJq89z2z6H1KYLHpThJLOrI3wUmE5KCzGo1TE/18eLsR+LKs2wBAegXBtZ2i44Lm2LN3LFS8fg1IdY9PyLxOZVKcR91FOhMFsnsMaoKUIdSqpG+QCNuiUVmh4sEHuyj8xOAj1ntqmw0sSxZHY+dhO5eV5Cy6vItsvQaWH6Lm5gQg+i+B1mXJ9kZ20T+Tu8TEgiH8ErG+iuzXqzgSY1T7/dgHyrwy6HbKJ3URKyLnZYxr7Cw4AdpOe/sJa2ygogG/ehZ22C5QrNikHKCmK6KqN2mGErQqUmkOn9JEHX02m2nB7lkz17/iN0Q+u3mLEoSblH419/7ERRYMgOMuF4GTBj1MuGMKXE/UiGhdc2OMg/QEduSNyxNZUFg0t5YPwpfpH4kC+CPZw69XRu6TyS9e0zOOfdtznj9bcojOjsdEo/Hc9lyVwQgNtVdlrzLV03jBO/J0c5qtJ+eZq5h43iX29S2FOn9d0cDQ8U2FCN12b9Kj/+x3lcdtBJKPkKdp1ofkm54qRqzvXqwhxkWmw4I84dBz/GdC0xqYswXIUONUvFVVj6RjclNFx/zXBUNSjMaWTIqmPIqpuU1j73vwdCriCahLVsgpBcFg+vJCCWsXtHmJbqB2C9U4fTEGGlIUJTkjUCse3KHPvWR9hIzDJGcb0CS+5qKlK2wKw/DHPpu8fRoaUmF7/pqiyttqJJFrN0gz6zCU2yOe+dJXx7aquIKNch5FTYEmgCy+bT6Ey2L22m3irUGpcC/oFpgq4hZ2rOvNpoUc4WuWfPvblnrwPofDbNyJkh3nllJm+8vQ1DJ0ZxNAiOmoTeq5D+kVj0Vp1M+CtRkdW9KU5lPWsjWxD5qsLoQWE+eKeX5Vd0UPJ4UCSH906cxZpLm+l8JU3wjxWKjof8JAJcXBv8chW/XMXuUFh1QivhFVWCwwZf3d3BUExMt/4br61yAxiZI8Iuez5OssqI0aUnaauVnQJnHWEiF6DjN2mMboXEJaKMjsplGpU8umWy00X9yLgs+0sb9ZESbWqajUbT5Ck0YAdRJIft569HqpoEC1ku6P87c6QUuk9mUd9LXF94i6Kkc2nTQm6MHsjHN7Zz7WtP8pvFTwMw+4MhfnLIBuqWlVjzm2YyJZ34zhPMOWaM7oeEx6DQq+O2SnhbLIJrqwT+KYQvbTdmWfDFJryyyXUHHcus/0kI2IfjomRKkyMwdE0QbasmkuOy5rIOnll4J4rkMGSLzykklwnIVaquwlm/vpBgtUhR8eJqYrbvBv3ce8ed9GgJGmtBnD1aitCqcagX0xDX5wHXpamGvE45AbyyweENXzOVDKYkM0AIaSjBH/7nRLq0cXq1FDoOecfHt2qc9ds3s2t+HVImj1SsiMZeQwTXozP7+kFOfv1MIjXNhvgdxBXjo0odPVpi8r38duEzXP7Gi4RrBpmcNwCuyxLPTFQc9susQJrIilForig89LYjrg8e9fsrXe3zOzrxKRnFz5mfnssVfz2ZUE+ZzG8DPPnpjgwcEUE1IFIT7ujDNq4jDpLhk0KMHx9g2V1trHihBbNBom5NiYZ2AQOt1JBe0/VRRs4OM3Z8kCn3pAm/UkGTLFKObxLrPmxE2f6bzfzojC3Mv38Qyy82YW/cmMy3+G+8tsorQH5nD9VGhenPjhE41ECXXfqtCAEMiq5Oxvaz+73r8Q5ZfPpsFwXdg9c16bdiyDhMvzNBYIXJxntjjLZHiSPm613auCC1SCJ+TMJFk+yagEd8VFGryN3L76HdSrO4cSfu3PsI7vvDnxi2QyLLzvajjdn8+OZ+ml8uUJimY/bIzLhlDFeSSO/hZ2J7P62v5Vh3WyMbDm+mS03Tb9WhYaOPW3Q/kmTKvRm2O2mIvzT8BLdNFWkYNfiHqyqgKDh+r7jnVkxcj8ba85v422F3YSMRkit4JZOkLcJOhm0/d47tS90Hmwi4VQqKFyVdFP0DXSPjeERenVmHVzboNxvFCNOqvX/Hxq1UGLIFr+67yC6AeDnPgFaPWV+HVKoQXZpgwIyRkctCi6HmiMoVAkdX6Vyapstbpt/WsaO1WPVcAbweZt0yzKHWxdx6yBPItcQkDTEO1SQbu5bDpdVitc97aAkcAHoqQ319jlE9ytf+KRwx/iUvt8+l4vOIKsCuZRb4vEgjNeirJIEuISuwQ3Ejb0W2xbBlpiwe4/dPHyU+479UaLw1j8+yiL1RZOOp9bR+kcO7QszkWx/LU+5WaTLyJLcJsvkX9fTelkJ52KbpjDxRuUzR1UjZQZqUPKuvaUHZMMyOv+lneJt6VvqbaVuRYcaKFN7XK+hbbIyQzPJL28gc7GXXQzcx7YYUhfu9k/CUH/q1VW4AHs1i4xkxZt2QYPRlm/wRHhRcKq6Ggst22S30PJJi8PAI5R10GpUiG80G4kqWhq8L9N6bJPnTAOWDPSTKIn3lO1y2jSRCOGowSwdJlPxV8aX/LPMFVUnjvUdnMGOvAX7nPMSYLa4guaKXhseKzP/zABgw8uMQTV/n8Q1IfHNCK/K5Lul1XnY9eRNDB4fJHOnD65qYrkzGDtCrj5Jv9FL8jZ8vH6ljXnkLZ42/h+u4vNyyC1LFEGV+rWx3IwERN64qrD8tzmuH38qE46VRKTNgeVFw0LD5sNxFXM2S+GkIfBrBVFXIm8sVJF1j3VmNBCQTWXIJyWUUyWFuzYfv+jwwnsaNx5BDYpMrujpRuVyDsPjYxdzE0lA3UqGMHa9DLhlc9ubxPHDIg1RsDUVxmLD9DO8XpuPqNHsml9Mf2QW5WBEj1qBfqCYVhRn3JLm89Av+uPBR8o6P2foYq41mbFemR0tScVX866p0Ppam8RNRjVyQ/wDyH2BICgk1TL1d5PTU+/zJezBOUDRIUWWUgQSSIgugimlBMkV7xMXrWqxRmr6XIkdCQv14po+7pMOhw8+L3dfR8UKG7JsNbHodZl2boNSjMTHFR/z9Aq3P5yafz5k3jTHl0RSVOh055lDxaHhdk7zlRXFsZNOl/cAUHY6Y8TsqpHf0kznPx8QBfj7TptGrjzK0KMKUP6QJ/bNKZff/zgawVV4BAMZOCZGe52PalUnsz8XY7Ltud8OfimC5FC8RkV8lR3x4/pJB50VpjBaFt66YhYNEXM1QdDzUKwXM2ilfdDyIFqKLXzI599VX2assgknlZpdl77Wi7GEzZIXJO148VYPmh3L8ZK8NLLh5C/mZHkotGi1f5BndP8KnH0yl7+oGVMdhpws3k53qY9VNrSSdMHGlQKUWVOq4MldfcToXHXU6nwamoWPzldbO2RPvM3eiTzyUshDEoCrIhTKSabHuzBhPHXMXY3awNqILMFpzCYblCl7Z5I7Dj8IN+HA1lZBdoeAL1Zj5Krcf9hhDdgQNB69s1saguvh5VUN4HCZqKbk1CEvG8ZGyg+hFk5hdZECKgCKjjOeQShVm/CVLVC4TV7N0qCX6jCbqm4tkd/ZyeP0yIfm1bJyGOtyxcazOJpy6MAC992zhwtdPwnZlBqwwXWqKoqOzOhWn58Ikhxz6DW1/z2DMEIqKwX0jrP9dI4sXbk9CDmEjcUhhJQ9vvJ/9El+jbhpEGUxidYpGJJIkYCCNMcJpcc2YqGsQCs5YdDLfkawAq7K5wGej07DTMsoZefqPb+Dbyxvw95lkZgT417/a+eCzHlY9HWfwhAgSUO7WUeM2dl5GH7LRxmwiqTKa4pCa50dyYHwPP58u7uKNFbNZ+ngH646O44049OgJFMlh7clNlKZo9F6XZKwc/q+so61yA/DLVSYIsfLeVowmle1PGaTtjQxe2cTKybQvzjB8ZITiFJ21RjM5x4vhKrRfn8GzxWL0jghKxCXviGjpkisqCE2yJhV4pqviIowyMx8b5YzhdwDoP6Me/xSTYbOO8GCFOX8cZsFuA/zo9wNUpmlsOKuB8MoqStnlkwem8skdPeQafThpiY6TJnCrsPK+Fsp+McpaVm0n4/jp0VL8bs8jiCxLoiQzrApNAeDD+jmMKSHOHX8HpSruoa4iSECSZbPm0hbeOOpWknaIoqvXGmkiebbiamiSzef5HlEKKzKhQpaoXWLEFTwBpy5I3vFRcXTyrobjyii4jFpRkGVhbNIUrLZ6UQ0AsuSg4BJVikQKwkORlzy15B6PAJYWyxRdnZBcYdT2ENfEiG/wkCj+fpOWubowPhkmUrwRJV8R0mnXxQ34mHXnKJctOZ6AZDBkR5iTGuLo45bR9GqBifMC/P2DuSx7sJ1yo4oScRk7McTcW4ZJrA5wfscvMJEJWyUuHXmN+4ovMt8cFJbsWFSkCnl1XJ+OERQLy2OI3ourKQLFZtlIqgqqWCI7F7+lKHuoW1ZmaI84q05vIfGzAHPuHSH09ypGk0phZw+rr4yLE31bPx89MI1Pnu9my5v1fPDydFb/Pc76vzWz5vk4A0dGqf+kRLVOxfGIkaCMQ6jGpBsy6zA8GtlrAgT6DOY/NfBfWUtb5QaQtEM0KjmcuMSbj8+m3Ksxd9EICy7YzDZPDKOUXdK/8NVCQk10yWb6h6M0PF2k//R6tiyIEqgZaTrVCeF4q710hMqt4mpIuOhrbHp/O052T/HwFywP4cVl9j1tDTvvtYmu+ydIzQvwzTNNJKcH6b1vnOr2Gl+92kFxHxEnppQc9jljLZ7NFp/f18VQVx1eyUTBZQfvFu466BAu3+tY7KaIOH00laQtus5hs8j9LfvRZabYzdhUO71ER/6ct5fw6qF3sMGMEZAMOtQMpqvSZzThlcxJKfHahZ1CQpsvMdUR/MFN4TakTJ7b/3Y/AJpkYdaqqClqmgePOVhwC2QZqWqhjmVBEfkDJceDJlnYrkxjUejhi4r4faViWRCKLZubf3LYpGw4ruRwXJnMwT4sn8Qfog8i5Qpig/HpuHpN21+L6XK9OrNuH+Pnr55LYzVP7+lJPCMWXz3WzsilEdoaM5iuQn6Wl+DqKnnHR9FVGTBjHPj+UlZd1UrQNXg5tgDZdfl98iUWpf+Bt1rC1VVh0ipVGWpuA6AzOyxOe8sRSULlivisi7VmKxCzi2xRopySfo/45jwrftvKxPY+ZlyWoGt9GtNVUH0u5S4d/VtBMQ5IBqM1KfqAGSNhB8k4fhJXBnA1ibm3D6MhgkGTdpiMozJbT7G3v5+Ko/P57h1M7Oljxp/GIP+fisQf4rVVbgAhuSKIwJJJfVuR95/rZe1FTbS/naH71hRGSCGSryKZLrt4k5QrKtN/m6TUrSFdrhGVq/+Bns47PvrNBvKOjyGrjpQdEHfhskvDiiJbdq4jM1cQWebdNMiMS5NEvi0zdn6IFR+1svneeuqeqtD9aIr+U+p595FeRuujzFZBQgAAIABJREFU5B0fE/kAO56zifDyKuvubMLaTRYmHKXEFDXNhfudJKTFmooyUZgsyytVGwOFoGzxmdLJqBZhv8raSWHLxtO70LCp1EZymmSJEl4yma6PkbBE+OQD++2NK0tIZQM35KerKLhy/W4EPDrrzCaBIa8p8aKKMPtIVQu7IVxjEsqT3EEHGb9cZcCM0aulqeRq16ZyrbPu0cWcvlLF9XooujoxWWwSFVejEPIy8LM6Yi8Xufhv74i49XxZWKZ1TczvS1VIZXA9GjPvTrDh1DbCqysM3BglEw0w+l6IwgoPTdk81hyZwIYqSkl49Wd6honJRdKn+Mju6OWAiWX8oeEgFoe25+Dxr7h748O0Z0bE+5JliokKg0qE+eYgku0gOQ5KpoAbDYmwkEItTak2Gv08MgPHKzHnN8NM9eVYeW8rdkim5fwMdUaNVRiSCJYqNcu26KkANKrioNGwWRdtZcOvmoj9vYTvG/EsBuQqjithurDZ8te0AhYbL2hAzbnw0HfZOz/ca6vcAPKOtwbBsAlLVcYJMXxelPf/Pg0kUCs2nSemWbBgC8bpZeadOUhws8Hmc+pImRqa5AgDkB0m53iRcfBWDAqbPDQuzTHtuSRdZ6RQc+KL6/w0zZS7RQk7tEuUj1+YyhsfzKZyaYCJOj9Tzpyg9ZUcQ5dH4Dqddm9WxEQXs/z09K+JfFRh6e87sA9WUXAIS1WuOewXXHzEqUKEEwmCqoiY7loZTCQEEkiuix0O8m5oNvOL/QT8MmvOi/DoL++k4moMWPW1VCCVag2mOWTVsYN3CznHW1POecR9HuiScuRkLyktyFMfPUtILhNXcqw1mpnnGZ5UUeI4yLny98BRWYaU+AwUXOqVAiuNJqK1DakUqRdjt6ohSvmI8PT/+Ygj6DObSNamJAG5ysipESQHZj0yiivL31t+a5oGqVzFjceQCmU67DQnfPoJiXCYrvPS7HvoOvY5eR0/OXwD280fJvJSGdmCqS8kCcnlGsXIIIePpXe04zRJXC+9wOLg9vym8WiCGNw+8ATblQfExhsO8EFsLvNKm4krJU4ZfY+rk68g5Usi3MTnrfkkxOiv9fhxhq6OEvyXQfpBDw3xMiv/0EpwvUHjjSJcRsqCEnZJ2UEB/rSDhGq6EkUSuoyoUsI+S8b0y8x6YpSYLHiMFVdlyBafnSbZhOUK5fkapR01uO02oWn4AV9b5RSgTcmScvzkHV3w19W8OGkGikgufHNvM4rj4l9iEv84i2dULORZlybgUrD9Et2+BI4jIeMiVV200n/OWf+dlfzZrV3YPbDrkf0kDwzi294i5hYZqPqYfckoze8VWPW7FtIn+sASFYV33GDeqUME1hp8fHsPwaPElUPB5coDT0BSXVwkkcJbS6Zxgn5hI66YeMoldNcm76jIhsmYFkEGdulczTlNryFloSs6wVqjmVZV0HK/8w306gkmHC+PHrAX6I6Yt9eCRLoqCfq9TUi2w3LDJxgJNRT3gBVmyKwjroqxqGQLQg8gSma/j7iSY0W1jahSEg9nTvQySoYLIUV03GubzXf5BR1ain6jgVY1y5AVRGlzKBzmJf50jvM/fJE/HXswUlEk76LItf+2wtRqgpsGX0AGzKLM7Qftz4GHLiMb9ePLGCibHdo/TOMOQ+8140Q/K/PROdNIzfHRpOTJNXnJPBim+acT3Lvtk5ySOoMLGk/juo1Pc8Pgc/y+4yg+zbfzWnBbjkl+xslj7+M4Lh2lBO6U4CSdWSp9D+Rs1dN8dngX/lcM5t02wPL920jv6af/l3V0PZKmY9cUwf4q3x7aiCI5bLHq6VQnGK0tahAuzHqlwGZ/PYFDq3S+mmbdVU3oIVH1BSSDlB2gV0+QtANE5TLrTm9i/mkD8OyzcOKJP9ha2iorgEqtW59x/OiSTVQu0ajkifSJ06i4wMOavVvpu6WR0s4eHF1i+W2t9P0hxjeXxRk7PkT5QJ3Rg8P0HdTI+PEBNv+6jq9u6mDFvS0Up2rYdRJvfzSDL/s7mTgygBT//udnHB8pK0DrNXmaXy+w4coG0ieK60NAMpFXOexy1Cb8G0zeu2cG1hESFVfh2C9P57pDjhMnpOMI04qm4AZ8YvFrihDnWDZRXYwddytu4Nlv7+LisTcBuPjtJex91Hp23G4zLcdlmf/mFpKmEC35ZZMuLUPSDnDD/j8VFYUj7MmS5aB6VbqNJBt9zay+PC6Iu65C0grXzD8BwkqFJdm5omlYKotuueuK8tx1SdhBuvRxttETgneniyagNbVRVACVqtg4/B7BMlQVTnvubLr0cfrNesJyhYBksPTUNtSiS8/TSc5/83XcYmnyCuGG/MzKb+GW5GKCToVlWiun9ZzJm4M/5mDzcqK7V/lin27WnN7KZ090k9nPh+OTqP+wxJFHLWfaHUkU08YrmyS29bH+1kaiX5V5oP1BVhzYzsVNP2ODp5krB15kR2eQND6ebdiZPbOraaqIvECpXHN7mpboDdS4EDo2Mz0JVt3QgiRB0/UFFFz6ft1AuUtl6m/SSA5s2a2+5vjTJsfTdk1mPldP06UKpNnmn9Ujl120t8QYOyaXyTjiurnWaCauFFhrtDD+kwDMmSPSgX5AlP9WuQFEaum1Ci6NShEDhQk7SCxVxNHBjUCjkqPn6xR1L5bpP72ONYe1MLYwjLlIZf3/NLHmhiaW/raTNdfF+frKTkbODrP5mBj175Tw95t8flsXmeYAo7aIGa86YtNRENeHbf46Ss+T42w4vZENpzYTkEymawk8r5nse9w6XAfWLm4mvH+Zd/PbcO2hJ9L1O1MIaxRZsAXyJQEUsR1ROps2kmmzc2kDt2x6HIC4neWzQA+XnHQspl8mdaiPr+7p4Otz2glvKTPjvCR7/LKPWYkEo1aIjWY9ix49UwAzHBfXqyNlC0jlKnPGN+B1LZaGu7l7/8fIOP7JfsR3RKRGJcfahZ24QR+u60KpLByRholbKNKkFEhaYYquylzPCEZQNMguvPRv318VKlWxmemCgDT1BfHfxNWsaB4iEZprMLGHj54HxwnmKqy5tQcnGgLXpdVIc8PYC1QkDRl4tusngrFYqTLzjiEOXnwJbVp60iOw5rhmlLLL11d0MHxohPY7s8w9aoTGkQKmK7P8wA5W3dhC44dFXl92Pee/tYTLdjqDb7UGrhp+kXnSKH/zz2dVoIOZ5hi6Y2JHApObsVSjQQE4wEazAbndZcPpjXS8laHt6wy6z2bppR14UjaVZhVlgfD87+TbLCS+SEzYQUxXYYMV5LNKI3Elx/rZzZhRmRlfjFFxNYquSqNSRJEcpmsJMjVgSkA2RSzYypXw9ts/2FraKjeApCOskV7JZMCKMmzWUa8UcIoSll9hwgkRlSpEflekElfpO6uRTnWClBOg5GjElSKl2uy/VU3jlUwcV2bmuyO0P58ldV6Q4d3qCMjVSR++RxYncpNSpOXLDNNuTjKwX5ShK8J4JZO+XAOBK6tsc+4o5myFT1+ayrpZca7e52f86+ApuIpoxIEorYGaG08X3XDbocHIcs3aJ7l65GV0x8IBftVxKmdedzIHXruMar2Ko8s4B0sMXhJlyXuzWH59K8FlVdoOn6Bps+Djdz8+VLtSeIVPIOTH9Wj8yBnGkBSWB0UD0SuZkx39qFKaXFCuquB4dZEeHAoIRaCu4bY302/FiCkFknaAldUWRv0hAJy8JPoYXh27NYacrwiXYSqDUjQIyIJnGJWrRKUSW8brSC4KoWYdWm/P8tc9H0YyTBTT5NItL2PLCh/7p2Eh840p7MVSQViSpz2V55w3ThZWcBSGdq2j0qrS+1qCd26exRf3daJvseg5fBzvMoOZ+hjmcSqJ68O0/CPP7FNGueXu+xn/V4BBPcZVmxbTrFf5XdNhVGSNRrvAvn0fI49NCPybIqN57dozZ09OTAZ+VUe1UaHtxgy6YdLz4jiuBHraQh+zcVyZpZV2Pin1MlfPTaonB8wYgdohtkNgM/kdPXi/MOlSU/SbDYxaITJ2gJBsknH8+OWq6OccdxxEo/Dkkz/YWtoqN4AutUCrmkeTLGQcWrU0AcmiWOdBy9qYpoz3Q5PosgrD54cJBIWZpEPN4K+lfgiWnoLjCtZ9XaFM99Up8jM9LDu3FUUSUtS84/sPI8ZE1sus88Yod2h8/YcOKq5OcHWFA49ezYynEvSdGuP1R7fBHzf4yyEHiEXu9yJVLVFaFkSpi2HCaFLMpIN+tjGH+XPfQ2xvDPBg/R5s8jSyWWtg6aJu/nrEfWIj8oFblCZtvRVJJ32Cn49f6EaxbGYeN8Yju+4uaDmqLHBdkiTYgF6dHxU28o2nje5HN9GkFCZJOQHJqDX2KqTsoFiI2eL3JblXx62ZZ6JyCVlyJuW4TlA8Qrmsv7ZAVeRcWWgC/F4kTVwd7jzmp3S+NkH7LyfYfsYgRy5YwYyfJXA0iZ7Hx+l9OsHlr73AvtV1zDZGuKdpP5opMqBGMTw+HK8uFIMVIdKZeVeS8xf/CoCAZrDxuBjRTyp0bkhROkBnzQtxTK/CNseOoX5k0W/FWH1CE+tubST2ZZGWhRl8FYO+t+swZZXfbn4O2+Nlpa8dQ1K4PPsOV5XeoX10s/jeat+/hTw5wlWCLkMXRQj+y2DmIUni7+bZfEEUHIjfK6LnZMlhtmeI1UaIqCK4lD1agqLjoeKq5B2die4AniEL24G5+gijVoRGNcc3RtOkgS2u5kHX4aij4KWXoPLDBIVslRvARjPMymrLpD66US7RZ8YYao4iuRDor9J2d4ZKXOXTw3sYtSPs4N3ChO3HcSU2mvV0qVlStsCANyplPDeaeJIW/TfX0eAtEVey5G0fIblMVC4RqxGC2l/MoORcvrhnClVZofOmNAuO3II3Z/LtEw0s/c0Urn3oJH679zG4Xm1y3CQZpuh0B3y42bzoLLc1I5k2B6aXcdOWZ8hLXhZ1/pIlgW3YtjLI63tuy91HPTxpS1aLDlW/0DaE5ArTNo/R9scMO5y3BTXn4k+YPDL8V57ZcBcXb3qZmeao0Nv7/TRlEkytJvlXtJeDo8snHX9rjRa8kkXR1ek3o3SqabF4PRpoKo5fE/PwGhOxUSmyutKGgsM2emLyCtBZSeF6PbWRXlV08wslUBWajQy3rH+EOeeP4FlnMfzzCCuubCV9VYjEAaI51nFVhgWHbObnYx+y3tPMu/H5tFfG2RKIQzpXux5Zgl+QKYKqMO3xCRa9+wuiconsSV7skMR2dw9RcTQGuutZ9mIblS6VWaePMW/ZABnbj7xQYcVDbYQGqsw9fJR4IsuXT3TQ6Oa4ePQ1plbHkV2Hv8Z2Z0H2Wx4YfYynWu/CrSH57IpEp5XFM2wSfatE3ZdlXCDcV2HgtijLFnUydHSUKc+kiSXydKoTODXvv1cyKTpiNBquRZtVXA1vk4lsQTmtYyKzq69/8mD6jmS90WwQv8Cxx0IuB0uW/CBraavcAOyahNd2ZUGosSL0auN4fiJK7NmPjuD/3KT/jHqa/DmRkWc0k3H8bLHqmKGl6DPrJvsIxfUyU59JMfSLCMm5YZJ2AL9sElezhOQKmmSzrCIEI5F1VbZcEqVtS4YjDlrJ7AdG2XhEI6vebMG3p8rDB+5N+0uDwnHmgJQVenXX7xWnvqYiRcM4QXGNOWzscy5MvsXXvk4ubFzIYLCZHawBFFx2Omc9OcdLQDKJylXUvIMcdjBGVDovSfOj/QaZdu841SaF0TPDfOrrBmCzp4Hd82u5feBJLl/3HIHCBAtSawF4d8E8WpU8ecdLm5KlQ0uRcz3E5DK6ZHPKil+KBV8xkLIF1GQOKVsQ5hhZZlm1Hb9cZdSK0m9FyAeEAKic1kjs0Yjr0Wp9hzxOQ4Q2ucCdfX+lpzTKrb/el48/nErfNQ3oZ7msOa2Br2/vZPlVIsPAP2jSbOVIqmGUUpWgXSWn+nBbYsjfJSIrooqSqoKvOPv3oxz/5tl4og7fntxA7M0SU9ZNiMUV01jzeDPVZpXOk9O0rM/Sb0UY3i3KN4vj2D6J2ceO0bI8y7eXxdglsw6fawASz+nb8ss5F/Bswy541tsopjiJ2+/JMmP6KLvutontzxok9E6F3F5eJBeGClGiSolvzm5BclxmPThKpAZz6TMb8dZgKqarYiORtMX1MVO70vYbovxfVm0VHAg1Xxslat+7AffeG2IxeO65H2QtbZUbQNIKo+DSo6WJKQW6tAxjdpDBphjJBUGany9g1stsWPh9CdWqpunVkrSpGYZrzPaZ+hj1SonmWwrYPpmJ8wO0qnlMVyVpB9Aki2GrjozjozMnjBtGvUz4tSq9Z41jhBQ2Lo4xfqufC64+n1P3OUkkAYX9AiFeKIlOMogOebkqUn4BOV/k4Mwyzk39g0993Vw7/QRKngCOT2O30BqqbQobt2nEdFXWm00oZRs17+BMSOy1/wbir+YYOSPMqx/Npf+pBk594zR+N/VnDOp16K7N8dMW8UT9LuxVXMed+VfYu7KeMS3C5X96lnW1CO6iq4kMwWyRxBdBIutK9F5VEbN/wxTXB8vGtazJ97G9Z4AePTEZga2FbKoxhYYtRR696rbJ78iNhGjIjnPj5qdwJYkLmo/jncXzhLEKGLDCIhMPifGTgpRnariuhKPArsUNXD74En6nSlH1IufLYhyXL4nKpOaEdH2Cwjz75hEW/u1Ciqd5sEIyjTfmKdqCultq1Pn6iXZMv8zsM0fpyGepVwoMTq9n4O8xEvuGmHvjCHUfVZjYwUfIriArLm4kRNbx0PBFig0fN2J7JPK9OgOHR/nmkjgbr6/nq2fa6VvazDcPx0nMC7LtA0MkqyGiU0skDg7R/nwGoyTVmAxFQrKJ7cpE5RKaZNOqprGRiY0XcTRobxIYu5n6mOBcOmJz7dVSk5xGNA2OPhpeeQXK/3dK0Fa5AcTVrChZrQiaZLGh1iRqVHMMHBNFMVwKLR7aApla11lmgxHnq0oHX1W6KDoe0bgzY7jLXVqW5Bg4PUq23stao5FRS/jok3ZYNArdHDOvHQNAn3DwJw2W3tDBmy9uw9r5ca4++mRmfbmC3bJrcT0qcq4k7v4efTILwJVl3KAfpzGKE/CxoLiRRcNv8Lm/mxubDsH5zpq7T5Fd1vcxfGKEgCoqmqhcYsOqRgA6Xs2S7/HyyZKpvHXxbKRml5Nrp7ZbqvJyYB6zKsN0m+M8GdmJy3p/Sb1dZG51iH9GZiLL4v+XG/Uy/U9JfrzbZubOG2Gfhev40UGDLF75R27vf4wDs8uRPKqQwcaimA1+pFyBDWYDCi6mq7KNniAqlyj16MjfuqQcH1LVJKabHD/+MQ/0P0iDVaDOLnHX2DPcOfg4LX/J0TMhdAZeyWQ7fRy/ZrL591HUkoPRqLDhsgZ+UlyHigOWU8OxKaL8H00J6nIqI5qqiozdGKH3oSTHvHMhgxdHaPiwRO87SUI1rt5wUx199zYQGK3SeF6OVkT5vdFXT+r+IBuuaaDxyzzh1WKRybbLqa8s4fJXFwt4h+tBkiG9l5+Xbp7PxnMaWHt8C/kdvRi6QqNaYc2pLfgHTKb9I0He8TL+8wBa3qHx78XJ53bACjNbTyNLDm1KAdNVyNh+QssqGFNVtH/Lpt/NK4JTokqRtUbjZDMagCOPhEIBPv/8/7yWtsoNYItZX+uSivL8u5iosFSl5+NxHI9E3TdlGi4rkMyFCEtVYkqBqFJiL/8GokqJmFIkrmYJPmRgBWVGfhUmJItudZcmsGGzR0aYck+KaTsnqPtXDT6xm4dN7zeS+7mHeq9IjKm0+NnT6OPKsVeQC/8GCfXUgkAsW1QDNZBlR26EX4+/ySa1gRubD6UajmA3RFh7Zj0PDz6Io8PgwrrJZJ4mOc9Od24CIH2gj8+f7uTb1ma28QxjuzLxS0TkuBv083bz9lQklT0zq3EiAdYozbzvnY4E7D1rJWvLjbQ9keGw/VbSfFue4lSdDVc2MvhQHUv/1M4jsd0IuxUuyH/A4m/v5LEtf+HOTY9w1ddP82N7kE5XTFPa1DRJ20fG8TMxNYC/z6BiqhyZ/YqHV/+JX45/iN81WeFp56Gmn/BWZA62ojLnphFadxlnxn1jxJ0K/yh1iaCXuI4EeEdt5DaXddc2IQE75jeIzU2WaxMNAf9wYlHx2dZGqa5HZfp9Y+zvvYL8TA/bXj/ERD4gGnaSw6pt2+j/bT2xf5Zw7jfpUtPElCLLjXZGTw7z2RtdZOf6kBCi313u78OoKfeEMQwKjpedfH0ANCqikltWbWfIDtJ8aJ5Sh0b7wxkydoBNC2Kke3x4nzZxkCef141WkGGrjlHbT9IOUxrTCXxuMLxfmIBkYiORcTy8UOhlrmdk0suSq1UDAOy4o/j7F1/8n9fSVqkEFNFfGkk7REAyaju9ytcjHcxbMsD4z4Okwz5m3JWk+ZM8a89tpu6QAsF6C9OVRVioo9GcztH9+jirf9ZCwh/GV6zSujpH5PMy9W+WCK4UJ3C1TsH0Siz/ZysjsTo61AxJI0xczRCXK9xw9/1s2aEFAFeWcCNBdkmuQh+v8EHL9t9DKiey6BEf/7vlJSxZ4brWoyiHw8jpAmsvaefxeffQdkmGgZ/WEWqs0uakqZcr+P5QofnDAo4Kb902k4inwnR5jD6zkUcO3Rc7FhCcRMOkouqs9LazoNCHVDaQXJd55hCD3nraP5zgkKO/IbTaoLi7zpbr6hjvCpB3fKIp2A/ziptpMzOYkoLu2uhWkXE9xI8KfeydXUVpPw3z9zJ9C0R2gY1EuttPT2ac+acMcOD4Wj7TOugkT1n1cEXXCTiuNJkA3F4d55bZT9P5hwzZ17xMezDBUFOEuvWinC3M0Jnyv2n+9XoH1i0SU4vjHDb+Ba/4dhfuQdsR3obvBEe11KPvrNLdj6c5Zf/TWHzXn5l98wj9v6unXhF4ta+OmULd+2U6b5vgw72mIU93mKmPknL8eKeYLH2inT0W9KFnbNpuzSF9AwOXR3G7JVzAJxkYkoicK/4boCMqV6igMvDLKDOuTxJYVqV3xxSpw/303JGieSLL5roGHFfm/5H33sGRXWXe/+fc2Llb3coazciTPTOOeBwAZxvbgHEAk5YFwwILmLgYzLJLXswumLTkYMA2eQ0YL2CDcQJsbDyO48lJI42kllrd6ty3bzj398e50wMLVe9umXfr53pP1ZRmNC2p1X3Pc5/zfb5h2isQhIJxo8KJdhHrs23QYPLSAloYUg1UAGtG6zDtZzBF0Atp7a1CAVat+qsUgKdlBzCoN3hmbCbyVHMibYDLSbdNorlw8Io+Drytnzt+sI5O3uS4f57llM0HGbm8Sv5dTSY+V2btVxYYf+cSuhcyfKjG+S/cyfnH7+aYF82x/BNVAk1j6zWjVL7Vh70UMPPmHAuFXMSVz7Pemqfo52jIGHnN4YyXbQNAdD11vq8/zmWNR9TYCjXzlwM5rpy+gxXdMv828nzmU/29zX/rpZ9m02fnCDXBI29a3kN9Gz+yWPmFCl5a0DrdYkWiQkFv4YQmXzp4FgB6Q6HuYcRcezizimV+lYF2hWOq+xjxqjx69Sh+QpDa7rL/fXnu/eZqDq3IUQ5SLPhphm5rcNZz97DaXeCrQ+fy4qPfwZXrrqJoZlnRKfG+FS/hw6OXIWTIKS+f4vQv7MGT6jybWqkuzqH7Wnzg8ku5vf8kRr0q/5F6BmErmgh4Phg6h+x+rqi9l4e/OE7qQJeTXjhFbl+b5D4Flt370dUQwrq3L9BdrlHV47y2cT8TS9OqE4jbYJmIQCKzSQUGQvR/FqLTpXl7kq+fcSbj367Sf5dqwdfbsyR1l0c/sgwvoXPSNVPkww5lmejhRIHQCZOo5CFg+Nd1Tj53ipG/r2N0QpKaixdqLAQpHnNWIEONYaOKDAVFP435MoGfFmy+cZJWaFA5J4kIwbxLibTKMsmAXiemeeQ0F+3HXUZ/WOfga/pwVloUIuu2MWOJRCRYk1HqsvyvW/Xkk//fLQCt0KIhNRXYGI2zvFBj/OYlqhtjmJtCJBqxkz2Kv8hx/y0TTL+mD1MLKNzZYuJTS6z8eJn+e9uEAlKTXdoJi8lX9fHgl1bwwEMr2HbLCA+/ZjnaTxy8pMZDL53ovSlJrcuMnyGmKQuy/X5eeb5HKjh0ZStGBAgG+RSUqxw3u4NLmo9xa+5EHjPGQIbseNcYH7jwZrytkPtxh8UrU6xYXmGluUhmT4fN/3SQ+rE2ZiOkfXqMdjRGWgjSJF4reyw1mU6qjRZI9uqqeEw4Czwn2ENTWJzxqz1o3RAB1FJx8kYrcj82OOuO3Wx+60EOiTxvWvl3/DhzIs5Sh0UZ45r+y2gJm3dP3cJj9jgP3b6cpSvijH+2yqkfP4AjDQbvVpuseHGKV3/2AZ5bf4IFM8O9I8crEpKuqXFooEJV9EaX0gUpdv9wkKCrsfnKKQam64QayOMFBz/aR9/DHfA17GGPlrC5pnw7lqdkxgQSmY4rqW7XVeaifqACTCNx0q0Hj2PH2DBHvbtMetHpGaQEAxq73zdI8jGX9g8sYsKjLmMEaKwyFREKDepnxXATOpOvyTN6v8IsBr/aJP+dFkFNo6A3SWhdWtLGFgGrzCVuEccy/eI++n/RojoVo7YhhjesUbinpcBWTRXuYa1K8hsdxt+xRPXUGDvfOsywXqcYpDCFT1UmSEbkH+W+1CYRTRN66+STYXoa5uae0l56WhaAnNahFqXcVIMErdBix5ZR8ts7HHxRnoZUL9qM38ek30dwnMbD717B1M0FHtgywZZd49x7txqZ7X1HgQfvmeCeG9divN+ic6HJdE6Bis9YPEjmZx1qL43jZKyIAqsumoZUQpoBvcFKo6JERYR4G5YppDqQEEi0pQZavYPel+Kt1bspWn18wz6J0DTY9cZ+PnXRdzhKK7HhPfP4BY3tbxjCCQ0eqB3F6rfDMENuAAAgAElEQVQu4iV19p2pNvQDp02wEKRZb7b41sXnQyAVOt7pEsaPhGhO+WqstK47x5nlJ5kdz5H9Q5ft/zZEdX2cld8u945B638/y/K3VVg8McV7Jl7OfDyvmIqGgexLUUnk+XjufEb8Gq9t3ocfM9jxr0PMvCrDyuvLnPSRKfLfbRPEBSIUlJZMTmhN8pvM0chQUxs2mnwIP0D2qRzFt934OuY2ZLnvGyvRq5L8f3bwE4IAnYMXF9j3on6Sezxisz7FL6Q4qlviBdVHVOvveopYZZmEubRyLD5scz7QB6aBG0/wmdjzoQar3lRmebhIMirg5UsTNE6wOO5T09htj4LeZExvMulne4SfQ2/PEqsHODmDX/7maFprVMu/6p/KXHjqdi580zbGv11leKbGQb+PqrQ4PbGb6pUxRACrby2R1DwqJybIb1MbWHpw9F1znHDFDKMfrFE6PcXO64doxxTRzBQBA3qLMb2GE5oM6k1MAtKag8URgBCA445TH7dte0p76b9VAIQQOSHEzUKInUKIHUKI04QQeSHEHUKIPdHHvuixQgjx70KIvUKIJ4QQJz6lZ/gXlhfqDOjKv+9w8u+zbt2DtGDxBSnGjTZ1GeN4e5ZGZF3lSGV86UiTJTPBxEOq2lefk8AioKA3OeTHe9p6gOTNLloAj71yjPXWHDHNZaWh3pyY5uKGOm1ps9/Pk9fVnecNX/uROpNGOvpXNh7gktrDPL/8MMu8Cl8ePp+unWDnOwb56sVfY0CvU7i+TexJn60fGMXIqQSZ5357K8mdHnuuHWDV3YtUNiZwVxuMGUvc3lqh7KsySTWjj9toU/OKc2Do1PuHaWg2z+wq5+O1UwtMvr6P3ZeO0LjcJrvVwd2vs2ypyqp3lGmutNnzzX7ctgIrQ8skTMbRF+sgJVuH13NL5kQuLD1CbJeLIyxmP5ClfHaCsRtrtEZMGufa5B9sYf3axyTg/thKZcQZhohohBhqQhme1JqsvGmGVmjRd1ybvZ8dIF72IFDbrxykeOLDo7RWm4gQEjWP32fX8vKlB8glJGEjChdZXFLTgZhyFwoG+5RuQQhC0+Cg1sdn8heQe6jD2AdqrNArLARpJDr73tePVZIMf7lBUnhM+5keIxJg56YRFs5IsfrGRVq2zSO/Guf2vevZcusyyi9PYu30GfvnGqeeeZAzT9vN0N82yH20Q/6uDq2jTPq/2yT3yzauNIhPeax69SInnzbFuteXsA/5PHbdGAe/1YdMqNwGTYTkNIe2NHmiOxY5KWVohzalIP3npqCDkb1ZucxTWf/dDuCzwO1hGK4HjgN2AO8B7gzDcA1wZ/RvgIuANdGf1wNfekrP8C+shOYxE6QitpRP3bcZ+1mN2vlx9Lzkke5wj2u93lLju+PsGWb8PibMKgWtjXg8xE9pFFdlWAjSmMJXkViBar+mvD7GbqlSOSXB4miahFAX9tbIbWciUnoltC5pzaESKAXXuFnm7399p+LFaxqnLO3kGZXdvGLxdzxiL+chMcqOd49xx/M/iSkCjO0BGz49x+y5GerPs6nKBOW9KcY+W2Pqgj7cCZ3Mk12WLo8zYS5S9HN8//Jz1AsRRFp914N8Vt0NG22QIR1MVnRL+EKjvsnm8X9YxoBep/I81R0c/6sZhq6uE2v6HPpCH1o6VOxEEZmgSgnRBsbz+f7Qs+loJmuvW1DGoMKmebpC7g0k0yf3YZYkK+5aoiksdqSW99iAoecRJuNKWOMHyGWDhHEbM7qrzZ+XprYmhtmRbHhojgGjzlC8we7Pq9Hnsg9XMb7YxiDgyuk7EZk0MpeC/j60UlX9zrqOXlWGKkipmJemwb32ar6f2cyy79UIvq5uGG6o45xo0niuzcg36wy0jmg+DitNAeqvjmGWJOt+rYQ6jTDBoQ15tn9gmJ/ceTw/+uVxbH3/COVnpUgvOqy6YZEVH1giecAjNhOw4Q3zjN+uPBRyuzrUTo/x6NfG2H7/MNOX9dEI4yQ0xQ4s+mnMyAl5vT2HjoxUrnUSWlfFtP/xKqgu9f96ARBCZIAzgOsBwjB0wzCsApcAN0QPuwG4NPr7JcCNoVoPADkhxMhTepb/Zc36WTKiiybU3TL9pEus4jN3Xiay9Do8JYhTCtQoaD6yZt7v5SkGGbLbHbxNOgVDPTb3R2esapBkaGsD+0DAwmUpho0aJZlAotJsQWEOBaNJW9oU/axyD0aZZRT0JqtPKir3HstiRDRJyi5fGzibD9/7Y+655JNM+lmmK3mOv2oGN2uw79p+nMhD78LPbyfUBPMfSrHy2xUCS3Do+Tm2dpfxjTNOUy2/oSuq8eE0oMjrHvUmYeGjEWJqAQ99bIK0pQqiO2bQPdog+bMuA/e02Hb1MK21Fv/42jcoJD0i/wjPVzLlvjSi69F04EeFU+i/s42+T9L2LEaub9A5ysCeC0gvqDGp/bDPrvQyaHXUZgRlbuIHKhcwm0RIiWh1+MzFl/KYsxwZaiycnCYUMHpNDeGqzMfMBklrxES4Icd8sMjiyxOc19jGoFtVEe0RNRgtoionYqozgCgQRHUDNxZO577UWo79l1k2/qTItFdQactXpTCbEu3GLjvdETQh0YR6DSeMMo+eNk5jmc3K7ywCkNNbvUKxxp6ne5SF9xqDQ5/KseMXw/znE5u45w+ruP/7E4QC5l6c4uAX+wD4w4cneOCTR9E5z6KlWzjSirIDdJ4RmySpdbHEEU+KgaijHNA7ONLsuQn1Vl7Fk/1vdAArgRLwTSHEo0KIrwshksBQGIZzANHHqCdhDPhjB8ND0ef+ZAkhXi+E2CKE2FIqlf5HTzqvN3HR8EJdzf5/VyIUsHR6Ak1INlkNxo06D3RWRYBhvMe7BuUgHN/v0l6jWtNho0ZZxolpauY6bFRZdXeJUIdt54/gqZwoNCQaklKQoSwTkZdbguVGhZDD7WuSFUYbQcjosU1E4DPSrXJfah23vWcTec1lp9tHDJcXvP8J7Gmf6c/3US4oTT87IPufHYqvTmNYkswPO8xekiU95HLdt14E8RhBQZ17xVRRCX9MFXBx2FAjJTwyUm2Eg1fmGTy2SSu00ISkGGSYPzZNYoeHM6HzyMvGKQVpYvsXCVMJgmwSmYqr7yWE+t4Ahs7t6WMIdRj6YYNlv1vCmgnY9s5hKs+OM3pDDW9II1b0eeg5YwTDfWrT55VbsEzGFAjY7CB8daGLtsOAUSetOSTyalqSmnJZ/cNFYsKjIi0WT08RmBrWAZ/Mri6BJnhR8xGlOswlejr9w6nNMpeK/P4cJWmO24SB5F/jZ/FIbDlDV9c55s5DCnTbmGTmWVn6r2+yMTxE0c8q8hGwzR0l0DVmXpYl82CX8KDoORoVtA6F6IZRlgmG9A4zfh+ubtIoxNl34hC1Z8fIPtClvFZ1XMPNGgVNSdeLfo411gI5vY0X6jzmLKcUZHi4O0Y1il9vSFM9NkiS0Zw/TwayLEin/1cKgAGcCHwpDMMTgBZH2v2/tMRf+NyfORiEYfjVMAxPCsPwpIGBgf/Wkz28Dqv4VBaAgXlPQHljkrGhDkU/yy4vjknIBnuGgtZi2Kj2vP7dUMcLdMy6JMwLNCEjUC/GuN4krTmUggwD97eoHJtgeWGJINQY15vR9teYMMq9O8GAXmefN4gd4QarzCUaUot+acForoqB5BOvu5BPXPA9DvoZJBqDH2+S/bnD4rvTuKeYWCLAFAEnfXaaIKXRfkOMxA0euhOy/7X9LAQplv+0pBx6glB5CmTTyh48Uu6JWhO6LpfN3odGqAwn3tDX8w1MCp81ZplQCxEStr9ihHWpeYb1ukLSm220Zkd54lkmwg8UDqCrlOQl36J6TpzBHzUY+V6dTt6gel6CA1cXsBoSN6sjQjj/mdvQl1rIvpSiPzsuWrurvo9lEgqhWJG5FO/dehnlIEkjp/j07RNNBj7bZLaWpRSkqZ4fx+xIdr1qkOTDLnJQ44Klx8h1ahiLDWUqGmEMMpNAa3T40MyPeF31N4iWgyl9vly8iXPFQT40cQW77BGe8ZYp9J8ElIMkxdensRcDYrf5FPRmL3/HFD4T5iJzz1Os0NxthyPRfB7rLqMs7Z478h3ttVEh6zCm11hlLrD/ef0kpjz07eo7aiLERWfS7WeDVWSnOwRAgNbzYxiMyEXTXoFWaEWUd4mL3sOl/mTFYk9ZFfjfKQCHgENhGB7mHd6MKgjzh1v76OPCHz1+/I++fhkw+5Se5X9ZLWljioC87rBUidP3aJvOWSa/7azAEgHlIMVWd5CGjEd+dBnGjSp6ZJqZbjmIEOaSaaqRLmBYr7PLK+CFOuPtMrHHPCrPSqqLU8bZ6g4qxN+ssBCk0AmpBKmeoCMeFYRikKAb6rihoZKFlgK6eZ03vPnXpLUOdRljxbcXWfflEodelqX9xgS1iJqcPNgl+asu+19VYL6bZOX1i9TOj7G0KsHHX/u3SkcglXGlcFz8wWzPqONwu9uvd3lR42EA3HUGsqDjRfHie7wBvFAjv0WZf1hjPpNeP2WprMjCmH2kbQ8CleGXVlkC2BYyn6Z8SQJzUVK4u8XCpWlG4k2843UqJyUwZ9XxKFONHI8cD9odJSSK2n7hKHKSqDURLYfxDytNR3uF6s6mX5jDWgx49i17AdDPBC+lMdBsUfxEFnvex0JyQfmRXhYipkFo6Mp/QEqGgzoDzUWE66G1O6xwy6TDLl3N4n3DL2SHOcKx/zBL/41NDp5WwF2mM/HjCnvcYSSCENEzSOk/qk1jk836O4p4ocHW7jLGzTIDWpdho6aOKloHHUklSFGWCRKaR+WChOqW7lWbeimr4taXmxVmgzQbrSIWytNywDgiHV5jlnlm/AClaMwcEz6zXh9p7b9sdCmhUoH+/qe0l/6PBSAMwyIwLYRYF33qXGA7cCvwquhzrwJ+Gv39VuCV0TTgVKB2+Kjw11rt0I4cVmIs//0SmoRtzxpllbmg5Lt6m7EoajqtdVhnLlAJFOFjwqwSN9VmTQXKTjomPLZFQZRVmSB8QiAktDZbDOpNxowlJBr7vAFKQZyCrrLf1ltFVpqLFPQm3eiYUAoyOKGBJXz0hkTzIRw/ckGtv3WODR+aZ/7cNPe9fxXTQZKqTFD0s+RudAh1CF6ps/zfl9A7km3vGqagN7GePKiirTwf0XII4zb6UkupC21bmXaYBn/XuA8jDAiB6rEKmGyFFuUgyXFWEf1hn/Qe1W5bMwET5iLDelOdqUHlALY7ypuw6ykLHE1T9mCOR+vZNqEAzYfueQa7vEEqQYra38Wwmupu529BYRIAxhFQLTQNZVISmXGKQCJcn1ZooK1QTaKRknRONBm8qUlatNmr9XPg7H6yt3eYen6GRz+2jBB4WWMLpikI06rFRtd7wSdICVExCxMRhbbjKBfgRIrW4wal81Kc9KFpjr1uhvnLUmR+53B0aSaiAofoQqVNt0KD2kUxMo926S7okSN1loq0cKSKUB8w6gzoHdLRuX2/14+RkzQ22eQeUZ+rFuJINPJRWKoXKh7Lb9tracgYG61ZMqLLrJ/GCzWV5xhR3HN6m/QfawEAajWF2fzfLgDRegvwHSHEE8DxwLXAvwLnCyH2AOdH/wb4BbAf2At8DXjTU3qGf2FtiJD9fd4g41tqBAlBbnMz0gV4ONLsRYUN6g2m/SyJKF+uIU3CZIi0BCzBKrPEpNfPhLVITutQDRKM71fEj+LqDK3QVKQb0eUYa4605rLHHSKmeT0SUk7r4EcFYKW5SCu0aEobqxIgdagP2DihyaoflFj3zhILp6R54DNHsSExjymUf/yQW2XFzRVmLsixWEsw/r0lZl+SZd/EENeecTEimSCMRcrCclVtfDeyGIukxce0pzirup0AgQCqR6kRqE7IpDfAfj9L7uYOQRz8hEZyposMNe7rrFKjNNNQ8WMDebRyvecodNgZWLge+1KDuAWdUINtx49wjFXEFD4zZ2fxLfV69P+2BWM5RKerbL4Oe+wJgZiaU1MLz1eqSeA9z30ljXEbaUBsl8eOvxkisd9j+P4mE2aFyksTmDXJ6M8bTL0oz8wVGWKhz3UHbsJuNY+g/pp6jhB1BlFXBCCiLuSffv4D+hNddnxxiD0vG2D1VxdJ3uciQsje6vxJgrQTGhT9LPtOVpts2ZYqa6wFCnoTU8goUMUkCDUmvRwDeoOY8HrXZ+M0G/tggJfU0NfLyIHJVDeQKIzmnKSSaddDdcbP6200wp5jdTGKap+OBGq9taiAyadaAP5bWoAwDB8DTvoL/3XuX3hsCFz1lJ7V/2F5oYYMNea9LOHOkNqaOMO2yx4vSxBqTJhV9ngF1lhFLCR1UKQUIVU4hUzSHTawDgY4oYEMtciyOWTUXMLdpeFnBLnRlrIX09tYBGx1R5gwFznOnmE+SFEN4704sT6h2HCPOMvZHDtIXHoYNYmf0/DRMb8oWXPdIo2zbdyvJLB1ZWc2rNeVPdkdbax6wMxLsxz93nnChODQ27N897zTFMXVD6BcJRnTOMOcYvPBezjKWSAVOLjCYM7IMuotUdfsHgDojJusMkuUZYKN9iFM6dP/yybFc7L0PdFGLmm0QovvvvN5JFtFJfn1A7S2Q5hNoTUdhTU0WgrMi5bwQwghobns8/oo6C2CmMA5yiS5y8VsSF50xa+5+fOnqI7F6RJmU2okODQAbYfQttBqLbyRPoxqGysW0D7aIvtYl61vTuN+VCf1vS4zz8pSOTlJc7VF5gaH5S9cYvFDaUZvqbO2M8e18z/mwxNXUNPNnodfqGvqWJBJEh4m0IRw5U9/RVUmVPSbLpm5Nkvp2DSnfOAA0oDlP61wGK6qBkmKYQ4dib9BI4gLkg+5/OGCiZ7B5warSEkm2O8OssGeYdbvU0EwqJl+aXOKsS/Xaa22MA1JXjSpBCkSkdVc0c9SDLSexdiMzPZMQA6H1VSCFMNWjZx2JMcCgIXoxP2/1AH8/2rNRFryi5JbSe5yCY4W7PcypDWHYaPBHq9AQWthIVkIUlgiIKupu10rtJBoeM/Q6d/SZEhrc4w9S1pTybcZ0cWaC+iMWVSkypmbdPtxQgXU7XcHaUeGDgWtjSn8XgQXqIThGT+DXpGIENyUxsD2Jqdft5e5izI88qVlPKwNUQlStKRNOTLmXHnbIu6gTmF3k/6HWjz6T8u4pn4FYSqOCCRGGPBSuY0bpr7GW+d/yURngZ3mEHf0HcuDsQkKskWf7JCWXfyo67VXeJSlwjhiwif3BwerLKk+N44ZD4k7itGY3LGg6MtRZBZSqrt3KqamC4m4uoN7Pv1uHbOmfrfcvg4eOg0ZU74JY0pN56U1nnPnNmXgAeou7PnIXEqNRk0DEQSKC1CsIroeH7zgpSwdlyD2hMd4rErpghQD9zSYbfShiZA9Lxsk+4RD9pEOlViS2jlx3KzOKm+eT+/7FuPOIoPVEv1BU31vXYOFMlpk6X3RG7ey1lzAJGDMqNOStkLWXxry4A9XEKQ0Urs8rBn1u6lEYgW8pWJdqsfHyWxxWGWWet6Je7x+Sn6GY+xDxETAgF5nTK8REz4NaZEsqUIcjAmKQTYisClMQCekGiRYZy4w4+VJCpf15mLPbiynt4lpHgNGHS/UmfRyf7oJHnpIfdy48SntpadlAchoDl6o88T0GNZSQHltkrqMERMBXqgxoKucgMP+9abwOej3kdCU/11eb3LwlD7scoC/RWUEtqXNeIQbmM0AIyMZ0BtMGEtstGdJaF0G9Hp0jIiR0zpM+gVa0iantXujwgCBh06s4iE1iC34mLOSybf1cegLWZaMJAW9yRprnlwk6jFbPqP3Vqk8K87K6yosnpngyUtGSbxO6eD7W2U+OfM9rly4l8di47xl7BW8ZvhV/OtRL+LLoxdw0+AZJIMuOxJjSMBw1H3sydxo7wjQCi3sX/v4lmD7s4dpxkxMJ+hNM4K+pDr3B5IwEcNdlldR2rpQQJ5pECZslp5IEY3Kye9oMaA3qEdBLa0+mxBoLbcYvatGymspUlEk1NGqTVVgXA9KFWVZbplqs+qqKBtNSfXJGAsXpjBaIcf8fhqJRvslBl5eI//pFjmtQ/k5CexawLaPjhCXLp+e+S7vn7+F9ywpqyzhBYhUUhUxVNd4X2c1AKUgyaDeiMJlfDhOsOsrRyZRIoChm+ocr89wSmyaYaNBbV2c3P42edGlFVqq4AUJCnqThowx6eXJR6rUqowztthg+SerBDFBfM4jrzcjX4oh9ruDSvGnO3RDnbVWkQDBVncYLzRwQpOd3RH2u4PR9Rb/801w112wZg2Mj//5//0P1tOyALRCi6Kf49RJpZGX6wWDeoOqjNGICkFSuExYi1ioUc1KsxJFZ/lUgwTBxRp+RmP4+jplmWSdWVeyVSDRcmknFY6wxxvAFJJqkCAmfGVEGhmGjhpLPfPQIJKQpTUHPQiwFwOEBM2D2rE2D7x5JcUwS05vU5WJKBHYIae1ydzroHUhs8UhtAVTV+V48oLV4HQZbFf45MJ/MOYv8ZGBi/nI+AvZ3T9xhLDj+7yjeBtm6PPb9Dp0oL7cAgEXXL2DobDOCmNJiZgedKkenyCZ8tANSeCp9hPXQ680Fb8+DAktA7NYQ9gWIgiRg30EuQTawhLj+yLnYAHygKbAS72NFxpkUgrE1KREd0IurDymMIqYBUEkBvJ8ZD6NSCUR9aYaDQoVkPIS6/UA9N/dwjnNxM3pJG5XGYTthM2e1w3Q99sO7T+YtM6xCTXIHuowdW+OkplhtTNPzlcWbEjJ3L/H+djNyl69IWNstGd6mZAAXmgw6StGnb/ZwE8I3H71Pj7jg9OMXVDBuRmmmjm6K3WMTohTVF5942aZjO5E2JLPsFGjG+rUZYzuvE7271roTUn94hixJwPivktMKJu5YaNGUvisMxdohSblIEXRz5HXm5jCZyFIM2g0ON6e7rFNPfQjG8D34d57lT3YU1xPzwIgbQb0OtYu1aLNrVG6aUeaaEKyxx3sbfSqjOOic1drLdN+lmKQUSBOKuTg3/SR/YVD9l6HXZ4C/IpBBscw8V0NF41hvUZbmlRlggBVaJLCZdorMO0VGNAbVINkL/+ttjfBqa+cRAQgbYF7lE5ryGbMWGJMr0XdgxIqrTOVW9HQA3WkDvFpnx2fGaRze5xrp76PMZLlI5M/IIHHNYXLuD+9VuEBQah08H7A88sPs7kzyfXJ01juLOJlBLFKQOs0i9wfHEa+XqciY8i6YGB7k8rmOIMHathlH8PxufXRE444F7vKZw95JAwk1AVarYXW9ghzafLzTUIB7qBGsuhiiUApFKWNF9MghPQel8VTElzcfBQtpoMM1cbvz+IP5RC+EjHJwT7183QN0XHp/4RD5bg4A3c16RgWzWdajP9BFVknNLFeHdIpmKz75DxT6T4Wjk6Tf6hNeTTFOza9lroWZ8yvkQ9arHn2HJ/b9D28qKh3o402oHfIaR3SmkLYJ4yycn8WNp1jLfAErRUGd31uLWEg2PgPRZ5zxk7SD6p23t7rUg5SKhhVr5MWKk7dC3WeaIyx+qcLnH3pHnK7Ozzy6XG8Uy00L6R70FCmpELSkjZVaTPtZ5nx+1hvzTNsHIldO6z+c0KjlyVwOF8RgIcfVsag/68WAJVfH8ed0/HjGl7eoBwk2WAt0ZAxCnqTemj3gixzmsO4Ve7xwCe9AWaDNMW3pGmvNTn5XZN09xoRv8DHS2vEGj7JqBrvdoeYMBfxQp2FIM2A7lLQmz2Thpzewqko4cr5F+3ojX66EwaeqZMQHmnNpSrjTBhLxCKgaEs3RU5z6Pt5By2AA28vEDsHZn5cgBBeu/c2lntlPjpyCXtzUcJvsQxSIlMxxtwKry3dzRZzGT8rPINNnUPU18WwmgEHXpinc57Nqi+X6G+1kT9Vo81V3yxz0nmHsA8GZB52+dwLv8+393+R18zfRZ+vuPRao6N89zIJRLtLVnYYaS2SW5wnnBF0BwyawzFS8w5prRNdrCZaLESTIHyoXhhnqFPjjOLjalwlJdpiDb3WUWKpSk05CLciF+G2GtMtnp2i74k2/rygfHISayZgfbFIEGo8YYyy/20FBh5sMfSzJs1TLHKPtuk4Blf9x4/ZZ/WzEM+Qll0K97fxtutkozyHrN6O8gziNGQMU8ge7hOLzvrF49KY9QAvNDGf7/Pgr1aw68YB3BMNxm5Tk6EVf7/EWW/YzdHXFhn+Zp3M19us+cICG6+a42Vnb2H1P5SRfYIdPxkiflHA1FEqfnz1ZIWinyUpXAaMOgFK528JFfDqhKaa/QsfXcjoOQZssOeoBsk/FQN99auKBHTun2Hw/+P1tHQEWmWW2NpdhlkP8LMaG6wlZgObvV6GMb3W8wlICMV/b0grQlZV5W9LBYqVYwme+Nwox71shnNfvIvH/32MydP6cfImqX0uMREwqDdYZZbZ6Q711IcPOYozEBMezl6TY26YYfg7qvVcODsN6ZDBW5q0bYuE64IImfWzjBo17mmv5azE7miU5KN9OcBeCqhvsNl21TANJ4ERBEDI8+uP8bP+k3g0txpRbylALqvGatZChavLt+MKg08tfwF9nSbL3AoN21K6+nM0dkz0c+KvZ+i/qsH63xQBWDw7ydJZCVZdu0hlU4IfHjidkyq7ubz0IC8QW/h67tn8PH0sJ7f385zpJznWOUQmOOJGI28FmRTYpoe/oKKuGkGc9dYcrbTVe1wtEae90uTy6S3cG1+rQAlDVyCgrqnQkSBAWKbS8PfnCC2D906+hpvDf2P8lipzZ2ZZwyKJ37tYlwcESLa/eISJH5Y57tpD7HrvIJoLha0t5Mkaa05aIOgImnMW8UWPMy/by/S71fSiG0XFF4Msw3oNL1Q+kavMBbxQxwsNmusVGzEdqLv9qNlk4fQ0O545wtC2KqddMkVldZLkVJdlv62id4+MDJvLbIqnpKleHotLg10AACAASURBVGfp7DgSnZj08Feqe+zCriTHnjejriHhktNcZakWJpnxcwqTMB12e4N4ocG4qSi+lSDBGmuBtowKwNQU3HgjvPGNRwRBT2E9LQsAKJdfrR7STRs86RYYNWpsdQcZN8voQpIULhnNoRwksYQCu/Z7eQb0BsuMDouBqdyE1sTY+ZNBVl9ZZvMrp1h1Xol2wSI55+ItQjWr/AbGjCXKMkmzGyO216P/nhYn3DlN8nEXaQlmLs3SerHFkyePccZL9hCkNGzhEwKONElrHR7qTDBultnnFagGCY6+c45N/6Y4UjMfyKJrEAs91r20iP61EE/ofCd1MqKuDENFSwVuiFqTlzoPs749y7+MXMJSYHOapja4OSspn5hkKpNn9OglAkswcG+L+oRNvO6y7/MDFN0Ma9+zQPWYBL84dDS/yK9heMjhqtKvefPS3by8/iD5oM2SkeT3qTXsyS+jW/NJGgGv9u/BrAektnj4McHiwTT+mKbCSoYVoCgN6N/f4uCr8xz9vnk2yBLb0svVJME0kMm4Gg2m4oh6m3AoSv7xAlqPuSydGGfFjyrc9oqNPCu1H56A4HIVYpK2HaY/0sf6yxYYvk+NyvJb21ROSRCCwmISsPDsNHFcJv5FtdbJdpe6iLHBmqctDYpBijVWkaKfja6TFOYK1Ql4nqKZT/tZ5emvtzGXqSOed5nObS/fhBl65BodND2kbVjEkopOrhMyoDUoBTEG9BaTaZUeNDRZZ4cciXIoGpQCpU/RhVRjYKvEI84yNsemebg7RkHrRP6ACXJaRxnOAFx3nfp49dV/lX30tCwAXqirN6UukRlBS9o80FnJRvsQXmigRedxU6iRz053iFVmCVMPmPFzBNSoBgnaofJaO7QsT3CbRvr6Lqu/ski+ru54Ky6vMLC+gWsYhE3BpsosyV1ur/K3jrXY965+SlckaPTHGdUbuK5ObrqDHxdIBBKdbmjSkjarrAXqMoYXGjzrP/ey6ppFOoMmiXmP2sY4k24/w2aNAdFAI2TphXHqD8cIk5bS0bse2BabvWleXvodd6Q38ptlJ6BVW4yHNUIgtt+n+pI4G/QSqbe10NyQbkHHzkrqI3FaoUVioYsWQHfEUGo6Q6foG/w8vpHjmwfIB23uT63m2uwF+Om0mgD0G2gdjyvlvTSOt6ECmce7XHDZdmZu6KN1rI0zqC4nr1/DPuiz4y3DjH2wzourD/KB9HLFKAwCRBiqicNMCZJxtHI1clES4Hnce/E6Lv3QY5y8c5La6jjp3Q6NIM6wVccUkunj+rCv9DnqWxW8lEZ+T5v9QT8daWELj5jw8WydOz57NCfcMMXqj5ZZdn2NYExDe7nJtEyQ/iOBTTk6Z7fH1SbTfIU5jBl1YiJg0s/idRQI17Qtxk1lqEJesQaHtQbTfo6c1mZUb1ORFsN6nYa0KGgtmittsvsVYFj2UsyGfYwbFYY0hSWpUZ/GOYlDTPp2RGLTaYUWeb2JExqKoDQ5CV/7Gvzt38Ly5X+VvfS0xACm/LwSA9UlQUZjjbXAensWUwRqPOf2owmJExrs8QYYN8tUo4ivjObwYHs1e9xhTrSVNPQYa5FHmaD8phT3PXgU2748RGAJzJaPvccn/2SLTKmDm9KZf0WarZ8a5p7frGb/fw4w/6Y0sSE1aSjJBEmni7EgIaaEHjqSVGRPHRMeGdFh8w0HWHP1IkunJFjakKQ7YVCJp0jraiqgzSttYf38GB+4+0e88Jbf9fj4y5tFrln4OfvtQVpWnBOmn4SFMs/b9CBuRjH0dl88ADf5DN3RpL7ZBg+YkjgrDZLC5biyIpF8pnEuVGqIVocTanv5p9LP2WsP8Zv4ak5t7mWNV0J4Plqjhb5YR1QbyI7ASxi0j7VxkzpBUmP0b6vs3DWIMaq4EEFCw1rwGUvX+erZ53BKYy+bqgd6TEbRbKsx3R9lJlzWeZzz9f2EqQTfuO15+GnBqm8s4q3TSO3ussYsUpXxnlf+/msKNNba6F2J+WTAtFfAEj42AV4k215vL+C8Um1yp2Cy8h8rZC+uk3y8y7R3pH1ORrx+t09HaqAFCmea9PvY4xVUaGdd/dzZWI5Zv4+GjPXAYKc3AtZ4qDvGgO5G8W2+yqMct9APSUpBmjFjCQ1JVcb5Yf0ETolNR+EfOpO+xc7uCMfbszihgSPNngVc0nPgiiuUCvB97/ur7aWnZQFYb83jomM4AdIWJCMQp6B1mfQLnBo/GI0CVRBDW9rktA4LgSL2rLGLrLIWmPXjbLBneMgZpWA0qcoEMqbhXWSy+LIkei3krpvW8fu7VvK7W1fzh5uO4jfvWUP1sgSNsRhlGccJTWQolNNMqKHNqe7Aj2k9gVA3NPBCg2S3ywnvOsTEvyxRuTDOA1+fID/Voro6TkLrsiai1erlSJN2gmpFN8cneettP+fo66d5//xPcdH4+NgLuLS8hbOcPYhkAnunh9mVNM+wyWUdll+3ROM0m/mj0xiBxF4KaAxEKT571LcXt6QQiTh9ZsB7ln7JtF3gPRuu5DNDF1ExUryueR90XZChChvtyyA9jY6ufmfNCNlyo5pDn3f1TuzhAD8mQIBd8ikGKTZ9dj8lI81ry/f0jjJhUsmND3P3ZX8f51af5LSF7aBpdDuCA68oMHx7nWbexl4KaC1a5LQOuahdt2IBD39mHALI7HBYyywBGl10dEIkgpgIWAwU3bj48hQPXjdBcs7ltMsnOeGfp5hbUPjACkN59ZeDNKEhEDJEQ4GEh1l7mbLqCrOFtjL49FMM6G4PAE1rDo40OcaaY4+nGH2KLNbCyAZozZCC1or4KsoE5MzkTkrSZq25QEL4vY5kmzvYY5iuMJY40Wow8i912LIFvvUtOOqov9peeloWgMPzfpkRhHVBVVp4oc5DzniUsJpjpzvEbm/wT+b2CnhTeEA5SFGWSXJRFsBhrX/Rz6IT8quXbIQQTv3EAVYY9SiPr8OYsURVJnqkoZzW4bHueA/Ui7ejc7Cu4YY6QfQSbzwwy5pLS+R+0mHP2/vZ+YUhanoCe9bHGlejtEmvnwANq63EPJ1BAyc02OkOMe9keOf7fsWoqPKtrz+Tak0BVflWhbf95tekpl20bsj+FxUQPwgxa5Klf0wyUmvSTauLSRuSVGUCe4dPEBMU/ThBPsVrFu4ihs9HcxfidAVtK87386exoT3DOrPWcwgSno9mS+Keh9n1kTGBfVTA5IfyZJ9wED+RVFYl0RywFwJljpJscdPgGazvFnmmdkipATtdRKONaHUI+pKIUiUiDBGpCLu8/xdXEFpQeEKNv7wZNaLd6Q5R0JtMewUKGztMPq+AkDDw7jZ+qBGEWs+c5Z726p6ffohG+KKQx+8a5eCr86y8eZGXXPgwJ3xlmpklJbvN6A6hIZAyInNFtNxJd4Dxver9Zh1UA8Xe3O9lGNQbyOgmo75GFe+87rC1u4yFII1Ig9mSBFJ1Gx56z+W3Ejn9tKNY8EGjwXJjiQDBrN/HdneYA9/RWX5TFd75ThUO+ldcT8sCUPSzjBtV/IxGrOHhhKq1XW8VmfJVrPdac4FBvUFOb6uEFc0lp3V6dGAv0sjv8Qrk9aaKAo8MQcoyTmFdk/m/TzP8kwbNH2nUZYxSkGHaK6ATUvTTjOlNikGG8xL7e3JN0VQdgG5IQgSmHzDy6zrrn1vEWJA8+o1lzLwtx72do1nvFNHbIXNDGYp+VpGZggReoFrKwySV5UaFcz+5g7H7avzhgxMsO32Jf/zlnerFsC2SrS66G+JmNarPiTP6ixq1o2Ps3dSPsT3AG1Vvsz0kyetN4ts9OutMpOMyUitxdmc3t+ZOZMbsU8KdQHJndhOu0Dm9tkN1AVHAaRDTCDvQaVs4tqlScC5O0tlgMvL1OotrU5hLAUZXEpMuTmhwp1zOpFngNXN3ocWjwFQpwTQwFmqQTqopQRhFp5erVD2dA1f0k/m9el3zi00G9AbDRo2c1mHAUGds8wK14TbcWiQ701HErFCjIe0e8QcUHjTtFZiJ91F6f4qdvxiifrzNik8scdYZexj9VI1ljQqhUM9jjVlWEeBegfOTewm2CbyCxnRfnyLyaF0WgjRlmewBe+vNRba6gwShRlVarLfm1Mg6UiTqrbCXSuVIJTJTz03ihTqt0OhxV0wRkBAOK79Y4qRrpnGfZcHHPvZX30tPywLghQbTfg4tF2LWFVWyLmPUQ6W6c0Kzd/ePCU/ZeAcpxeiTCYJQU9TMUMMk6M1Y/ziRNSY8dl81yMLJKY69epYNP5vjGKtITPN68//7OhNoyJ4BSEPGOUYqlZaPRrzsktjrIUIovSDF/b+aoHpmAhlqnJ3aztyUakG9kSN3m2GjBra6GaadDk5oUvhak+XfqFK+Mon1NwG6UGdIgImT5hm+S6Hh8+dmaPo2+UfbzJ6ZRZuRxPd4NNeq1tJIQ8lNkd7epbnBJsyl+djkd9EJuSV7oooBkxI6Do4v2BZfxjHNSZXG4wfKeDMmwBGknC52wlfW2NgsvDhFZleXzHAHva2KoOso8Croz3Nfcg1j7hKXz/8eQB0DnK76I6Jdpykzz4t+t593/e5XFN+WUj8PKCy0mfYKNGSMAOXOk9cdKoPqdWicahE/6GPP+2hChb5O+XnykQy7E5oq8SmykZtanWfyW/3cdctaWqdZrPpcmROffQizJTE8SSNSlJ5oz1J0LQbvbdI+2WLMrKnEIEJWmaUotMNhpeHzkDPOsFHrkaPqMsYqs4RU+xyrGTBsKOJYTm8r63rhUQqS0XWtk9ebaEKS9RzOfO8envHpaQ5dkmXHNwdULuBfeT0tC8CwUSWtOXQzBmZNtfQTZjUyvmhT0Nq9dh9UjNOw3mLSy2MKn4zmUNCb6EIS07yeMOcwUHeY17+VcQ58vUDneJO1by8Rf2OH7O62sgRHZ8JapBRkmA3STHsFTOFTnFPAVnp7F/tQQCigeFWa5mdSxPp93FAnr7dpS5tljqLVelmNDfYcbiSscXKqZS/sbBG/wWfdtSVmLsrym/esxkUx0ILojGgJn9HrVQEoPy/B4MEGIoD2epP+H6r2uXOsunC2iiFW7C5j1iWf8C8GIRj2qlT0JIuJvJIV+wFyIEdoWxxIDzPuLyl6cMwCy6SeiZOqdjFLAXJAY9bvIwg1HjtVYQFp64hzTcJVbLu9/xyjrKmz+IsrD5Cxo+g0KQlG+hFtBz9tccypU7z7tp8wai4pZ6a+DLNvUEUyeEQd4Q5jOqUgzXZ3CLdfvVe7Lx3ELWjED/nElzwMEbDWXKA/IgIZSMpBMhrTqWKS0Hxix3n8/osrefC2FcyerX6W8GDVq0uYt/nsafZhPSixSgE7LxyK2KAKL6rKOIN6g4LW4RFXqUZLQZqY8CIQ2qQcJBHpqCDWVcx3THMxhU8i0hWYwscUyl4upnmMPlBj5WWLjNzcYO4dGXZ8aojdYuivtX3+ZD0tx4BpzSEmAsJ+gVGTeC2d6WSGcaNOMUgy5fdRCVJsjh2kIS0kMB1ZfjuhSS6yFJ/2CuT0NgnRZdyoscfrJ0BghjoeOucnd/KIs4z2dy0mvlJmxeeXWPbzGs1jLOobY7SXW/TJDgPdBtrukPSTDsmZSFxjaXjjgvvuWMmo2WTazzCgt2jIOHqgACbZjrQHCZduaCmpcpBEjqgoqvznOxx/zywL56b4/XVHkbfaVKLwCCMCPsNFQfJJ9TM7fRbxqpKNLks26buxTuWcOPWMukuuzZbI3aNa4tfceg87DZW/VzGVjx7VuuLo+wFBPkX+4BJx6dGf9Fjs2OAHBMMC/fEAYYXMrMqR1jp4oUF6dYfAFJQ7NimrrY4krkFSeHz71K/zB20toHgOVx24lWuXv5AdH1vOl864CQ3J8osXKEt1Hh42qlRlHEsE7P27flZ8qsqKX1XwP2LgWIob3wos6kEML6EKwGDYxF9vwDYfa1GS2tal4VnsdIZ5OfM9n/2ZIMsub5DN8UkqQYyY8Fnw09RXx+h+Qmf8Z0vIvCCxzWPz3dO4OQ0/oRMkQZwXkNWOMPdWGEs0QpNWBPKOG1U0QuYjyW9ObyNDjZKfZi2LJPUuK81FnFCnEHWlUmoEaCSEz+i+KsMfazB2dw1n1OCBz08Qu9jnJKPFk+5fsAT7K6ynZQdQDRJM+zmCY5UH3bLtFeXnH1X3CbPC5thBqtImJnxm/D4G9Ba6kOT0NlN+H16o99JW1Nlf0TIPW1XntDZtqRhZO+QoB97cz92/W83efyrgxnQKt7dY/fFFjrtuhtHP1Ynv9GgcH2PqLUq22V5m0U0b1MM4pUD5BshQYAqftOawyQwxHPWzGnaM3d6gSoHRWxgJdccYv2eJ6mk2O78wyMqk4qyr3IKA4UhWmt7r9ObvHdukRuSQ8w0fsykpXpNB99Qdd5ocwW9CWqtM+mSbPstHAJ1AXQYimVD2XU4XvdzA0tTXPXfqQb6/93OYjQbekI5VkVgLPsb/196Zx8d1Vnf/+9xl9n000kiyFstW7Nhx4tghGySELIWEtkDZt9C8YaclBUIhQN8XCrTQsqSFllIIS0PZS0kIS8gCAUJInMWJ492WZW0eazSLZjTb3Z73j+dqktK0pcV5E73R+XzmM5p7r6TnPnPvuec553d+v36lLNTwgpRkHCeqEW1ZNNeoKKgdMJh1k7Slies7odIbo5zfmeCv3/YVvnzB55m10/TqS1gYOFLrKjO7UiOv1ygGkrimQK9JQh+2fIej40qNkGZjhtWN0WqYtDFYGgvSSelEp2y2XHGM0apakvXqS9zXHlFNYkaJaSflc+2pKHDQqJCabCGAyQ9kuPXnG9j5xUHaJ5tE5mz0Bmx51nHif9yk/RWjKwiy3BOS12u0pU7RizBg1Cm6cVJaWzX2NNR3FUhIdrRGu9fxhNVLpNRm8KtVMq9cYttzZsjfW+PQn/Yw89Ms3nMFZTfCXitA1YuciFvn39mKjADUU7zJgc09DFEhsbPD/u39zDppdJ/OKSI6JLQ2u60BNgfmfFBGk4LP4WcKt8vKen9rlERkPyU3pmrCfk/3rKuw29vCk6rho0en9foQP71iiJy2yPHFJL2hGlP0MBCsEtE6BDsuQ39XJdSyaYdMEppimcn4T5+o1iGlWRywDSy/cT9rNMFc6JaBzAl1UQuguC5O2YjheO0uy5Emva44pdmSTLwszYYvFumJLpEKq2ig764lZt+W5MC6PtYeUjdBoGyRvXuJ2Vcnyd2yxNatE3AjdHpDUG8gU4kuHbiMhojNq2jC9BxSbhMvm0Qf8EkuPXDXiC7sulerYbQ8GsEgjEB8Qi0TZMrGkxqXXvkreC9MvTJF+uctNvzv49x85ibOzh1h2kmxnvluPd5FCbgus+bIMDTHTUa+UuHA+b1UnxVlPDBPW+q0fCxBylJK0RY6Vk7HGdJI3dPkrGdPAqpN2xQOU3aGkmaR0hsUnCQh0/b1FpIMHFJ4/9JYjA3hEuUNAUKHbBprDA69sZf8PTWydzYYvEEdt7QmQHu7QXUkgj2iEVnrsjDkMZlO0paBLj4g1PCb1lpxnjYzgXHEQ5+0edGO+4jv6CA8aI0YTL8xxcN/OEAq18JCJ6u1SNJR/BPy8XlWr0gHoBpxLLxewdJwgMgDFilN1WeXM6uqJOMQ9/v2NTxsTenCRzS7CxFOaS22hKYpuAkGjQrrzRoPW1lSWlMRjOgNTCT3d7Kk9AZVL8hpgQJlL0Ay2aLsxYjRRhOKFHKeOBuHCxgND9KKghzAlaplOKs3u4QlsajKcB+q55CuYMwsE/5qm9SP2yBg5iVJxr+yAJug+PI4FjpDepW21Fnar5xHO6ejb1aRRMGJ0/N9BS1eGgnw4JsGOdTJc0pEcbIO3FlDs2D60gx9tyyh6RIJrE0d5x3fu42s1mTWTZLSmhTdBOPnz0EDxv6gAF+AV3/1ZjoHHrlk7JNU9aUuwwyXFtE7kqWBIDFbRVbDPy+zd/0AWb1Gwo+2dNPjwY8McMbzpzjrLyb55V+NkdWXurTqy9WUgK7OadCoIGxonBVAk3DROw9wzw3DTA+lMHEJOcrhWbqGlCYaYOKxtCZA6dokybcskdzXpv8jNbafM0n1VPUkNYXLuLnInKMguQHhErnbwokIWusMtIMup7xBVWlu/MIW+k5ZpPHKIAUnwamTcwR/aRO80yGxo032xmaXI2EEcIMCGVCs0NvFNEbHQwIXXnCwO3dSg8Z4gJk/SrH3kjyxzW2SuoXmKPbgshsjITrMuknyeo2svvTb3ziPYSvSAbhoqgxn1GieHiB1V4uaG6Qgk2wJzlF0o2jCY8pJ06vX0YRCYQG+o3BooloyFZuPchSHfdUfF0UXnhI2+6wcUa1DXGvhSo2SFyOuWUzaPQwaFfLmEgftHJNWD6cGZ5m10yyOh8n9fImQUBn7jN7ElloX3LHc2il95p5+u4qpS9y/kox8uoI1pGMUXHa/vx/zmMf4exYI7neYeUeKyWgarwMX/7nikiutj+GF1dPhmVdPENzp0OnTMV2XnFFnkz7LQdHHehbI/LxFZ1CncFoCCapeLiBaUmCXqhfGRIX17pQgPKeeXMuAJkO47F+bZxOK8640rtpbtwTnaN+lxtDcYmJPaUgNUre0ca8QNKSpmqFQT87m5gATb+xh/acXWPecIoWLE93vteRGCWmKLmvYKFNzg2htSTtqsuvvBznv+Yc59Q1z7P2XPsqRKKa/jKoFQgyKRxrBLAzuHh4mfEOHi87fT/i4w5bnFVg8P8Te5+XhOTARVv83JGwaboD0T1ssnhVm7RdKDHxmEdfQ2P35PMnNTX9sEfJGjb1jfTRGg2RfvcSYsUitZWBNa2iTkJlq0J4NEPdahHFouAGy9ywRmbApvCvB1FCa1lqT+f4EJ8XmKbgJIlqHWSdDTSpC27oXIqfXKPmQ5ZIbJas/qh34BNqKdABZrYUtOhTcGMZ5Nr03LLH+3iIzZ6ZVbVg4bDBbHBVKvTfl0yxZUrG6Vj2FvMuIJQI+LLPhBRk2y5S8KHGtzY7WGFtC04qU0o2Q0hvMOilGzTITfrKw5EWZddKENEslEzWHLaFpas8Ikr+lTqstGDcVYGRZc3DSyZLXF8nobURMXbyyIohf3WT421UKL47RSAYZ/acykZDFr/5hhDM/OsXQP1Xp/5cai88NI45Ioj4XQt/uGq1PquWAdsDj4Q/lcUIaW6+ew7rdJHJRh1DaZ0F+sMPuK/sJaYqDzkUgNQged+nMm1QyUVU61WzO/doEUoCQdJ/OWb3BYjyMExYICbVomLar/vfmG49h92gUTk0w/qUidkIjdU8LY9aj0J/iJKGalYLC46gbY/6NcTK3Nzj56gJz/6ryJhFhk9UbhISLp2sctnuJ2y01hpAgPGoz93dJRl5TZui1VYJf9hCWWpKEo3YXBKSiAFeV6aTJg3cPUqlGWPelBUa/Websd0ziXiNYOilIZ6OBE9boPVYnNOMQKDhkf9Lk+Plxjv5FmnJ/lKhQ0lzrzBJ1L0DDC6oqEpKm1KmYEdZvqDGxTvFE5vUlDrm91LwQw0aF8B9b6A3JjteMMGxUOGLlGAvMd5clRSfBkFkiJFx+1Rpj1Cxiai6Tdo68USWk2Y80A51gW5FJwKIbVdRLbpTmcwN4CUHmq01GzSqmcGl4Qe7uKBBN3QtRdKPk9ZpCYUmdWVtVCXJah4KrngKev+7M+2SM44ECIaGIO5XMWLxbsw0Ju1uSimstqm6UUbPMPivHnJMm+Cw1Tr0m2WX1YAqHhgyQ98O4jN5mws5Q7leJsfFr5xn+dpUjb82w8y/XEDTUza0jGYlWefj/9HPnv47RuThA+rtNsvc0u3Nh1GS3OemeTwzz0EuGqPxulM4anVM/OoOwJDUfAowE79WCeSeOJiQdaagrQMK665U606BRpX+qTv+Xayyern4v5Ucsca3NqFFC8yQIlVgLCJfMvga52xpMvLQH3ZAYx106owZCwtrvqNr7snBK1Q1jSZ010Sq7P5NHCsGZb5kET+JJxfZ00M7hIlSE1VAIvEo0QtWLsPPsNTz01wPk7l4i97o6waJyou2oAUhf8lyjKYMcsBUxTNGNsyZdY+lPQuy5M8/EN3qYujyNSEmyP2vSc1ODtT8r4ekw/fI0P/ruyez+Uj/l/ijbglW/5q8Sh5pPLDtuqmij4MZoyABHnQgJsRxJBZl10gwaVRrSJLzPprI+4uNRkl34cNGNU3BSZPUlRg2LSTtD3qiS8HtHsvoSbWlSdmNMWr8d+ed/ZCvSASjl1CQ5o8YefZDJF2TI/6iGvQAFVynvKC12g6zWIKc3qHphcnoLU7j0GnVyeo2iF+T8UJ3DVm93KXDQ6mPOThPSbPZ1+jFxMYVDxq/9Fp0EltTJ60tUfZz5qFmk4MS7GfEHBgawYxqBkkMW9Xs60ndEi0zaiv6pdcxECohO2Bz5SIaHrxogoHndv1vyothSOSZjq8vUpUmEI6mcFebuL6pusMOvy/Kzzyquu3ynzoBZoWMa7Pk/eeIHLQY+UCOXrCuuvpEA4VGPraEZPCkQSKQmaI6ZDH+ugjchKNQSDLypihsUTF+qdO0aPmV11QuzeCSE1gG9JbGmNaaWMoxeU8bK6ExdoTABZsGjsiZK6ekRRr5ZZkiUuqQboOCwVS9CaMRl9yf7Se1vETlm0/AC6HiMm8UuoEvMqehDG5B+h10Y7YWCqY+k6ftZnfw7lYNoDxiYPgw3orlEhEooxjWbrNZg1klQk0GqhNl9Rp6F98W4//ohHrxnkJs/fzLCkRx5bQ/zH4xjb9HVd2zUOe5q3WpBzkdqxvUWB20FGY8Ki0F9kaKbYN6NUfLFYpZZfcMdm9hEh84mnZzeoO0FuuxRoMRkI1qH+zsZ1pklbGl0+wU0PLYFFtB8mPLjYSvSARy2HyFwDAmb+qsCaDZY/6xu+OXyXtWLMGn3UHDiaMLr9gzEKdlpiAAAIABJREFUtVbXsz5sCwbNik8QabMpeAzN79FeF5gn4PMLVn1hkZxRo1evs6M9wrqAylxnHuWx41qLXr2OtUZH70gCt3vdqKLqKV7BhGjR/7UaF7zwMFKDhVOjHHpJjpxep+AkiWttBKgEmxciqzXI3Npg4x/Ns7QlyN7P9VHYrsplgR6X/JD6+0uzflVBb1C5KMrcGxKMf7XI4OsWEUB7jcFBO+vPh+zmJGbPTiGDgkvf9DDnv+YQsX0dHr62n3hKzeOyXl7ZjRK4+5GLN3vXEs/74E4SOzs8/P5+puNZTnbnCc/ahMYdJl7SQ3jOwb1V7wqnLPgRVFxrkdIs2hcaPPBHQ5iLHrFZi1knraIuL6C+R19SptQXoSZV6D3rJJh6SZoD1+aIHFbLm5Dj4CJwpEZL6ggkAZQOxKyTZshYxJMac3aaIaNKQwaYsHopt0JcfM0+nJzO7BuTiqjDSTBkKNKQkhfuAsPqPhzcRPU5xLU2fXqLA3Yvlt+iDkq7simDVL0wlX1RNBcKG5TDGDJLbAksqBKhE/exH5EuT+GgUWHQqOFJjV59iT12kqy+hMYj834ibUU6gOXw25Y644F5ghugfH6E0z47Q20miOerrkSF6tYKCNeXBXO7YqFZn3dtuSdA98UYim60Sx3W8IKK/80XFn1aaI6osCh50a5a67jZYsLJKIyBr0oU1yw6OQM3INj4oQKFulpmRESHUjXM0FurjFxToXFmgMVLw8SnO+Q0xS6rCU+F5kLlLNrSJPhth3VvLlHeGOGBL61hKpxF8/nr55wUxWgMNybIHG/gScU8GxI2O69ew7HL4/T+soHUwCw45LVFBo0aOh66f1HFIm32vriP+ESHxM429793DXvPG2DBUxDVZXpsDcnGOwpYPRpWSmPgEzX6v13n0Ft7MJ8n2RKcoX5Ahf7V8SCdS3UaawKMf6ZIr5/dDwmHqLAURHhZsPVtEiuqkTjQZuD+Khqeou9yEsRnlRMKDCiOx5TWRPc1+eael6T0nCgSOOkV86R+0cbw1Dk1/TVzWxpEtQ7TTpIpO8PGQIGd7TUUnCSDbomz/niK8AGHhz48wPFYkoIb4dzwEebcOJN2D1U3Qk5vMGFniGttBo1KV2ey7oUoe4osplevU/bLyG3PJKerBrKBfT7T9CkORR+JOOeEu+rSy9dn2wtQ8sIqynSjTNo9XQm6lNZhc2BZee/E2op0AHUvzKi50KVL3tEeZv7DcTQHxt+3gImq89e8UNcrA3h+KS6lNbugGhfVtVfzQgwYFUpujCFfTLTqRRTjq95knVliR3vA53c3KNgpUlqHPVa8Sx9ek0GKToKqF8QROq0hk9hRi1M/OosrYWzXAuf+/hHW/LDKxDsz/Ojzm5g4s4dQ2aE6ESEqLDYHCpjCxZOCqNdm7C8W2P7OaYrb4hy8vod4ymLYKHdlygeMKnUvTH0kSOSwcnhj/sVy0O6nMqxuYmlA8pDF+MVFEtc0CU65DN1QRbMlfV9ZYst1x2iuNXEigq0fm2XrJ6bpW1RObrmjcZN7jPhP2rRHDPSWJFKwOfCuHuTVBpOOWi5EDyjsQHl9lEOyj92v7Se7s0FLSf0R81l5NeGxxxfITBoOrUETwoKzXzfJyYceSZD171/EyuocTCinltQ6NLwgBTdJ2Y0hClA8JUbxAlXlSe5sE6w7xIX6P7Y0yOl1xs0KupActnP0GnXWzc7ztP81RfzWDvvf38vUBVk/R2TQ9AwG9DrjgXlGzTJtqTNkVP1oUmE5in5r+XIH53JUE9fa7O8M+MzPJukHmthRjeJQvMvsswwRtn1RmlknrXIe+lK3nD0WmCek2VS9CAd9SbrHw1ZkFSDuT+SWQIHdPg1YeU2EmauTrPvQAuZNLt4LgpRdt4sacxGU3Bi9ep19Vj/jgUIX/68kwRcpuzGGjbIv37SkWn3bw9SNChYq4RcQrsISmB2KbrQbRcT1Dg25LORgENMsrJjOrv81wJYvzJF4oEVqT5t2n8Evv7qWztNMsjQobFPRgXmnQ21EhfAhOhiW5PQXzBJ72GL68hT3XjNCMthiyVPnEZXqyeihIovOZoPMbU3anuGDUEy21Y8w/ql5SudGsC426P/zGnZKY+DGxUcm01Pr52PvTXLrOSdzRnWSdX+5wMmfLXRr26OfUz0LYxeVMNqSxH0W7Q0Gof0Oh0f6ELZa5hTdOAMPVXHDArFWstE8RuYVbZy/04jf4st/a23KMtbNCXhS47gbJq3XWDg9QnyiQ/8rqzz4tQGi6zoEdzvUNgXpNZdI6U12Wf2sM4vYUifptUnvbjL18jQzf5bE/VPB4LdrBAou2h1t1v3lApXzI7RHDPanM2yoHiNwyKXvhzX6vruEZwqmP56i8sIwKa/ZxeQv196LbhxL6hSdBFGto7QhjBpzdppRcwFTuN1ItC1Nla13g2wKzSiH4HVI39yieGEcSxg0pElKa1P3AlhSR/OVf5eFRiypkdNbTDsJLE/lIFJ+5DTt/JowyAmyFRkBLMt577Z6lUKrz9n/4OWDLG0NMPDeRY7tCHU7/upeuKu2UvNCjJoLDOhNJfkl3C4PwKZAiVknTc3ndjts59TvSNWrD3QloXXhofkCklFhM+1EuL81iidV67ArBZrn4YwJ3IAgvbtNZ8jgF18ZwztTMGbW0IRHdFObzojOhh/Nk9UbWHt1xj+rkHvmMZcHPj3Ibe/dyDFSXZEPWxpk/IpCx7/wjC0Cs+RRmYnRlEHqXpj1H1xAb3n84s/Wc3yrwtm7rwuyb3c/P3h4E9+/bxNeUDB7cYoDF/SxNTLFsb4k9/7NMN/48RnMXpb4N/MupMQNwa4b89x141rspMbWH0zTqy+R0Sxyep3Y3Rbzp8cpaXEmrF4O6Rmq74wRn1IOa85JM2DUmXYyRESHlJ+PCQobGRbsu74XzZM8+4o9ZKaXCB10KJ0c64qrbg/O+tGbQ/QhC70tCW93sTE5/rEk39p3OlZehwjkv1hj86sKbD9vhstO2cOZz5hi6x/OkrupwfzvRfnVj0dovzhE1O8aXb5OlCy3JKJ18NDImyqMX2eWmLR6GDUXKHlRn3hEI68vsc6soKO6TZcj09hdHcJVm+nLUl2x2qpPCVfw+QY9H+EXEjZlL0TBV6teThRO2hk8KboCLifaVmQE4KLUf+LCxvPDPBfBaLDKvZ8a5uxXTnLG5VN877pTyZ2pwthJu4cxP6k366R9Uo+y0okTHgNGhV3+lzvtZGhLr7veS4gObU1JNQG+aGOKzcEZkprNUSdBn77EWGDe55KrEtplY5Y9Tt81S3F7lMrWCOuuX+Ciyw5y9JIM5fPCjKyv0BAG7VNMsj9oEP39DuGHHsmW333jCJ1+k5PEcULCIaI57Gir7P+CD2zypKDsxrhnY5BL2c3Td01yR/86Tr59jv6bauy5Kk9uY53jnQRO5BjNOwXt5+g0giHaAVXDjwuVxKy6qsqxMXCMwohO81kB+AHcesdJRAIWZz9jkqkr0xRPUTJsR1+QYeyfFzhwPIeWl5RKERL728xfpZzN00LT7OwMcO/zB7jw2gaBOZcRq8TtjQ2cFznkC2yqDkxLGkgE7fUm89en6XtpmU0vP45mS0pnqWTupuAxqp5a2086Wfp/VMUz4eh5SSypU3ATbAofVz0Y60KUPhYlfn+H6nSIcNWmlTSxBw20c1xiEZeKHWXBindRdg0vSMSHI2d0m5Id8dt9PYb8MmBCV6jPQV1FUUrjIUHZjWFJnUGzQtVv7zVu8HCjAu9Z0JIB6j45Sd0NMxpY8HMaLUzhUfCJQfL6EmNGk/utHuacJOPmAvvtXoaM8uNyL63ICCCAInc46qTJ6Z5PAe5Q8sLoazz2fL2PTsbk91/7IIl72+jCY0twxq8AtLskEW1pMGhUyPkCnaNGRYF9jBIeKnIY0Otd3P2DrRHansmoWWbQLGNLg6IX9PvTPaKizcBdFcZfOY9ZVh78wb8eZMc3Rjj63gzfu+lU5l6RYOgXFba9e4a1LypxyguPk/x+GyFBFCSVP41x7wNr+OmR9TTzQWxpUPKiHLB7KbshRs0iW4KzHPXrwimtTUjY9G1bxErptG7TiB7tsPWdsyxuDnHkDRkaMkA82KF5RoD0r5pdQpQLw0cBqMsQGl63x+Kw3UtU61DxL+SY1mH9NxbQXCi+IkbOB0XVXh1Cs2Ho66pWPnjXIkLCwtkxQsJmnw+Y8nSd8u+p0ubgpxYZC8xT8sLsaA8zafcwaff4BBgKYTm7Ocruz+UJHXcUQcc6VS6bc5LkdIsAHgN6mfgPOpTPjSKTQikUaU2OOuluxlzEBQ+eO4jxKph8YxbnVTriWRInpDPtKCdmS4OQcMjpLTYGjlN0FDKv6AbY1R4iqqmekmUJuAGj4vdkGCQ11fYb0my2BOcYNsvd5GazZTJwyyLTF6VZCoSYs9PdRrOLIzN+uXOBtjSYdRLdJ/xhO8tx1/Sh6C2a0iCutf6NavGJtBXpAJZpugtOkjlHtWIeddKktDazTprDuT52fb0fK2tw6kvnGP5whWpdhWW21LvQ3+Xk1qyTpiED7LP6GDXLPgRTlQWPOmkanhIZGQseJ6Qpiedlvb2iG0f3PBZuNDn9+bNsfdUcwYMOD7+zn3+57zRKL4yiCVUvjq5v87P3nMRd947w09vWs/9LOX71hRHu/c4QsxclMVqSX7xsFCtlKolz4XVD/byxyAGrT/EPOElODs75c6E06ueJUz0vRP6ORZ7+R6q8eNen1xIIqX6Hmheiek6YxMEOnWmD04Kz+LwdGHiKSt3nv9sYOEZEdDCWE42dJTLXNzn+zBiFoSS7rbwi1hgLUH9mkKGvVEh0HAZuVgm7njMVYYqOpFevU3Jj1IcVliD1nRa9t6juuKy+hC11BswKEkFHGmwMHKctDfZvz2P3KEjxtlfO0DoQIK61+GlzVDV0/cQlNm0x93tJim6cvLFIwVVcfB5Kr2D5xjpo57py7jrSF/JsUPdC5I2qYhp2VAUoZ9SICsVjcF7kAHl9kcNWL0U30dUEBFXSnXMjNL0gg75c+DLac9CoMP6NIoGqi/dSlXiOaB2iWoeosLi3kwGUuCgorcuQcHxl6zJtafiAJoODVh8Der3LDnWibUU6gLY0acgA54UnMIXXrb9XfdktUzgEB1y+/61TmHlJig3XzfOM50yQvrWF5Wk+gq9N1VWc/1GtQ1ZrdMUYbP8LiPiJn5BmE9E6uFJToR46G4wFMg81Oe2jM5x9wSTb3jKNWJTc+6FhfnnHWva+vp+12bICdWg2U05GJYb0FrZuwhg0LgihXyg5siVH8+og+pLHOR8/ongLNcVbWHbV+ldHtStvCxa64wIICJcNpoONztQzMgRLHon9bfZe2wfD+KoyBoNGjYlL1AU39qMSZS/ELiuvzhfdBzy53Z4AXXgkfeYj7Zs2Rsnj6FszmLiKbMWvhe97cy9m0cP9B5vUbS0qvxPmsMyoPIifydd9BwNQ2xBk87uPMTqluidHzQUl6eY/tT0piGsWo/cvEDjuMfGWLFrb48KXHiB4r6NUc4XN+n8s0sybzD43qSoyepO8vkhOb6Ah/V4Hrcvt1/YUfdmsm2RXZ5BJO6N6O9xYl2k4pbWICotZJ9WVjDeFy8bgHFuCs+T0BhHR6SYHB/Smv/SIMGmnKHlRMlobe0ln8FOLVM8JceCsHGU31q04LV+/03aWrL5EyYtS8qIU3ISvCBSg5oVoS5Oc3mDUXKApDcbN4uNyL61IB6BucpeCG2HWUYmquqcIP3ThkTcWqckg0YzFrg8PsuMbQ8gwnPH6Kc565lHOvHaS0r4YeWNRJfR8CKmielaov6YXVHVdYXX12XpbNdbeV2T0L0sMPL3E018wwZovVGmuC7D7U33sv70P51WCZkABVqpemJTeJKc1/ZtYMqgrSqmEUNpvDRkgZ9Qobowy8dosPf/cwLtVUHQSPC04q3IUSEpujAGzQsENdteSoKiu7mhliTY6rPluVZGJnm7SeZZqRV6uSpjCY3o4y+LmIOnvN7sadABJobj0bL8cmtWapLQWTX+9nf9ajcWLQhza0qfq3H7iseaFSJ1jU3lWmJHPVNCbkpnnpKj7ZB5xP3Repr4GmPhwRjERvbpKfKHdpWMTqOakmgxiS4113yxhxzR2v3aAG79xKp2kzvZXTTN8a5nIjzvEfmVx9Mo0LVMBtibtHr/EpqPjUfP7O0zcbvWm5MbIag3GAwV04THow26H9CWVh0CxMG8MFLtdpVUv7Lcn6+R1FxuFDwGYdmPowmPWjwqyWoOO1Mlc1yJYdpl7Z5KApsbioZHwS5MZfYkBU+WXslrDH6NiO05pHR9T0qbkhYloyiEv04adaFuRScDliyak2djoXUpmHYnrk0pM21maXoCcUcc9QzB3Y5KTf3Scnu826P/7GgOf3k1jPEBnXKc8EqU1apJeIwGXnk4Dp6HTa9cJHnMY2l0hvNsmeVSVZDwDas8IMXNVigMX9qKnpL80CDIkqsxJg5rU2BKYZ8JJKqAQksN2L+OBQpf6ScdjSF9iwkkqSvJ3SPp/XuOMt05hfNHjwe154j6dOaj1ftULYeKy6BNEOFIjdrjN2W+eJDxpM3tOkv77apjzLpPpHqJ+3bzkxhgySxSem2TDX81z394QfZtVKL4sm1X3wmwJzDPt36wBfABQA3a9vZ+MvtQltfT86krB7VC5OsjTnnsUO6qx+PQw5wbnqHqqMWefk+CgDSfpqoNwrj+D/QWD018xw4bL53n4S3nIhfwmHomOh5yWJL/X4siLs1hhk9KaGN//xhYuef1eTn/zDG5Y0NxgcPhVPQwZZeK+M5q106SCLTwEST8SVPPWYdKJkNDaVL2IcsBam4ymSEvv7wyQ8rvtPDSqTphho4ImJCHpsNsaUPvkPKN+yS6puez34cDLFaaCk8Qsulzy+X2UfidC9fQIEdHhJL+vZJ+VVxGPL1Sa1ZcICYeaf10r9SlViZiw1bkV3SimD2R7PGxFOoCSq57e03aWQaPCvBtXiRoZIKs3OGj1MRookvNZczypQRg6Lwzw098fJLHQ5KSb5kn+so2512Xsxwtov8a4tJ6F7s+LQyGczRr7/6CX5maT8ulRyokYeaNKmhYFN0mvWCKqW5S8MBl9iazWYpfV63MONIkKmxGjwrSTVMSRuGjCY5fVy6BRJac3KGpRdnx5mDNffpRTr5hF/zMX72Uamga7OoPYfskoIFza/le35ntVNnxqHjukc9uXNpBZ02DgkkUS17bJfmiJjN5k0s4wbWdxEZRfGGXd3xbZ+uVpfvzBzWxhlrRucZt/cR53w8zZ6om27rAKOxdeFsPY7FG21LwvA6RArYU3yQICRX09cmeFO85ZS0pvMmunyRpL5I16dy41PKqnRbj10ydz8R/v5fQ/mOUXn1vn75MctPJc+je7EEJSfbPq1R81iwz21/jJZ9dz2XP3ECq7NA2dXGWJdshgZ3OYjcE56l6YXZ01bESNJ6p1mLRyivvRT7LFtTZxYdOROrus3u64NpmLNCU0pMG8Heew1cvm4CwlL8qQWerCsktOlEF9kUWPLrBnU6DAnBunX1bZ8NYiuutx8J29JDVF5mH6rFRxXV0rca2lwn831nVIWbFE1BeQLbkxAsKl4Caou4ohuOjEOe8E3T+PthXpAJpekKbfkpnUFLFizQupL9zp6Yad+5epmlANHVUvqMBDPb3c/4fDZK9cIips6naA+EwHMQua6eIEdRbNMEbII5br0IgHuksMF8GAXmei1euzB9WYtHpIaU0yepOAdCn5ENrNgXl+3hrD0nVygSIH7SxRYSn8twx2yUJm/Y7DhNYm29fkl/88xpar5th6zRyVb4YpvizKurOOU+4NM9iqsXQowNbvzQCQ2NNh5ndSLP55iJl0mp5Qg8LLEox+vUTtyiATI73dxpR1ZolCLkbxhTF6v7VE5m0qwVhxldxVzQtRJUJE65AsNsl/Xd249deGmLB6GTArlN0Yca3FmLHIhKNQkbm/WcKJatRzAQavrrL2hiL9QyqkVWvmKMKH6Kb1Bg1C8CyXw9/MMXbFAhc8/yC6JSnlDE7bO0X+O3Umr8gw359gs1Gg5IWpHw1w4dsPEay6TF+epP/bdbZdNsOBj+bY8uxp5pw054WPMu1ECOBR8oJU3Sh5v0O07Zl+yN2kI3WmnLSfLHQYNwscdGI0vSAaHhsDxS6PRFRYiqlJU8lnhRLVsaTGpN2jWoI1xQC84cPHSe1oseOTQzTXBWi6CpDV8II+E5RacoWEYi5e7gpc1hQ0hUfWRwJO21lM3WFjQLVRb/LfT7StyBzAeKCAhocpHMr+mnXUL8GMB+bZEppmwkmi4fGr1hgHrD4CqDVg3Uf5DRpV4prFrJskblrURkMcPTtD48wQc1tSWBsNjg8nmYpkiGsWBSdJn5+RL3sh8qbCrGtCckl0r4K2dvpJ+snCqhuh6CrloYSm2n/zek1p82kdxswyVTdCVl/yQ0GbcbNEWxrUcyH2fy3HgQ/lCFQcTnrXAudeMMmzN+3nlO3HOPulR0l+QyXo9l/Vy0OfGaSeD3JqcJa6F2DhrTGciM66ty3Q71aZ9bUSQkJRoB+8QoFtTvrEPALJohdWQqleWDXp2E22vmkWraVu2uNGnAGz0iWqiAqL4/6TafieEolb2hx5U4a9n8ljtFxOvXKOWl1jS3CWXn/O2r66bcmNU/OUcKa1xeSGfz2N6iWqQpO9o8mpr5mjnTb4+SvGCdc7dB4SDP1FhbMumyS+t81PP3YShz+Q41vf2U57jcHmNxwn9e4WvXXF7qPAOYq8ZFOgQN4v8Sa0NqNmGQvNZ/atd2vri16Qto9HADhoZ5W+oF8xWt6+/O5Jjahw8KTW3X/qjbMMf6lK9bUR2s83mbR7VFlVa7IxcBwNRUeutAQivrZEkjk7zZhRJqW1mPDx/0U3oViC/QTuvBvj/s7Q43IvrcgIwJYGdS9M0VVECkHhEhIe+9w4Ea1D0wt20VhbQ1NdMoW8sahIKj31xDvY6Sdn1Jhy0iS0NuvMEjs7awgJm0Gz2MWGx4XDgFHBRlUQdltryOpL1KXOuFlhzlU4/ryhwCFR3wks33gNL8iouaCWJj7/nKfXyRoqApn3s8Q72kMMmBU2Boqq+eTVNj9/2TpyDy+RPdDAOmbgxjQCwy6T2zIEMg77OgOMiiJlN0bVjWAKl3jfPLs+MsD2N0/T9xd1jr0vyYBep+BGFBvROii8Js76LxTxDDXePXY/IWEzbFVZ86YK0Z0Wxy6P0/9Pdb87MkJOr3ez16Zw6HGajP55mc6AzrErEyyYCRY+s0jfH1YYubzMzz67nnZCYQ76NTU3Ob1GXQt317YDg1VuufZkzu0/zPDnqxiLHiYel190d/f7lgYcvzDOxPt6MIbU0iM53uTQv/Qy9LEKJ103z/ofCQ79SY67XzTK6UwT0yzusdd2wV6W1MGFYaNCwfVbuo1F8npN6UbKIAl/jDoe834YntJaaJpFW+oEcDHxumpDIU3xQoxdX2Lg/Yssnh3i7quHCeKQM2pK51F4qhzp08/X3JDfn9BQUYax6ONZ6r4uRJ2m12bKybAtOE3RU7mLZbLUE20r0gFYUmedWcTyA5iDdg8pvUmvrthYS06MraEZxRzsd5zZ/lospTWZ9XsAlhMyUa1DRm9S8sKMmkVSWqdLKxbX2hx3lQ5A0aer2ho6SkqzKLhR9vsik3FjEU14TDtJ6l6Ys0Jz7LFUUinvt5/GdbVmXG7kUTTlBnNOmvFAoZtIWhYoqXohPKEztyXFgycPc274CHutPky/o85FY2NwjqoXYaO5wLSwsaRO0zMxL3OZuTLJ2HUlMODwe7LMOhnWBeYpuTHSV7XIfLdJoOyScNuMmguEjtvk37RIeKfF7EeSzIsY/dQxcX3n4jBklpiweonrLYY+WiG212LXZ/MsBcIM6WUOPiNN5VqTk95R5MKXHuCevx/BWa8R01QvwIydYdEO02vUSWktQsLlHGea6BG1f8/b8pTXR8hNLoEJrVyAqXPSxHs79OlL7PFzFXXgmJFk4ZoouRcssf5DRTa+f57BrywSPuRQW6+g4AU30eV6iGodTOGR0poq6So1Unqbw3aOrL7EpN1DRl/CQ6PhBbuissvf1ayTxjJqjJpV6p7JmCgy+P4quS83OH5RnJm/TRIPdroPnJIXJas1ujJgKb8aNO/GKTgqb7Wcx1JqQA5Vnwug6ka7jqEhA/Q+Ko9yIu03WgIIId4mhNgthHhYCPE1IURICLFWCHG3EOKgEOIbQoiAf2zQ/3zI3z96oged0puUPAXCmHPSZPUlArhdDP+gWWHOSZLVGtjSIK/XcBH+BaeAGkUngYWixWp4QcpuxG8j1tht5al6EbJ+ksfyKw06koTosKczyI72MHm90c2KR31qp2WK6V+0hvzW4BZRYbPRbJDVGt3y2zIuoOAmGQ8UsKXBLxobGDXLxH3y0roXUrVyo8IzwxPoSPL6Ypc4c1lk0pYGOzsqU133whyw+ggJl73v6WP+NTHGriux/YoZNs4f88+/ykwsyYN/PQgSwnfYWNcbnHJJgdjuDpN/l+XuF63tsvhoSPLGIrY0KLsxxgLzrP3xAqOfrzD7qiTFSxLdJ2lGa7PwuzF+/oX1GEWXZz73EOs/UcQtqX73AbNCQlflvzgW8zfHyF9SInN7k/0f6OXgW3ppPCfIxBtzFF6XoPK8CMm+lnJs0iBn1Ji0exgwFn0RF4PmyQEe+Mog9/7DEEHbp0r74RKx73fo9xbJG1UVyWltbKkx78aViIub5KCdJaG1iQoLTXiqOqAvMeRLgw0YdUzhPMLQ45k0PQP3kEb/q2vkvtxg7nUJjvxjmnokRNXn8dsSWOi2jpvCYdrOdnM+vXqdkGYrkldT9Z/M2mklaOM7xe2hye7mMYcYAAAKBElEQVT1HvId++Nh/6UDEEIMAm8FzpBSngLowMuAjwKflFKOAxXgSv9XrgQqUsr1wCf9406o3d8axZUaA0adTYHjVL1It/U3onUoOCmqboSIz6UWEQ55vca0k6HgJii6CUKayura0iClN7tr86YXJG8sMmYuUHSjXRloUEkgF8G20BR5o0rBjfpRRcuXHlOgFxfBpuAx6n7PQFKzmbBDZPQ2Ka3li5I2u/Xk5ZbkZ8d2M+2kiGuPyJPpeOxoj2AK2NEe6j5dIlqHshtj1KyS0Ze6/ASqU85AQ9ImwIP/e4C5DyRJ3NvmzAuPMvjaKrnr68Ru7hBb6CCA2CGL8//sMM0NBr/6wSilS6O+gIVat7f8/7l804Vvsdn01gKlrRF2X5P323sVZflRJ63amc8VPHDLINXnhln76TLrPq5AVmuvKXPxZw5xzvsOc9J5RS56/X4cXWfqW1nuetkYCa3NpJ3jYCdPwUn66suK4qvkRhWXgPBoS51d7SFchHL8AtKX2Xzv+1tYPFmF6Gf80TSnPOMYJ31qnqHKAgetfDciyGpNpQkplEqPi1BLRJ9avupGGDKa7OwMkNHa3RswMd+i7901znr2JJkHG+z5yz4eevcgUcNVreBuhLIbY2enl5yuHkDLGIiAz0eh+VWJqA99dhFsDc0w6ybZZ/VR9wKU3CgDxmIXtp3QHh9GoN90CWAAYSGEDURQPC0XAq/w938ZeD/wGeB5/s8A3wY+LYQQUsoTBmbWhCQgXKpegJyPiLPRGdRqTDpptgRnmXZSFJw4OpKyF/Lx3jWKbkLRe/kKr3NOmrZrMmYuEBcOZTeGjocnhSrdaC0KboKs1mDUqFD1glQ9s/sU1oXHYTtHzqixJTDPjs6gn8UNEtcVwGbRU8jFhhNQvQV+Vjiv12g7pq9Q1OCwncVDY8LOdGvVyyxEh2yFUVfJuhA6ns9spPtkJw67rDVd4cppPwIKCYd7XjlC+AKL0/5pluyNDYK3uoxS+Xfzag0aNDJBFl0lsRbFn1v/qel60P+PNTZ9okBzU4D7vjiMCMvuBa5Yclp+x18FegX3fHyE3JvqjHygTM8vm/T+ZAl+AsGsTnlTiP1v66P47BipSJON4hhzTpqnhw9TcGNdxqI+famL2Jy0e7rY+AGz4lO/Ke4GCx0Rgnu+P0Jctojf3mHN9YuMfLLC0KcqbDxjnqNnZzHOSXB8a5x0sEHRi/u0ccqJL0ODmzJI2TXZHpzlwEKWvjtr9P+kRv/3a+DBoVfmuOP1J7F+8DiepzHtpPx2YgcNj3Wm+jsZfYlBPxFa9QJYrt7lFFiuCqg1flzBxXW1tAtptv8wUNiF5ZL2iTbxm9yXQoirgA8DLeDHwFXAr/ynPEKIIeCHUspThBAPA8+RUs74+w4DZ0kpF37tb74eeD3A8PDw9qNHj564s1q1/9hcFwoF9UoklNa8rsMHPwgf+AD09sK73gUvfzn88IdwxRXw8MOwaxd8/ONKo/5FL4LPfQ5S/80e9eVrzbIgGDzx5/Yf2cGDcN11cPPNsHOn2haPw7nnwvAw9PdDPq/eXReKRZifV+8PPQR33qm2p9NKnvt971PztoJMCHGflPKMf7dDSvmfvoA0cDuQA0zgu8CrgUOPOmYI2OX/vBtY86h9h4Hsf/Y/tm/fLlftSWD33Sfl2WdLqW7Vf/9av17KL39ZSs97okf6P7diUcpvflPKN7xByq1bpeztlVKIxz7fVErKbdukfM97pPzFL6S07Sd69P9jA+6Vj3Hv/SZLgIuBI1LKou9JvgOcC6SEEIaU0gHWAHP+8TO+Q5gRQhhAEnh8mplX7cTatm1w112wZw/ccAP88pdw003w9rfDs58NF18M2oqEjjxiPT3w4her17I5jnriHzsGhgG5nDou8Phw8T+Z7DdxAFPA2UKICGoJcBFwL/AT4EXA14HXADf4x9/of77L33+774FWbaXYpk3q9VQxw4CBAfV6itl/6c6llHejknn3A7v83/lH4F3A24UQh4AscJ3/K9cBWX/724F3Pw7jXrVVW7UTYL9REvDxtjPOOEPee++9T/QwVm3V/r+1/ygJuMIXdKu2aqv229iqA1i1VXsK26oDWLVVewrbqgNYtVV7CtuqA1i1VXsK26oDWLVVewrbk6IMKIQoAv+dZoAeYOG/POrJayt5/Ct57LCyx//bjH1ESpn79Y1PCgfw3zUhxL2PVdNcKbaSx7+Sxw4re/yPx9hXlwCrtmpPYVt1AKu2ak9hW6kO4B+f6AH8lraSx7+Sxw4re/wnfOwrMgewaqu2aifGVmoEsGqrtmonwFYdwKqt2lPYVpwDEEI8Rwix36cdf9JxDQghhoQQPxFC7PWp1K/yt2eEELf4NOq3CCHS/nYhhPhb/3weEkJse2LPAIQQuhDiASHETf7nJ4wC/r9rQoiUEOLbQoh9/ndwzkqZ+yeCfn9FOQAhhA78HXApsAl4uRDiyUZd4wDvkFKeDJwNvMUf47uB26SiUb+NR4hSLgXG/dfrUczKT7RdBex91OcnjAL+f2B/A/xISrkROA11Hk/6uX/C6PcfiyjwyfoCzgFuftTna4Brnuhx/RdjvgG4BNgP9Pvb+oH9/s+fBV7+qOO7xz1B412DukkuBG4CBAp9Zvz6dwDcDJzj/2z4x4kncOwJ4Mivj2ElzD0wCEwDGX8ubwKe/XjP/YqKAHhkkpZtxt/2pDQ/LDsduBvok1IeA/Dfl7Wpn2zndC3wp9AVpM8CVanIX+Hfjq87dn//on/8E2VjQBH4or+E+bwQIsoKmHsp5SzwMRQH5zHUXN7H4zz3K80BiMfY9qSsYwohYsC/AH8ipaz9Z4c+xrYn5JyEEL8LzEsp73v05sc4VP4G+54IM4BtwGeklKcDDf5zTsonzfj9vMTzgLXAABBFLVF+3U7o3K80B7BMOb5sj6Yjf9KYEMJE3fz/LKX8jr/5uBCi39/fD8z7259M5/R04PeFEJMotucLURFByqd4h8emgOdJQgE/A8xIRWQLisx2Gytj7rv0+1JKG/g39PuPMb4TMvcrzQHsAMb9zGgAlSS58Qke078xIYRAMSPvlVJ+4lG7lunS4d/TqF/uZ6TPBhaXw9X/1yalvEZKuUZKOYqa29ullK/kEQp4eGwKeHgSUMBLKQvAtBBig7/pImAPK2DueRT9vn8NLY/98Z37Jyph81skSy4DDqAUh977RI/nMcb3DFQo9hCw039dhlqf3QYc9N8z/vECVdk4jKJdP+OJPgd/XBcAN/k/jwH3AIeAbwFBf3vI/3zI3z/2JBj3VpRuxUMoFav0Spl74APAPuBh4Hog+HjP/SoUeNVW7SlsK20JsGqrtmon0FYdwKqt2lPYVh3Aqq3aU9hWHcCqrdpT2FYdwKqt2lPYVh3Aqq3aU9hWHcCqrdpT2P4v0ODAoVt1ve4AAAAASUVORK5CYII=\n",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# What about Harris-Affine features?\n",
+ "harris_affine_local_detector = ScaleSpaceDetector(n_feats, \n",
+ " resp_module=kornia.feature.CornerHarris(0.05),\n",
+ " nms_module=nms,\n",
+ " mr_size=mr_size,\n",
+ " aff_module=kornia.feature.LAFAffineShapeEstimator(patch_size=19),\n",
+ " minima_are_also_good=False)\n",
+ "lafs, resps = harris_affine_local_detector(timg)\n",
+ "visualize_LAF(timg,lafs)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# Now lets also detect feature orientation\n",
+ "harris_affine_local_detector = ScaleSpaceDetector(n_feats, \n",
+ " resp_module=kornia.feature.CornerHarris(0.05),\n",
+ " nms_module=nms,\n",
+ " mr_size=mr_size,\n",
+ " aff_module=kornia.feature.LAFAffineShapeEstimator(patch_size=19),\n",
+ " ori_module=kornia.feature.LAFOrienter(patch_size=19))\n",
+ "\n",
+ "lafs, resps = harris_affine_local_detector(timg)\n",
+ "visualize_LAF(timg,lafs)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "torch.Size([1, 50, 128])\n",
+ "tensor([0.0825, 0.0127, 0.0190, 0.0117, 0.2476, 0.0145, 0.0135, 0.0149, 0.2476,\n",
+ " 0.0098, 0.0492, 0.2046, 0.2476, 0.0324, 0.1899, 0.1524, 0.0130, 0.0096,\n",
+ " 0.0136, 0.0116, 0.0143, 0.0137, 0.0106, 0.0149, 0.0106, 0.0060, 0.0537,\n",
+ " 0.1639, 0.0147, 0.0097, 0.2127, 0.1845, 0.0088, 0.0187, 0.0108, 0.0152,\n",
+ " 0.0119, 0.0144, 0.0191, 0.0114, 0.0079, 0.0095, 0.0119, 0.0122, 0.0071,\n",
+ " 0.0070, 0.0129, 0.0150, 0.0111, 0.0241, 0.0152, 0.0217, 0.0111, 0.0217,\n",
+ " 0.0151, 0.0221, 0.0098, 0.0213, 0.0246, 0.0237, 0.0071, 0.0174, 0.0155,\n",
+ " 0.0224, 0.0129, 0.0172, 0.0170, 0.0160, 0.0084, 0.1562, 0.0650, 0.0167,\n",
+ " 0.0067, 0.2476, 0.1090, 0.0083, 0.0050, 0.2476, 0.0427, 0.0162, 0.0132,\n",
+ " 0.0099, 0.0127, 0.0104, 0.0072, 0.1049, 0.0563, 0.0108, 0.0066, 0.1619,\n",
+ " 0.0517, 0.0093, 0.0038, 0.1700, 0.0157, 0.0058, 0.0728, 0.0194, 0.0145,\n",
+ " 0.0200, 0.0343, 0.1202, 0.1914, 0.0324, 0.0058, 0.0221, 0.1540, 0.1101,\n",
+ " 0.0067, 0.0105, 0.0134, 0.0180, 0.0949, 0.0283, 0.0177, 0.0267, 0.1562,\n",
+ " 0.0725, 0.2303, 0.0405, 0.1614, 0.0208, 0.2255, 0.2365, 0.1372, 0.0114,\n",
+ " 0.0121, 0.0230], grad_fn=)\n"
+ ]
+ }
+ ],
+ "source": [
+ "#Lets describe patches with SIFT descriptor\n",
+ "descriptor = kornia.SIFTDescriptor(32)\n",
+ "\n",
+ "patches = kornia.feature.extract_patches_from_pyramid(timg, lafs)\n",
+ "B, N, CH, H, W = patches.size()\n",
+ "# Descriptor accepts standard tensor [B, CH, H, W], while patches are [B, N, CH, H, W] shape\n",
+ "# So we need to reshape a bit :) \n",
+ "descs = descriptor(patches.view(B * N, CH, H, W)).view(B, N, -1)\n",
+ "print (descs.shape)\n",
+ "print (descs[0, 0])"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.4"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/homography_regression/.gitignore b/examples/homography_regression/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..60baa9cb833f9e075739f327f4fe68477c84a093
--- /dev/null
+++ b/examples/homography_regression/.gitignore
@@ -0,0 +1 @@
+data/*
diff --git a/examples/homography_regression/download_data.sh b/examples/homography_regression/download_data.sh
new file mode 100644
index 0000000000000000000000000000000000000000..21c91aa8aac02db9df4c36b1435d32ae7db78315
--- /dev/null
+++ b/examples/homography_regression/download_data.sh
@@ -0,0 +1,11 @@
+#!/bin/bash
+# This script is useful to download the example data
+
+DATA_DIR=./data
+
+mkdir -p $DATA_DIR
+wget http://www.robots.ox.ac.uk/~vgg/research/affine/det_eval_files/img1.ppm -P $DATA_DIR
+wget http://www.robots.ox.ac.uk/~vgg/research/affine/det_eval_files/img2.ppm -P $DATA_DIR
+wget http://www.robots.ox.ac.uk/~vgg/research/affine/det_eval_files/H1to2p -P $DATA_DIR
+
+echo "## Succeeded to download files to $DATA_DIR"
diff --git a/examples/homography_regression/homography.ipynb b/examples/homography_regression/homography.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..76bff0c97ef7102d1042695927f4bed0cd24ec1f
--- /dev/null
+++ b/examples/homography_regression/homography.ipynb
@@ -0,0 +1,250 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import cv2\n",
+ "import matplotlib.pyplot as plt\n",
+ "import numpy as np\n",
+ "import os\n",
+ "import torch\n",
+ "import torch.nn as nn\n",
+ "import torch.nn.functional as F\n",
+ "import torch.optim as optim\n",
+ "import kornia as tgm"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Input Parameters\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "input_dir = 'data'\n",
+ "src_name = 'img1.ppm' # source image file\n",
+ "dst_name = 'img2.ppm' # destinatipn image file\n",
+ "learning_rate = 1e-3\n",
+ "num_iterations = 400 \n",
+ "log_interval = 100 # print log every 200 iterations\n",
+ "use_cuda = torch.cuda.is_available()\n",
+ "device = torch.device('cuda' if use_cuda else 'cpu')\n",
+ "print('Using ', device)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def load_image(file_name):\n",
+ " \"\"\"Loads the image with OpenCV and converts to torch.Tensor \n",
+ " \"\"\"\n",
+ " assert os.path.isfile(file_name), \"Invalid file {}\".format(file_name)\n",
+ "\n",
+ " # load image with OpenCV \n",
+ " img = cv2.imread(file_name, cv2.IMREAD_COLOR)\n",
+ "\n",
+ " # convert image to torch tensor \n",
+ " tensor = tgm.utils.image_to_tensor(img).float() / 255.\n",
+ " tensor = tensor.view(1, *tensor.shape) # 1xCxHxW\n",
+ " return tensor, img"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Container to hold the homography as a trainable parameter"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "class MyHomography(nn.Module):\n",
+ " def __init__(self):\n",
+ " super(MyHomography, self).__init__()\n",
+ " self.homo = nn.Parameter(torch.Tensor(3, 3))\n",
+ " self.reset_parameters()\n",
+ "\n",
+ " def reset_parameters(self):\n",
+ " torch.nn.init.eye_(self.homo)\n",
+ "\n",
+ " def forward(self):\n",
+ " return torch.unsqueeze(self.homo, dim=0) # 1x3x3 "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Read images and convert to tensor"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "%matplotlib inline\n",
+ "img_src_t, img_src = load_image(os.path.join(input_dir, src_name))\n",
+ "img_dst_t, img_dst = load_image(os.path.join(input_dir, dst_name))\n",
+ "fig, (ax1, ax2) = plt.subplots(1, 2, sharey=True)\n",
+ "fig.set_figheight(15)\n",
+ "fig.set_figwidth(15)\n",
+ "ax1.imshow(img_src[:,:,::-1])\n",
+ "ax1.set_title('Source image')\n",
+ "ax2.imshow(img_dst[:,:,::-1])\n",
+ "ax2.set_title('Destination image')\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Initialize the warper and the homography"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "height, width = img_src_t.shape[-2:]\n",
+ "warper = tgm.HomographyWarper(height, width) #todo comment\n",
+ "dst_homo_src = MyHomography().to(device)\n",
+ "optimizer = optim.Adam(dst_homo_src.parameters(), lr=learning_rate)\n",
+ "# send data to device\n",
+ "img_src_t, img_dst_t = img_src_t.to(device), img_dst_t.to(device)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def draw_rectangle(image, dst_homo_src):\n",
+ " height, width = image.shape[:2]\n",
+ " pts_src = torch.FloatTensor([[\n",
+ " [-1, -1], # top-left\n",
+ " [1, -1], # bottom-left\n",
+ " [1, 1], # bottom-right\n",
+ " [-1, 1], # top-right\n",
+ " ]]).to(dst_homo_src.device)\n",
+ " # transform points\n",
+ " pts_dst = tgm.transform_points(torch.inverse(dst_homo_src), pts_src)\n",
+ "\n",
+ " def compute_factor(size):\n",
+ " return 1.0 * size / 2\n",
+ "\n",
+ " def convert_coordinates_to_pixel(coordinates, factor):\n",
+ " return factor * (coordinates + 1.0)\n",
+ " # compute convertion factor\n",
+ " x_factor = compute_factor(width - 1)\n",
+ " y_factor = compute_factor(height - 1)\n",
+ " pts_dst = pts_dst.cpu().squeeze().detach().numpy()\n",
+ " pts_dst[..., 0] = convert_coordinates_to_pixel(\n",
+ " pts_dst[..., 0], x_factor)\n",
+ " pts_dst[..., 1] = convert_coordinates_to_pixel(\n",
+ " pts_dst[..., 1], y_factor)\n",
+ "\n",
+ " # do the actual drawing\n",
+ " for i in range(4):\n",
+ " pt_i, pt_ii = tuple(pts_dst[i % 4]), tuple(pts_dst[(i + 1) % 4])\n",
+ " image = cv2.line(image, pt_i, pt_ii, (255, 0, 0), 3)\n",
+ " return image\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Main optimization loop\n",
+ "\n",
+ "This is the loss function to minimize the photometric error:\n",
+ " $ L = \\sum |I_{ref} - \\omega(I_{dst}, H_{ref}^{dst}))|$"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for iter_idx in range(num_iterations):\n",
+ " # warp the reference image to the destiny with current homography\n",
+ " img_src_to_dst = warper(img_src_t, dst_homo_src())\n",
+ "\n",
+ " # compute the photometric loss\n",
+ " loss = F.l1_loss(img_src_to_dst, img_dst_t, reduction='none')\n",
+ "\n",
+ " # propagate the error just for a fixed window\n",
+ " w_size = 100 # window size\n",
+ " h_2, w_2 = height // 2, width // 2\n",
+ " loss = loss[..., h_2 - w_size:h_2 + w_size, w_2 - w_size:w_2 + w_size]\n",
+ " loss = torch.mean(loss)\n",
+ "\n",
+ " # compute gradient and update optimizer parameters\n",
+ " optimizer.zero_grad()\n",
+ " loss.backward()\n",
+ " optimizer.step()\n",
+ "\n",
+ " if iter_idx % log_interval == 0 or iter_idx == num_iterations-1:\n",
+ " print('Train iteration: {}/{}\\tLoss: {:.6}'.format(\n",
+ " iter_idx, num_iterations, loss.item()))\n",
+ " # merge warped and target image for visualization\n",
+ " img_src_to_dst = warper(img_src_t, dst_homo_src())\n",
+ " img_vis = 255. * 0.5 * (img_src_to_dst + img_dst_t)\n",
+ " img_vis_np = tgm.utils.tensor_to_image(img_vis[0, ...])\n",
+ " image_draw = draw_rectangle(img_vis_np, dst_homo_src())\n",
+ " plt.imshow(image_draw.astype('uint')[:,:,::-1])\n",
+ " plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.6"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/homography_regression/install_dependencies.sh b/examples/homography_regression/install_dependencies.sh
new file mode 100644
index 0000000000000000000000000000000000000000..b4604e5198b45accae1a82b5e14fecb10f9a7b35
--- /dev/null
+++ b/examples/homography_regression/install_dependencies.sh
@@ -0,0 +1,7 @@
+#!/bin/bash -ex
+
+# install torchgeometry from source
+cd ../.. && python setup.py install && cd examples/homography_regression
+
+# we need last opencv
+conda install opencv --yes
diff --git a/examples/homography_regression/main.py b/examples/homography_regression/main.py
new file mode 100644
index 0000000000000000000000000000000000000000..d7a9e952381cb2d2285a6682aa5c30ca4acab898
--- /dev/null
+++ b/examples/homography_regression/main.py
@@ -0,0 +1,163 @@
+import argparse
+import os
+
+import cv2
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+
+import kornia as dgm
+
+
+def load_homography(file_name):
+ """Load a homography from text file."""
+ if not os.path.isfile(file_name):
+ raise AssertionError(f"Invalid file {file_name}")
+ return torch.from_numpy(np.loadtxt(file_name)).float()
+
+
+def load_image(file_name):
+ """Load the image with OpenCV and converts to torch.Tensor."""
+ if not os.path.isfile(file_name):
+ raise AssertionError(f"Invalid file {file_name}")
+
+ # load image with OpenCV
+ img = cv2.imread(file_name, cv2.IMREAD_COLOR)
+
+ # convert image to torch tensor
+ tensor = dgm.utils.image_to_tensor(img).float() / 255.0
+ tensor = tensor.view(1, *tensor.shape) # 1xCxHxW
+
+ return tensor, img
+
+
+class MyHomography(nn.Module):
+ def __init__(self):
+ super().__init__()
+ self.homo = nn.Parameter(torch.Tensor(3, 3))
+
+ self.reset_parameters()
+
+ def reset_parameters(self):
+ torch.nn.init.eye_(self.homo)
+
+ def forward(self):
+ return torch.unsqueeze(self.homo, dim=0) # 1x3x3
+
+
+def HomographyRegressionApp():
+ # Training settings
+ parser = argparse.ArgumentParser(description='Homography Regression with photometric loss.')
+ parser.add_argument('--input-dir', type=str, required=True, help='the path to the directory with the input data.')
+ parser.add_argument('--output-dir', type=str, required=True, help='the path to output the results.')
+ parser.add_argument(
+ '--num-iterations', type=int, default=1000, metavar='N', help='number of training iterations (default: 1000)'
+ )
+ parser.add_argument('--lr', type=float, default=1e-3, metavar='LR', help='learning rate (default: 1e-3)')
+ parser.add_argument('--cuda', action='store_true', default=False, help='enables CUDA training')
+ parser.add_argument('--seed', type=int, default=666, metavar='S', help='random seed (default: 666)')
+ parser.add_argument(
+ '--log-interval',
+ type=int,
+ default=10,
+ metavar='N',
+ help='how many batches to wait before logging training status',
+ )
+ parser.add_argument(
+ '--log-interval-vis',
+ type=int,
+ default=100,
+ metavar='N',
+ help='how many batches to wait before visual logging training status',
+ )
+ args = parser.parse_args()
+
+ # define the device to use for inference
+ use_cuda = args.cuda and torch.cuda.is_available()
+ device = torch.device('cuda' if use_cuda else 'cpu')
+
+ torch.manual_seed(args.seed)
+
+ # load the data
+ img_src, _ = load_image(os.path.join(args.input_dir, 'img1.ppm'))
+ img_dst, _ = load_image(os.path.join(args.input_dir, 'img2.ppm'))
+
+ # instantiate the homography warper from `kornia`
+ height, width = img_src.shape[-2:]
+ warper = dgm.HomographyWarper(height, width)
+
+ # create the homography as the parameter to be optimized
+ dst_homo_src = MyHomography().to(device)
+
+ # create optimizer
+ optimizer = optim.Adam(dst_homo_src.parameters(), lr=args.lr)
+
+ # main training loop
+
+ for iter_idx in range(args.num_iterations):
+ # send data to device
+ img_src, img_dst = img_src.to(device), img_dst.to(device)
+
+ # warp the reference image to the destiny with current homography
+ img_src_to_dst = warper(img_src, dst_homo_src())
+
+ # compute the photometric loss
+ loss = F.l1_loss(img_src_to_dst, img_dst, reduction='none')
+
+ # propagate the error just for a fixed window
+ w_size = 100 # window size
+ h_2, w_2 = height // 2, width // 2
+ loss = loss[..., h_2 - w_size: h_2 + w_size, w_2 - w_size: w_2 + w_size]
+ loss = torch.mean(loss)
+
+ # compute gradient and update optimizer parameters
+ optimizer.zero_grad()
+ loss.backward()
+ optimizer.step()
+
+ if iter_idx % args.log_interval == 0:
+ print(f'Train iteration: {iter_idx}/{args.num_iterations}\tLoss: {loss.item():.6}')
+ print(dst_homo_src.homo)
+
+ def draw_rectangle(image, dst_homo_src):
+ height, width = image.shape[:2]
+ pts_src = torch.FloatTensor(
+ [[[-1, -1], [1, -1], [1, 1], [-1, 1]]] # top-left # bottom-left # bottom-right # top-right
+ ).to(dst_homo_src.device)
+ # transform points
+ pts_dst = dgm.transform_points(torch.inverse(dst_homo_src), pts_src)
+
+ def compute_factor(size):
+ return 1.0 * size / 2
+
+ def convert_coordinates_to_pixel(coordinates, factor):
+ return factor * (coordinates + 1.0)
+
+ # compute conversion factor
+ x_factor = compute_factor(width - 1)
+ y_factor = compute_factor(height - 1)
+ pts_dst = pts_dst.cpu().squeeze().detach().numpy()
+ pts_dst[..., 0] = convert_coordinates_to_pixel(pts_dst[..., 0], x_factor)
+ pts_dst[..., 1] = convert_coordinates_to_pixel(pts_dst[..., 1], y_factor)
+
+ # do the actual drawing
+ for i in range(4):
+ pt_i, pt_ii = tuple(pts_dst[i % 4]), tuple(pts_dst[(i + 1) % 4])
+ image = cv2.line(image, pt_i, pt_ii, (255, 0, 0), 3)
+ return image
+
+ if iter_idx % args.log_interval_vis == 0:
+ # merge warped and target image for visualization
+ img_src_to_dst = warper(img_src, dst_homo_src())
+ img_vis = 255.0 * 0.5 * (img_src_to_dst + img_dst)
+ img_vis_np = dgm.utils.tensor_to_image(img_vis)
+ image_draw = draw_rectangle(img_vis_np, dst_homo_src())
+ # save warped image to disk
+ file_name = os.path.join(args.output_dir, f'warped_{iter_idx}.png')
+ cv2.imwrite(file_name, image_draw)
+
+
+if __name__ == "__main__":
+ HomographyRegressionApp()
diff --git a/examples/homography_regression/readme.rst b/examples/homography_regression/readme.rst
new file mode 100644
index 0000000000000000000000000000000000000000..04cd6828e9a1de719ef9e6c29bd2320cbc02a37d
--- /dev/null
+++ b/examples/homography_regression/readme.rst
@@ -0,0 +1,82 @@
+Homography Regression by Gradient Descent
+=========================================
+
+This examples show how to use the `HomographyWarper` in order to do a regression where the parameter to optimize in this case is the homography driven by the gradient from a photometric loss.
+
+Quick overview
+--------------
+
+.. code:: python
+
+ # load the data
+ img_src = load_image(os.path.join(args.input_dir, 'img1.ppm'))
+ img_dst = load_image(os.path.join(args.input_dir, 'img2.ppm'))
+
+ # instantiate the homography warper from `kornia`
+ height, width = img_src.shape[-2:]
+ warper = dgm.HomographyWarper(height, width)
+
+ # create the homography as the parameter to be optimized
+ # NOTE: MyHomography is an inherited nn.Module class
+ dst_homo_src = MyHomography().to(device)
+
+ # create optimizer
+ optimizer = optim.Adam(dst_homo_src.parameters(), lr=args.lr)
+
+ # main training loop
+
+ for iter_idx in range(args.num_iterations):
+ # send data to device
+ img_src, img_dst = img_src.to(device), img_dst.to(device)
+
+ # warp the reference image to the destiny with current homography
+ img_src_to_dst = warper(img_src, dst_homo_src())
+
+ # compute the photometric loss
+ loss = F.l1_loss(img_src_to_dst, img_dst)
+
+ # compute gradient and update optimizer parameters
+ optimizer.zero_grad()
+ loss.backward()
+ optimizer.step()
+
+Downloading the data
+====================
+
+You can download the data by running: ``./download_data.sh``
+
+Usage
+=====
+
+1. From root, run the docker development or build first if needed: ``//kornia/dev_en.sh``
+2. Browse to ``cd /code/kornia/examples/homography_regression``
+3. Install the dependencies by running: ``./install_dependencies.sh``
+4. Now you can run the example followingthe instructions below:
+
+.. code:: bash
+
+ python main.py --input-dir ./data --output-dir ./out --num-iterations 1000 --log-interval-vis 200 --cuda --lr 1e-3
+
+
+.. code:: bash
+
+main.py [-h] --input-dir INPUT_DIR --output-dir OUTPUT_DIR
+ [--num-iterations N] [--lr LR] [--momentum M] [--cuda]
+ [--seed S] [--log-interval N]
+
+Homography Regression with perception loss.
+
+optional arguments:
+ -h, --help show this help message and exit
+ --input-dir INPUT_DIR
+ the path to the directory with the input data.
+ --output-dir OUTPUT_DIR
+ the path to output the results.
+ --num-iterations N number of training iterations (default: 1000)
+ --lr LR learning rate (default: 1e-3)
+ --cuda enables CUDA training
+ --seed S random seed (default: 666)
+ --log-interval N how many batches to wait before logging training
+ status
+ --log-interval-vis N how many batches to wait before visual logging
+ training status
diff --git a/examples/train/image_classifier/README.rst b/examples/train/image_classifier/README.rst
new file mode 100644
index 0000000000000000000000000000000000000000..ec8f8601034d7fe346153107369468c7eec8cfa1
--- /dev/null
+++ b/examples/train/image_classifier/README.rst
@@ -0,0 +1,30 @@
+Image Classifier Example
+========================
+
+This is a toy example implementing an image classification application.
+
+1. Install dependencies
+
+.. code-block:: python
+
+ pip install -r requirements.tx
+
+2. Execute the script: The entry point to this example is the file
+
+.. code-block:: python
+
+ python main.py
+
+3. Modify the hyper-parameters in `config.yml` and execute
+
+.. code-block:: python
+
+ python main.py num_epochs=50
+
+4. Sweep hyper-parameters
+
+.. code-block:: python
+
+ python main.py --multirun num_epochs=1 lr=1e-3,1e-4
+
+Explore hydra to make cool stuff with the config files: https://hydra.cc/
diff --git a/examples/train/image_classifier/config.yaml b/examples/train/image_classifier/config.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..d189995b412bcbc7e7ec20a40620ea145ea207a1
--- /dev/null
+++ b/examples/train/image_classifier/config.yaml
@@ -0,0 +1,6 @@
+
+data_path: ./data
+batch_size: 64
+num_epochs: 250
+lr: 1e-3
+output_path: ./output
diff --git a/examples/train/image_classifier/main.py b/examples/train/image_classifier/main.py
new file mode 100644
index 0000000000000000000000000000000000000000..774d8695be522d143f03c450c32d93972ccc986b
--- /dev/null
+++ b/examples/train/image_classifier/main.py
@@ -0,0 +1,78 @@
+import hydra
+import torch
+import torch.nn as nn
+import torchvision
+import torchvision.transforms as T
+from hydra.core.config_store import ConfigStore
+from hydra.utils import to_absolute_path
+
+import kornia as K
+from kornia.x import Configuration, ImageClassifierTrainer, ModelCheckpoint
+
+cs = ConfigStore.instance()
+# Registering the Config class with the name 'config'.
+cs.store(name="config", node=Configuration)
+
+
+@hydra.main(config_path=".", config_name="config.yaml")
+def my_app(config: Configuration) -> None:
+
+ # create the model
+ model = nn.Sequential(
+ K.contrib.VisionTransformer(image_size=32, patch_size=16, embed_dim=128, num_heads=3),
+ K.contrib.ClassificationHead(embed_size=128, num_classes=10),
+ )
+
+ # create the dataset
+ train_dataset = torchvision.datasets.CIFAR10(
+ root=to_absolute_path(config.data_path), train=True, download=True, transform=T.ToTensor())
+
+ valid_dataset = torchvision.datasets.CIFAR10(
+ root=to_absolute_path(config.data_path), train=False, download=True, transform=T.ToTensor())
+
+ # create the dataloaders
+ train_dataloader = torch.utils.data.DataLoader(
+ train_dataset, batch_size=config.batch_size, shuffle=True, num_workers=8, pin_memory=True)
+
+ valid_daloader = torch.utils.data.DataLoader(
+ valid_dataset, batch_size=config.batch_size, shuffle=True, num_workers=8, pin_memory=True)
+
+ # create the loss function
+ criterion = nn.CrossEntropyLoss()
+
+ # instantiate the optimizer and scheduler
+ optimizer = torch.optim.AdamW(model.parameters(), lr=config.lr)
+ scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
+ optimizer, config.num_epochs * len(train_dataloader))
+
+ # define some augmentations
+ _augmentations = nn.Sequential(
+ K.augmentation.RandomHorizontalFlip(p=0.75),
+ K.augmentation.RandomVerticalFlip(p=0.75),
+ K.augmentation.RandomAffine(degrees=10.),
+ K.augmentation.PatchSequential(
+ K.augmentation.ColorJitter(0.1, 0.1, 0.1, 0.1, p=0.8),
+ grid_size=(2, 2), # cifar-10 is 32x32 and vit is patch 16
+ patchwise_apply=False,
+ ),
+ )
+
+ def augmentations(self, sample: dict) -> dict:
+ out = _augmentations(sample["input"])
+ return {"input": out, "target": sample["target"]}
+
+ model_checkpoint = ModelCheckpoint(
+ filepath="./outputs", monitor="top5",
+ )
+
+ trainer = ImageClassifierTrainer(
+ model, train_dataloader, valid_daloader, criterion, optimizer, scheduler, config,
+ callbacks={
+ "augmentations": augmentations, "on_checkpoint": model_checkpoint,
+ }
+ )
+ trainer.fit()
+
+
+if __name__ == "__main__":
+ my_app()
diff --git a/examples/train/image_classifier/requirements.txt b/examples/train/image_classifier/requirements.txt
new file mode 100644
index 0000000000000000000000000000000000000000..fe932f25ab2104ef97ed7758abad8479e6a34ae7
--- /dev/null
+++ b/examples/train/image_classifier/requirements.txt
@@ -0,0 +1,3 @@
+kornia[x]
+torchvision
+hydra-core
diff --git a/examples/train/semantic_segmentation/README.rst b/examples/train/semantic_segmentation/README.rst
new file mode 100644
index 0000000000000000000000000000000000000000..cbce59ca938779053e8b760024fbccaee6d7d0df
--- /dev/null
+++ b/examples/train/semantic_segmentation/README.rst
@@ -0,0 +1,30 @@
+Semantic Segmentation Example
+=============================
+
+This is a toy example implementing a semantic segmentation application.
+
+1. Install dependencies
+
+.. code-block:: python
+
+ pip install -r requirements.tx
+
+2. Execute the script: The entry point to this example is the file
+
+.. code-block:: python
+
+ python main.py
+
+3. Modify the hyper-parameters in `config.yml` and execute
+
+.. code-block:: python
+
+ python main.py num_epochs=50
+
+4. Sweep hyper-parameters
+
+.. code-block:: python
+
+ python main.py --multirun num_epochs=1 lr=1e-3,1e-4
+
+Explore hydra to make cool stuff with the config files: https://hydra.cc/
diff --git a/examples/train/semantic_segmentation/config.yaml b/examples/train/semantic_segmentation/config.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..93319d0bd9eb4fd78517b514e5b6441897931e43
--- /dev/null
+++ b/examples/train/semantic_segmentation/config.yaml
@@ -0,0 +1,7 @@
+
+data_path: ./data
+batch_size: 4
+num_epochs: 2
+lr: 1e-3
+output_path: ./output
+image_size: [224, 224]
diff --git a/examples/train/semantic_segmentation/main.py b/examples/train/semantic_segmentation/main.py
new file mode 100644
index 0000000000000000000000000000000000000000..387d302108761c5ab9c35d5fe4cc61142bca0308
--- /dev/null
+++ b/examples/train/semantic_segmentation/main.py
@@ -0,0 +1,95 @@
+import hydra
+import numpy as np
+import torch
+import torch.nn as nn
+import torchvision
+from hydra.core.config_store import ConfigStore
+from hydra.utils import to_absolute_path
+
+import kornia as K
+from kornia.x import Configuration, Lambda, SemanticSegmentationTrainer
+
+cs = ConfigStore.instance()
+# Registering the Config class with the name 'config'.
+cs.store(name="config", node=Configuration)
+
+
+@hydra.main(config_path=".", config_name="config.yaml")
+def my_app(config: Configuration) -> None:
+
+ class Transform(nn.Module):
+ def __init__(self, image_size):
+ super().__init__()
+ self.resize = K.geometry.Resize(image_size, interpolation='nearest')
+
+ @torch.no_grad()
+ def forward(self, x, y):
+ x = K.utils.image_to_tensor(np.array(x))
+ x, y = x.float() / 255., torch.from_numpy(y)
+ return self.resize(x), self.resize(y)
+
+ # make image size homogeneous
+ transform = Transform(tuple(config.image_size))
+
+ # create the dataset
+ train_dataset = torchvision.datasets.SBDataset(
+ root=to_absolute_path(config.data_path), image_set='train', download=False, transforms=transform)
+
+ valid_dataset = torchvision.datasets.SBDataset(
+ root=to_absolute_path(config.data_path), image_set='val', download=False, transforms=transform)
+
+ # create the dataloaders
+ train_dataloader = torch.utils.data.DataLoader(
+ train_dataset, batch_size=config.batch_size, shuffle=True, num_workers=8, pin_memory=True)
+
+ valid_daloader = torch.utils.data.DataLoader(
+ valid_dataset, batch_size=config.batch_size, shuffle=True, num_workers=8, pin_memory=True)
+
+ # create the loss function
+ criterion = nn.CrossEntropyLoss()
+
+ # create the model
+ model = nn.Sequential(
+ torchvision.models.segmentation.fcn_resnet50(pretrained=False),
+ Lambda(lambda x: x['out']),
+ )
+
+ # instantiate the optimizer and scheduler
+ optimizer = torch.optim.AdamW(model.parameters(), lr=config.lr)
+ scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
+ optimizer, config.num_epochs * len(train_dataloader))
+
+ # define some augmentations
+ _augmentations = K.augmentation.AugmentationSequential(
+ K.augmentation.RandomHorizontalFlip(p=0.75),
+ K.augmentation.RandomVerticalFlip(p=0.75),
+ K.augmentation.RandomAffine(degrees=10.),
+ data_keys=['input', 'mask']
+ )
+
+ def preprocess(self, sample: dict) -> dict:
+ target = sample["target"].argmax(1).unsqueeze(1).float()
+ return {"input": sample["input"], "target": target}
+
+ def augmentations(self, sample: dict) -> dict:
+ x, y = _augmentations(sample["input"], sample["target"])
+ # NOTE: use matplotlib to visualise before/after samples
+ return {"input": x, "target": y}
+
+ def on_before_model(self, sample: dict) -> dict:
+ target = sample["target"].squeeze(1).long()
+ return {"input": sample["input"], "target": target}
+
+ trainer = SemanticSegmentationTrainer(
+ model, train_dataloader, valid_daloader, criterion, optimizer, scheduler, config,
+ callbacks={
+ "preprocess": preprocess,
+ "augmentations": augmentations,
+ "on_before_model": on_before_model,
+ }
+ )
+ trainer.fit()
+
+
+if __name__ == "__main__":
+ my_app()
diff --git a/examples/train/semantic_segmentation/requirements.txt b/examples/train/semantic_segmentation/requirements.txt
new file mode 100644
index 0000000000000000000000000000000000000000..fe932f25ab2104ef97ed7758abad8479e6a34ae7
--- /dev/null
+++ b/examples/train/semantic_segmentation/requirements.txt
@@ -0,0 +1,3 @@
+kornia[x]
+torchvision
+hydra-core
diff --git a/kornia/__init__.py b/kornia/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..2317157f59a7213b41914148c84cccb994e919b2
--- /dev/null
+++ b/kornia/__init__.py
@@ -0,0 +1,31 @@
+# import the version variable
+from ._version import __version__
+
+# NOTE: kornia filters and geometry must go first since are the core of the library
+# and by changing the import order you might get into a circular dependencies issue.
+from . import filters
+from . import geometry
+
+# import the other modules for convenience
+from . import (
+ augmentation,
+ color,
+ contrib,
+ enhance,
+ feature,
+ losses,
+ metrics,
+ morphology,
+ utils,
+ x,
+)
+# NOTE: we are going to expose to top level very few things
+from kornia.constants import pi
+from kornia.testing import xla_is_available
+from kornia.utils import (
+ eye_like,
+ vec_like,
+ create_meshgrid,
+ image_to_tensor,
+ tensor_to_image,
+)
diff --git a/kornia/_version.py b/kornia/_version.py
new file mode 100644
index 0000000000000000000000000000000000000000..906d362f7de4fa4a809146a1ea93fb01d22ceab9
--- /dev/null
+++ b/kornia/_version.py
@@ -0,0 +1 @@
+__version__ = "0.6.0"
diff --git a/kornia/augmentation/README.md b/kornia/augmentation/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..93d2eb6a85d6b3625f9261677021f7c1f4d8b195
--- /dev/null
+++ b/kornia/augmentation/README.md
@@ -0,0 +1,49 @@
+# Kornia Differentiable Data Augmentation
+
+## Supported Operations
+
+
+
diff --git a/kornia/augmentation/__init__.py b/kornia/augmentation/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..36b7f81eb9004cdf2390efa07214a59a5ae1842c
--- /dev/null
+++ b/kornia/augmentation/__init__.py
@@ -0,0 +1,92 @@
+from .augmentation import (
+ CenterCrop,
+ ColorJitter,
+ Denormalize,
+ Normalize,
+ PadTo,
+ RandomAffine,
+ RandomBoxBlur,
+ RandomChannelShuffle,
+ RandomCrop,
+ RandomElasticTransform,
+ RandomEqualize,
+ RandomErasing,
+ RandomFisheye,
+ RandomGaussianBlur,
+ RandomGaussianNoise,
+ RandomGrayscale,
+ RandomHorizontalFlip,
+ RandomInvert,
+ RandomMotionBlur,
+ RandomPerspective,
+ RandomPosterize,
+ RandomResizedCrop,
+ RandomRotation,
+ RandomSharpness,
+ RandomSolarize,
+ RandomThinPlateSpline,
+ RandomVerticalFlip,
+)
+from .augmentation3d import (
+ CenterCrop3D,
+ RandomAffine3D,
+ RandomCrop3D,
+ RandomDepthicalFlip3D,
+ RandomEqualize3D,
+ RandomHorizontalFlip3D,
+ RandomMotionBlur3D,
+ RandomPerspective3D,
+ RandomRotation3D,
+ RandomVerticalFlip3D,
+)
+from .base import AugmentationBase2D, AugmentationBase3D
+from .container import AugmentationSequential, ImageSequential, PatchSequential, VideoSequential
+from .mix_augmentation import RandomCutMix, RandomMixUp
+
+__all__ = [
+ "AugmentationBase2D",
+ "CenterCrop",
+ "ColorJitter",
+ "Normalize",
+ "Denormalize",
+ "PadTo",
+ "RandomAffine",
+ "RandomBoxBlur",
+ "RandomCrop",
+ "RandomChannelShuffle",
+ "RandomErasing",
+ "RandomElasticTransform",
+ "RandomFisheye",
+ "RandomGrayscale",
+ "RandomGaussianBlur",
+ "RandomGaussianNoise",
+ "RandomHorizontalFlip",
+ "RandomVerticalFlip",
+ "RandomPerspective",
+ "RandomResizedCrop",
+ "RandomRotation",
+ "RandomSolarize",
+ "RandomSharpness",
+ "RandomPosterize",
+ "RandomEqualize",
+ "RandomMotionBlur",
+ "RandomInvert",
+ "RandomThinPlateSpline",
+ "RandomMixUp",
+ "RandomCutMix",
+ "AugmentationBase3D",
+ "CenterCrop3D",
+ "RandomAffine3D",
+ "RandomCrop3D",
+ "RandomDepthicalFlip3D",
+ "RandomVerticalFlip3D",
+ "RandomHorizontalFlip3D",
+ "RandomRotation3D",
+ "RandomPerspective3D",
+ "RandomEqualize3D",
+ "RandomMotionBlur3D",
+ "AugmentationSequential",
+ "ImageSequential",
+ "PatchSequential",
+ "VideoSequential",
+]
diff --git a/kornia/augmentation/augmentation.py b/kornia/augmentation/augmentation.py
new file mode 100644
index 0000000000000000000000000000000000000000..445611787a3fdf2d59a7e9a603cc5853c291d037
--- /dev/null
+++ b/kornia/augmentation/augmentation.py
@@ -0,0 +1,2390 @@
+import warnings
+from typing import cast, Dict, List, Optional, Tuple, Union
+
+import torch
+from torch.nn.functional import pad
+
+from kornia.augmentation.base import GeometricAugmentationBase2D, IntensityAugmentationBase2D, TensorWithTransformMat
+from kornia.color import rgb_to_grayscale
+from kornia.constants import BorderType, pi, Resample, SamplePadding
+from kornia.enhance import (
+ adjust_brightness,
+ adjust_contrast,
+ adjust_hue,
+ adjust_saturation,
+ denormalize,
+ equalize,
+ invert,
+ normalize,
+ posterize,
+ sharpness,
+ solarize,
+)
+from kornia.filters import box_blur, gaussian_blur2d, motion_blur
+from kornia.geometry.bbox import bbox_generator, bbox_to_mask
+from kornia.geometry.conversions import deg2rad
+from kornia.geometry.transform import (
+ affine,
+ crop_by_transform_mat,
+ elastic_transform2d,
+ get_affine_matrix2d,
+ get_perspective_transform,
+ get_tps_transform,
+ hflip,
+ remap,
+ resize,
+ vflip,
+ warp_affine,
+ warp_image_tps,
+ warp_perspective,
+)
+from kornia.geometry.transform.affwarp import _compute_rotation_matrix, _compute_tensor_center
+from kornia.utils import _extract_device_dtype, create_meshgrid
+
+from . import random_generator as rg
+from .utils import _range_bound, _transform_input
+
+
+class RandomHorizontalFlip(GeometricAugmentationBase2D):
+ r"""Apply a random horizontal flip to a tensor image or a batch of tensor images with a given probability.
+
+ .. image:: _static/img/RandomHorizontalFlip.png
+
+ Input should be a tensor of shape (C, H, W) or a batch of tensors :math:`(B, C, H, W)`.
+ If Input is a tuple it is assumed that the first element contains the aforementioned tensors and the second,
+ the corresponding transformation matrix that has been applied to them. In this case the module
+ will Horizontally flip the tensors and concatenate the corresponding transformation matrix to the
+ previous one. This is especially useful when using this functionality as part of an ``nn.Sequential`` module.
+
+ Args:
+ p: probability of the image being flipped.
+ return_transform: if ``True`` return the matrix describing the transformation applied to each
+ input tensor. If ``False`` and the input is a tuple the applied transformation
+ won't be concatenated.
+ same_on_batch: apply the same transformation across the batch.
+ keepdim: whether to keep the output shape the same as input (True) or broadcast it
+ to the batch form (False).
+
+ Shape:
+ - Input: :math:`(C, H, W)` or :math:`(B, C, H, W)`, Optional: :math:`(B, 3, 3)`
+ - Output: :math:`(B, C, H, W)`
+
+ .. note::
+ This function internally uses :func:`kornia.geometry.transform.hflip`.
+
+ Examples:
+ >>> input = torch.tensor([[[[0., 0., 0.],
+ ... [0., 0., 0.],
+ ... [0., 1., 1.]]]])
+ >>> seq = RandomHorizontalFlip(p=1.0, return_transform=True)
+ >>> seq(input)
+ (tensor([[[[0., 0., 0.],
+ [0., 0., 0.],
+ [1., 1., 0.]]]]), tensor([[[-1., 0., 2.],
+ [ 0., 1., 0.],
+ [ 0., 0., 1.]]]))
+ >>> seq.inverse(seq(input)).equal(input)
+ True
+ """
+
+ def __repr__(self) -> str:
+ return self.__class__.__name__ + f"({super().__repr__()})"
+
+ def generate_parameters(self, batch_shape: torch.Size) -> Dict[str, torch.Tensor]:
+ return dict(batch_shape=torch.as_tensor(batch_shape))
+
+ def compute_transformation(self, input: torch.Tensor, params: Dict[str, torch.Tensor]) -> torch.Tensor:
+ w: int = cast(int, params['batch_shape'][-1])
+ flip_mat: torch.Tensor = torch.tensor(
+ [[-1, 0, w - 1], [0, 1, 0], [0, 0, 1]], device=input.device, dtype=input.dtype
+ )
+
+ return flip_mat.repeat(input.size(0), 1, 1)
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ return hflip(input)
+
+ def inverse_transform(
+ self,
+ input: torch.Tensor,
+ transform: Optional[torch.Tensor] = None,
+ size: Optional[Tuple[int, int]] = None,
+ **kwargs,
+ ) -> torch.Tensor:
+ return self.apply_transform(
+ input, params=self._params, transform=torch.as_tensor(transform, device=input.device, dtype=input.dtype)
+ )
+
+
+class RandomVerticalFlip(GeometricAugmentationBase2D):
+ r"""Apply a random vertical flip to a tensor image or a batch of tensor images with a given probability.
+
+ .. image:: _static/img/RandomVerticalFlip.png
+
+ Args:
+ p: probability of the image being flipped.
+ return_transform: if ``True`` return the matrix describing the transformation applied to each
+ input tensor. If ``False`` and the input is a tuple the applied transformation
+ won't be concatenated.
+ same_on_batch: apply the same transformation across the batch.
+ keepdim: whether to keep the output shape the same as input (True) or broadcast it
+ to the batch form (False).
+
+ Shape:
+ - Input: :math:`(C, H, W)` or :math:`(B, C, H, W)`, Optional: :math:`(B, 3, 3)`
+ - Output: :math:`(B, C, H, W)`
+
+ .. note::
+ This function internally uses :func:`kornia.geometry.transform.vflip`.
+
+ Examples:
+ >>> input = torch.tensor([[[[0., 0., 0.],
+ ... [0., 0., 0.],
+ ... [0., 1., 1.]]]])
+ >>> seq = RandomVerticalFlip(p=1.0, return_transform=True)
+ >>> seq(input)
+ (tensor([[[[0., 1., 1.],
+ [0., 0., 0.],
+ [0., 0., 0.]]]]), tensor([[[ 1., 0., 0.],
+ [ 0., -1., 2.],
+ [ 0., 0., 1.]]]))
+ >>> seq.inverse(seq(input)).equal(input)
+ True
+ """
+
+ def __repr__(self) -> str:
+ return self.__class__.__name__ + f"({super().__repr__()})"
+
+ def generate_parameters(self, batch_shape: torch.Size) -> Dict[str, torch.Tensor]:
+ return dict(batch_shape=torch.as_tensor(batch_shape))
+
+ def compute_transformation(self, input: torch.Tensor, params: Dict[str, torch.Tensor]) -> torch.Tensor:
+ h: int = cast(int, params['batch_shape'][-2])
+ flip_mat: torch.Tensor = torch.tensor(
+ [[1, 0, 0], [0, -1, h - 1], [0, 0, 1]], device=input.device, dtype=input.dtype
+ )
+
+ return flip_mat.repeat(input.size(0), 1, 1)
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ return vflip(input)
+
+ def inverse_transform(
+ self,
+ input: torch.Tensor,
+ transform: Optional[torch.Tensor] = None,
+ size: Optional[Tuple[int, int]] = None,
+ **kwargs,
+ ) -> torch.Tensor:
+ return self.apply_transform(
+ input, params=self._params, transform=torch.as_tensor(transform, device=input.device, dtype=input.dtype)
+ )
+
+
+class ColorJitter(IntensityAugmentationBase2D):
+ r"""Apply a random transformation to the brightness, contrast, saturation and hue of a tensor image.
+
+ .. image:: _static/img/ColorJitter.png
+
+ Args:
+ p: probability of applying the transformation.
+ brightness: The brightness factor to apply.
+ contrast: The contrast factor to apply.
+ saturation: The saturation factor to apply.
+ hue: The hue factor to apply.
+ return_transform: if ``True`` return the matrix describing the transformation applied to each
+ input tensor. If ``False`` and the input is a tuple the applied transformation
+ won't be concatenated.
+ same_on_batch: apply the same transformation across the batch.
+ keepdim: whether to keep the output shape the same as input (True) or broadcast it
+ to the batch form (False).
+
+ Shape:
+ - Input: :math:`(C, H, W)` or :math:`(B, C, H, W)`, Optional: :math:`(B, 3, 3)`
+ - Output: :math:`(B, C, H, W)`
+
+ .. note::
+ This function internally uses :func:`kornia.enhance.adjust_brightness`,
+ :func:`kornia.enhance.adjust_contrast`. :func:`kornia.enhance.adjust_saturation`,
+ :func:`kornia.enhance.adjust_hue`.
+
+ Examples:
+ >>> rng = torch.manual_seed(0)
+ >>> inputs = torch.ones(1, 3, 3, 3)
+ >>> aug = ColorJitter(0.1, 0.1, 0.1, 0.1, p=1.)
+ >>> aug(inputs)
+ tensor([[[[0.9993, 0.9993, 0.9993],
+ [0.9993, 0.9993, 0.9993],
+ [0.9993, 0.9993, 0.9993]],
+
+ [[0.9993, 0.9993, 0.9993],
+ [0.9993, 0.9993, 0.9993],
+ [0.9993, 0.9993, 0.9993]],
+
+ [[0.9993, 0.9993, 0.9993],
+ [0.9993, 0.9993, 0.9993],
+ [0.9993, 0.9993, 0.9993]]]])
+ """
+
+ def __init__(
+ self,
+ brightness: Union[torch.Tensor, float, Tuple[float, float], List[float]] = 0.0,
+ contrast: Union[torch.Tensor, float, Tuple[float, float], List[float]] = 0.0,
+ saturation: Union[torch.Tensor, float, Tuple[float, float], List[float]] = 0.0,
+ hue: Union[torch.Tensor, float, Tuple[float, float], List[float]] = 0.0,
+ return_transform: bool = False,
+ same_on_batch: bool = False,
+ p: float = 1.0,
+ keepdim: bool = False,
+ ) -> None:
+ super().__init__(p=p, return_transform=return_transform, same_on_batch=same_on_batch, keepdim=keepdim)
+ self._device, self._dtype = _extract_device_dtype([brightness, contrast, hue, saturation])
+ self.brightness = brightness
+ self.contrast = contrast
+ self.saturation = saturation
+ self.hue = hue
+
+ def __repr__(self) -> str:
+ repr = f"brightness={self.brightness}, contrast={self.contrast}, saturation={self.saturation}, hue={self.hue}"
+ return self.__class__.__name__ + f"({repr}, {super().__repr__()})"
+
+ def generate_parameters(self, batch_shape: torch.Size) -> Dict[str, torch.Tensor]:
+ brightness: torch.Tensor = _range_bound(
+ self.brightness, 'brightness', center=1.0, bounds=(0, 2), device=self._device, dtype=self._dtype
+ )
+ contrast: torch.Tensor = _range_bound(
+ self.contrast, 'contrast', center=1.0, device=self._device, dtype=self._dtype
+ )
+ saturation: torch.Tensor = _range_bound(
+ self.saturation, 'saturation', center=1.0, device=self._device, dtype=self._dtype
+ )
+ hue: torch.Tensor = _range_bound(self.hue, 'hue', bounds=(-0.5, 0.5), device=self._device, dtype=self._dtype)
+ return rg.random_color_jitter_generator(
+ batch_shape[0], brightness, contrast, saturation, hue, self.same_on_batch, self.device, self.dtype
+ )
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ transforms = [
+ lambda img: adjust_brightness(img, params['brightness_factor'] - 1),
+ lambda img: adjust_contrast(img, params['contrast_factor']),
+ lambda img: adjust_saturation(img, params['saturation_factor']),
+ lambda img: adjust_hue(img, params['hue_factor'] * 2 * pi),
+ ]
+
+ jittered = input
+ for idx in params['order'].tolist():
+ t = transforms[idx]
+ jittered = t(jittered)
+
+ return jittered
+
+
+class RandomGrayscale(IntensityAugmentationBase2D):
+ r"""Apply random transformation to Grayscale according to a probability p value.
+
+ .. image:: _static/img/RandomGrayscale.png
+
+ Args:
+ p: probability of the image to be transformed to grayscale.
+ return_transform: if ``True`` return the matrix describing the transformation applied to each
+ input tensor. If ``False`` and the input is a tuple the applied transformation
+ won't be concatenated.
+ same_on_batch: apply the same transformation across the batch.
+ keepdim: whether to keep the output shape the same as input (True) or broadcast it
+ to the batch form (False).
+
+ Shape:
+ - Input: :math:`(C, H, W)` or :math:`(B, C, H, W)`, Optional: :math:`(B, 3, 3)`
+ - Output: :math:`(B, C, H, W)`
+
+ .. note::
+ This function internally uses :func:`kornia.color.rgb_to_grayscale`.
+
+ Examples:
+ >>> rng = torch.manual_seed(0)
+ >>> inputs = torch.randn((1, 3, 3, 3))
+ >>> rec_er = RandomGrayscale(p=1.0)
+ >>> rec_er(inputs)
+ tensor([[[[-1.1344, -0.1330, 0.1517],
+ [-0.0791, 0.6711, -0.1413],
+ [-0.1717, -0.9023, 0.0819]],
+
+ [[-1.1344, -0.1330, 0.1517],
+ [-0.0791, 0.6711, -0.1413],
+ [-0.1717, -0.9023, 0.0819]],
+
+ [[-1.1344, -0.1330, 0.1517],
+ [-0.0791, 0.6711, -0.1413],
+ [-0.1717, -0.9023, 0.0819]]]])
+ """
+
+ def __init__(
+ self, return_transform: bool = False, same_on_batch: bool = False, p: float = 0.1, keepdim: bool = False
+ ) -> None:
+ super().__init__(p=p, return_transform=return_transform, same_on_batch=same_on_batch, keepdim=keepdim)
+
+ def __repr__(self) -> str:
+ return self.__class__.__name__ + f"({super().__repr__()})"
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ # Make sure it returns (*, 3, H, W)
+ grayscale = torch.ones_like(input)
+ grayscale[:] = rgb_to_grayscale(input)
+ return grayscale
+
+
+class RandomErasing(IntensityAugmentationBase2D):
+ r"""Erase a random rectangle of a tensor image according to a probability p value.
+
+ .. image:: _static/img/RandomErasing.png
+
+ The operator removes image parts and fills them with zero values at a selected rectangle
+ for each of the images in the batch.
+
+ The rectangle will have an area equal to the original image area multiplied by a value uniformly
+ sampled between the range [scale[0], scale[1]) and an aspect ratio sampled
+ between [ratio[0], ratio[1])
+
+ Args:
+ p: probability that the random erasing operation will be performed.
+ scale: range of proportion of erased area against input image.
+ ratio: range of aspect ratio of erased area.
+ same_on_batch: apply the same transformation across the batch.
+ keepdim: whether to keep the output shape the same as input (True) or broadcast it
+ to the batch form (False).
+
+ Shape:
+ - Input: :math:`(C, H, W)` or :math:`(B, C, H, W)`, Optional: :math:`(B, 3, 3)`
+ - Output: :math:`(B, C, H, W)`
+
+ Note:
+ Input tensor must be float and normalized into [0, 1] for the best differentiability support.
+ Additionally, this function accepts another transformation tensor (:math:`(B, 3, 3)`), then the
+ applied transformation will be merged int to the input transformation tensor and returned.
+
+ Examples:
+ >>> rng = torch.manual_seed(0)
+ >>> inputs = torch.ones(1, 1, 3, 3)
+ >>> rec_er = RandomErasing((.4, .8), (.3, 1/.3), p=0.5)
+ >>> rec_er(inputs)
+ tensor([[[[1., 0., 0.],
+ [1., 0., 0.],
+ [1., 0., 0.]]]])
+ """
+
+ # Note: Extra params, inplace=False in Torchvision.
+ def __init__(
+ self,
+ scale: Union[torch.Tensor, Tuple[float, float]] = (0.02, 0.33),
+ ratio: Union[torch.Tensor, Tuple[float, float]] = (0.3, 3.3),
+ value: float = 0.0,
+ return_transform: bool = False,
+ same_on_batch: bool = False,
+ p: float = 0.5,
+ keepdim: bool = False,
+ ) -> None:
+ super().__init__(p=p, return_transform=return_transform, same_on_batch=same_on_batch, keepdim=keepdim)
+ self._device, self._dtype = _extract_device_dtype([scale, ratio])
+ self.scale = scale
+ self.ratio = ratio
+ self.value: float = float(value)
+
+ def __repr__(self) -> str:
+ repr = f"scale={self.scale}, ratio={self.ratio}, value={self.value}"
+ return self.__class__.__name__ + f"({repr}, {super().__repr__()})"
+
+ def generate_parameters(self, batch_shape: torch.Size) -> Dict[str, torch.Tensor]:
+ scale = torch.as_tensor(self.scale, device=self._device, dtype=self._dtype)
+ ratio = torch.as_tensor(self.ratio, device=self._device, dtype=self._dtype)
+ return rg.random_rectangles_params_generator(
+ batch_shape[0],
+ batch_shape[-2],
+ batch_shape[-1],
+ scale=scale,
+ ratio=ratio,
+ value=self.value,
+ same_on_batch=self.same_on_batch,
+ device=self.device,
+ dtype=self.dtype,
+ )
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ _, c, h, w = input.size()
+ values = params['values'].unsqueeze(-1).unsqueeze(-1).unsqueeze(-1).repeat(1, *input.shape[1:]).to(input)
+
+ bboxes = bbox_generator(params['xs'], params['ys'], params['widths'], params['heights'])
+ mask = bbox_to_mask(bboxes, w, h) # Returns B, H, W
+ mask = mask.unsqueeze(1).repeat(1, c, 1, 1).to(input) # Transform to B, c, H, W
+ transformed = torch.where(mask == 1.0, values, input)
+ return transformed
+
+
+class RandomPerspective(GeometricAugmentationBase2D):
+ r"""Apply a random perspective transformation to an image tensor with a given probability.
+
+ .. image:: _static/img/RandomPerspective.png
+
+ Args:
+ p: probability of the image being perspectively transformed..
+ distortion_scale: it controls the degree of distortion and ranges from 0 to 1.
+ resample: the interpolation method to use.
+ return_transform: if ``True`` return the matrix describing the transformation
+ applied to each.
+ same_on_batch: apply the same transformation across the batch. Default: False.
+ align_corners: interpolation flag.
+ keepdim: whether to keep the output shape the same as input (True) or broadcast it
+ to the batch form (False).
+
+ Shape:
+ - Input: :math:`(C, H, W)` or :math:`(B, C, H, W)`, Optional: :math:`(B, 3, 3)`
+ - Output: :math:`(B, C, H, W)`
+
+ .. note::
+ This function internally uses :func:`kornia.geometry.transform.warp_pespective`.
+
+ Examples:
+ >>> rng = torch.manual_seed(0)
+ >>> inputs= torch.tensor([[[[1., 0., 0.],
+ ... [0., 1., 0.],
+ ... [0., 0., 1.]]]])
+ >>> aug = RandomPerspective(0.5, p=0.5)
+ >>> out = aug(inputs)
+ >>> out
+ tensor([[[[0.0000, 0.2289, 0.0000],
+ [0.0000, 0.4800, 0.0000],
+ [0.0000, 0.0000, 0.0000]]]])
+ >>> aug.inverse(out)
+ tensor([[[[0.0500, 0.0961, 0.0000],
+ [0.2011, 0.3144, 0.0000],
+ [0.0031, 0.0130, 0.0053]]]])
+ """
+
+ def __init__(
+ self,
+ distortion_scale: Union[torch.Tensor, float] = 0.5,
+ resample: Union[str, int, Resample] = Resample.BILINEAR.name,
+ return_transform: bool = False,
+ same_on_batch: bool = False,
+ align_corners: bool = False,
+ p: float = 0.5,
+ keepdim: bool = False,
+ ) -> None:
+ super().__init__(p=p, return_transform=return_transform, same_on_batch=same_on_batch, keepdim=keepdim)
+ self._device, self._dtype = _extract_device_dtype([distortion_scale])
+ self.distortion_scale = distortion_scale
+ self.resample: Resample = Resample.get(resample)
+ self.align_corners = align_corners
+ self.flags: Dict[str, torch.Tensor] = dict(
+ interpolation=torch.tensor(self.resample.value), align_corners=torch.tensor(align_corners)
+ )
+
+ def __repr__(self) -> str:
+ repr = (
+ f"distortion_scale={self.distortion_scale}, interpolation={self.resample.name}, "
+ f"align_corners={self.align_corners}"
+ )
+ return self.__class__.__name__ + f"({repr}, {super().__repr__()})"
+
+ def generate_parameters(self, batch_shape: torch.Size) -> Dict[str, torch.Tensor]:
+ distortion_scale = torch.as_tensor(self.distortion_scale, device=self._device, dtype=self._dtype)
+ return rg.random_perspective_generator(
+ batch_shape[0],
+ batch_shape[-2],
+ batch_shape[-1],
+ distortion_scale,
+ self.same_on_batch,
+ self.device,
+ self.dtype,
+ )
+
+ def compute_transformation(self, input: torch.Tensor, params: Dict[str, torch.Tensor]) -> torch.Tensor:
+ return get_perspective_transform(params['start_points'].to(input), params['end_points'].to(input))
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ _, _, height, width = input.shape
+ transform = cast(torch.Tensor, transform)
+ return warp_perspective(
+ input, transform, (height, width), mode=self.resample.name.lower(), align_corners=self.align_corners
+ )
+
+ def inverse_transform(
+ self,
+ input: torch.Tensor,
+ transform: Optional[torch.Tensor] = None,
+ size: Optional[Tuple[int, int]] = None,
+ **kwargs,
+ ) -> torch.Tensor:
+ return self.apply_transform(
+ input, params=self._params, transform=torch.as_tensor(transform, device=input.device, dtype=input.dtype)
+ )
+
+
+class RandomAffine(GeometricAugmentationBase2D):
+ r"""Apply a random 2D affine transformation to a tensor image.
+
+ .. image:: _static/img/RandomAffine.png
+
+ The transformation is computed so that the image center is kept invariant.
+
+ Args:
+ p: probability of applying the transformation.
+ degrees: Range of degrees to select from.
+ If degrees is a number instead of sequence like (min, max), the range of degrees
+ will be (-degrees, +degrees). Set to 0 to deactivate rotations.
+ translate: tuple of maximum absolute fraction for horizontal
+ and vertical translations. For example translate=(a, b), then horizontal shift
+ is randomly sampled in the range -img_width * a < dx < img_width * a and vertical shift is
+ randomly sampled in the range -img_height * b < dy < img_height * b. Will not translate by default.
+ scale: scaling factor interval.
+ If (a, b) represents isotropic scaling, the scale is randomly sampled from the range a <= scale <= b.
+ If (a, b, c, d), the scale is randomly sampled from the range a <= scale_x <= b, c <= scale_y <= d.
+ Will keep original scale by default.
+ shear: Range of degrees to select from.
+ If float, a shear parallel to the x axis in the range (-shear, +shear) will be applied.
+ If (a, b), a shear parallel to the x axis in the range (-shear, +shear) will be applied.
+ If (a, b, c, d), then x-axis shear in (shear[0], shear[1]) and y-axis shear in (shear[2], shear[3])
+ will be applied. Will not apply shear by default.
+ resample: resample mode from "nearest" (0) or "bilinear" (1).
+ padding_mode: padding mode from "zeros" (0), "border" (1) or "refection" (2).
+ return_transform: if ``True`` return the matrix describing the transformation applied to each.
+ same_on_batch: apply the same transformation across the batch.
+ align_corners: interpolation flag.
+ keepdim: whether to keep the output shape the same as input (True) or broadcast it to the batch form (False).
+
+ Shape:
+ - Input: :math:`(C, H, W)` or :math:`(B, C, H, W)`, Optional: :math:`(B, 3, 3)`
+ - Output: :math:`(B, C, H, W)`
+
+ .. note::
+ This function internally uses :func:`kornia.geometry.transform.warp_affine`.
+
+ Examples:
+ >>> rng = torch.manual_seed(0)
+ >>> input = torch.rand(1, 1, 3, 3)
+ >>> aug = RandomAffine((-15., 20.), return_transform=True, p=1.)
+ >>> out = aug(input)
+ >>> out
+ (tensor([[[[0.3961, 0.7310, 0.1574],
+ [0.1781, 0.3074, 0.5648],
+ [0.4804, 0.8379, 0.4234]]]]), tensor([[[ 0.9923, -0.1241, 0.1319],
+ [ 0.1241, 0.9923, -0.1164],
+ [ 0.0000, 0.0000, 1.0000]]]))
+ >>> aug.inverse(out)
+ tensor([[[[0.3890, 0.6573, 0.1865],
+ [0.2063, 0.3074, 0.5459],
+ [0.3892, 0.7896, 0.4224]]]])
+ >>> input
+ tensor([[[[0.4963, 0.7682, 0.0885],
+ [0.1320, 0.3074, 0.6341],
+ [0.4901, 0.8964, 0.4556]]]])
+ """
+
+ def __init__(
+ self,
+ degrees: Union[torch.Tensor, float, Tuple[float, float]],
+ translate: Optional[Union[torch.Tensor, Tuple[float, float]]] = None,
+ scale: Optional[Union[torch.Tensor, Tuple[float, float], Tuple[float, float, float, float]]] = None,
+ shear: Optional[Union[torch.Tensor, float, Tuple[float, float]]] = None,
+ resample: Union[str, int, Resample] = Resample.BILINEAR.name,
+ return_transform: bool = False,
+ same_on_batch: bool = False,
+ align_corners: bool = False,
+ padding_mode: Union[str, int, SamplePadding] = SamplePadding.ZEROS.name,
+ p: float = 0.5,
+ keepdim: bool = False,
+ ) -> None:
+ super().__init__(p=p, return_transform=return_transform, same_on_batch=same_on_batch, keepdim=keepdim)
+ self._device, self._dtype = _extract_device_dtype([degrees, translate, scale, shear])
+ self.degrees = degrees
+ self.translate = translate
+ self.scale = scale
+ self.shear = shear
+ self.resample: Resample = Resample.get(resample)
+ self.padding_mode: SamplePadding = SamplePadding.get(padding_mode)
+ self.align_corners = align_corners
+ self.flags: Dict[str, torch.Tensor] = dict(
+ resample=torch.tensor(self.resample.value),
+ padding_mode=torch.tensor(self.padding_mode.value),
+ align_corners=torch.tensor(align_corners),
+ )
+
+ def __repr__(self) -> str:
+ repr = (
+ f"degrees={self.degrees}, translate={self.translate}, scale={self.scale}, shear={self.shear}, "
+ f"resample={self.resample.name}"
+ )
+ return self.__class__.__name__ + f"({repr}, {super().__repr__()})"
+
+ def generate_parameters(self, batch_shape: torch.Size) -> Dict[str, torch.Tensor]:
+ degrees = _range_bound(self.degrees, 'degrees', 0, (-360, 360), device=self._device, dtype=self._dtype)
+ translate: Optional[torch.Tensor] = None
+ scale: Optional[torch.Tensor] = None
+ shear: Optional[torch.Tensor] = None
+
+ if self.translate is not None:
+ translate = _range_bound(
+ self.translate, 'translate', bounds=(0, 1), check='singular', device=self._device, dtype=self._dtype
+ )
+ if self.scale is not None:
+ scale = torch.as_tensor(self.scale, device=self._device, dtype=self._dtype)
+ if len(scale) == 2:
+ scale = _range_bound(
+ scale, 'scale', bounds=(0, float('inf')), check='singular', device=self._device, dtype=self._dtype
+ )
+ elif len(scale) == 4:
+ scale = torch.cat(
+ [
+ _range_bound(
+ scale[:2],
+ 'scale_x',
+ bounds=(0, float('inf')),
+ check='singular',
+ device=self._device,
+ dtype=self._dtype,
+ ),
+ _range_bound(
+ scale[2:],
+ 'scale_y',
+ bounds=(0, float('inf')),
+ check='singular',
+ device=self._device,
+ dtype=self._dtype,
+ ),
+ ]
+ )
+ else:
+ raise ValueError(f"'scale' expected to be either 2 or 4 elements. Got {scale}")
+ if self.shear is not None:
+ shear = torch.as_tensor(self.shear, device=self._device, dtype=self._dtype)
+ shear = torch.stack(
+ [
+ _range_bound(
+ shear if shear.dim() == 0 else shear[:2],
+ 'shear-x',
+ 0,
+ (-360, 360),
+ device=self._device,
+ dtype=self._dtype,
+ ),
+ torch.tensor([0, 0], device=self._device, dtype=self._dtype)
+ if shear.dim() == 0 or len(shear) == 2
+ else _range_bound(shear[2:], 'shear-y', 0, (-360, 360), device=self._device, dtype=self._dtype),
+ ]
+ )
+ return rg.random_affine_generator(
+ batch_shape[0],
+ batch_shape[-2],
+ batch_shape[-1],
+ degrees,
+ translate,
+ scale,
+ shear,
+ self.same_on_batch,
+ self.device,
+ self.dtype,
+ )
+
+ def compute_transformation(self, input: torch.Tensor, params: Dict[str, torch.Tensor]) -> torch.Tensor:
+ return get_affine_matrix2d(
+ torch.as_tensor(params['translations'], device=input.device, dtype=input.dtype),
+ torch.as_tensor(params['center'], device=input.device, dtype=input.dtype),
+ torch.as_tensor(params['scale'], device=input.device, dtype=input.dtype),
+ torch.as_tensor(params['angle'], device=input.device, dtype=input.dtype),
+ deg2rad(torch.as_tensor(params['sx'], device=input.device, dtype=input.dtype)),
+ deg2rad(torch.as_tensor(params['sy'], device=input.device, dtype=input.dtype)),
+ )
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ _, _, height, width = input.shape
+ transform = cast(torch.Tensor, transform)
+ return warp_affine(
+ input,
+ transform[:, :2, :],
+ (height, width),
+ self.resample.name.lower(),
+ align_corners=self.align_corners,
+ padding_mode=self.padding_mode.name.lower(),
+ )
+
+ def inverse_transform(
+ self,
+ input: torch.Tensor,
+ transform: Optional[torch.Tensor] = None,
+ size: Optional[Tuple[int, int]] = None,
+ **kwargs,
+ ) -> torch.Tensor:
+ return self.apply_transform(
+ input, params=self._params, transform=torch.as_tensor(transform, device=input.device, dtype=input.dtype)
+ )
+
+
+class CenterCrop(GeometricAugmentationBase2D):
+ r"""Crop a given image tensor at the center.
+
+ .. image:: _static/img/CenterCrop.png
+
+ Args:
+ size: Desired output size (out_h, out_w) of the crop.
+ If integer, out_h = out_w = size.
+ If Tuple[int, int], out_h = size[0], out_w = size[1].
+ align_corners: interpolation flag.
+ resample: The interpolation mode.
+ return_transform: if ``True`` return the matrix describing the transformation
+ applied to each.
+ p: probability of applying the transformation for the whole batch.
+ keepdim: whether to keep the output shape the same as input (True) or broadcast it
+ to the batch form (False).
+ cropping_mode: The used algorithm to crop. ``slice`` will use advanced slicing to extract the tensor based
+ on the sampled indices. ``resample`` will use `warp_affine` using the affine transformation
+ to extract and resize at once. Use `slice` for efficiency, or `resample` for proper
+ differentiability.
+
+ Shape:
+ - Input: :math:`(C, H, W)` or :math:`(B, C, H, W)`, Optional: :math:`(B, 3, 3)`
+ - Output: :math:`(B, C, out_h, out_w)`
+
+ .. note::
+ This function internally uses :func:`kornia.geometry.transform.crop_by_boxes`.
+
+ Examples:
+ >>> rng = torch.manual_seed(0)
+ >>> inputs = torch.randn(1, 1, 4, 4)
+ >>> inputs
+ tensor([[[[-1.1258, -1.1524, -0.2506, -0.4339],
+ [ 0.8487, 0.6920, -0.3160, -2.1152],
+ [ 0.3223, -1.2633, 0.3500, 0.3081],
+ [ 0.1198, 1.2377, 1.1168, -0.2473]]]])
+ >>> aug = CenterCrop(2, p=1., cropping_mode="resample")
+ >>> out = aug(inputs)
+ >>> out
+ tensor([[[[ 0.6920, -0.3160],
+ [-1.2633, 0.3500]]]])
+ >>> aug.inverse(out, padding_mode="border")
+ tensor([[[[ 0.6920, 0.6920, -0.3160, -0.3160],
+ [ 0.6920, 0.6920, -0.3160, -0.3160],
+ [-1.2633, -1.2633, 0.3500, 0.3500],
+ [-1.2633, -1.2633, 0.3500, 0.3500]]]])
+ """
+
+ def __init__(
+ self,
+ size: Union[int, Tuple[int, int]],
+ align_corners: bool = True,
+ resample: Union[str, int, Resample] = Resample.BILINEAR.name,
+ return_transform: bool = False,
+ p: float = 1.0,
+ keepdim: bool = False,
+ cropping_mode: str = 'slice',
+ ) -> None:
+ # same_on_batch is always True for CenterCrop
+ # Since PyTorch does not support ragged tensor. So cropping function happens batch-wisely.
+ super().__init__(p=1.0, return_transform=return_transform, same_on_batch=True, p_batch=p, keepdim=keepdim)
+ if isinstance(size, tuple):
+ self.size = (size[0], size[1])
+ elif isinstance(size, int):
+ self.size = (size, size)
+ else:
+ raise Exception(f"Invalid size type. Expected (int, tuple(int, int). " f"Got: {type(size)}.")
+ self.resample = Resample.get(resample)
+ self.align_corners = align_corners
+ self.flags: Dict[str, torch.Tensor] = dict(
+ interpolation=torch.tensor(self.resample.value), align_corners=torch.tensor(align_corners)
+ )
+ self.cropping_mode = cropping_mode
+
+ def __repr__(self) -> str:
+ repr = f"size={self.size}"
+ return self.__class__.__name__ + f"({repr}, {super().__repr__()})"
+
+ def generate_parameters(self, batch_shape: torch.Size) -> Dict[str, torch.Tensor]:
+ return rg.center_crop_generator(batch_shape[0], batch_shape[-2], batch_shape[-1], self.size, self.device)
+
+ def compute_transformation(self, input: torch.Tensor, params: Dict[str, torch.Tensor]) -> torch.Tensor:
+ transform: torch.Tensor = get_perspective_transform(params['src'].to(input), params['dst'].to(input))
+ transform = transform.expand(input.shape[0], -1, -1)
+ return transform
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ if self.cropping_mode == 'resample': # uses bilinear interpolation to crop
+ transform = cast(torch.Tensor, transform)
+ return crop_by_transform_mat(
+ input, transform[:, :2, :], self.size, self.resample.name.lower(), 'zeros', self.align_corners
+ )
+ if self.cropping_mode == 'slice': # uses advanced slicing to crop
+ # TODO: implement as separated function `crop_and_resize_iterative`
+ B, C, _, _ = input.shape
+ H, W = self.size
+ out = torch.empty(B, C, H, W, device=input.device, dtype=input.dtype)
+ for i in range(B):
+ x1 = int(params['src'][i, 0, 0])
+ x2 = int(params['src'][i, 1, 0]) + 1
+ y1 = int(params['src'][i, 0, 1])
+ y2 = int(params['src'][i, 3, 1]) + 1
+ out[i] = input[i : i + 1, :, y1:y2, x1:x2]
+ return out
+ raise NotImplementedError(f"Not supported type: {self.cropping_mode}.")
+
+ def inverse_transform(
+ self,
+ input: torch.Tensor,
+ transform: Optional[torch.Tensor] = None,
+ size: Optional[Tuple[int, int]] = None,
+ **kwargs,
+ ) -> torch.Tensor:
+ if self.cropping_mode != 'resample':
+ raise NotImplementedError(
+ f"`inverse` is only applicable for resample cropping mode. Got {self.cropping_mode}."
+ )
+ if size is None:
+ size = self.size
+ mode = self.resample.name.lower() if "mode" not in kwargs else kwargs['mode']
+ align_corners = self.align_corners if "align_corners" not in kwargs else kwargs['align_corners']
+ padding_mode = 'zeros' if "padding_mode" not in kwargs else kwargs['padding_mode']
+ transform = cast(torch.Tensor, transform)
+ return crop_by_transform_mat(input, transform[:, :2, :], size, mode, padding_mode, align_corners)
+
+
+class RandomRotation(GeometricAugmentationBase2D):
+ r"""Apply a random rotation to a tensor image or a batch of tensor images given an amount of degrees.
+
+ .. image:: _static/img/RandomRotation.png
+
+ Args:
+ p: probability of applying the transformation.
+ degrees: range of degrees to select from. If degrees is a number the
+ range of degrees to select from will be (-degrees, +degrees).
+ resample: Default: the interpolation mode.
+ return_transform: if ``True`` return the matrix describing the transformation applied to each
+ input tensor. If ``False`` and the input is a tuple the applied transformation
+ won't be concatenated.
+ same_on_batch: apply the same transformation across the batch.
+ align_corners: interpolation flag.
+ keepdim: whether to keep the output shape the same as input (True) or broadcast it
+ to the batch form (False).
+
+ Shape:
+ - Input: :math:`(C, H, W)` or :math:`(B, C, H, W)`, Optional: :math:`(B, 3, 3)`
+ - Output: :math:`(B, C, H, W)`
+
+ .. note::
+ This function internally uses :func:`kornia.geometry.transform.affine`.
+
+ Examples:
+ >>> rng = torch.manual_seed(0)
+ >>> input = torch.tensor([[1., 0., 0., 2.],
+ ... [0., 0., 0., 0.],
+ ... [0., 1., 2., 0.],
+ ... [0., 0., 1., 2.]])
+ >>> aug = RandomRotation(degrees=45.0, return_transform=True, p=1.)
+ >>> out = aug(input)
+ >>> out[0]
+ tensor([[[[0.9824, 0.0088, 0.0000, 1.9649],
+ [0.0000, 0.0029, 0.0000, 0.0176],
+ [0.0029, 1.0000, 1.9883, 0.0000],
+ [0.0000, 0.0088, 1.0117, 1.9649]]]])
+ >>> out[1]
+ tensor([[[ 1.0000, -0.0059, 0.0088],
+ [ 0.0059, 1.0000, -0.0088],
+ [ 0.0000, 0.0000, 1.0000]]])
+ >>> aug.inverse(out)
+ tensor([[[[9.6526e-01, 8.6824e-03, 1.7263e-02, 1.9305e+00],
+ [8.6398e-03, 2.9485e-03, 5.8971e-03, 1.7365e-02],
+ [2.9054e-03, 9.9416e-01, 1.9825e+00, 2.3134e-02],
+ [2.5777e-05, 1.1640e-02, 9.9992e-01, 1.9392e+00]]]])
+ """
+
+ # Note: Extra params, center=None, fill=0 in TorchVision
+
+ def __init__(
+ self,
+ degrees: Union[torch.Tensor, float, Tuple[float, float], List[float]],
+ resample: Union[str, int, Resample] = Resample.BILINEAR.name,
+ return_transform: bool = False,
+ same_on_batch: bool = False,
+ align_corners: bool = True,
+ p: float = 0.5,
+ keepdim: bool = False,
+ ) -> None:
+ super().__init__(p=p, return_transform=return_transform, same_on_batch=same_on_batch, keepdim=keepdim)
+ self._device, self._dtype = _extract_device_dtype([degrees])
+ self.degrees = degrees
+ self.resample: Resample = Resample.get(resample)
+ self.align_corners = align_corners
+ self.flags: Dict[str, torch.Tensor] = dict(
+ interpolation=torch.tensor(self.resample.value), align_corners=torch.tensor(align_corners)
+ )
+
+ def __repr__(self) -> str:
+ repr = f"degrees={self.degrees}, interpolation={self.resample.name}"
+ return self.__class__.__name__ + f"({repr}, {super().__repr__()})"
+
+ def generate_parameters(self, batch_shape: torch.Size) -> Dict[str, torch.Tensor]:
+ degrees = _range_bound(self.degrees, 'degrees', 0, (-360, 360), device=self._device, dtype=self._dtype)
+ return rg.random_rotation_generator(batch_shape[0], degrees, self.same_on_batch, self.device, self.dtype)
+
+ def compute_transformation(self, input: torch.Tensor, params: Dict[str, torch.Tensor]) -> torch.Tensor:
+ # TODO: Update to use `get_rotation_matrix2d`
+ angles: torch.Tensor = params["degrees"].to(input)
+
+ center: torch.Tensor = _compute_tensor_center(input)
+ rotation_mat: torch.Tensor = _compute_rotation_matrix(angles, center.expand(angles.shape[0], -1))
+
+ # rotation_mat is B x 2 x 3 and we need a B x 3 x 3 matrix
+ trans_mat: torch.Tensor = torch.eye(3, device=input.device, dtype=input.dtype).repeat(input.shape[0], 1, 1)
+ trans_mat[:, 0] = rotation_mat[:, 0]
+ trans_mat[:, 1] = rotation_mat[:, 1]
+
+ return trans_mat
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ transform = cast(torch.Tensor, transform)
+ return affine(input, transform[..., :2, :3], self.resample.name.lower(), 'zeros', self.align_corners)
+
+ def inverse_transform(
+ self,
+ input: torch.Tensor,
+ transform: Optional[torch.Tensor] = None,
+ size: Optional[Tuple[int, int]] = None,
+ **kwargs,
+ ) -> torch.Tensor:
+ return self.apply_transform(
+ input, params=self._params, transform=torch.as_tensor(transform, device=input.device, dtype=input.dtype)
+ )
+
+
+class RandomCrop(GeometricAugmentationBase2D):
+ r"""Crop random patches of a tensor image on a given size.
+
+ .. image:: _static/img/RandomCrop.png
+
+ Args:
+ p: probability of applying the transformation for the whole batch.
+ size: Desired output size (out_h, out_w) of the crop.
+ Must be Tuple[int, int], then out_h = size[0], out_w = size[1].
+ padding: Optional padding on each border
+ of the image. Default is None, i.e no padding. If a sequence of length
+ 4 is provided, it is used to pad left, top, right, bottom borders
+ respectively. If a sequence of length 2 is provided, it is used to
+ pad left/right, top/bottom borders, respectively.
+ pad_if_needed: It will pad the image if smaller than the
+ desired size to avoid raising an exception. Since cropping is done
+ after padding, the padding seems to be done at a random offset.
+ fill: Pixel fill value for constant fill. Default is 0. If a tuple of
+ length 3, it is used to fill R, G, B channels respectively.
+ This value is only used when the padding_mode is constant.
+ padding_mode: Type of padding. Should be: constant, edge, reflect or symmetric.
+ resample: the interpolation mode.
+ return_transform: if ``True`` return the matrix describing the transformation applied to each
+ input tensor. If ``False`` and the input is a tuple the applied transformation
+ won't be concatenated.
+ same_on_batch: apply the same transformation across the batch.
+ align_corners: interpolation flag.
+ keepdim: whether to keep the output shape the same as input (True) or broadcast it
+ to the batch form (False).
+ cropping_mode: The used algorithm to crop. ``slice`` will use advanced slicing to extract the tensor based
+ on the sampled indices. ``resample`` will use `warp_affine` using the affine transformation
+ to extract and resize at once. Use `slice` for efficiency, or `resample` for proper
+ differentiability.
+
+ Shape:
+ - Input: :math:`(C, H, W)` or :math:`(B, C, H, W)`, Optional: :math:`(B, 3, 3)`
+ - Output: :math:`(B, C, out_h, out_w)`
+
+ Note:
+ Input tensor must be float and normalized into [0, 1] for the best differentiability support.
+ Additionally, this function accepts another transformation tensor (:math:`(B, 3, 3)`), then the
+ applied transformation will be merged int to the input transformation tensor and returned.
+
+ Examples:
+ >>> _ = torch.manual_seed(0)
+ >>> inputs = torch.arange(1*1*3*3.).view(1, 1, 3, 3)
+ >>> aug = RandomCrop((2, 2), p=1., cropping_mode="resample")
+ >>> out = aug(inputs)
+ >>> out
+ tensor([[[[3., 4.],
+ [6., 7.]]]])
+ >>> aug.inverse(out, padding_mode="border")
+ tensor([[[[3., 4., 4.],
+ [3., 4., 4.],
+ [6., 7., 7.]]]])
+ """
+
+ def __init__(
+ self,
+ size: Tuple[int, int],
+ padding: Optional[Union[int, Tuple[int, int], Tuple[int, int, int, int]]] = None,
+ pad_if_needed: Optional[bool] = False,
+ fill: int = 0,
+ padding_mode: str = 'constant',
+ resample: Union[str, int, Resample] = Resample.BILINEAR.name,
+ return_transform: bool = False,
+ same_on_batch: bool = False,
+ align_corners: bool = True,
+ p: float = 1.0,
+ keepdim: bool = False,
+ cropping_mode: str = 'slice',
+ ) -> None:
+ # Since PyTorch does not support ragged tensor. So cropping function happens batch-wisely.
+ super().__init__(
+ p=1.0, return_transform=return_transform, same_on_batch=same_on_batch, p_batch=p, keepdim=keepdim
+ )
+ self.size = size
+ self.padding = padding
+ self.pad_if_needed = pad_if_needed
+ self.fill = fill
+ self.padding_mode = padding_mode
+ self.resample: Resample = Resample.get(resample)
+ self.align_corners = align_corners
+ self.flags: Dict[str, torch.Tensor] = dict(
+ interpolation=torch.tensor(self.resample.value), align_corners=torch.tensor(align_corners)
+ )
+ self.cropping_mode = cropping_mode
+
+ def __repr__(self) -> str:
+ repr = (
+ f"crop_size={self.size}, padding={self.padding}, fill={self.fill}, pad_if_needed={self.pad_if_needed}, "
+ f"padding_mode={self.padding_mode}, resample={self.resample.name}"
+ )
+ return self.__class__.__name__ + f"({repr}, {super().__repr__()})"
+
+ def generate_parameters(self, batch_shape: torch.Size) -> Dict[str, torch.Tensor]:
+ return rg.random_crop_generator(
+ batch_shape[0],
+ (batch_shape[-2], batch_shape[-1]),
+ self.size,
+ same_on_batch=self.same_on_batch,
+ device=self.device,
+ dtype=self.dtype,
+ )
+
+ def compute_padding(self, shape: torch.Size) -> List[int]:
+ if len(shape) != 4:
+ raise AssertionError(f"Expected BCHW. Got {shape}.")
+ padding = [0, 0, 0, 0]
+ if self.padding is not None:
+ if isinstance(self.padding, int):
+ self.padding = cast(int, self.padding)
+ padding = [self.padding, self.padding, self.padding, self.padding]
+ elif isinstance(self.padding, tuple) and len(self.padding) == 2:
+ self.padding = cast(Tuple[int, int], self.padding)
+ padding = [self.padding[1], self.padding[1], self.padding[0], self.padding[0]]
+ elif isinstance(self.padding, tuple) and len(self.padding) == 4:
+ self.padding = cast(Tuple[int, int, int, int], self.padding)
+ padding = [self.padding[3], self.padding[2], self.padding[1], self.padding[0]]
+
+ if self.pad_if_needed and shape[-2] < self.size[0]:
+ padding = [0, 0, (self.size[0] - shape[-2]), self.size[0] - shape[-2]]
+
+ if self.pad_if_needed and shape[-1] < self.size[1]:
+ padding = [self.size[1] - shape[-1], self.size[1] - shape[-1], 0, 0]
+
+ return padding
+
+ def precrop_padding(self, input: torch.Tensor, padding: List[int] = None) -> torch.Tensor:
+ if padding is None:
+ padding = self.compute_padding(input.shape)
+
+ input = pad(input, padding, value=self.fill, mode=self.padding_mode)
+
+ return input
+
+ def compute_transformation(self, input: torch.Tensor, params: Dict[str, torch.Tensor]) -> torch.Tensor:
+ transform: torch.Tensor = get_perspective_transform(params['src'].to(input), params['dst'].to(input))
+ return transform
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ if self.cropping_mode == 'resample': # uses bilinear interpolation to crop
+ transform = cast(torch.Tensor, transform)
+ return crop_by_transform_mat(
+ input,
+ transform,
+ self.size,
+ mode=self.resample.name.lower(),
+ padding_mode='zeros',
+ align_corners=self.align_corners,
+ )
+ if self.cropping_mode == 'slice': # uses advanced slicing to crop
+ B, C, _, _ = input.shape
+ out = torch.empty(B, C, *self.size, device=input.device, dtype=input.dtype)
+ for i in range(B):
+ x1 = int(params['src'][i, 0, 0])
+ x2 = int(params['src'][i, 1, 0]) + 1
+ y1 = int(params['src'][i, 0, 1])
+ y2 = int(params['src'][i, 3, 1]) + 1
+ out[i] = input[i : i + 1, :, y1:y2, x1:x2]
+ return out
+ raise NotImplementedError(f"Not supported type: {self.flags['mode']}.")
+
+ def inverse_transform(
+ self,
+ input: torch.Tensor,
+ transform: Optional[torch.Tensor] = None,
+ size: Optional[Tuple[int, int]] = None,
+ **kwargs,
+ ) -> torch.Tensor:
+ if self.cropping_mode != 'resample':
+ raise NotImplementedError(
+ f"`inverse` is only applicable for resample cropping mode. Got {self.cropping_mode}."
+ )
+ size = cast(Tuple[int, int], size)
+ mode = self.resample.name.lower() if "mode" not in kwargs else kwargs['mode']
+ align_corners = self.align_corners if "align_corners" not in kwargs else kwargs['align_corners']
+ padding_mode = 'zeros' if "padding_mode" not in kwargs else kwargs['padding_mode']
+ transform = cast(torch.Tensor, transform)
+ return crop_by_transform_mat(input, transform[:, :2, :], size, mode, padding_mode, align_corners)
+
+ def inverse(
+ self,
+ input: TensorWithTransformMat,
+ params: Optional[Dict[str, torch.Tensor]] = None,
+ size: Optional[Tuple[int, int]] = None,
+ **kwargs,
+ ) -> torch.Tensor:
+ out = super().inverse(input, params, size, **kwargs)
+ if params is None:
+ params = self._params
+ if 'padding_size' in params:
+ padding_size = params['padding_size'].unique(dim=0).cpu().squeeze().numpy().tolist()
+ padding_size = [-padding_size[0], -padding_size[1], -padding_size[2], -padding_size[3]]
+ else:
+ padding_size = [0, 0, 0, 0]
+ return self.precrop_padding(out, padding_size)
+
+ def forward(
+ self,
+ input: TensorWithTransformMat,
+ params: Optional[Dict[str, torch.Tensor]] = None,
+ return_transform: Optional[bool] = None,
+ ) -> TensorWithTransformMat:
+ if isinstance(input, (tuple, list)):
+ input_temp = _transform_input(input[0])
+ input_pad = self.compute_padding(input[0].shape)
+ _input = (self.precrop_padding(input_temp, input_pad), input[1])
+ else:
+ input = cast(torch.Tensor, input) # TODO: weird that cast is not working under this context.
+ input_temp = _transform_input(input)
+ input_pad = self.compute_padding(input_temp.shape)
+ _input = self.precrop_padding(input_temp, input_pad) # type: ignore
+ out = super().forward(_input, params, return_transform)
+
+ # Update the actual input size for inverse
+ _padding_size = torch.tensor(tuple(input_pad), device=input_temp.device, dtype=torch.long).expand(
+ input_temp.size(0), -1
+ )
+ self._params.update({"padding_size": _padding_size})
+
+ if not self._params['batch_prob'].all():
+ # undo the pre-crop if nothing happened.
+ if isinstance(out, tuple) and isinstance(input, tuple):
+ return input[0], out[1]
+ if isinstance(out, tuple) and not isinstance(input, tuple):
+ return input, out[1]
+ return input
+ return out
+
+
+class RandomResizedCrop(GeometricAugmentationBase2D):
+ r"""Crop random patches in an image tensor and resizes to a given size.
+
+ .. image:: _static/img/RandomResizedCrop.png
+
+ Args:
+ size: Desired output size (out_h, out_w) of each edge.
+ Must be Tuple[int, int], then out_h = size[0], out_w = size[1].
+ scale: range of size of the origin size cropped.
+ ratio: range of aspect ratio of the origin aspect ratio cropped.
+ resample: the interpolation mode.
+ return_transform: if ``True`` return the matrix describing the transformation applied to each
+ input tensor. If ``False`` and the input is a tuple the applied transformation
+ won't be concatenated.
+ same_on_batch: apply the same transformation across the batch.
+ align_corners: interpolation flag.
+ keepdim: whether to keep the output shape the same as input (True) or broadcast it
+ to the batch form (False).
+ cropping_mode: The used algorithm to crop. ``slice`` will use advanced slicing to extract the tensor based
+ on the sampled indices. ``resample`` will use `warp_affine` using the affine transformation
+ to extract and resize at once. Use `slice` for efficiency, or `resample` for proper
+ differentiability.
+
+ Shape:
+ - Input: :math:`(C, H, W)` or :math:`(B, C, H, W)`, Optional: :math:`(B, 3, 3)`
+ - Output: :math:`(B, C, out_h, out_w)`
+
+ Note:
+ Input tensor must be float and normalized into [0, 1] for the best differentiability support.
+ Additionally, this function accepts another transformation tensor (:math:`(B, 3, 3)`), then the
+ applied transformation will be merged int to the input transformation tensor and returned.
+
+ Example:
+ >>> rng = torch.manual_seed(0)
+ >>> inputs = torch.tensor([[[0., 1., 2.],
+ ... [3., 4., 5.],
+ ... [6., 7., 8.]]])
+ >>> aug = RandomResizedCrop(size=(3, 3), scale=(3., 3.), ratio=(2., 2.), p=1., cropping_mode="resample")
+ >>> out = aug(inputs)
+ >>> out
+ tensor([[[[1.0000, 1.5000, 2.0000],
+ [4.0000, 4.5000, 5.0000],
+ [7.0000, 7.5000, 8.0000]]]])
+ >>> aug.inverse(out, padding_mode="border")
+ tensor([[[[1., 1., 2.],
+ [4., 4., 5.],
+ [7., 7., 8.]]]])
+ """
+
+ def __init__(
+ self,
+ size: Tuple[int, int],
+ scale: Union[torch.Tensor, Tuple[float, float]] = (0.08, 1.0),
+ ratio: Union[torch.Tensor, Tuple[float, float]] = (3.0 / 4.0, 4.0 / 3.0),
+ resample: Union[str, int, Resample] = Resample.BILINEAR.name,
+ return_transform: bool = False,
+ same_on_batch: bool = False,
+ align_corners: bool = True,
+ p: float = 1.0,
+ keepdim: bool = False,
+ cropping_mode: str = 'slice',
+ ) -> None:
+ # Since PyTorch does not support ragged tensor. So cropping function happens all the time.
+ super().__init__(
+ p=1.0, return_transform=return_transform, same_on_batch=same_on_batch, p_batch=p, keepdim=keepdim
+ )
+ self._device, self._dtype = _extract_device_dtype([scale, ratio])
+ self.size = size
+ self.scale = scale
+ self.ratio = ratio
+ self.resample: Resample = Resample.get(resample)
+ self.align_corners = align_corners
+ self.flags: Dict[str, torch.Tensor] = dict(
+ interpolation=torch.tensor(self.resample.value), align_corners=torch.tensor(align_corners)
+ )
+ self.cropping_mode = cropping_mode
+
+ def __repr__(self) -> str:
+ repr = f"size={self.size}, scale={self.scale}, ratio={self.ratio}, interpolation={self.resample.name}"
+ return self.__class__.__name__ + f"({repr}, {super().__repr__()})"
+
+ def generate_parameters(self, batch_shape: torch.Size) -> Dict[str, torch.Tensor]:
+ scale = torch.as_tensor(self.scale, device=self._device, dtype=self._dtype)
+ ratio = torch.as_tensor(self.ratio, device=self._device, dtype=self._dtype)
+ target_size: torch.Tensor = rg.random_crop_size_generator(
+ batch_shape[0],
+ (batch_shape[-2], batch_shape[-1]),
+ scale,
+ ratio,
+ self.same_on_batch,
+ self.device,
+ self.dtype,
+ )['size']
+ return rg.random_crop_generator(
+ batch_shape[0],
+ (batch_shape[-2], batch_shape[-1]),
+ target_size,
+ resize_to=self.size,
+ same_on_batch=self.same_on_batch,
+ device=self.device,
+ dtype=self.dtype,
+ )
+
+ def compute_transformation(self, input: torch.Tensor, params: Dict[str, torch.Tensor]) -> torch.Tensor:
+ transform: torch.Tensor = get_perspective_transform(params['src'].to(input), params['dst'].to(input))
+ transform = transform.expand(input.shape[0], -1, -1)
+ return transform
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ if self.cropping_mode == 'resample': # uses bilinear interpolation to crop
+ transform = cast(torch.Tensor, transform)
+ return crop_by_transform_mat(
+ input,
+ transform,
+ self.size,
+ mode=self.resample.name.lower(),
+ padding_mode='zeros',
+ align_corners=self.align_corners,
+ )
+ if self.cropping_mode == 'slice': # uses advanced slicing to crop
+ B, C, _, _ = input.shape
+ out = torch.empty(B, C, *self.size, device=input.device, dtype=input.dtype)
+ for i in range(B):
+ x1 = int(params['src'][i, 0, 0])
+ x2 = int(params['src'][i, 1, 0]) + 1
+ y1 = int(params['src'][i, 0, 1])
+ y2 = int(params['src'][i, 3, 1]) + 1
+ out[i] = resize(
+ input[i : i + 1, :, y1:y2, x1:x2],
+ self.size,
+ interpolation=(self.resample.name).lower(),
+ align_corners=self.align_corners,
+ )
+ return out
+ raise NotImplementedError(f"Not supported type: {self.cropping_mode}.")
+
+ def inverse_transform(
+ self,
+ input: torch.Tensor,
+ transform: Optional[torch.Tensor] = None,
+ size: Optional[Tuple[int, int]] = None,
+ **kwargs,
+ ) -> torch.Tensor:
+ if self.cropping_mode != 'resample':
+ raise NotImplementedError(
+ f"`inverse` is only applicable for resample cropping mode. Got {self.cropping_mode}."
+ )
+ size = cast(Tuple[int, int], size)
+ mode = self.resample.name.lower() if "mode" not in kwargs else kwargs['mode']
+ align_corners = self.align_corners if "align_corners" not in kwargs else kwargs['align_corners']
+ padding_mode = 'zeros' if "padding_mode" not in kwargs else kwargs['padding_mode']
+ transform = cast(torch.Tensor, transform)
+ return crop_by_transform_mat(input, transform[:, :2, :], size, mode, padding_mode, align_corners)
+
+
+class Normalize(IntensityAugmentationBase2D):
+ r"""Normalize tensor images with mean and standard deviation.
+
+ .. math::
+ \text{input[channel] = (input[channel] - mean[channel]) / std[channel]}
+
+ Where `mean` is :math:`(M_1, ..., M_n)` and `std` :math:`(S_1, ..., S_n)` for `n` channels,
+
+ Args:
+ mean: Mean for each channel.
+ std: Standard deviations for each channel.
+
+ Return:
+ Normalised tensor with same size as input :math:`(*, C, H, W)`.
+
+ .. note::
+ This function internally uses :func:`kornia.enhance.normalize`.
+
+ Examples:
+
+ >>> norm = Normalize(mean=torch.zeros(4), std=torch.ones(4))
+ >>> x = torch.rand(1, 4, 3, 3)
+ >>> out = norm(x)
+ >>> out.shape
+ torch.Size([1, 4, 3, 3])
+ """
+
+ def __init__(
+ self,
+ mean: Union[torch.Tensor, Tuple[float], List[float], float],
+ std: Union[torch.Tensor, Tuple[float], List[float], float],
+ return_transform: bool = False,
+ p: float = 1.0,
+ keepdim: bool = False,
+ ) -> None:
+ super().__init__(p=p, return_transform=return_transform, same_on_batch=True, keepdim=keepdim)
+ if isinstance(mean, float):
+ mean = torch.tensor([mean])
+
+ if isinstance(std, float):
+ std = torch.tensor([std])
+
+ if isinstance(mean, (tuple, list)):
+ mean = torch.tensor(mean)
+
+ if isinstance(std, (tuple, list)):
+ std = torch.tensor(std)
+
+ self.mean = mean
+ self.std = std
+
+ def __repr__(self) -> str:
+ repr = f"mean={self.mean}, std={self.std}"
+ return self.__class__.__name__ + f"({repr}, {super().__repr__()})"
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ return normalize(input, self.mean, self.std)
+
+
+class Denormalize(IntensityAugmentationBase2D):
+ r"""Denormalize tensor images with mean and standard deviation.
+
+ .. math::
+ \text{input[channel] = (input[channel] * std[channel]) + mean[channel]}
+
+ Where `mean` is :math:`(M_1, ..., M_n)` and `std` :math:`(S_1, ..., S_n)` for `n` channels,
+
+ Args:
+ mean: Mean for each channel.
+ std: Standard deviations for each channel.
+
+ Return:
+ Denormalised tensor with same size as input :math:`(*, C, H, W)`.
+
+ .. note::
+ This function internally uses :func:`kornia.enhance.denormalize`.
+
+ Examples:
+
+ >>> norm = Denormalize(mean=torch.zeros(1, 4), std=torch.ones(1, 4))
+ >>> x = torch.rand(1, 4, 3, 3)
+ >>> out = norm(x)
+ >>> out.shape
+ torch.Size([1, 4, 3, 3])
+ """
+
+ def __init__(
+ self,
+ mean: torch.Tensor,
+ std: torch.Tensor,
+ return_transform: bool = False,
+ p: float = 1.0,
+ keepdim: bool = False,
+ ) -> None:
+ super().__init__(p=p, return_transform=return_transform, same_on_batch=True, keepdim=keepdim)
+ self.mean = mean
+ self.std = std
+
+ def __repr__(self) -> str:
+ repr = f"mean={self.mean}, std={self.std}"
+ return self.__class__.__name__ + f"({repr}, {super().__repr__()})"
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ return denormalize(input, self.mean, self.std)
+
+
+class RandomMotionBlur(IntensityAugmentationBase2D):
+ r"""Perform motion blur on 2D images (4D tensor).
+
+ .. image:: _static/img/RandomMotionBlur.png
+
+ Args:
+ p: probability of applying the transformation.
+ kernel_size: motion kernel size (odd and positive).
+ If int, the kernel will have a fixed size.
+ If Tuple[int, int], it will randomly generate the value from the range batch-wisely.
+ angle: angle of the motion blur in degrees (anti-clockwise rotation).
+ If float, it will generate the value from (-angle, angle).
+ direction: forward/backward direction of the motion blur.
+ Lower values towards -1.0 will point the motion blur towards the back (with angle provided via angle),
+ while higher values towards 1.0 will point the motion blur forward. A value of 0.0 leads to a
+ uniformly (but still angled) motion blur.
+ If float, it will generate the value from (-direction, direction).
+ If Tuple[int, int], it will randomly generate the value from the range.
+ border_type: the padding mode to be applied before convolving.
+ CONSTANT = 0, REFLECT = 1, REPLICATE = 2, CIRCULAR = 3.
+ resample: the interpolation mode.
+ keepdim: whether to keep the output shape the same as input (True) or broadcast it
+ to the batch form (False).
+
+ Shape:
+ - Input: :math:`(C, H, W)` or :math:`(B, C, H, W)`, Optional: :math:`(B, 3, 3)`
+ - Output: :math:`(B, C, H, W)`
+
+ Note:
+ Input tensor must be float and normalized into [0, 1] for the best differentiability support.
+ Additionally, this function accepts another transformation tensor (:math:`(B, 3, 3)`), then the
+ applied transformation will be merged int to the input transformation tensor and returned.
+
+ Please set ``resample`` to ``'bilinear'`` if more meaningful gradients wanted.
+
+ .. note::
+ This function internally uses :func:`kornia.filters.motion_blur`.
+
+ Examples:
+ >>> rng = torch.manual_seed(0)
+ >>> input = torch.ones(1, 1, 5, 5)
+ >>> motion_blur = RandomMotionBlur(3, 35., 0.5, p=1.)
+ >>> motion_blur(input)
+ tensor([[[[0.5773, 1.0000, 1.0000, 1.0000, 0.7561],
+ [0.5773, 1.0000, 1.0000, 1.0000, 0.7561],
+ [0.5773, 1.0000, 1.0000, 1.0000, 0.7561],
+ [0.5773, 1.0000, 1.0000, 1.0000, 0.7561],
+ [0.5773, 1.0000, 1.0000, 1.0000, 0.7561]]]])
+ """
+
+ def __init__(
+ self,
+ kernel_size: Union[int, Tuple[int, int]],
+ angle: Union[torch.Tensor, float, Tuple[float, float]],
+ direction: Union[torch.Tensor, float, Tuple[float, float]],
+ border_type: Union[int, str, BorderType] = BorderType.CONSTANT.name,
+ resample: Union[str, int, Resample] = Resample.NEAREST.name,
+ return_transform: bool = False,
+ same_on_batch: bool = False,
+ p: float = 0.5,
+ keepdim: bool = False,
+ ) -> None:
+ super().__init__(p=p, return_transform=return_transform, same_on_batch=same_on_batch, keepdim=keepdim)
+ self.kernel_size: Union[int, Tuple[int, int]] = kernel_size
+ self._device, self._dtype = _extract_device_dtype([angle, direction])
+
+ self.angle = angle
+ self.direction = direction
+ self.border_type = BorderType.get(border_type)
+ self.resample = Resample.get(resample)
+ self.flags: Dict[str, torch.Tensor] = {
+ "border_type": torch.tensor(self.border_type.value),
+ "interpolation": torch.tensor(self.resample.value),
+ }
+
+ def __repr__(self) -> str:
+ repr = (
+ f"kernel_size={self.kernel_size}, angle={self.angle}, direction={self.direction}, "
+ + f"border_type='{self.border_type.name.lower()}'"
+ )
+ return self.__class__.__name__ + f"({repr}, {super().__repr__()})"
+
+ def generate_parameters(self, batch_shape: torch.Size) -> Dict[str, torch.Tensor]:
+ angle = _range_bound(
+ self.angle, 'angle', center=0.0, bounds=(-360, 360), device=self._device, dtype=self._dtype
+ )
+ direction = _range_bound(
+ self.direction, 'direction', center=0.0, bounds=(-1, 1), device=self._device, dtype=self._dtype
+ )
+ return rg.random_motion_blur_generator(
+ batch_shape[0], self.kernel_size, angle, direction, self.same_on_batch, self.device, self.dtype
+ )
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ kernel_size: int = cast(int, params['ksize_factor'].unique().item())
+ angle = params['angle_factor']
+ direction = params['direction_factor']
+ return motion_blur(
+ input,
+ kernel_size,
+ angle,
+ direction,
+ border_type=self.border_type.name.lower(),
+ mode=self.resample.name.lower(),
+ )
+
+
+class RandomSolarize(IntensityAugmentationBase2D):
+ r"""Solarize given tensor image or a batch of tensor images randomly.
+
+ .. image:: _static/img/RandomSolarize.png
+
+ Args:
+ p: probability of applying the transformation.
+ thresholds:
+ If float x, threshold will be generated from (0.5 - x, 0.5 + x).
+ If tuple (x, y), threshold will be generated from (x, y).
+ additions:
+ If float x, addition will be generated from (-x, x).
+ If tuple (x, y), addition will be generated from (x, y).
+ same_on_batch: apply the same transformation across the batch.
+ return_transform: if ``True`` return the matrix describing the transformation applied to each
+ input tensor. If ``False`` and the input is a tuple the applied transformation won't be concatenated.
+ keepdim: whether to keep the output shape the same as input (True) or broadcast it
+ to the batch form (False).
+
+ Shape:
+ - Input: :math:`(C, H, W)` or :math:`(B, C, H, W)`, Optional: :math:`(B, 3, 3)`
+ - Output: :math:`(B, C, H, W)`
+
+ .. note::
+ This function internally uses :func:`kornia.enhance.solarize`.
+
+ Examples:
+ >>> rng = torch.manual_seed(0)
+ >>> input = torch.rand(1, 1, 5, 5)
+ >>> solarize = RandomSolarize(0.1, 0.1, p=1.)
+ >>> solarize(input)
+ tensor([[[[0.4132, 0.1412, 0.1790, 0.2226, 0.3980],
+ [0.2754, 0.4194, 0.0130, 0.4538, 0.2771],
+ [0.4394, 0.4923, 0.1129, 0.2594, 0.3844],
+ [0.3909, 0.2118, 0.1094, 0.2516, 0.3728],
+ [0.2278, 0.0000, 0.4876, 0.0353, 0.5100]]]])
+ """
+
+ def __init__(
+ self,
+ thresholds: Union[torch.Tensor, float, Tuple[float, float], List[float]] = 0.1,
+ additions: Union[torch.Tensor, float, Tuple[float, float], List[float]] = 0.1,
+ same_on_batch: bool = False,
+ return_transform: bool = False,
+ p: float = 0.5,
+ keepdim: bool = False,
+ ) -> None:
+ super().__init__(p=p, return_transform=return_transform, same_on_batch=same_on_batch)
+ self._device, self._dtype = _extract_device_dtype([thresholds, additions])
+ self.thresholds = thresholds
+ self.additions = additions
+
+ def __repr__(self) -> str:
+ repr = f"thresholds={self.thresholds}, additions={self.additions}"
+ return self.__class__.__name__ + f"({repr}, {super().__repr__()})"
+
+ def generate_parameters(self, batch_shape: torch.Size) -> Dict[str, torch.Tensor]:
+ thresholds = _range_bound(
+ self.thresholds, 'thresholds', center=0.5, bounds=(0.0, 1.0), device=self._device, dtype=self._dtype
+ )
+ additions = _range_bound(
+ self.additions, 'additions', bounds=(-0.5, 0.5), device=self._device, dtype=self._dtype
+ )
+ return rg.random_solarize_generator(
+ batch_shape[0], thresholds, additions, self.same_on_batch, self.device, self.dtype
+ )
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ thresholds = params['thresholds_factor']
+ additions: Optional[torch.Tensor]
+ if 'additions_factor' in params:
+ additions = params['additions_factor']
+ else:
+ additions = None
+ return solarize(input, thresholds, additions)
+
+
+class RandomPosterize(IntensityAugmentationBase2D):
+ r"""Posterize given tensor image or a batch of tensor images randomly.
+
+ .. image:: _static/img/RandomPosterize.png
+
+ Args:
+ p: probability of applying the transformation.
+ bits: Integer that ranged from (0, 8], in which 0 gives black image and 8 gives the original.
+ If int x, bits will be generated from (x, 8).
+ If tuple (x, y), bits will be generated from (x, y).
+ same_on_batch: apply the same transformation across the batch.
+ return_transform: if ``True`` return the matrix describing the transformation applied to each
+ input tensor. If ``False`` and the input is a tuple the applied transformation won't be concatenated.
+ keepdim: whether to keep the output shape the same as input (True) or broadcast it
+ to the batch form (False).
+
+ Shape:
+ - Input: :math:`(C, H, W)` or :math:`(B, C, H, W)`, Optional: :math:`(B, 3, 3)`
+ - Output: :math:`(B, C, H, W)`
+
+ .. note::
+ This function internally uses :func:`kornia.enhance.posterize`.
+
+ Examples:
+ >>> rng = torch.manual_seed(0)
+ >>> input = torch.rand(1, 1, 5, 5)
+ >>> posterize = RandomPosterize(3, p=1.)
+ >>> posterize(input)
+ tensor([[[[0.4706, 0.7529, 0.0627, 0.1255, 0.2824],
+ [0.6275, 0.4706, 0.8784, 0.4392, 0.6275],
+ [0.3451, 0.3765, 0.0000, 0.1569, 0.2824],
+ [0.5020, 0.6902, 0.7843, 0.1569, 0.2510],
+ [0.6588, 0.9098, 0.3765, 0.8471, 0.4078]]]])
+ """
+
+ def __init__(
+ self,
+ bits: Union[int, Tuple[int, int], torch.Tensor] = 3,
+ same_on_batch: bool = False,
+ return_transform: bool = False,
+ p: float = 0.5,
+ keepdim: bool = False,
+ ) -> None:
+ super().__init__(p=p, return_transform=return_transform, same_on_batch=same_on_batch, keepdim=keepdim)
+ self._device, self._dtype = _extract_device_dtype([bits])
+ self.bits = bits
+
+ def __repr__(self) -> str:
+ repr = f"(bits={self.bits}"
+ return self.__class__.__name__ + f"({repr}, {super().__repr__()})"
+
+ def generate_parameters(self, batch_shape: torch.Size) -> Dict[str, torch.Tensor]:
+ bits = torch.as_tensor(self.bits, device=self._device, dtype=self._dtype)
+ if len(bits.size()) == 0:
+ bits = bits.repeat(2)
+ bits[1] = 8
+ elif not (len(bits.size()) == 1 and bits.size(0) == 2):
+ raise ValueError(f"'bits' shall be either a scalar or a length 2 tensor. Got {bits}.")
+ return rg.random_posterize_generator(batch_shape[0], bits, self.same_on_batch, self.device, self.dtype)
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ return posterize(input, params['bits_factor'])
+
+
+class RandomSharpness(IntensityAugmentationBase2D):
+ r"""Sharpen given tensor image or a batch of tensor images randomly.
+
+ .. image:: _static/img/RandomSharpness.png
+
+ Args:
+ p: probability of applying the transformation.
+ sharpness: factor of sharpness strength. Must be above 0.
+ same_on_batch: apply the same transformation across the batch.
+ return_transform: if ``True`` return the matrix describing the transformation applied to each
+ input tensor. If ``False`` and the input is a tuple the applied transformation won't be concatenated.
+ keepdim: whether to keep the output shape the same as input (True) or broadcast it
+ to the batch form (False).
+
+ Shape:
+ - Input: :math:`(C, H, W)` or :math:`(B, C, H, W)`, Optional: :math:`(B, 3, 3)`
+ - Output: :math:`(B, C, H, W)`
+
+ .. note::
+ This function internally uses :func:`kornia.enhance.sharpness`.
+
+ Examples:
+ >>> rng = torch.manual_seed(0)
+ >>> input = torch.rand(1, 1, 5, 5)
+ >>> sharpness = RandomSharpness(1., p=1.)
+ >>> sharpness(input)
+ tensor([[[[0.4963, 0.7682, 0.0885, 0.1320, 0.3074],
+ [0.6341, 0.4810, 0.7367, 0.4177, 0.6323],
+ [0.3489, 0.4428, 0.1562, 0.2443, 0.2939],
+ [0.5185, 0.6462, 0.7050, 0.2288, 0.2823],
+ [0.6816, 0.9152, 0.3971, 0.8742, 0.4194]]]])
+ """
+
+ def __init__(
+ self,
+ sharpness: Union[torch.Tensor, float, Tuple[float, float], torch.Tensor] = 0.5,
+ same_on_batch: bool = False,
+ return_transform: bool = False,
+ p: float = 0.5,
+ keepdim: bool = False,
+ ) -> None:
+ super().__init__(p=p, return_transform=return_transform, same_on_batch=same_on_batch, keepdim=keepdim)
+ self._device, self._dtype = _extract_device_dtype([sharpness])
+ self.sharpness = sharpness
+
+ def __repr__(self) -> str:
+ repr = f"sharpness={self.sharpness}"
+ return self.__class__.__name__ + f"({repr}, {super().__repr__()})"
+
+ def generate_parameters(self, batch_shape: torch.Size) -> Dict[str, torch.Tensor]:
+ sharpness = torch.as_tensor(self.sharpness, device=self._device, dtype=self._dtype)
+ if sharpness.dim() == 0:
+ sharpness = sharpness.repeat(2)
+ sharpness[0] = 0.0
+ elif not (sharpness.dim() == 1 and sharpness.size(0) == 2):
+ raise ValueError(f"'sharpness' must be a scalar or a length 2 tensor. Got {sharpness}.")
+ return rg.random_sharpness_generator(batch_shape[0], sharpness, self.same_on_batch, self.device, self.dtype)
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ factor = params['sharpness_factor']
+ return sharpness(input, factor)
+
+
+class RandomEqualize(IntensityAugmentationBase2D):
+ r"""Equalize given tensor image or a batch of tensor images randomly.
+
+ .. image:: _static/img/RandomEqualize.png
+
+ Args:
+ p: Probability to equalize an image.
+ same_on_batch: apply the same transformation across the batch.
+ return_transform: if ``True`` return the matrix describing the transformation applied to each
+ input tensor. If ``False`` and the input is a tuple the applied transformation
+ won't be concatenated.
+ keepdim: whether to keep the output shape the same as input (True) or broadcast it
+ to the batch form (False).
+
+ Shape:
+ - Input: :math:`(C, H, W)` or :math:`(B, C, H, W)`, Optional: :math:`(B, 3, 3)`
+ - Output: :math:`(B, C, H, W)`
+
+ .. note::
+ This function internally uses :func:`kornia.enhance.equalize`.
+
+ Examples:
+ >>> rng = torch.manual_seed(0)
+ >>> input = torch.rand(1, 1, 5, 5)
+ >>> equalize = RandomEqualize(p=1.)
+ >>> equalize(input)
+ tensor([[[[0.4963, 0.7682, 0.0885, 0.1320, 0.3074],
+ [0.6341, 0.4901, 0.8964, 0.4556, 0.6323],
+ [0.3489, 0.4017, 0.0223, 0.1689, 0.2939],
+ [0.5185, 0.6977, 0.8000, 0.1610, 0.2823],
+ [0.6816, 0.9152, 0.3971, 0.8742, 0.4194]]]])
+ """
+
+ def __init__(
+ self, same_on_batch: bool = False, return_transform: bool = False, p: float = 0.5, keepdim: bool = False
+ ) -> None:
+ super().__init__(p=p, return_transform=return_transform, same_on_batch=same_on_batch, keepdim=keepdim)
+
+ def __repr__(self) -> str:
+ return self.__class__.__name__ + f"({super().__repr__()})"
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ return equalize(input)
+
+
+class RandomGaussianBlur(IntensityAugmentationBase2D):
+ r"""Apply gaussian blur given tensor image or a batch of tensor images randomly.
+
+ .. image:: _static/img/RandomGaussianBlur.png
+
+ Args:
+ kernel_size: the size of the kernel.
+ sigma: the standard deviation of the kernel.
+ border_type: the padding mode to be applied before convolving.
+ The expected modes are: ``constant``, ``reflect``, ``replicate`` or ``circular``.
+ return_transform: if ``True`` return the matrix describing the transformation applied to each
+ input tensor. If ``False`` and the input is a tuple the applied transformation won't be concatenated.
+ same_on_batch: apply the same transformation across the batch.
+ p: probability of applying the transformation.
+
+ Shape:
+ - Input: :math:`(C, H, W)` or :math:`(B, C, H, W)`, Optional: :math:`(B, 3, 3)`
+ - Output: :math:`(B, C, H, W)`
+
+ .. note::
+ This function internally uses :func:`kornia.filters.gaussian_blur2d`.
+
+ Examples:
+ >>> rng = torch.manual_seed(0)
+ >>> input = torch.rand(1, 1, 5, 5)
+ >>> blur = RandomGaussianBlur((3, 3), (0.1, 2.0), p=1.)
+ >>> blur(input)
+ tensor([[[[0.6699, 0.4645, 0.3193, 0.1741, 0.1955],
+ [0.5422, 0.6657, 0.6261, 0.6527, 0.5195],
+ [0.3826, 0.2638, 0.1902, 0.1620, 0.2141],
+ [0.6329, 0.6732, 0.5634, 0.4037, 0.2049],
+ [0.8307, 0.6753, 0.7147, 0.5768, 0.7097]]]])
+ """
+
+ def __init__(
+ self,
+ kernel_size: Tuple[int, int],
+ sigma: Tuple[float, float],
+ border_type: str = 'reflect',
+ return_transform: bool = False,
+ same_on_batch: bool = False,
+ p: float = 0.5,
+ ) -> None:
+ super().__init__(p=p, return_transform=return_transform, same_on_batch=same_on_batch, p_batch=1.0)
+ self.kernel_size = kernel_size
+ self.sigma = sigma
+ self.border_type: BorderType = BorderType.get(border_type)
+
+ def __repr__(self) -> str:
+ return self.__class__.__name__ + f"({super().__repr__()})"
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ return gaussian_blur2d(input, self.kernel_size, self.sigma, self.border_type.name.lower())
+
+
+class GaussianBlur(RandomGaussianBlur):
+ def __init__(
+ self,
+ kernel_size: Tuple[int, int],
+ sigma: Tuple[float, float],
+ border_type: str = 'reflect',
+ return_transform: bool = False,
+ same_on_batch: bool = False,
+ p: float = 0.5,
+ ) -> None:
+ super().__init__(
+ kernel_size=kernel_size,
+ sigma=sigma,
+ border_type=border_type,
+ return_transform=return_transform,
+ same_on_batch=same_on_batch,
+ p=p,
+ )
+ warnings.warn(
+ "GaussianBlur is no longer maintained and will be removed from the future versions. "
+ "Please use RandomGaussianBlur instead.",
+ category=DeprecationWarning,
+ )
+
+
+class RandomInvert(IntensityAugmentationBase2D):
+ r"""Invert the tensor images values randomly.
+
+ .. image:: _static/img/RandomInvert.png
+
+ Args:
+ max_val: The expected maximum value in the input tensor. The shape has to
+ according to the input tensor shape, or at least has to work with broadcasting.
+ return_transform: if ``True`` return the matrix describing the transformation applied to each
+ input tensor. If ``False`` and the input is a tuple the applied transformation won't be concatenated.
+ same_on_batch: apply the same transformation across the batch.
+ p: probability of applying the transformation.
+
+ .. note::
+ This function internally uses :func:`kornia.enhance.invert`.
+
+ Examples:
+ >>> rng = torch.manual_seed(0)
+ >>> img = torch.rand(1, 1, 5, 5)
+ >>> inv = RandomInvert()
+ >>> inv(img)
+ tensor([[[[0.4963, 0.7682, 0.0885, 0.1320, 0.3074],
+ [0.6341, 0.4901, 0.8964, 0.4556, 0.6323],
+ [0.3489, 0.4017, 0.0223, 0.1689, 0.2939],
+ [0.5185, 0.6977, 0.8000, 0.1610, 0.2823],
+ [0.6816, 0.9152, 0.3971, 0.8742, 0.4194]]]])
+ """
+
+ def __init__(
+ self,
+ max_val: Union[float, torch.Tensor] = torch.tensor(1.0),
+ return_transform: bool = False,
+ same_on_batch: bool = False,
+ p: float = 0.5,
+ ) -> None:
+ super().__init__(p=p, return_transform=return_transform, same_on_batch=same_on_batch, p_batch=1.0)
+ self.max_val = max_val
+
+ def __repr__(self) -> str:
+ return self.__class__.__name__ + f"({super().__repr__()})"
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ return invert(input, torch.as_tensor(self.max_val, device=input.device, dtype=input.dtype))
+
+
+class RandomChannelShuffle(IntensityAugmentationBase2D):
+ r"""Shuffle the channels of a batch of multi-dimensional images.
+
+ .. image:: _static/img/RandomChannelShuffle.png
+
+ Args:
+ return_transform: if ``True`` return the matrix describing the transformation applied to each
+ input tensor. If ``False`` and the input is a tuple the applied transformation won't be concatenated.
+ same_on_batch: apply the same transformation across the batch.
+ p: probability of applying the transformation.
+
+ Examples:
+ >>> rng = torch.manual_seed(0)
+ >>> img = torch.arange(1*2*2*2.).view(1,2,2,2)
+ >>> RandomChannelShuffle()(img)
+ tensor([[[[4., 5.],
+ [6., 7.]],
+
+ [[0., 1.],
+ [2., 3.]]]])
+ """
+
+ def __init__(self, return_transform: bool = False, same_on_batch: bool = False, p: float = 0.5) -> None:
+ super().__init__(p=p, return_transform=return_transform, same_on_batch=same_on_batch, p_batch=1.0)
+
+ def __repr__(self) -> str:
+ return self.__class__.__name__ + f"({super().__repr__()})"
+
+ def generate_parameters(self, shape: torch.Size) -> Dict[str, torch.Tensor]:
+ B, C, _, _ = shape
+ channels = torch.rand(B, C).argsort(dim=1)
+ return dict(channels=channels)
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ out = torch.empty_like(input)
+ for i in range(out.shape[0]):
+ out[i] = input[i, params['channels'][i]]
+ return out
+
+
+class RandomGaussianNoise(IntensityAugmentationBase2D):
+ r"""Add gaussian noise to a batch of multi-dimensional images.
+
+ .. image:: _static/img/RandomGaussianNoise.png
+
+ Args:
+ mean: The mean of the gaussian distribution.
+ std: The standard deviation of the gaussian distribution.
+ return_transform: if ``True`` return the matrix describing the transformation applied to each
+ input tensor. If ``False`` and the input is a tuple the applied transformation won't be concatenated.
+ same_on_batch: apply the same transformation across the batch.
+ p: probability of applying the transformation.
+
+ Examples:
+ >>> rng = torch.manual_seed(0)
+ >>> img = torch.ones(1, 1, 2, 2)
+ >>> RandomGaussianNoise(mean=0., std=1., p=1.)(img)
+ tensor([[[[ 2.5410, 0.7066],
+ [-1.1788, 1.5684]]]])
+ """
+
+ def __init__(
+ self,
+ mean: float = 0.0,
+ std: float = 1.0,
+ return_transform: bool = False,
+ same_on_batch: bool = False,
+ p: float = 0.5,
+ ) -> None:
+ super().__init__(p=p, return_transform=return_transform, same_on_batch=same_on_batch, p_batch=1.0)
+ self.mean = mean
+ self.std = std
+
+ def __repr__(self) -> str:
+ return self.__class__.__name__ + f"({super().__repr__()})"
+
+ def generate_parameters(self, shape: torch.Size) -> Dict[str, torch.Tensor]:
+ noise = torch.randn(shape)
+ return dict(noise=noise)
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ return input + params['noise'].to(input.device) * self.std + self.mean
+
+
+class RandomFisheye(GeometricAugmentationBase2D):
+ r"""Add random camera radial distortion.
+
+ .. image:: _static/img/RandomFisheye.png
+
+ Args:
+ center_x: Ranges to sample respect to x-coordinate center with shape (2,).
+ center_y: Ranges to sample respect to y-coordinate center with shape (2,).
+ gamma: Ranges to sample for the gamma values respect to optical center with shape (2,).
+ return_transform: if ``True`` return the matrix describing the transformation applied to each
+ input tensor. If ``False`` and the input is a tuple the applied transformation won't be concatenated.
+ same_on_batch: apply the same transformation across the batch.
+ p: probability of applying the transformation.
+
+ Examples:
+ >>> img = torch.ones(1, 1, 2, 2)
+ >>> center_x = torch.tensor([-.3, .3])
+ >>> center_y = torch.tensor([-.3, .3])
+ >>> gamma = torch.tensor([.9, 1.])
+ >>> out = RandomFisheye(center_x, center_y, gamma)(img)
+ >>> out.shape
+ torch.Size([1, 1, 2, 2])
+ """
+
+ def __init__(
+ self,
+ center_x: torch.Tensor,
+ center_y: torch.Tensor,
+ gamma: torch.Tensor,
+ return_transform: bool = False,
+ same_on_batch: bool = False,
+ p: float = 0.5,
+ ) -> None:
+ super().__init__(p=p, return_transform=return_transform, same_on_batch=same_on_batch, p_batch=1.0)
+ self.center_x = self._check_tensor(center_x)
+ self.center_y = self._check_tensor(center_y)
+ self.gamma = self._check_tensor(gamma)
+ self.dist = torch.distributions.Uniform
+
+ def __repr__(self) -> str:
+ return self.__class__.__name__ + f"({super().__repr__()})"
+
+ def _check_tensor(self, data: torch.Tensor) -> torch.Tensor:
+ if not isinstance(data, torch.Tensor):
+ raise TypeError(f"Invalid input type. Expected torch.Tensor - got: {type(data)}")
+
+ if len(data.shape) != 1 and data.shape[0] != 2:
+ raise ValueError(f"Tensor must be of shape (2,). Got: {data.shape}.")
+
+ return data
+
+ def generate_parameters(self, shape: torch.Size) -> Dict[str, torch.Tensor]:
+ center_x = self.dist(self.center_x[:1], self.center_x[1:]).rsample(shape[:1])
+ center_y = self.dist(self.center_y[:1], self.center_y[1:]).rsample(shape[:1])
+ gamma = self.dist(self.gamma[:1], self.gamma[1:]).rsample(shape[:1])
+ return dict(center_x=center_x, center_y=center_y, gamma=gamma)
+
+ # TODO: It is incorrect to return identity
+ def compute_transformation(self, input: torch.Tensor, params: Dict[str, torch.Tensor]) -> torch.Tensor:
+ return self.identity_matrix(input)
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ # create the initial sampling fields
+ B, _, H, W = input.shape
+ grid = create_meshgrid(H, W, normalized_coordinates=True)
+ field_x = grid[..., 0].to(input) # 1xHxW
+ field_y = grid[..., 1].to(input) # 1xHxW
+ # vectorize the random parameters
+ center_x = params['center_x'].view(B, 1, 1).to(input)
+ center_y = params['center_y'].view(B, 1, 1).to(input)
+ gamma = params['gamma'].view(B, 1, 1).to(input)
+ # compute and apply the distances respect to the camera optical center
+ distance = ((center_x - field_x) ** 2 + (center_y - field_y) ** 2) ** 0.5
+ field_x = field_x + field_x * distance ** gamma # BxHxw
+ field_y = field_y + field_y * distance ** gamma # BxHxW
+ return remap(input, field_x, field_y, normalized_coordinates=True, align_corners=True)
+
+
+class RandomElasticTransform(GeometricAugmentationBase2D):
+ r"""Add random elastic transformation to a tensor image.
+
+ .. image:: _static/img/RandomElasticTransform.png
+
+ Args:
+ kernel_size: the size of the Gaussian kernel.
+ sigma: The standard deviation of the Gaussian in the y and x directions,
+ respectively. Larger sigma results in smaller pixel displacements.
+ alpha: The scaling factor that controls the intensity of the deformation
+ in the y and x directions, respectively.
+ align_corners: Interpolation flag used by `grid_sample`.
+ mode: Interpolation mode used by `grid_sample`. Either 'bilinear' or 'nearest'.
+ return_transform: if ``True`` return the matrix describing the transformation applied to each
+ input tensor. If ``False`` and the input is a tuple the applied transformation won't be concatenated.
+ same_on_batch: apply the same transformation across the batch.
+ p: probability of applying the transformation.
+
+ .. note::
+ This function internally uses :func:`kornia.geometry.transform.elastic_transform2d`.
+
+ Examples:
+ >>> img = torch.ones(1, 1, 2, 2)
+ >>> out = RandomElasticTransform()(img)
+ >>> out.shape
+ torch.Size([1, 1, 2, 2])
+ """
+
+ def __init__(
+ self,
+ kernel_size: Tuple[int, int] = (63, 63),
+ sigma: Tuple[float, float] = (32.0, 32.0),
+ alpha: Tuple[float, float] = (1.0, 1.0),
+ align_corners: bool = False,
+ mode: str = 'bilinear',
+ return_transform: bool = False,
+ same_on_batch: bool = False,
+ p: float = 0.5,
+ ) -> None:
+ super().__init__(p=p, return_transform=return_transform, same_on_batch=same_on_batch, p_batch=1.0)
+ self.kernel_size = kernel_size
+ self.sigma = sigma
+ self.alpha = alpha
+ self.align_corners = align_corners
+ self.mode = mode
+
+ def __repr__(self) -> str:
+ return self.__class__.__name__ + f"({super().__repr__()})"
+
+ def generate_parameters(self, shape: torch.Size) -> Dict[str, torch.Tensor]:
+ B, _, H, W = shape
+ if self.same_on_batch:
+ noise = torch.rand(1, 2, H, W, device=self.device, dtype=self.dtype).repeat(B, 1, 1, 1)
+ else:
+ noise = torch.rand(B, 2, H, W, device=self.device, dtype=self.dtype)
+ return dict(noise=noise * 2 - 1)
+
+ # TODO: It is incorrect to return identity
+ def compute_transformation(self, input: torch.Tensor, params: Dict[str, torch.Tensor]) -> torch.Tensor:
+ return self.identity_matrix(input)
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ return elastic_transform2d(
+ input, params['noise'].to(input), self.kernel_size, self.sigma, self.alpha, self.align_corners, self.mode
+ )
+
+
+class RandomThinPlateSpline(GeometricAugmentationBase2D):
+ r"""Add random noise to the Thin Plate Spline algorithm.
+
+ .. image:: _static/img/RandomThinPlateSpline.png
+
+ Args:
+ scale: the scale factor to apply to the destination points.
+ align_corners: Interpolation flag used by ``grid_sample``.
+ mode: Interpolation mode used by `grid_sample`. Either 'bilinear' or 'nearest'.
+ return_transform: if ``True`` return the matrix describing the transformation applied to each
+ input tensor. If ``False`` and the input is a tuple the applied transformation won't be concatenated.
+ same_on_batch: apply the same transformation across the batch.
+ p: probability of applying the transformation.
+
+ .. note::
+ This function internally uses :func:`kornia.geometry.transform.warp_image_tps`.
+
+ Examples:
+ >>> img = torch.ones(1, 1, 2, 2)
+ >>> out = RandomThinPlateSpline()(img)
+ >>> out.shape
+ torch.Size([1, 1, 2, 2])
+ """
+
+ def __init__(
+ self,
+ scale: float = 0.2,
+ align_corners: bool = False,
+ return_transform: bool = False,
+ same_on_batch: bool = False,
+ p: float = 0.5,
+ ) -> None:
+ super().__init__(p=p, return_transform=return_transform, same_on_batch=same_on_batch, p_batch=1.0)
+ self.align_corners = align_corners
+ self.dist = torch.distributions.Uniform(-scale, scale)
+
+ def generate_parameters(self, shape: torch.Size) -> Dict[str, torch.Tensor]:
+ B, _, _, _ = shape
+ src = torch.tensor([[[-1.0, -1.0], [-1.0, 1.0], [1.0, -1.0], [1.0, 1.0], [0.0, 0.0]]]).repeat(B, 1, 1) # Bx5x2
+ dst = src + self.dist.rsample(src.shape)
+ return dict(src=src, dst=dst)
+
+ # TODO: It is incorrect to return identity
+ def compute_transformation(self, input: torch.Tensor, params: Dict[str, torch.Tensor]) -> torch.Tensor:
+ return self.identity_matrix(input)
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ src = params['src'].to(input)
+ dst = params['dst'].to(input)
+ # NOTE: warp_image_tps need to use inverse parameters
+ kernel, affine = get_tps_transform(dst, src)
+ return warp_image_tps(input, src, kernel, affine, self.align_corners)
+
+
+class RandomBoxBlur(IntensityAugmentationBase2D):
+ """Add random blur with a box filter to an image tensor.
+
+ .. image:: _static/img/RandomBoxBlur.png
+
+ Args:
+ kernel_size: the blurring kernel size.
+ border_type: the padding mode to be applied before convolving.
+ The expected modes are: ``constant``, ``reflect``, ``replicate`` or ``circular``.
+ normalized: if True, L1 norm of the kernel is set to 1.
+ return_transform: if ``True`` return the matrix describing the transformation applied to each
+ input tensor. If ``False`` and the input is a tuple the applied transformation won't be concatenated.
+ same_on_batch (bool): apply the same transformation across the batch.
+ p: probability of applying the transformation.
+
+ .. note::
+ This function internally uses :func:`kornia.filters.box_blur`.
+
+ Examples:
+ >>> img = torch.ones(1, 1, 24, 24)
+ >>> out = RandomBoxBlur((7, 7))(img)
+ >>> out.shape
+ torch.Size([1, 1, 24, 24])
+ """
+
+ def __init__(
+ self,
+ kernel_size: Tuple[int, int] = (3, 3),
+ border_type: str = 'reflect',
+ normalized: bool = True,
+ return_transform: bool = False,
+ same_on_batch: bool = False,
+ p: float = 0.5,
+ ) -> None:
+ super().__init__(p=p, return_transform=return_transform, same_on_batch=same_on_batch, p_batch=1.0)
+ self.kernel_size = kernel_size
+ self.border_type = border_type
+ self.normalized = normalized
+
+ def compute_transformation(self, input: torch.Tensor, params: Dict[str, torch.Tensor]) -> torch.Tensor:
+ return self.identity_matrix(input)
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ return box_blur(input, self.kernel_size, self.border_type, self.normalized)
+
+
+class PadTo(GeometricAugmentationBase2D):
+ r"""Pad the given sample to a specific size.
+
+ Args:
+ size: a tuple of ints in the format (height, width) that give the spatial
+ dimensions to pad inputs to.
+ pad_mode: the type of padding to perform on the image (valid values
+ are those accepted by torch.nn.functional.pad)
+ pad_value: fill value for 'constant' padding applied to the image
+ p: probability of the image being flipped.
+ return_transform: if ``True`` return the matrix describing the transformation applied to each
+ input tensor. If ``False`` and the input is a tuple the applied transformation
+ won't be concatenated.
+ same_on_batch: apply the same transformation across the batch.
+ keepdim: whether to keep the output shape the same as input (True) or broadcast it
+ to the batch form (False).
+
+ Shape:
+ - Input: :math:`(C, H, W)` or :math:`(B, C, H, W)`, Optional: :math:`(B, 3, 3)`
+ - Output: :math:`(B, C, H, W)`
+
+ .. note::
+ This function internally uses :func:`torch.nn.functional.pad`.
+
+ Examples:
+ >>> img = torch.tensor([[[[0., 0., 0.],
+ ... [0., 0., 0.],
+ ... [0., 0., 0.]]]])
+ >>> pad = PadTo((4, 5), pad_value=1.)
+ >>> out = pad(img)
+ >>> out
+ tensor([[[[0., 0., 0., 1., 1.],
+ [0., 0., 0., 1., 1.],
+ [0., 0., 0., 1., 1.],
+ [1., 1., 1., 1., 1.]]]])
+ >>> pad.inverse(out)
+ tensor([[[[0., 0., 0.],
+ [0., 0., 0.],
+ [0., 0., 0.]]]])
+ """
+ def __init__(
+ self,
+ size: Tuple[int, int],
+ pad_mode: str = "constant",
+ pad_value: Union[int, float] = 0,
+ return_transform: bool = False,
+ ) -> None:
+ super().__init__(p=1., return_transform=return_transform, same_on_batch=True, p_batch=1.)
+ self.size = size
+ self.pad_mode = pad_mode
+ self.pad_value = pad_value
+
+ def __repr__(self) -> str:
+ return self.__class__.__name__ + f"({super().__repr__()})"
+
+ def generate_parameters(self, batch_shape: torch.Size) -> Dict[str, torch.Tensor]:
+ input_size = torch.tensor(batch_shape[-2:], dtype=torch.long).expand(batch_shape[0], -1)
+ return dict(input_size=input_size)
+
+ # TODO: It is incorrect to return identity
+ # TODO: Having a resampled version with ``warp_affine``
+ def compute_transformation(self, image: torch.Tensor, params: Dict[str, torch.Tensor]) -> torch.Tensor:
+ return self.identity_matrix(image)
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ _, _, height, width = input.shape
+ height_pad: int = self.size[0] - height
+ width_pad: int = self.size[1] - width
+ return torch.nn.functional.pad(
+ input, [0, width_pad, 0, height_pad], mode=self.pad_mode, value=self.pad_value)
+
+ def inverse_transform(
+ self,
+ input: torch.Tensor,
+ transform: Optional[torch.Tensor] = None,
+ size: Optional[Tuple[int, int]] = None,
+ **kwargs
+ ) -> torch.Tensor:
+ size = cast(Tuple[int, int], size)
+ return input[..., :size[0], :size[1]]
diff --git a/kornia/augmentation/augmentation3d.py b/kornia/augmentation/augmentation3d.py
new file mode 100644
index 0000000000000000000000000000000000000000..01738cd841a13703da386690be257ba731b480d0
--- /dev/null
+++ b/kornia/augmentation/augmentation3d.py
@@ -0,0 +1,1065 @@
+from typing import cast, Dict, Optional, Tuple, Union
+
+import torch
+from torch.nn.functional import pad
+
+from kornia.constants import BorderType, Resample
+from kornia.enhance import equalize3d
+from kornia.filters import motion_blur3d
+from kornia.geometry import (
+ affine3d,
+ crop_by_transform_mat3d,
+ deg2rad,
+ get_affine_matrix3d,
+ get_perspective_transform3d,
+ warp_affine3d,
+ warp_perspective3d,
+)
+from kornia.geometry.transform.affwarp import _compute_rotation_matrix3d, _compute_tensor_center3d
+from kornia.utils import _extract_device_dtype
+
+from . import random_generator as rg
+from .base import AugmentationBase3D, TensorWithTransformMat
+from .utils import _range_bound, _singular_range_check, _tuple_range_reader
+
+
+class RandomHorizontalFlip3D(AugmentationBase3D):
+ r"""Apply random horizontal flip to 3D volumes (5D tensor).
+
+ Args:
+ p: probability of the image being flipped.
+ return_transform: if ``True`` return the matrix describing the transformation applied to each
+ input tensor. If ``False`` and the input is a tuple the applied transformation
+ won't be concatenated.
+ same_on_batch: apply the same transformation across the batch.
+ keepdim: whether to keep the output shape the same as input ``True`` or broadcast it
+ to the batch form ``False``.
+
+ Shape:
+ - Input: :math:`(C, D, H, W)` or :math:`(B, C, D, H, W)`, Optional: :math:`(B, 4, 4)`
+ - Output: :math:`(B, C, D, H, W)`
+
+ Note:
+ Input tensor must be float and normalized into [0, 1] for the best differentiability support.
+ Additionally, this function accepts another transformation tensor (:math:`(B, 4, 4)`), then the
+ applied transformation will be merged int to the input transformation tensor and returned.
+
+ Examples:
+ >>> x = torch.eye(3).repeat(3, 1, 1)
+ >>> seq = RandomHorizontalFlip3D(p=1.0, return_transform=True)
+ >>> seq(x)
+ (tensor([[[[[0., 0., 1.],
+ [0., 1., 0.],
+ [1., 0., 0.]],
+
+ [[0., 0., 1.],
+ [0., 1., 0.],
+ [1., 0., 0.]],
+
+ [[0., 0., 1.],
+ [0., 1., 0.],
+ [1., 0., 0.]]]]]), tensor([[[-1., 0., 0., 2.],
+ [ 0., 1., 0., 0.],
+ [ 0., 0., 1., 0.],
+ [ 0., 0., 0., 1.]]]))
+ """
+
+ def __init__(
+ self, return_transform: bool = False, same_on_batch: bool = False, p: float = 0.5, keepdim: bool = False
+ ) -> None:
+ super().__init__(p=p, return_transform=return_transform, same_on_batch=same_on_batch, keepdim=keepdim)
+
+ def __repr__(self) -> str:
+ return self.__class__.__name__ + f"({super().__repr__()})"
+
+ def generate_parameters(self, batch_shape: torch.Size) -> Dict[str, torch.Tensor]:
+ return dict(batch_shape=torch.as_tensor(batch_shape))
+
+ def compute_transformation(self, input: torch.Tensor, params: Dict[str, torch.Tensor]) -> torch.Tensor:
+ w: int = cast(int, params['batch_shape'][-1])
+ flip_mat: torch.Tensor = torch.tensor(
+ [[-1, 0, 0, w - 1], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]], device=input.device, dtype=input.dtype
+ )
+ return flip_mat.repeat(input.size(0), 1, 1)
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ return torch.flip(input, [-1])
+
+
+class RandomVerticalFlip3D(AugmentationBase3D):
+ r"""Apply random vertical flip to 3D volumes (5D tensor).
+
+ Input should be a tensor of shape :math:`(C, D, H, W)` or a batch of tensors :math:`(*, C, D, H, W)`.
+ If Input is a tuple it is assumed that the first element contains the aforementioned tensors and the second,
+ the corresponding transformation matrix that has been applied to them. In this case the module
+ will Vertically flip the tensors and concatenate the corresponding transformation matrix to the
+ previous one. This is especially useful when using this functionality as part of an ``nn.Sequential`` module.
+
+ Args:
+ p: probability of the image being flipped.
+ return_transform: if ``True`` return the matrix describing the transformation applied to each
+ input tensor. If ``False`` and the input is a tuple the applied transformation
+ won't be concatenated.
+ same_on_batch: apply the same transformation across the batch.
+ keepdim: whether to keep the output shape the same as input ``True`` or broadcast it
+ to the batch form ``False``.
+
+ Shape:
+ - Input: :math:`(C, D, H, W)` or :math:`(B, C, D, H, W)`, Optional: :math:`(B, 4, 4)`
+ - Output: :math:`(B, C, D, H, W)`
+
+ Note:
+ Input tensor must be float and normalized into [0, 1] for the best differentiability support.
+ Additionally, this function accepts another transformation tensor (:math:`(B, 4, 4)`), then the
+ applied transformation will be merged int to the input transformation tensor and returned.
+
+ Examples:
+ >>> x = torch.eye(3).repeat(3, 1, 1)
+ >>> seq = RandomVerticalFlip3D(p=1.0, return_transform=True)
+ >>> seq(x)
+ (tensor([[[[[0., 0., 1.],
+ [0., 1., 0.],
+ [1., 0., 0.]],
+
+ [[0., 0., 1.],
+ [0., 1., 0.],
+ [1., 0., 0.]],
+
+ [[0., 0., 1.],
+ [0., 1., 0.],
+ [1., 0., 0.]]]]]), tensor([[[ 1., 0., 0., 0.],
+ [ 0., -1., 0., 2.],
+ [ 0., 0., 1., 0.],
+ [ 0., 0., 0., 1.]]]))
+ """
+
+ def __init__(
+ self, return_transform: bool = False, same_on_batch: bool = False, p: float = 0.5, keepdim: bool = False
+ ) -> None:
+ super().__init__(p=p, return_transform=return_transform, same_on_batch=same_on_batch, keepdim=keepdim)
+
+ def __repr__(self) -> str:
+ return self.__class__.__name__ + f"({super().__repr__()})"
+
+ def generate_parameters(self, batch_shape: torch.Size) -> Dict[str, torch.Tensor]:
+ return dict(batch_shape=torch.as_tensor(batch_shape))
+
+ def compute_transformation(self, input: torch.Tensor, params: Dict[str, torch.Tensor]) -> torch.Tensor:
+ h: int = cast(int, params['batch_shape'][-2])
+ flip_mat: torch.Tensor = torch.tensor(
+ [[1, 0, 0, 0], [0, -1, 0, h - 1], [0, 0, 1, 0], [0, 0, 0, 1]], device=input.device, dtype=input.dtype
+ )
+ return flip_mat.repeat(input.size(0), 1, 1)
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ return torch.flip(input, [-2])
+
+
+class RandomDepthicalFlip3D(AugmentationBase3D):
+ r"""Apply random flip along the depth axis of 3D volumes (5D tensor).
+
+ Input should be a tensor of shape :math:`(C, D, H, W)` or a batch of tensors :math:`(*, C, D, H, W)`.
+ If Input is a tuple it is assumed that the first element contains the aforementioned tensors and the second,
+ the corresponding transformation matrix that has been applied to them. In this case the module
+ will Depthically flip the tensors and concatenate the corresponding transformation matrix to the
+ previous one. This is especially useful when using this functionality as part of an ``nn.Sequential`` module.
+
+ Args:
+ p: probability of the image being flipped.
+ return_transform: if ``True`` return the matrix describing the transformation applied to each
+ input tensor. If ``False`` and the input is a tuple the applied transformation
+ won't be concatenated.
+ same_on_batch: apply the same transformation across the batch.
+ keepdim: whether to keep the output shape the same as input ``True`` or broadcast it
+ to the batch form ``False``.
+
+ Shape:
+ - Input: :math:`(C, D, H, W)` or :math:`(B, C, D, H, W)`, Optional: :math:`(B, 4, 4)`
+ - Output: :math:`(B, C, D, H, W)`
+
+ Note:
+ Input tensor must be float and normalized into [0, 1] for the best differentiability support.
+ Additionally, this function accepts another transformation tensor (:math:`(B, 4, 4)`), then the
+ applied transformation will be merged int to the input transformation tensor and returned.
+
+ Examples:
+ >>> x = torch.eye(3).repeat(3, 1, 1)
+ >>> seq = RandomDepthicalFlip3D(p=1.0, return_transform=True)
+ >>> seq(x)
+ (tensor([[[[[1., 0., 0.],
+ [0., 1., 0.],
+ [0., 0., 1.]],
+
+ [[1., 0., 0.],
+ [0., 1., 0.],
+ [0., 0., 1.]],
+
+ [[1., 0., 0.],
+ [0., 1., 0.],
+ [0., 0., 1.]]]]]), tensor([[[ 1., 0., 0., 0.],
+ [ 0., 1., 0., 0.],
+ [ 0., 0., -1., 2.],
+ [ 0., 0., 0., 1.]]]))
+
+ """
+
+ def __init__(
+ self, return_transform: bool = False, same_on_batch: bool = False, p: float = 0.5, keepdim: bool = False
+ ) -> None:
+ super().__init__(p=p, return_transform=return_transform, same_on_batch=same_on_batch, keepdim=keepdim)
+
+ def __repr__(self) -> str:
+ return self.__class__.__name__ + f"({super().__repr__()})"
+
+ def compute_transformation(self, input: torch.Tensor, params: Dict[str, torch.Tensor]) -> torch.Tensor:
+ d: int = input.shape[-3]
+ flip_mat: torch.Tensor = torch.tensor(
+ [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, -1, d - 1], [0, 0, 0, 1]], device=input.device, dtype=input.dtype
+ )
+ return flip_mat.repeat(input.size(0), 1, 1)
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ return torch.flip(input, [-3])
+
+
+class RandomAffine3D(AugmentationBase3D):
+ r"""Apply affine transformation 3D volumes (5D tensor).
+
+ The transformation is computed so that the center is kept invariant.
+
+ Args:
+ degrees: Range of yaw (x-axis), pitch (y-axis), roll (z-axis) to select from.
+ If degrees is a number, then yaw, pitch, roll will be generated from the range of (-degrees, +degrees).
+ If degrees is a tuple of (min, max), then yaw, pitch, roll will be generated from the range of (min, max).
+ If degrees is a list of floats [a, b, c], then yaw, pitch, roll will be generated from (-a, a), (-b, b)
+ and (-c, c).
+ If degrees is a list of tuple ((a, b), (m, n), (x, y)), then yaw, pitch, roll will be generated from
+ (a, b), (m, n) and (x, y).
+ Set to 0 to deactivate rotations.
+ translate: tuple of maximum absolute fraction for horizontal, vertical and
+ depthical translations (dx,dy,dz). For example translate=(a, b, c), then
+ horizontal shift will be randomly sampled in the range -img_width * a < dx < img_width * a
+ vertical shift will be randomly sampled in the range -img_height * b < dy < img_height * b.
+ depthical shift will be randomly sampled in the range -img_depth * c < dz < img_depth * c.
+ Will not translate by default.
+ scale: scaling factor interval.
+ If (a, b) represents isotropic scaling, the scale is randomly sampled from the range a <= scale <= b.
+ If ((a, b), (c, d), (e, f)), the scale is randomly sampled from the range a <= scale_x <= b,
+ c <= scale_y <= d, e <= scale_z <= f. Will keep original scale by default.
+ shears: Range of degrees to select from.
+ If shear is a number, a shear to the 6 facets in the range (-shear, +shear) will be applied.
+ If shear is a tuple of 2 values, a shear to the 6 facets in the range (shear[0], shear[1]) will be applied.
+ If shear is a tuple of 6 values, a shear to the i-th facet in the range (-shear[i], shear[i])
+ will be applied.
+ If shear is a tuple of 6 tuples, a shear to the i-th facet in the range (-shear[i, 0], shear[i, 1])
+ will be applied.
+ resample:
+ return_transform: if ``True`` return the matrix describing the transformation
+ applied to each.
+ same_on_batch: apply the same transformation across the batch.
+ align_corners: interpolation flag.
+ keepdim: whether to keep the output shape the same as input (True) or broadcast it
+ to the batch form (False). Default: False.
+
+ Shape:
+ - Input: :math:`(C, D, H, W)` or :math:`(B, C, D, H, W)`, Optional: :math:`(B, 4, 4)`
+ - Output: :math:`(B, C, D, H, W)`
+
+ Note:
+ Input tensor must be float and normalized into [0, 1] for the best differentiability support.
+ Additionally, this function accepts another transformation tensor (:math:`(B, 4, 4)`), then the
+ applied transformation will be merged int to the input transformation tensor and returned.
+
+ Examples:
+ >>> rng = torch.manual_seed(0)
+ >>> input = torch.rand(1, 1, 3, 3, 3)
+ >>> aug = RandomAffine3D((15., 20., 20.), p=1., return_transform=True)
+ >>> aug(input)
+ (tensor([[[[[0.4503, 0.4763, 0.1680],
+ [0.2029, 0.4267, 0.3515],
+ [0.3195, 0.5436, 0.3706]],
+
+ [[0.5255, 0.3508, 0.4858],
+ [0.0795, 0.1689, 0.4220],
+ [0.5306, 0.7234, 0.6879]],
+
+ [[0.2971, 0.2746, 0.3471],
+ [0.4924, 0.4960, 0.6460],
+ [0.3187, 0.4556, 0.7596]]]]]), tensor([[[ 0.9722, -0.0603, 0.2262, -0.1381],
+ [ 0.1131, 0.9669, -0.2286, 0.1486],
+ [-0.2049, 0.2478, 0.9469, 0.0102],
+ [ 0.0000, 0.0000, 0.0000, 1.0000]]]))
+ """
+
+ def __init__(
+ self,
+ degrees: Union[
+ torch.Tensor,
+ float,
+ Tuple[float, float],
+ Tuple[float, float, float],
+ Tuple[Tuple[float, float], Tuple[float, float], Tuple[float, float]],
+ ],
+ translate: Optional[Union[torch.Tensor, Tuple[float, float, float]]] = None,
+ scale: Optional[
+ Union[
+ torch.Tensor, Tuple[float, float], Tuple[Tuple[float, float], Tuple[float, float], Tuple[float, float]]
+ ]
+ ] = None,
+ shears: Union[
+ torch.Tensor,
+ float,
+ Tuple[float, float],
+ Tuple[float, float, float, float, float, float],
+ Tuple[
+ Tuple[float, float],
+ Tuple[float, float],
+ Tuple[float, float],
+ Tuple[float, float],
+ Tuple[float, float],
+ Tuple[float, float],
+ ],
+ ] = None,
+ resample: Union[str, int, Resample] = Resample.BILINEAR.name,
+ return_transform: bool = False,
+ same_on_batch: bool = False,
+ align_corners: bool = False,
+ p: float = 0.5,
+ keepdim: bool = False,
+ ) -> None:
+ super().__init__(p=p, return_transform=return_transform, same_on_batch=same_on_batch, keepdim=keepdim)
+ self._device, self._dtype = _extract_device_dtype([degrees, shears, translate, scale])
+ self.degrees = degrees
+ self.shears = shears
+ self.translate = translate
+ self.scale = scale
+
+ self.resample = Resample.get(resample)
+ self.align_corners = align_corners
+ self.flags: Dict[str, torch.Tensor] = dict(
+ resample=torch.tensor(self.resample.value), align_corners=torch.tensor(align_corners)
+ )
+
+ def __repr__(self) -> str:
+ repr = (
+ f"(degrees={self.degrees}, translate={self.translate}, scale={self.scale}, shear={self.shears}, "
+ f"resample={self.resample.name}, align_corners={self.align_corners}"
+ )
+ return self.__class__.__name__ + f"({repr}, {super().__repr__()})"
+
+ def generate_parameters(self, batch_shape: torch.Size) -> Dict[str, torch.Tensor]:
+ degrees = _tuple_range_reader(self.degrees, 3, self._device, self._dtype)
+ shear: Optional[torch.Tensor] = None
+ if self.shears is not None:
+ shear = _tuple_range_reader(self.shears, 6, self._device, self._dtype)
+
+ # check translation range
+ translate: Optional[torch.Tensor] = None
+ if self.translate is not None:
+ translate = torch.as_tensor(self.translate, device=self._device, dtype=self._dtype)
+ _singular_range_check(translate, 'translate', bounds=(0, 1), mode='3d')
+
+ # check scale range
+ scale: Optional[torch.Tensor] = None
+ if self.scale is not None:
+ scale = torch.as_tensor(self.scale, device=self._device, dtype=self._dtype)
+ if scale.shape == torch.Size([2]):
+ scale = scale.unsqueeze(0).repeat(3, 1)
+ elif scale.shape != torch.Size([3, 2]):
+ raise ValueError(f"'scale' shall be either shape (2) or (3, 2). Got {self.scale}.")
+ _singular_range_check(scale[0], 'scale-x', bounds=(0, float('inf')), mode='2d')
+ _singular_range_check(scale[1], 'scale-y', bounds=(0, float('inf')), mode='2d')
+ _singular_range_check(scale[2], 'scale-z', bounds=(0, float('inf')), mode='2d')
+ return rg.random_affine_generator3d(
+ batch_shape[0],
+ batch_shape[-3],
+ batch_shape[-2],
+ batch_shape[-1],
+ degrees,
+ translate,
+ scale,
+ shear,
+ self.same_on_batch,
+ self.device,
+ self.dtype,
+ )
+
+ def compute_transformation(self, input: torch.Tensor, params: Dict[str, torch.Tensor]) -> torch.Tensor:
+ transform: torch.Tensor = get_affine_matrix3d(
+ params['translations'],
+ params['center'],
+ params['scale'],
+ params['angles'],
+ deg2rad(params['sxy']),
+ deg2rad(params['sxz']),
+ deg2rad(params['syx']),
+ deg2rad(params['syz']),
+ deg2rad(params['szx']),
+ deg2rad(params['szy']),
+ ).to(input)
+ return transform
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ transform = cast(torch.Tensor, transform)
+ return warp_affine3d(
+ input,
+ transform[:, :3, :],
+ (input.shape[-3], input.shape[-2], input.shape[-1]),
+ self.resample.name.lower(),
+ align_corners=self.align_corners,
+ )
+
+
+class RandomRotation3D(AugmentationBase3D):
+ r"""Apply random rotations to 3D volumes (5D tensor).
+
+ Input should be a tensor of shape (C, D, H, W) or a batch of tensors :math:`(B, C, D, H, W)`.
+ If Input is a tuple it is assumed that the first element contains the aforementioned tensors and the second,
+ the corresponding transformation matrix that has been applied to them. In this case the module
+ will rotate the tensors and concatenate the corresponding transformation matrix to the
+ previous one. This is especially useful when using this functionality as part of an ``nn.Sequential`` module.
+
+ Args:
+ degrees: Range of degrees to select from.
+ If degrees is a number, then yaw, pitch, roll will be generated from the range of (-degrees, +degrees).
+ If degrees is a tuple of (min, max), then yaw, pitch, roll will be generated from the range of (min, max).
+ If degrees is a list of floats [a, b, c], then yaw, pitch, roll will be generated from (-a, a), (-b, b)
+ and (-c, c).
+ If degrees is a list of tuple ((a, b), (m, n), (x, y)), then yaw, pitch, roll will be generated from
+ (a, b), (m, n) and (x, y).
+ Set to 0 to deactivate rotations.
+ resample:
+ return_transform: if ``True`` return the matrix describing the transformation applied to each
+ input tensor. If ``False`` and the input is a tuple the applied transformation won't be concatenated.
+ same_on_batch: apply the same transformation across the batch.
+ align_corners: interpolation flag.
+ keepdim: whether to keep the output shape the same as input (True) or broadcast it
+ to the batch form (False).
+
+ Shape:
+ - Input: :math:`(C, D, H, W)` or :math:`(B, C, D, H, W)`, Optional: :math:`(B, 4, 4)`
+ - Output: :math:`(B, C, D, H, W)`
+
+ Note:
+ Input tensor must be float and normalized into [0, 1] for the best differentiability support.
+ Additionally, this function accepts another transformation tensor (:math:`(B, 4, 4)`), then the
+ applied transformation will be merged int to the input transformation tensor and returned.
+
+ Examples:
+ >>> rng = torch.manual_seed(0)
+ >>> input = torch.rand(1, 1, 3, 3, 3)
+ >>> aug = RandomRotation3D((15., 20., 20.), p=1.0, return_transform=True)
+ >>> aug(input)
+ (tensor([[[[[0.3819, 0.4886, 0.2111],
+ [0.1196, 0.3833, 0.4722],
+ [0.3432, 0.5951, 0.4223]],
+
+ [[0.5553, 0.4374, 0.2780],
+ [0.2423, 0.1689, 0.4009],
+ [0.4516, 0.6376, 0.7327]],
+
+ [[0.1605, 0.3112, 0.3673],
+ [0.4931, 0.4620, 0.5700],
+ [0.3505, 0.4685, 0.8092]]]]]), tensor([[[ 0.9722, 0.1131, -0.2049, 0.1196],
+ [-0.0603, 0.9669, 0.2478, -0.1545],
+ [ 0.2262, -0.2286, 0.9469, 0.0556],
+ [ 0.0000, 0.0000, 0.0000, 1.0000]]]))
+ """
+
+ def __init__(
+ self,
+ degrees: Union[
+ torch.Tensor,
+ float,
+ Tuple[float, float, float],
+ Tuple[Tuple[float, float], Tuple[float, float], Tuple[float, float]],
+ ],
+ resample: Union[str, int, Resample] = Resample.BILINEAR.name,
+ return_transform: bool = False,
+ same_on_batch: bool = False,
+ align_corners: bool = False,
+ p: float = 0.5,
+ keepdim: bool = False,
+ ) -> None:
+ super().__init__(p=p, return_transform=return_transform, same_on_batch=same_on_batch, keepdim=keepdim)
+ self._device, self._dtype = _extract_device_dtype([degrees])
+ self.degrees = degrees
+ self.resample = Resample.get(resample)
+ self.align_corners = align_corners
+ self.flags: Dict[str, torch.Tensor] = dict(
+ resample=torch.tensor(self.resample.value), align_corners=torch.tensor(align_corners)
+ )
+
+ def __repr__(self) -> str:
+ repr = f"degrees={self.degrees}, resample={self.resample.name}, align_corners={self.align_corners}"
+ return self.__class__.__name__ + f"({repr}, {super().__repr__()})"
+
+ def generate_parameters(self, batch_shape: torch.Size) -> Dict[str, torch.Tensor]:
+ degrees = _tuple_range_reader(self.degrees, 3, self._device, self._dtype)
+ return rg.random_rotation_generator3d(batch_shape[0], degrees, self.same_on_batch, self.device, self.dtype)
+
+ def compute_transformation(self, input: torch.Tensor, params: Dict[str, torch.Tensor]) -> torch.Tensor:
+ yaw: torch.Tensor = params["yaw"].to(input)
+ pitch: torch.Tensor = params["pitch"].to(input)
+ roll: torch.Tensor = params["roll"].to(input)
+
+ center: torch.Tensor = _compute_tensor_center3d(input)
+ rotation_mat: torch.Tensor = _compute_rotation_matrix3d(yaw, pitch, roll, center.expand(yaw.shape[0], -1))
+
+ # rotation_mat is B x 3 x 4 and we need a B x 4 x 4 matrix
+ trans_mat: torch.Tensor = torch.eye(4, device=input.device, dtype=input.dtype).repeat(input.shape[0], 1, 1)
+ trans_mat[:, 0] = rotation_mat[:, 0]
+ trans_mat[:, 1] = rotation_mat[:, 1]
+ trans_mat[:, 2] = rotation_mat[:, 2]
+
+ return trans_mat
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ transform = cast(torch.Tensor, transform)
+ return affine3d(input, transform[..., :3, :4], self.resample.name.lower(), 'zeros', self.align_corners)
+
+
+class RandomMotionBlur3D(AugmentationBase3D):
+ r"""Apply random motion blur on 3D volumes (5D tensor).
+
+ Args:
+ p: probability of applying the transformation.
+ kernel_size: motion kernel size (odd and positive).
+ If int, the kernel will have a fixed size.
+ If Tuple[int, int], it will randomly generate the value from the range batch-wisely.
+ angle: Range of degrees to select from.
+ If angle is a number, then yaw, pitch, roll will be generated from the range of (-angle, +angle).
+ If angle is a tuple of (min, max), then yaw, pitch, roll will be generated from the range of (min, max).
+ If angle is a list of floats [a, b, c], then yaw, pitch, roll will be generated from (-a, a), (-b, b)
+ and (-c, c).
+ If angle is a list of tuple ((a, b), (m, n), (x, y)), then yaw, pitch, roll will be generated from
+ (a, b), (m, n) and (x, y).
+ Set to 0 to deactivate rotations.
+ direction: forward/backward direction of the motion blur.
+ Lower values towards -1.0 will point the motion blur towards the back (with angle provided via angle),
+ while higher values towards 1.0 will point the motion blur forward. A value of 0.0 leads to a
+ uniformly (but still angled) motion blur.
+ If float, it will generate the value from (-direction, direction).
+ If Tuple[int, int], it will randomly generate the value from the range.
+ border_type: the padding mode to be applied before convolving.
+ CONSTANT = 0, REFLECT = 1, REPLICATE = 2, CIRCULAR = 3. Default: BorderType.CONSTANT.
+ resample: resample mode from "nearest" (0) or "bilinear" (1).
+ keepdim: whether to keep the output shape the same as input (True) or broadcast it to the batch form (False).
+
+ Shape:
+ - Input: :math:`(C, D, H, W)` or :math:`(B, C, D, H, W)`, Optional: :math:`(B, 4, 4)`
+ - Output: :math:`(B, C, D, H, W)`
+
+ Note:
+ Input tensor must be float and normalized into [0, 1] for the best differentiability support.
+ Additionally, this function accepts another transformation tensor (:math:`(B, 4, 4)`), then the
+ applied transformation will be merged int to the input transformation tensor and returned.
+
+ Examples:
+ >>> rng = torch.manual_seed(0)
+ >>> input = torch.rand(1, 1, 3, 5, 5)
+ >>> motion_blur = RandomMotionBlur3D(3, 35., 0.5, p=1.)
+ >>> motion_blur(input)
+ tensor([[[[[0.1654, 0.4772, 0.2004, 0.3566, 0.2613],
+ [0.4557, 0.3131, 0.4809, 0.2574, 0.2696],
+ [0.2721, 0.5998, 0.3956, 0.5363, 0.1541],
+ [0.3006, 0.4773, 0.6395, 0.2856, 0.3989],
+ [0.4491, 0.5595, 0.1836, 0.3811, 0.1398]],
+
+ [[0.1843, 0.4240, 0.3370, 0.1231, 0.2186],
+ [0.4047, 0.3332, 0.1901, 0.5329, 0.3023],
+ [0.3070, 0.3088, 0.4807, 0.4928, 0.2590],
+ [0.2416, 0.4614, 0.7091, 0.5237, 0.1433],
+ [0.1582, 0.4577, 0.2749, 0.1369, 0.1607]],
+
+ [[0.2733, 0.4040, 0.4396, 0.2284, 0.3319],
+ [0.3856, 0.6730, 0.4624, 0.3878, 0.3076],
+ [0.4307, 0.4217, 0.2977, 0.5086, 0.5406],
+ [0.3686, 0.2778, 0.5228, 0.7592, 0.6455],
+ [0.2033, 0.3014, 0.4898, 0.6164, 0.3117]]]]])
+ """
+
+ def __init__(
+ self,
+ kernel_size: Union[int, Tuple[int, int]],
+ angle: Union[
+ torch.Tensor,
+ float,
+ Tuple[float, float, float],
+ Tuple[Tuple[float, float], Tuple[float, float], Tuple[float, float]],
+ ],
+ direction: Union[torch.Tensor, float, Tuple[float, float]],
+ border_type: Union[int, str, BorderType] = BorderType.CONSTANT.name,
+ resample: Union[str, int, Resample] = Resample.NEAREST.name,
+ return_transform: bool = False,
+ same_on_batch: bool = False,
+ p: float = 0.5,
+ keepdim: bool = False,
+ ) -> None:
+ super().__init__(
+ p=p, return_transform=return_transform, same_on_batch=same_on_batch, p_batch=1.0, keepdim=keepdim
+ )
+ self._device, self._dtype = _extract_device_dtype([angle, direction])
+ self.kernel_size: Union[int, Tuple[int, int]] = kernel_size
+ self.angle = angle
+ self.direction = direction
+ self.resample = Resample.get(resample)
+ self.border_type = BorderType.get(border_type)
+ self.flags: Dict[str, torch.Tensor] = {
+ "border_type": torch.tensor(self.border_type.value),
+ "interpolation": torch.tensor(self.resample.value),
+ }
+
+ def __repr__(self) -> str:
+ repr = (
+ f"kernel_size={self.kernel_size}, angle={self.angle}, direction={self.direction}, "
+ + f"border_type='{self.border_type.name.lower()}'"
+ )
+ return self.__class__.__name__ + f"({repr}, {super().__repr__()})"
+
+ def generate_parameters(self, batch_shape: torch.Size) -> Dict[str, torch.Tensor]:
+ angle: torch.Tensor = _tuple_range_reader(self.angle, 3, self._device, self._dtype)
+ direction = _range_bound(
+ self.direction, 'direction', center=0.0, bounds=(-1, 1), device=self._device, dtype=self._dtype
+ )
+ return rg.random_motion_blur_generator3d(
+ batch_shape[0], self.kernel_size, angle, direction, self.same_on_batch, self.device, self.dtype
+ )
+
+ def compute_transformation(self, input: torch.Tensor, params: Dict[str, torch.Tensor]) -> torch.Tensor:
+ return self.identity_matrix(input)
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ kernel_size: int = cast(int, params['ksize_factor'].unique().item())
+ angle = params['angle_factor']
+ direction = params['direction_factor']
+ return motion_blur3d(
+ input, kernel_size, angle, direction, self.border_type.name.lower(), self.resample.name.lower()
+ )
+
+
+class CenterCrop3D(AugmentationBase3D):
+ r"""Apply center crop on 3D volumes (5D tensor).
+
+ Args:
+ p: probability of applying the transformation for the whole batch.
+ size (Tuple[int, int, int] or int): Desired output size (out_d, out_h, out_w) of the crop.
+ If integer, out_d = out_h = out_w = size.
+ If Tuple[int, int, int], out_d = size[0], out_h = size[1], out_w = size[2].
+ resample:
+ return_transform: if ``True`` return the matrix describing the transformation applied to each
+ input tensor. If ``False`` and the input is a tuple the applied transformation won't be concatenated.
+ align_corners: interpolation flag.
+ keepdim: whether to keep the output shape the same as input (True) or broadcast it
+ to the batch form (False).
+
+ Shape:
+ - Input: :math:`(C, D, H, W)` or :math:`(B, C, D, H, W)`, Optional: :math:`(B, 4, 4)`
+ - Output: :math:`(B, C, out_d, out_h, out_w)`
+
+ Note:
+ Input tensor must be float and normalized into [0, 1] for the best differentiability support.
+ Additionally, this function accepts another transformation tensor (:math:`(B, 4, 4)`), then the
+ applied transformation will be merged int to the input transformation tensor and returned.
+
+ Examples:
+ >>> rng = torch.manual_seed(0)
+ >>> inputs = torch.randn(1, 1, 2, 4, 6)
+ >>> inputs
+ tensor([[[[[-1.1258, -1.1524, -0.2506, -0.4339, 0.8487, 0.6920],
+ [-0.3160, -2.1152, 0.3223, -1.2633, 0.3500, 0.3081],
+ [ 0.1198, 1.2377, 1.1168, -0.2473, -1.3527, -1.6959],
+ [ 0.5667, 0.7935, 0.5988, -1.5551, -0.3414, 1.8530]],
+
+ [[ 0.7502, -0.5855, -0.1734, 0.1835, 1.3894, 1.5863],
+ [ 0.9463, -0.8437, -0.6136, 0.0316, -0.4927, 0.2484],
+ [ 0.4397, 0.1124, 0.6408, 0.4412, -0.1023, 0.7924],
+ [-0.2897, 0.0525, 0.5229, 2.3022, -1.4689, -1.5867]]]]])
+ >>> aug = CenterCrop3D(2, p=1.)
+ >>> aug(inputs)
+ tensor([[[[[ 0.3223, -1.2633],
+ [ 1.1168, -0.2473]],
+
+ [[-0.6136, 0.0316],
+ [ 0.6408, 0.4412]]]]])
+ """
+
+ def __init__(
+ self,
+ size: Union[int, Tuple[int, int, int]],
+ align_corners: bool = True,
+ resample: Union[str, int, Resample] = Resample.BILINEAR.name,
+ return_transform: bool = False,
+ p: float = 1.0,
+ keepdim: bool = False,
+ ) -> None:
+ # same_on_batch is always True for CenterCrop
+ # Since PyTorch does not support ragged tensor. So cropping function happens batch-wisely.
+ super().__init__(p=1.0, return_transform=return_transform, same_on_batch=True, p_batch=p, keepdim=keepdim)
+ if isinstance(size, tuple):
+ self.size = (size[0], size[1], size[2])
+ elif isinstance(size, int):
+ self.size = (size, size, size)
+ else:
+ raise Exception(f"Invalid size type. Expected (int, tuple(int, int int). Got: {size}.")
+ self.resample = Resample.get(resample)
+ self.align_corners = align_corners
+ self.flags: Dict[str, torch.Tensor] = dict(
+ interpolation=torch.tensor(self.resample.value), align_corners=torch.tensor(align_corners)
+ )
+
+ def __repr__(self) -> str:
+ repr = f"size={self.size}"
+ return self.__class__.__name__ + f"({repr}, {super().__repr__()})"
+
+ def generate_parameters(self, batch_shape: torch.Size) -> Dict[str, torch.Tensor]:
+ return rg.center_crop_generator3d(
+ batch_shape[0], batch_shape[-3], batch_shape[-2], batch_shape[-1], self.size, device=self.device
+ )
+
+ def compute_transformation(self, input: torch.Tensor, params: Dict[str, torch.Tensor]) -> torch.Tensor:
+ transform: torch.Tensor = get_perspective_transform3d(params['src'].to(input), params['dst'].to(input))
+ transform = transform.expand(input.shape[0], -1, -1)
+ return transform
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ transform = cast(torch.Tensor, transform)
+ return crop_by_transform_mat3d(
+ input, transform, self.size, mode=self.resample.name.lower(), align_corners=self.align_corners
+ )
+
+
+class RandomCrop3D(AugmentationBase3D):
+ r"""Apply random crop on 3D volumes (5D tensor).
+
+ Crops random sub-volumes on a given size.
+
+ Args:
+ p: probability of applying the transformation for the whole batch.
+ size: Desired output size (out_d, out_h, out_w) of the crop.
+ Must be Tuple[int, int, int], then out_d = size[0], out_h = size[1], out_w = size[2].
+ padding: Optional padding on each border of the image.
+ Default is None, i.e no padding. If a sequence of length 6 is provided, it is used to pad
+ left, top, right, bottom, front, back borders respectively.
+ If a sequence of length 3 is provided, it is used to pad left/right,
+ top/bottom, front/back borders, respectively.
+ pad_if_needed: It will pad the image if smaller than the
+ desired size to avoid raising an exception. Since cropping is done
+ after padding, the padding seems to be done at a random offset.
+ fill: Pixel fill value for constant fill. Default is 0. If a tuple of
+ length 3, it is used to fill R, G, B channels respectively.
+ This value is only used when the padding_mode is constant.
+ padding_mode: Type of padding. Should be: constant, edge, reflect or symmetric. Default is constant.
+ resample:
+ return_transform: if ``True`` return the matrix describing the transformation applied to each
+ input tensor. If ``False`` and the input is a tuple the applied transformation won't be concatenated
+ same_on_batch: apply the same transformation across the batch.
+ align_corners: interpolation flag.
+ keepdim: whether to keep the output shape the same as input (True) or broadcast it
+ to the batch form (False).
+
+ Shape:
+ - Input: :math:`(C, D, H, W)` or :math:`(B, C, D, H, W)`, Optional: :math:`(B, 4, 4)`
+ - Output: :math:`(B, C, , out_d, out_h, out_w)`
+
+ Note:
+ Input tensor must be float and normalized into [0, 1] for the best differentiability support.
+ Additionally, this function accepts another transformation tensor (:math:`(B, 4, 4)`), then the
+ applied transformation will be merged int to the input transformation tensor and returned.
+
+ Examples:
+ >>> rng = torch.manual_seed(0)
+ >>> inputs = torch.randn(1, 1, 3, 3, 3)
+ >>> aug = RandomCrop3D((2, 2, 2), p=1.)
+ >>> aug(inputs)
+ tensor([[[[[-1.1258, -1.1524],
+ [-0.4339, 0.8487]],
+
+ [[-1.2633, 0.3500],
+ [ 0.1665, 0.8744]]]]])
+ """
+
+ def __init__(
+ self,
+ size: Tuple[int, int, int],
+ padding: Optional[Union[int, Tuple[int, int, int], Tuple[int, int, int, int, int, int]]] = None,
+ pad_if_needed: Optional[bool] = False,
+ fill: int = 0,
+ padding_mode: str = 'constant',
+ resample: Union[str, int, Resample] = Resample.BILINEAR.name,
+ return_transform: bool = False,
+ same_on_batch: bool = False,
+ align_corners: bool = True,
+ p: float = 1.0,
+ keepdim: bool = False,
+ ) -> None:
+ # Since PyTorch does not support ragged tensor. So cropping function happens batch-wisely.
+ super().__init__(
+ p=1.0, return_transform=return_transform, same_on_batch=same_on_batch, p_batch=p, keepdim=keepdim
+ )
+ self.size = size
+ self.padding = padding
+ self.pad_if_needed = pad_if_needed
+ self.fill = fill
+ self.padding_mode = padding_mode
+ self.resample = Resample.get(resample)
+ self.align_corners = align_corners
+ self.flags: Dict[str, torch.Tensor] = dict(
+ interpolation=torch.tensor(self.resample.value), align_corners=torch.tensor(align_corners)
+ )
+
+ def __repr__(self) -> str:
+ repr = (
+ f"crop_size={self.size}, padding={self.padding}, fill={self.fill}, pad_if_needed={self.pad_if_needed}, "
+ f"padding_mode={self.padding_mode}, resample={self.resample.name}"
+ )
+ return self.__class__.__name__ + f"({repr}, {super().__repr__()})"
+
+ def generate_parameters(self, batch_shape: torch.Size) -> Dict[str, torch.Tensor]:
+ return rg.random_crop_generator3d(
+ batch_shape[0],
+ (batch_shape[-3], batch_shape[-2], batch_shape[-1]),
+ self.size,
+ same_on_batch=self.same_on_batch,
+ device=self.device,
+ dtype=self.dtype,
+ )
+
+ def precrop_padding(self, input: torch.Tensor) -> torch.Tensor:
+ if self.padding is not None:
+ if isinstance(self.padding, int):
+ padding = [self.padding, self.padding, self.padding, self.padding, self.padding, self.padding]
+ elif isinstance(self.padding, (tuple, list)) and len(self.padding) == 3:
+ padding = [
+ self.padding[0],
+ self.padding[0],
+ self.padding[1],
+ self.padding[1],
+ self.padding[2],
+ self.padding[2],
+ ]
+ elif isinstance(self.padding, (tuple, list)) and len(self.padding) == 6:
+ padding = [
+ self.padding[0],
+ self.padding[1],
+ self.padding[2],
+ self.padding[3], # type: ignore
+ self.padding[4], # type: ignore
+ self.padding[5], # type: ignore
+ ]
+ else:
+ raise ValueError(f"`padding` must be an integer, 3-element-list or 6-element-list. Got {self.padding}.")
+ input = pad(input, padding, value=self.fill, mode=self.padding_mode)
+
+ if self.pad_if_needed and input.shape[-3] < self.size[0]:
+ padding = [0, 0, 0, 0, self.size[0] - input.shape[-3], self.size[0] - input.shape[-3]]
+ input = pad(input, padding, value=self.fill, mode=self.padding_mode)
+
+ if self.pad_if_needed and input.shape[-2] < self.size[1]:
+ padding = [0, 0, (self.size[1] - input.shape[-2]), self.size[1] - input.shape[-2], 0, 0]
+ input = pad(input, padding, value=self.fill, mode=self.padding_mode)
+
+ if self.pad_if_needed and input.shape[-1] < self.size[2]:
+ padding = [self.size[2] - input.shape[-1], self.size[2] - input.shape[-1], 0, 0, 0, 0]
+ input = pad(input, padding, value=self.fill, mode=self.padding_mode)
+
+ return input
+
+ def compute_transformation(self, input: torch.Tensor, params: Dict[str, torch.Tensor]) -> torch.Tensor:
+ transform: torch.Tensor = get_perspective_transform3d(params['src'].to(input), params['dst'].to(input))
+ transform = transform.expand(input.shape[0], -1, -1)
+ return transform
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ transform = cast(torch.Tensor, transform)
+ return crop_by_transform_mat3d(
+ input, transform, self.size, mode=self.resample.name.lower(), align_corners=self.align_corners
+ )
+
+ def forward( # type: ignore
+ self,
+ input: TensorWithTransformMat,
+ params: Optional[Dict[str, torch.Tensor]] = None,
+ return_transform: Optional[bool] = None,
+ ) -> TensorWithTransformMat:
+ if type(input) is tuple:
+ input = (self.precrop_padding(input[0]), input[1])
+ else:
+ input = self.precrop_padding(input) # type:ignore
+ return super().forward(input, params, return_transform)
+
+
+class RandomPerspective3D(AugmentationBase3D):
+ r"""Apply andom perspective transformation to 3D volumes (5D tensor).
+
+ Args:
+ p: probability of the image being perspectively transformed.
+ distortion_scale: it controls the degree of distortion and ranges from 0 to 1.
+ resample:
+ return_transform: if ``True`` return the matrix describing the transformation applied to each.
+ same_on_batch: apply the same transformation across the batch.
+ align_corners: interpolation flag.
+ keepdim: whether to keep the output shape the same as input (True) or broadcast it
+ to the batch form (False).
+
+ Shape:
+ - Input: :math:`(C, D, H, W)` or :math:`(B, C, D, H, W)`, Optional: :math:`(B, 4, 4)`
+ - Output: :math:`(B, C, D, H, W)`
+
+ Note:
+ Input tensor must be float and normalized into [0, 1] for the best differentiability support.
+ Additionally, this function accepts another transformation tensor (:math:`(B, 4, 4)`), then the
+ applied transformation will be merged int to the input transformation tensor and returned.
+
+ Examples:
+ >>> rng = torch.manual_seed(0)
+ >>> inputs= torch.tensor([[[
+ ... [[1., 0., 0.],
+ ... [0., 1., 0.],
+ ... [0., 0., 1.]],
+ ... [[1., 0., 0.],
+ ... [0., 1., 0.],
+ ... [0., 0., 1.]],
+ ... [[1., 0., 0.],
+ ... [0., 1., 0.],
+ ... [0., 0., 1.]]
+ ... ]]])
+ >>> aug = RandomPerspective3D(0.5, p=1., align_corners=True)
+ >>> aug(inputs)
+ tensor([[[[[0.3976, 0.5507, 0.0000],
+ [0.0901, 0.3668, 0.0000],
+ [0.0000, 0.0000, 0.0000]],
+
+ [[0.2651, 0.4657, 0.0000],
+ [0.1390, 0.5174, 0.0000],
+ [0.0000, 0.0000, 0.0000]],
+
+ [[0.0000, 0.1153, 0.0000],
+ [0.0000, 0.0000, 0.0000],
+ [0.0000, 0.0000, 0.0000]]]]])
+ """
+
+ def __init__(
+ self,
+ distortion_scale: Union[torch.Tensor, float] = 0.5,
+ resample: Union[str, int, Resample] = Resample.BILINEAR.name,
+ return_transform: bool = False,
+ same_on_batch: bool = False,
+ align_corners: bool = False,
+ p: float = 0.5,
+ keepdim: bool = False,
+ ) -> None:
+ super().__init__(p=p, return_transform=return_transform, same_on_batch=same_on_batch, keepdim=keepdim)
+ self._device, self._dtype = _extract_device_dtype([distortion_scale])
+ self.distortion_scale = distortion_scale
+ self.resample = Resample.get(resample)
+ self.align_corners = align_corners
+ self.flags: Dict[str, torch.Tensor] = dict(
+ interpolation=torch.tensor(self.resample.value), align_corners=torch.tensor(align_corners)
+ )
+
+ def __repr__(self) -> str:
+ repr = (
+ f"distortion_scale={self.distortion_scale}, resample={self.resample.name}, "
+ f"align_corners={self.align_corners}"
+ )
+ return self.__class__.__name__ + f"({repr}, {super().__repr__()})"
+
+ def generate_parameters(self, batch_shape: torch.Size) -> Dict[str, torch.Tensor]:
+ distortion_scale = torch.as_tensor(self.distortion_scale, device=self._device, dtype=self._dtype)
+ return rg.random_perspective_generator3d(
+ batch_shape[0],
+ batch_shape[-3],
+ batch_shape[-2],
+ batch_shape[-1],
+ distortion_scale,
+ self.same_on_batch,
+ self.device,
+ self.dtype,
+ )
+
+ def compute_transformation(self, input: torch.Tensor, params: Dict[str, torch.Tensor]) -> torch.Tensor:
+ return get_perspective_transform3d(params['start_points'], params['end_points']).to(input)
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ transform = cast(torch.Tensor, transform)
+ return warp_perspective3d(
+ input,
+ transform,
+ (input.shape[-3], input.shape[-2], input.shape[-1]),
+ flags=self.resample.name.lower(),
+ align_corners=self.align_corners,
+ )
+
+
+class RandomEqualize3D(AugmentationBase3D):
+ r"""Apply random equalization to 3D volumes (5D tensor).
+
+ Args:
+ p: probability of the image being equalized.
+ return_transform: if ``True`` return the matrix describing the transformation applied to each
+ input tensor. If ``False`` and the input is a tuple the applied transformation won't be concatenated.
+ same_on_batch): apply the same transformation across the batch.
+ keepdim: whether to keep the output shape the same as input (True) or broadcast it
+ to the batch form (False).
+
+ Shape:
+ - Input: :math:`(C, D, H, W)` or :math:`(B, C, D, H, W)`, Optional: :math:`(B, 4, 4)`
+ - Output: :math:`(B, C, D, H, W)`
+
+ Note:
+ Input tensor must be float and normalized into [0, 1] for the best differentiability support.
+ Additionally, this function accepts another transformation tensor (:math:`(B, 4, 4)`), then the
+ applied transformation will be merged int to the input transformation tensor and returned.
+
+ Examples:
+ >>> rng = torch.manual_seed(0)
+ >>> input = torch.rand(1, 1, 3, 3, 3)
+ >>> aug = RandomEqualize3D(p=1.0)
+ >>> aug(input)
+ tensor([[[[[0.4963, 0.7682, 0.0885],
+ [0.1320, 0.3074, 0.6341],
+ [0.4901, 0.8964, 0.4556]],
+
+ [[0.6323, 0.3489, 0.4017],
+ [0.0223, 0.1689, 0.2939],
+ [0.5185, 0.6977, 0.8000]],
+
+ [[0.1610, 0.2823, 0.6816],
+ [0.9152, 0.3971, 0.8742],
+ [0.4194, 0.5529, 0.9527]]]]])
+ """
+
+ def __init__(
+ self, p: float = 0.5, return_transform: bool = False, same_on_batch: bool = False, keepdim: bool = False
+ ) -> None:
+ super().__init__(p=p, return_transform=return_transform, same_on_batch=same_on_batch, keepdim=keepdim)
+
+ def __repr__(self) -> str:
+ return self.__class__.__name__ + f"({super().__repr__()})"
+
+ def compute_transformation(self, input: torch.Tensor, params: Dict[str, torch.Tensor]) -> torch.Tensor:
+ return self.identity_matrix(input)
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ return equalize3d(input)
diff --git a/kornia/augmentation/base.py b/kornia/augmentation/base.py
new file mode 100644
index 0000000000000000000000000000000000000000..ba1c759c6d5d967c6780bb5590a7e861f3ea2d32
--- /dev/null
+++ b/kornia/augmentation/base.py
@@ -0,0 +1,541 @@
+import warnings
+from typing import cast, Dict, Optional, Tuple, Union
+
+import torch
+import torch.nn as nn
+from torch.distributions import Bernoulli
+
+import kornia
+from kornia.utils.helpers import _torch_inverse_cast
+
+from .utils import (
+ _adapted_sampling,
+ _transform_input,
+ _transform_input3d,
+ _transform_output_shape,
+ _validate_input_dtype,
+)
+
+TensorWithTransformMat = Union[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]
+
+
+class _BasicAugmentationBase(nn.Module):
+ r"""_BasicAugmentationBase base class for customized augmentation implementations.
+
+ Plain augmentation base class without the functionality of transformation matrix calculations.
+ By default, the random computations will be happened on CPU with ``torch.get_default_dtype()``.
+ To change this behaviour, please use ``set_rng_device_and_dtype``.
+
+ Args:
+ p: probability for applying an augmentation. This param controls the augmentation probabilities element-wise.
+ p_batch: probability for applying an augmentation to a batch. This param controls the augmentation
+ probabilities batch-wise.
+ same_on_batch: apply the same transformation across the batch.
+ keepdim: whether to keep the output shape the same as input ``True`` or broadcast it to
+ the batch form ``False``.
+ """
+
+ def __init__(
+ self, p: float = 0.5, p_batch: float = 1.0, same_on_batch: bool = False, keepdim: bool = False
+ ) -> None:
+ super().__init__()
+ self.p = p
+ self.p_batch = p_batch
+ self.same_on_batch = same_on_batch
+ self.keepdim = keepdim
+ self._params: Dict[str, torch.Tensor] = {}
+ if p != 0.0 or p != 1.0:
+ self._p_gen = Bernoulli(self.p)
+ if p_batch != 0.0 or p_batch != 1.0:
+ self._p_batch_gen = Bernoulli(self.p_batch)
+ self.set_rng_device_and_dtype(torch.device('cpu'), torch.get_default_dtype())
+
+ def __repr__(self) -> str:
+ return f"p={self.p}, p_batch={self.p_batch}, same_on_batch={self.same_on_batch}"
+
+ def __unpack_input__(self, input: torch.Tensor) -> torch.Tensor:
+ return input
+
+ def __check_batching__(self, input: TensorWithTransformMat):
+ """Check if a transformation matrix is returned, it has to be in the same batching mode as output."""
+ raise NotImplementedError
+
+ def transform_tensor(self, input: torch.Tensor) -> torch.Tensor:
+ """Standardize input tensors."""
+ raise NotImplementedError
+
+ def generate_parameters(self, batch_shape: torch.Size) -> Dict[str, torch.Tensor]:
+ return {}
+
+ def apply_transform(self, input: torch.Tensor, params: Dict[str, torch.Tensor]) -> torch.Tensor:
+ raise NotImplementedError
+
+ def set_rng_device_and_dtype(self, device: torch.device, dtype: torch.dtype) -> None:
+ """Change the random generation device and dtype.
+
+ Note:
+ The generated random numbers are not reproducible across different devices and dtypes.
+ """
+ self.device = device
+ self.dtype = dtype
+
+ def __batch_prob_generator__(
+ self, batch_shape: torch.Size, p: float, p_batch: float, same_on_batch: bool
+ ) -> torch.Tensor:
+ batch_prob: torch.Tensor
+ if p_batch == 1:
+ batch_prob = torch.tensor([True])
+ elif p_batch == 0:
+ batch_prob = torch.tensor([False])
+ else:
+ batch_prob = _adapted_sampling((1,), self._p_batch_gen, same_on_batch).bool()
+
+ if batch_prob.sum().item() == 1:
+ elem_prob: torch.Tensor
+ if p == 1:
+ elem_prob = torch.tensor([True] * batch_shape[0])
+ elif p == 0:
+ elem_prob = torch.tensor([False] * batch_shape[0])
+ else:
+ elem_prob = _adapted_sampling((batch_shape[0],), self._p_gen, same_on_batch).bool()
+ batch_prob = batch_prob * elem_prob
+ else:
+ batch_prob = batch_prob.repeat(batch_shape[0])
+ return batch_prob
+
+ def forward_parameters(self, batch_shape) -> Dict[str, torch.Tensor]:
+ to_apply = self.__batch_prob_generator__(batch_shape, self.p, self.p_batch, self.same_on_batch)
+ _params = self.generate_parameters(torch.Size((int(to_apply.sum().item()), *batch_shape[1:])))
+ if _params is None:
+ _params = {}
+ _params['batch_prob'] = to_apply
+ return _params
+
+ def apply_func(self, input: torch.Tensor, params: Dict[str, torch.Tensor]) -> TensorWithTransformMat:
+ input = self.transform_tensor(input)
+ return self.apply_transform(input, params)
+
+ def forward( # type: ignore
+ self, input: torch.Tensor, params: Optional[Dict[str, torch.Tensor]] = None # type: ignore
+ ) -> TensorWithTransformMat:
+ in_tensor = self.__unpack_input__(input)
+ self.__check_batching__(input)
+ ori_shape = in_tensor.shape
+ in_tensor = self.transform_tensor(in_tensor)
+ batch_shape = in_tensor.shape
+ if params is None:
+ params = self.forward_parameters(batch_shape)
+ self._params = params
+
+ output = self.apply_func(input, self._params)
+ return _transform_output_shape(output, ori_shape) if self.keepdim else output
+
+
+class _AugmentationBase(_BasicAugmentationBase):
+ r"""_AugmentationBase base class for customized augmentation implementations.
+
+ Advanced augmentation base class with the functionality of transformation matrix calculations.
+
+ Args:
+ pprobability for applying an augmentation. This param controls the augmentation probabilities
+ element-wise for a batch.
+ p_batch: probability for applying an augmentation to a batch. This param controls the augmentation
+ probabilities batch-wise.
+ return_transform: if ``True`` return the matrix describing the geometric transformation applied to each
+ input tensor. If ``False`` and the input is a tuple the applied transformation won't be concatenated.
+ same_on_batch: apply the same transformation across the batch.
+ keepdim: whether to keep the output shape the same as input ``True`` or broadcast it
+ to the batch form ``False``.
+ """
+
+ def __init__(
+ self,
+ return_transform: bool = None,
+ same_on_batch: bool = False,
+ p: float = 0.5,
+ p_batch: float = 1.0,
+ keepdim: bool = False,
+ ) -> None:
+ super().__init__(p, p_batch=p_batch, same_on_batch=same_on_batch, keepdim=keepdim)
+ self.p = p
+ self.p_batch = p_batch
+ self.return_transform = return_transform
+
+ def __repr__(self) -> str:
+ return super().__repr__() + f", return_transform={self.return_transform}"
+
+ def identity_matrix(self, input: torch.Tensor) -> torch.Tensor:
+ raise NotImplementedError
+
+ def compute_transformation(self, input: torch.Tensor, params: Dict[str, torch.Tensor]) -> torch.Tensor:
+ raise NotImplementedError
+
+ def apply_transform(
+ self, input: torch.Tensor, params: Dict[str, torch.Tensor], transform: Optional[torch.Tensor] = None
+ ) -> torch.Tensor:
+ raise NotImplementedError
+
+ def __unpack_input__( # type: ignore
+ self, input: TensorWithTransformMat
+ ) -> Tuple[torch.Tensor, Optional[torch.Tensor]]:
+ if isinstance(input, tuple):
+ in_tensor = input[0]
+ in_transformation = input[1]
+ return in_tensor, in_transformation
+ in_tensor = input
+ return in_tensor, None
+
+ def apply_func( # type: ignore
+ self,
+ in_tensor: torch.Tensor,
+ in_transform: Optional[torch.Tensor], # type: ignore
+ params: Dict[str, torch.Tensor],
+ return_transform: bool = False,
+ ) -> TensorWithTransformMat:
+ to_apply = params['batch_prob']
+
+ # if no augmentation needed
+ if torch.sum(to_apply) == 0:
+ output = in_tensor
+ trans_matrix = self.identity_matrix(in_tensor)
+ # if all data needs to be augmented
+ elif torch.sum(to_apply) == len(to_apply):
+ trans_matrix = self.compute_transformation(in_tensor, params)
+ output = self.apply_transform(in_tensor, params, trans_matrix)
+ else:
+ output = in_tensor.clone()
+ trans_matrix = self.identity_matrix(in_tensor)
+ trans_matrix[to_apply] = self.compute_transformation(in_tensor[to_apply], params)
+ output[to_apply] = self.apply_transform(in_tensor[to_apply], params, trans_matrix[to_apply])
+
+ self._transform_matrix = trans_matrix
+
+ if return_transform:
+ out_transformation = trans_matrix if in_transform is None else trans_matrix @ in_transform
+ return output, out_transformation
+
+ if in_transform is not None:
+ return output, in_transform
+
+ return output
+
+ def forward( # type: ignore
+ self,
+ input: TensorWithTransformMat,
+ params: Optional[Dict[str, torch.Tensor]] = None, # type: ignore
+ return_transform: Optional[bool] = None,
+ ) -> TensorWithTransformMat:
+ in_tensor, in_transform = self.__unpack_input__(input)
+ self.__check_batching__(input)
+ ori_shape = in_tensor.shape
+ in_tensor = self.transform_tensor(in_tensor)
+ batch_shape = in_tensor.shape
+
+ if return_transform is None:
+ return_transform = self.return_transform
+ return_transform = cast(bool, return_transform)
+ if params is None:
+ params = self.forward_parameters(batch_shape)
+ if 'batch_prob' not in params:
+ params['batch_prob'] = torch.tensor([True] * batch_shape[0])
+ # TODO(jian): we cannot throw a warning every time.
+ # warnings.warn("`batch_prob` is not found in params. Will assume applying on all data.")
+
+ self._params = params
+ output = self.apply_func(in_tensor, in_transform, self._params, return_transform)
+ return _transform_output_shape(output, ori_shape) if self.keepdim else output
+
+
+class AugmentationBase2D(_AugmentationBase):
+ r"""AugmentationBase2D base class for customized augmentation implementations.
+
+ For any augmentation, the implementation of "generate_parameters" and "apply_transform" are required while the
+ "compute_transformation" is only required when passing "return_transform" as True.
+
+ Args:
+ p: probability for applying an augmentation. This param controls the augmentation probabilities
+ element-wise for a batch.
+ p_batch: probability for applying an augmentation to a batch. This param controls the augmentation
+ probabilities batch-wise.
+ return_transform: if ``True`` return the matrix describing the geometric transformation applied to each
+ input tensor. If ``False`` and the input is a tuple the applied transformation won't be concatenated.
+ same_on_batch: apply the same transformation across the batch.
+ keepdim: whether to keep the output shape the same as input ``True`` or broadcast it to the batch
+ form ``False``.
+ """
+
+ def __check_batching__(self, input: TensorWithTransformMat):
+ if isinstance(input, tuple):
+ inp, mat = input
+ if len(inp.shape) == 4:
+ if len(mat.shape) != 3:
+ raise AssertionError('Input tensor is in batch mode ' 'but transformation matrix is not')
+ if mat.shape[0] != inp.shape[0]:
+ raise AssertionError(
+ f"In batch dimension, input has {inp.shape[0]} but transformation matrix has {mat.shape[0]}"
+ )
+ elif len(inp.shape) in (2, 3):
+ if len(mat.shape) != 2:
+ raise AssertionError("Input tensor is in non-batch mode but transformation matrix is not")
+ else:
+ raise ValueError(f'Unrecognized output shape. Expected 2, 3, or 4, got {len(inp.shape)}')
+
+ def transform_tensor(self, input: torch.Tensor) -> torch.Tensor:
+ """Convert any incoming (H, W), (C, H, W) and (B, C, H, W) into (B, C, H, W)."""
+ _validate_input_dtype(input, accepted_dtypes=[torch.float16, torch.float32, torch.float64])
+ return _transform_input(input)
+
+ def identity_matrix(self, input) -> torch.Tensor:
+ """Return 3x3 identity matrix."""
+ return kornia.eye_like(3, input)
+
+
+class IntensityAugmentationBase2D(AugmentationBase2D):
+ r"""IntensityAugmentationBase2D base class for customized intensity augmentation implementations.
+
+ For any augmentation, the implementation of "generate_parameters" and "apply_transform" are required while the
+ "compute_transformation" is only required when passing "return_transform" as True.
+
+ Args:
+ p: probability for applying an augmentation. This param controls the augmentation probabilities
+ element-wise for a batch.
+ p_batch: probability for applying an augmentation to a batch. This param controls the augmentation
+ probabilities batch-wise.
+ return_transform: if ``True`` return the matrix describing the geometric transformation applied to each
+ input tensor. If ``False`` and the input is a tuple the applied transformation won't be concatenated.
+ same_on_batch: apply the same transformation across the batch.
+ keepdim: whether to keep the output shape the same as input ``True`` or broadcast it
+ to the batch form ``False``.
+ """
+
+ def compute_transformation(self, input: torch.Tensor, params: Dict[str, torch.Tensor]) -> torch.Tensor:
+ return self.identity_matrix(input)
+
+
+class GeometricAugmentationBase2D(AugmentationBase2D):
+ r"""GeometricAugmentationBase2D base class for customized geometric augmentation implementations.
+
+ For any augmentation, the implementation of "generate_parameters" and "apply_transform" are required while the
+ "compute_transformation" is only required when passing "return_transform" as True.
+
+ Args:
+ p: probability for applying an augmentation. This param controls the augmentation probabilities
+ element-wise for a batch.
+ p_batch: probability for applying an augmentation to a batch. This param controls the augmentation
+ probabilities batch-wise.
+ return_transform: if ``True`` return the matrix describing the geometric transformation applied to each
+ input tensor. If ``False`` and the input is a tuple the applied transformation won't be concatenated.
+ same_on_batch: apply the same transformation across the batch.
+ keepdim: whether to keep the output shape the same as input ``True`` or broadcast it
+ to the batch form ``False``.
+ """
+
+ def inverse_transform(
+ self,
+ input: torch.Tensor,
+ transform: Optional[torch.Tensor] = None,
+ size: Optional[Tuple[int, int]] = None,
+ **kwargs,
+ ) -> torch.Tensor:
+ """By default, the exact transformation as ``apply_transform`` will be used."""
+ raise NotImplementedError
+
+ def compute_inverse_transformation(self, transform: torch.Tensor):
+ """Compute the inverse transform of given transformation matrices."""
+ return _torch_inverse_cast(transform)
+
+ def get_transformation_matrix(
+ self, input: torch.Tensor, params: Optional[Dict[str, torch.Tensor]] = None
+ ) -> torch.Tensor:
+ if params is not None:
+ transform = self.compute_transformation(input, params)
+ elif not hasattr(self, "_transform_matrix"):
+ params = self.forward_parameters(input.shape)
+ transform = self.identity_matrix(input)
+ transform[params['batch_prob']] = self.compute_transformation(input[params['batch_prob']], params)
+ else:
+ transform = self._transform_matrix
+ return torch.as_tensor(transform, device=input.device, dtype=input.dtype)
+
+ def inverse(
+ self,
+ input: TensorWithTransformMat,
+ params: Optional[Dict[str, torch.Tensor]] = None,
+ size: Optional[Tuple[int, int]] = None,
+ **kwargs,
+ ) -> torch.Tensor:
+ if isinstance(input, (list, tuple)):
+ input, transform = input
+ else:
+ transform = self.get_transformation_matrix(input, params)
+ if params is not None:
+ transform = self.identity_matrix(input)
+ transform[params['batch_prob']] = self.compute_transformation(input[params['batch_prob']], params)
+
+ ori_shape = input.shape
+ in_tensor = self.transform_tensor(input)
+ batch_shape = input.shape
+ if params is None:
+ params = self._params
+ if size is None and "input_size" in params:
+ # Majorly for cropping functions
+ size = params['input_size'].unique(dim=0).squeeze().numpy().tolist()
+ size = (size[0], size[1])
+ if 'batch_prob' not in params:
+ params['batch_prob'] = torch.tensor([True] * batch_shape[0])
+ warnings.warn("`batch_prob` is not found in params. Will assume applying on all data.")
+ output = input.clone()
+ to_apply = params['batch_prob']
+ # if no augmentation needed
+ if torch.sum(to_apply) == 0:
+ output = in_tensor
+ # if all data needs to be augmented
+ elif torch.sum(to_apply) == len(to_apply):
+ transform = self.compute_inverse_transformation(transform)
+ output = self.inverse_transform(in_tensor, transform, size, **kwargs)
+ else:
+ transform[to_apply] = self.compute_inverse_transformation(transform[to_apply])
+ output[to_apply] = self.inverse_transform(in_tensor[to_apply], transform[to_apply], size, **kwargs)
+ return cast(torch.Tensor, _transform_output_shape(output, ori_shape)) if self.keepdim else output
+
+
+class AugmentationBase3D(_AugmentationBase):
+ r"""AugmentationBase3D base class for customized augmentation implementations.
+
+ For any augmentation, the implementation of "generate_parameters" and "apply_transform" are required while the
+ "compute_transformation" is only required when passing "return_transform" as True.
+
+ Args:
+ p: probability for applying an augmentation. This param controls the augmentation probabilities
+ element-wise for a batch.
+ p_batch: probability for applying an augmentation to a batch. This param controls the augmentation
+ probabilities batch-wise.
+ return_transform: if ``True`` return the matrix describing the geometric transformation applied to each
+ input tensor. If ``False`` and the input is a tuple the applied transformation won't be concatenated.
+ same_on_batch: apply the same transformation across the batch.
+ """
+
+ def __check_batching__(self, input: TensorWithTransformMat):
+ if isinstance(input, tuple):
+ inp, mat = input
+ if len(inp.shape) == 5:
+ if len(mat.shape) != 3:
+ raise AssertionError('Input tensor is in batch mode ' 'but transformation matrix is not')
+ if mat.shape[0] != inp.shape[0]:
+ raise AssertionError(
+ f"In batch dimension, input has {inp.shape[0]} but transformation matrix has {mat.shape[0]}"
+ )
+ elif len(inp.shape) in (3, 4):
+ if len(mat.shape) != 2:
+ raise AssertionError("Input tensor is in non-batch mode but transformation matrix is not")
+ else:
+ raise ValueError(f'Unrecognized output shape. Expected 3, 4 or 5, got {len(inp.shape)}')
+
+ def transform_tensor(self, input: torch.Tensor) -> torch.Tensor:
+ """Convert any incoming (D, H, W), (C, D, H, W) and (B, C, D, H, W) into (B, C, D, H, W)."""
+ _validate_input_dtype(input, accepted_dtypes=[torch.float16, torch.float32, torch.float64])
+ return _transform_input3d(input)
+
+ def identity_matrix(self, input) -> torch.Tensor:
+ """Return 4x4 identity matrix."""
+ return kornia.eye_like(4, input)
+
+
+class MixAugmentationBase(_BasicAugmentationBase):
+ r"""MixAugmentationBase base class for customized mix augmentation implementations.
+
+ For any augmentation, the implementation of "generate_parameters" and "apply_transform" are required.
+ "apply_transform" will need to handle the probabilities internally.
+
+ Args:
+ p: probability for applying an augmentation. This param controls if to apply the augmentation for the batch.
+ p_batch: probability for applying an augmentation to a batch. This param controls the augmentation
+ probabilities batch-wise.
+ same_on_batch: apply the same transformation across the batch.
+ keepdim: whether to keep the output shape the same as input ``True`` or broadcast it
+ to the batch form ``False``.
+ """
+
+ def __init__(self, p: float, p_batch: float, same_on_batch: bool = False, keepdim: bool = False) -> None:
+ super().__init__(p, p_batch=p_batch, same_on_batch=same_on_batch, keepdim=keepdim)
+
+ def __check_batching__(self, input: TensorWithTransformMat):
+ if isinstance(input, tuple):
+ inp, mat = input
+ if len(inp.shape) == 4:
+ if len(mat.shape) != 3:
+ raise AssertionError('Input tensor is in batch mode ' 'but transformation matrix is not')
+ if mat.shape[0] != inp.shape[0]:
+ raise AssertionError(
+ f"In batch dimension, input has {inp.shape[0]} but transformation matrix has {mat.shape[0]}"
+ )
+ elif len(inp.shape) in (2, 3):
+ if len(mat.shape) != 2:
+ raise AssertionError("Input tensor is in non-batch mode but transformation matrix is not")
+ else:
+ raise ValueError(f'Unrecognized output shape. Expected 2, 3, or 4, got {len(inp.shape)}')
+
+ def __unpack_input__( # type: ignore
+ self, input: TensorWithTransformMat
+ ) -> Tuple[torch.Tensor, Optional[torch.Tensor]]:
+ if isinstance(input, tuple):
+ in_tensor = input[0]
+ in_transformation = input[1]
+ return in_tensor, in_transformation
+ in_tensor = input
+ return in_tensor, None
+
+ def transform_tensor(self, input: torch.Tensor) -> torch.Tensor:
+ """Convert any incoming (H, W), (C, H, W) and (B, C, H, W) into (B, C, H, W)."""
+ _validate_input_dtype(input, accepted_dtypes=[torch.float16, torch.float32, torch.float64])
+ return _transform_input(input)
+
+ def apply_transform( # type: ignore
+ self, input: torch.Tensor, label: torch.Tensor, params: Dict[str, torch.Tensor]
+ ) -> Tuple[torch.Tensor, torch.Tensor]:
+ raise NotImplementedError
+
+ def apply_func( # type: ignore
+ self, in_tensor: torch.Tensor, label: torch.Tensor, params: Dict[str, torch.Tensor]
+ ) -> Tuple[torch.Tensor, torch.Tensor]:
+ to_apply = params['batch_prob']
+
+ # if no augmentation needed
+ if torch.sum(to_apply) == 0:
+ output = in_tensor
+ # if all data needs to be augmented
+ elif torch.sum(to_apply) == len(to_apply):
+ output, label = self.apply_transform(in_tensor, label, params)
+ else:
+ raise ValueError(
+ "Mix augmentations must be performed batch-wisely. Element-wise augmentation is not supported."
+ )
+
+ return output, label
+
+ def forward( # type: ignore
+ self,
+ input: TensorWithTransformMat,
+ label: Optional[torch.Tensor] = None,
+ params: Optional[Dict[str, torch.Tensor]] = None,
+ ) -> Tuple[TensorWithTransformMat, torch.Tensor]:
+ in_tensor, in_trans = self.__unpack_input__(input)
+ ori_shape = in_tensor.shape
+ in_tensor = self.transform_tensor(in_tensor)
+ # If label is not provided, it would output the indices instead.
+ if label is None:
+ if isinstance(input, (tuple, list)):
+ device = input[0].device
+ else:
+ device = input.device
+ label = torch.arange(0, in_tensor.size(0), device=device, dtype=torch.long)
+ if params is None:
+ batch_shape = in_tensor.shape
+ params = self.forward_parameters(batch_shape)
+ self._params = params
+
+ output, lab = self.apply_func(in_tensor, label, self._params)
+ output = _transform_output_shape(output, ori_shape) if self.keepdim else output # type: ignore
+ if in_trans is not None:
+ return (output, in_trans), lab
+ return output, lab
diff --git a/kornia/augmentation/container/__init__.py b/kornia/augmentation/container/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e2da07e75f50c0232db1758ba56c0d9db9b0ca3f
--- /dev/null
+++ b/kornia/augmentation/container/__init__.py
@@ -0,0 +1,4 @@
+from .augment import AugmentationSequential
+from .image import ImageSequential
+from .patch import PatchSequential
+from .video import VideoSequential
diff --git a/kornia/augmentation/container/augment.py b/kornia/augmentation/container/augment.py
new file mode 100644
index 0000000000000000000000000000000000000000..ba1a9c0287450aa1a7858a22022b52a0b36d4639
--- /dev/null
+++ b/kornia/augmentation/container/augment.py
@@ -0,0 +1,290 @@
+import warnings
+from itertools import zip_longest
+from typing import cast, List, Optional, Tuple, Union
+
+import torch
+
+from kornia.augmentation.base import (
+ _AugmentationBase,
+ GeometricAugmentationBase2D,
+ IntensityAugmentationBase2D,
+ TensorWithTransformMat,
+)
+from kornia.constants import DataKey
+
+from .base import SequentialBase
+from .image import ImageSequential, ParamItem
+from .patch import PatchSequential
+from .utils import ApplyInverse
+from .video import VideoSequential
+
+__all__ = ["AugmentationSequential"]
+
+
+class AugmentationSequential(ImageSequential):
+ r"""AugmentationSequential for handling multiple input types like inputs, masks, keypoints at once.
+
+ .. image:: https://kornia-tutorials.readthedocs.io/en/latest/_images/data_augmentation_sequential_5_1.png
+ :width: 49 %
+ .. image:: https://kornia-tutorials.readthedocs.io/en/latest/_images/data_augmentation_sequential_7_0.png
+ :width: 49 %
+
+ Args:
+ *args: a list of kornia augmentation modules.
+ data_keys: the input type sequential for applying augmentations.
+ Accepts "input", "mask", "bbox", "bbox_xyxy", "bbox_xywh", "keypoints".
+ same_on_batch: apply the same transformation across the batch.
+ If None, it will not overwrite the function-wise settings.
+ return_transform: if ``True`` return the matrix describing the transformation
+ applied to each. If None, it will not overwrite the function-wise settings.
+ keepdim: whether to keep the output shape the same as input (True) or broadcast it
+ to the batch form (False). If None, it will not overwrite the function-wise settings.
+ random_apply: randomly select a sublist (order agnostic) of args to
+ apply transformation.
+ If int, a fixed number of transformations will be selected.
+ If (a,), x number of transformations (a <= x <= len(args)) will be selected.
+ If (a, b), x number of transformations (a <= x <= b) will be selected.
+ If True, the whole list of args will be processed as a sequence in a random order.
+ If False, the whole list of args will be processed as a sequence in original order.
+
+ .. note::
+ Mix augmentations (e.g. RandomMixUp, RandomCutMix) can only be working with "input" data key.
+ It is not clear how to deal with the conversions of masks, bounding boxes and keypoints.
+
+ .. note::
+ See a working example `here `__.
+
+ Examples:
+ >>> import kornia
+ >>> input = torch.randn(2, 3, 5, 6)
+ >>> bbox = torch.tensor([[
+ ... [1., 1.],
+ ... [2., 1.],
+ ... [2., 2.],
+ ... [1., 2.],
+ ... ]]).expand(2, -1, -1)
+ >>> points = torch.tensor([[[1., 1.]]]).expand(2, -1, -1)
+ >>> aug_list = AugmentationSequential(
+ ... kornia.augmentation.ColorJitter(0.1, 0.1, 0.1, 0.1, p=1.0),
+ ... kornia.augmentation.RandomAffine(360, p=1.0),
+ ... data_keys=["input", "mask", "bbox", "keypoints"],
+ ... return_transform=False,
+ ... same_on_batch=False,
+ ... random_apply=10,
+ ... )
+ >>> out = aug_list(input, input, bbox, points)
+ >>> [o.shape for o in out]
+ [torch.Size([2, 3, 5, 6]), torch.Size([2, 3, 5, 6]), torch.Size([2, 4, 2]), torch.Size([2, 1, 2])]
+ >>> out_inv = aug_list.inverse(*out)
+ >>> [o.shape for o in out_inv]
+ [torch.Size([2, 3, 5, 6]), torch.Size([2, 3, 5, 6]), torch.Size([2, 4, 2]), torch.Size([2, 1, 2])]
+
+ This example demonstrates the integration of VideoSequential and AugmentationSequential.
+
+ Examples:
+ >>> import kornia
+ >>> input = torch.randn(2, 3, 5, 6)[None]
+ >>> bbox = torch.tensor([[
+ ... [1., 1.],
+ ... [2., 1.],
+ ... [2., 2.],
+ ... [1., 2.],
+ ... ]]).expand(2, -1, -1)[None]
+ >>> points = torch.tensor([[[1., 1.]]]).expand(2, -1, -1)[None]
+ >>> aug_list = AugmentationSequential(
+ ... VideoSequential(
+ ... kornia.augmentation.ColorJitter(0.1, 0.1, 0.1, 0.1, p=1.0),
+ ... kornia.augmentation.RandomAffine(360, p=1.0),
+ ... ),
+ ... data_keys=["input", "mask", "bbox", "keypoints"]
+ ... )
+ >>> out = aug_list(input, input, bbox, points)
+ >>> [o.shape for o in out]
+ [torch.Size([1, 2, 3, 5, 6]), torch.Size([1, 2, 3, 5, 6]), torch.Size([1, 2, 4, 2]), torch.Size([1, 2, 1, 2])]
+ """
+
+ def __init__(
+ self,
+ *args: Union[_AugmentationBase, ImageSequential],
+ data_keys: List[Union[str, int, DataKey]] = [DataKey.INPUT],
+ same_on_batch: Optional[bool] = None,
+ return_transform: Optional[bool] = None,
+ keepdim: Optional[bool] = None,
+ random_apply: Union[int, bool, Tuple[int, int]] = False,
+ ) -> None:
+ super().__init__(
+ *args,
+ same_on_batch=same_on_batch,
+ return_transform=return_transform,
+ keepdim=keepdim,
+ random_apply=random_apply,
+ )
+
+ self.data_keys = [DataKey.get(inp) for inp in data_keys]
+
+ if not all(in_type in DataKey for in_type in self.data_keys):
+ raise AssertionError(f"`data_keys` must be in {DataKey}. Got {data_keys}.")
+
+ if self.data_keys[0] != DataKey.INPUT:
+ raise NotImplementedError(f"The first input must be {DataKey.INPUT}.")
+
+ self.contains_video_sequential: bool = False
+ for arg in args:
+ if isinstance(arg, PatchSequential) and not arg.is_intensity_only():
+ warnings.warn("Geometric transformation detected in PatchSeqeuntial, which would break bbox, mask.")
+ if isinstance(arg, VideoSequential):
+ self.contains_video_sequential = True
+
+ def inverse( # type: ignore
+ self,
+ *args: torch.Tensor,
+ params: Optional[List[ParamItem]] = None,
+ data_keys: Optional[List[Union[str, int, DataKey]]] = None,
+ ) -> Union[torch.Tensor, List[torch.Tensor]]:
+ """Reverse the transformation applied.
+
+ Number of input tensors must align with the number of``data_keys``. If ``data_keys`` is not set, use
+ ``self.data_keys`` by default.
+ """
+ if data_keys is None:
+ data_keys = cast(List[Union[str, int, DataKey]], self.data_keys)
+ if len(args) != len(data_keys):
+ raise AssertionError(
+ "The number of inputs must align with the number of data_keys, "
+ f"Got {len(args)} and {len(data_keys)}."
+ )
+ if params is None:
+ if self._params is None:
+ raise ValueError(
+ "No parameters available for inversing, please run a forward pass first "
+ "or passing valid params into this function."
+ )
+ params = self._params
+
+ outputs = []
+ for input, dcate in zip(args, data_keys):
+ if dcate == DataKey.INPUT and isinstance(input, (tuple, list)):
+ input, _ = input # ignore the transformation matrix whilst inverse
+ for (name, module), param in zip_longest(list(self.get_forward_sequence(params))[::-1], params[::-1]):
+ if isinstance(module, (_AugmentationBase, ImageSequential)):
+ param = params[name] if name in params else param
+ else:
+ param = None
+ if isinstance(module, IntensityAugmentationBase2D) and dcate in DataKey:
+ pass # Do nothing
+ elif isinstance(module, ImageSequential) and module.is_intensity_only() and dcate in DataKey:
+ pass # Do nothing
+ elif isinstance(module, VideoSequential) and dcate not in [DataKey.INPUT, DataKey.MASK]:
+ batch_size: int = input.size(0)
+ input = input.view(-1, *input.shape[2:])
+ input = ApplyInverse.inverse_by_key(input, module, param, dcate)
+ input = input.view(batch_size, -1, *input.shape[1:])
+ elif isinstance(module, PatchSequential):
+ raise NotImplementedError("Geometric involved PatchSequential is not supported.")
+ elif isinstance(module, (GeometricAugmentationBase2D, ImageSequential)) and dcate in DataKey:
+ input = ApplyInverse.inverse_by_key(input, module, param, dcate)
+ elif isinstance(module, (SequentialBase,)):
+ raise ValueError(f"Unsupported Sequential {module}.")
+ else:
+ raise NotImplementedError(f"data_key {dcate} is not implemented for {module}.")
+ outputs.append(input)
+
+ if len(outputs) == 1 and isinstance(outputs, (tuple, list)):
+ return outputs[0]
+
+ return outputs
+
+ def __packup_output__( # type: ignore
+ self, output: List[TensorWithTransformMat], label: Optional[torch.Tensor] = None
+ ) -> Union[
+ TensorWithTransformMat,
+ Tuple[TensorWithTransformMat, Optional[torch.Tensor]],
+ List[TensorWithTransformMat],
+ Tuple[List[TensorWithTransformMat], Optional[torch.Tensor]],
+ ]:
+ if len(output) == 1 and isinstance(output, (tuple, list)) and self.return_label:
+ return output[0], label
+ if len(output) == 1 and isinstance(output, (tuple, list)):
+ return output[0]
+ if self.return_label:
+ return output, label
+ return output
+
+ def forward( # type: ignore
+ self,
+ *args: TensorWithTransformMat,
+ label: Optional[torch.Tensor] = None,
+ params: Optional[List[ParamItem]] = None,
+ data_keys: Optional[List[Union[str, int, DataKey]]] = None,
+ ) -> Union[
+ TensorWithTransformMat,
+ Tuple[TensorWithTransformMat, Optional[torch.Tensor]],
+ List[TensorWithTransformMat],
+ Tuple[List[TensorWithTransformMat], Optional[torch.Tensor]],
+ ]:
+ """Compute multiple tensors simultaneously according to ``self.data_keys``."""
+ if data_keys is None:
+ data_keys = cast(List[Union[str, int, DataKey]], self.data_keys)
+ else:
+ data_keys = [DataKey.get(inp) for inp in data_keys]
+
+ if len(args) != len(data_keys):
+ raise AssertionError(
+ f"The number of inputs must align with the number of data_keys. Got {len(args)} and {len(data_keys)}."
+ )
+
+ if params is None:
+ if DataKey.INPUT in data_keys:
+ _input = args[data_keys.index(DataKey.INPUT)]
+ if isinstance(_input, (tuple, list)):
+ inp = _input[0]
+ else:
+ inp = _input
+ if self.contains_video_sequential:
+ _, out_shape = self.autofill_dim(inp, dim_range=(3, 5))
+ else:
+ _, out_shape = self.autofill_dim(inp, dim_range=(2, 4))
+ params = self.forward_parameters(out_shape)
+ else:
+ raise ValueError("`params` must be provided whilst INPUT is not in data_keys.")
+
+ outputs: List[TensorWithTransformMat] = [None] * len(data_keys) # type: ignore
+ if DataKey.INPUT in data_keys:
+ idx = data_keys.index(DataKey.INPUT)
+ out = super().forward(args[idx], label, params=params)
+ if self.return_label:
+ input, label = cast(Tuple[TensorWithTransformMat, torch.Tensor], out)
+ else:
+ input = cast(TensorWithTransformMat, out)
+ outputs[idx] = input
+
+ self.return_label = label is not None or self.contains_label_operations(params)
+
+ for idx, (input, dcate, out) in enumerate(zip(args, data_keys, outputs)):
+ if out is not None:
+ continue
+ for param in params:
+ module = self.get_submodule(param.name)
+ if dcate == DataKey.INPUT:
+ input, label = self.apply_to_input(input, label, module=module, param=param)
+ elif isinstance(module, IntensityAugmentationBase2D) and dcate in DataKey:
+ pass # Do nothing
+ elif isinstance(module, ImageSequential) and module.is_intensity_only() and dcate in DataKey:
+ pass # Do nothing
+ elif isinstance(module, VideoSequential) and dcate not in [DataKey.INPUT, DataKey.MASK]:
+ batch_size: int = input.size(0)
+ input = input.view(-1, *input.shape[2:])
+ input, label = ApplyInverse.apply_by_key(input, label, module, param, dcate)
+ input = input.view(batch_size, -1, *input.shape[1:])
+ elif isinstance(module, PatchSequential):
+ raise NotImplementedError("Geometric involved PatchSequential is not supported.")
+ elif isinstance(module, (GeometricAugmentationBase2D, ImageSequential,)) and dcate in DataKey:
+ input, label = ApplyInverse.apply_by_key(input, label, module, param, dcate)
+ elif isinstance(module, (SequentialBase,)):
+ raise ValueError(f"Unsupported Sequential {module}.")
+ else:
+ raise NotImplementedError(f"data_key {dcate} is not implemented for {module}.")
+ outputs[idx] = input
+
+ return self.__packup_output__(outputs, label)
diff --git a/kornia/augmentation/container/base.py b/kornia/augmentation/container/base.py
new file mode 100644
index 0000000000000000000000000000000000000000..8c5c9e32d5963b1a3d0a4383c3bf601b95fc4e34
--- /dev/null
+++ b/kornia/augmentation/container/base.py
@@ -0,0 +1,176 @@
+from collections import OrderedDict
+from typing import Any, Iterator, List, NamedTuple, Optional, Tuple, Union
+
+import torch
+import torch.nn as nn
+
+from kornia.augmentation.base import _AugmentationBase, MixAugmentationBase
+
+__all__ = ["SequentialBase", "ParamItem"]
+
+
+class ParamItem(NamedTuple):
+ name: str
+ data: Optional[Union[dict, list]]
+
+
+class SequentialBase(nn.Sequential):
+ r"""SequentialBase for creating kornia modulized processing pipeline.
+
+ Args:
+ *args : a list of kornia augmentation and image operation modules.
+ same_on_batch: apply the same transformation across the batch.
+ If None, it will not overwrite the function-wise settings.
+ return_transform: if ``True`` return the matrix describing the transformation
+ applied to each. If None, it will not overwrite the function-wise settings.
+ keepdim: whether to keep the output shape the same as input (True) or broadcast it
+ to the batch form (False). If None, it will not overwrite the function-wise settings.
+ """
+
+ def __init__(
+ self,
+ *args: nn.Module,
+ same_on_batch: Optional[bool] = None,
+ return_transform: Optional[bool] = None,
+ keepdim: Optional[bool] = None,
+ ) -> None:
+ # To name the modules properly
+ _args = OrderedDict()
+ for idx, mod in enumerate(args):
+ if not isinstance(mod, nn.Module):
+ raise NotImplementedError(f"Only nn.Module are supported at this moment. Got {mod}.")
+ _args.update({f"{mod.__class__.__name__}_{idx}": mod})
+ super().__init__(_args)
+ self._same_on_batch = same_on_batch
+ self._return_transform = return_transform
+ self._keepdim = keepdim
+ self._params: Optional[List[ParamItem]] = None
+ self.update_attribute(same_on_batch, return_transform, keepdim)
+
+ def update_attribute(
+ self,
+ same_on_batch: Optional[bool] = None,
+ return_transform: Optional[bool] = None,
+ keepdim: Optional[bool] = None,
+ ) -> None:
+ for mod in self.children():
+ # MixAugmentation does not have return transform
+ if isinstance(mod, (_AugmentationBase, MixAugmentationBase)):
+ if same_on_batch is not None:
+ mod.same_on_batch = same_on_batch
+ if keepdim is not None:
+ mod.keepdim = keepdim
+ if isinstance(mod, _AugmentationBase):
+ if return_transform is not None:
+ mod.return_transform = return_transform
+ if isinstance(mod, SequentialBase):
+ mod.update_attribute(same_on_batch, return_transform, keepdim)
+
+ def get_submodule(self, target: str) -> nn.Module:
+ """Get submodule.
+
+ This code is taken from torch 1.9.0 since it is not introduced
+ back to torch 1.7.1. We included this for maintaining more
+ backward torch versions.
+
+ Args:
+ target: The fully-qualified string name of the submodule
+ to look for. (See above example for how to specify a
+ fully-qualified string.)
+
+ Returns:
+ torch.nn.Module: The submodule referenced by ``target``
+
+ Raises:
+ AttributeError: If the target string references an invalid
+ path or resolves to something that is not an
+ ``nn.Module``
+ """
+ if target == "":
+ return self
+
+ atoms: List[str] = target.split(".")
+ mod: torch.nn.Module = self
+
+ for item in atoms:
+
+ if not hasattr(mod, item):
+ raise AttributeError(mod._get_name() + " has no " "attribute `" + item + "`")
+
+ mod = getattr(mod, item)
+
+ if not isinstance(mod, torch.nn.Module):
+ raise AttributeError("`" + item + "` is not " "an nn.Module")
+
+ return mod
+
+ @property
+ def same_on_batch(self) -> Optional[bool]:
+ return self._same_on_batch
+
+ @same_on_batch.setter
+ def same_on_batch(self, same_on_batch: Optional[bool]) -> None:
+ self._same_on_batch = same_on_batch
+ self.update_attribute(same_on_batch=same_on_batch)
+
+ @property
+ def return_transform(self) -> Optional[bool]:
+ return self._return_transform
+
+ @return_transform.setter
+ def return_transform(self, return_transform: Optional[bool]) -> None:
+ self._return_transform = return_transform
+ self.update_attribute(return_transform=return_transform)
+
+ @property
+ def keepdim(self) -> Optional[bool]:
+ return self._keepdim
+
+ @keepdim.setter
+ def keepdim(self, keepdim: Optional[bool]) -> None:
+ self._keepdim = keepdim
+ self.update_attribute(keepdim=keepdim)
+
+ def clear_state(self) -> None:
+ self._params = None
+
+ def update_params(self, param: Any) -> None:
+ if self._params is None:
+ self._params = [param]
+ else:
+ self._params.append(param)
+
+ # TODO: Implement this for all submodules.
+ def forward_parameters(self, batch_shape: torch.Size) -> List[ParamItem]:
+ raise NotImplementedError
+
+ def get_children_by_indices(self, indices: torch.Tensor) -> Iterator[Tuple[str, nn.Module]]:
+ modules = list(self.named_children())
+ for idx in indices:
+ yield modules[idx]
+
+ def get_children_by_params(self, params: List[ParamItem]) -> Iterator[Tuple[str, nn.Module]]:
+ modules = list(self.named_children())
+ # TODO: Wrong params passed here when nested ImageSequential
+ for param in params:
+ yield modules[list(dict(self.named_children()).keys()).index(param.name)]
+
+ def get_params_by_module(self, named_modules: Iterator[Tuple[str, nn.Module]]) -> Iterator[ParamItem]:
+ # This will not take module._params
+ for name, _ in named_modules:
+ yield ParamItem(name, None)
+
+ def contains_label_operations(self, params: List) -> bool:
+ raise NotImplementedError
+
+ def autofill_dim(self, input: torch.Tensor, dim_range: Tuple[int, int] = (2, 4)) -> Tuple[torch.Size, torch.Size]:
+ """Fill tensor dim to the upper bound of dim_range.
+
+ If input tensor dim is smaller than the lower bound of dim_range, an error will be thrown out.
+ """
+ ori_shape = input.shape
+ if len(ori_shape) < dim_range[0] or len(ori_shape) > dim_range[1]:
+ raise RuntimeError(f"input shape expected to be in {dim_range} while got {ori_shape}.")
+ while len(input.shape) < dim_range[1]:
+ input = input[None]
+ return ori_shape, input.shape
diff --git a/kornia/augmentation/container/image.py b/kornia/augmentation/container/image.py
new file mode 100644
index 0000000000000000000000000000000000000000..97b42a277e5ec2f16cc232e3819d1d923b2a1db3
--- /dev/null
+++ b/kornia/augmentation/container/image.py
@@ -0,0 +1,323 @@
+from itertools import zip_longest
+from typing import Iterator, List, Optional, Tuple, Type, Union
+
+import torch
+import torch.nn as nn
+
+import kornia
+from kornia.augmentation.base import (
+ _AugmentationBase,
+ GeometricAugmentationBase2D,
+ IntensityAugmentationBase2D,
+ MixAugmentationBase,
+ TensorWithTransformMat,
+)
+
+from .base import ParamItem, SequentialBase
+from .utils import ApplyInverseInterface, InputApplyInverse
+
+__all__ = ["ImageSequential"]
+
+
+class ImageSequential(SequentialBase):
+ r"""Sequential for creating kornia image processing pipeline.
+
+ Args:
+ *args : a list of kornia augmentation and image operation modules.
+ same_on_batch: apply the same transformation across the batch.
+ If None, it will not overwrite the function-wise settings.
+ return_transform: if ``True`` return the matrix describing the transformation
+ applied to each. If None, it will not overwrite the function-wise settings.
+ keepdim: whether to keep the output shape the same as input (True) or broadcast it
+ to the batch form (False). If None, it will not overwrite the function-wise settings.
+ random_apply: randomly select a sublist (order agnostic) of args to
+ apply transformation.
+ If int, a fixed number of transformations will be selected.
+ If (a,), x number of transformations (a <= x <= len(args)) will be selected.
+ If (a, b), x number of transformations (a <= x <= b) will be selected.
+ If True, the whole list of args will be processed as a sequence in a random order.
+ If False, the whole list of args will be processed as a sequence in original order.
+
+ .. note::
+ Transformation matrix returned only considers the transformation applied in ``kornia.augmentation`` module.
+ Those transformations in ``kornia.geometry`` will not be taken into account.
+
+ Examples:
+ >>> _ = torch.manual_seed(77)
+ >>> import kornia
+ >>> input, label = torch.randn(2, 3, 5, 6), torch.tensor([0, 1])
+ >>> aug_list = ImageSequential(
+ ... kornia.color.BgrToRgb(),
+ ... kornia.augmentation.ColorJitter(0.1, 0.1, 0.1, 0.1, p=1.0),
+ ... kornia.filters.MedianBlur((3, 3)),
+ ... kornia.augmentation.RandomAffine(360, p=1.0),
+ ... kornia.enhance.Invert(),
+ ... kornia.augmentation.RandomMixUp(p=1.0),
+ ... return_transform=True,
+ ... same_on_batch=True,
+ ... random_apply=10,
+ ... )
+ >>> out, lab = aug_list(input, label=label)
+ >>> lab
+ tensor([[0.0000, 1.0000, 0.1214],
+ [1.0000, 0.0000, 0.1214]])
+ >>> out[0].shape, out[1].shape
+ (torch.Size([2, 3, 5, 6]), torch.Size([2, 3, 3]))
+
+ Reproduce with provided params.
+ >>> out2, lab2 = aug_list(input, label=label, params=aug_list._params)
+ >>> torch.equal(out[0], out2[0]), torch.equal(out[1], out2[1]), torch.equal(lab[1], lab2[1])
+ (True, True, True)
+ """
+
+ def __init__(
+ self,
+ *args: nn.Module,
+ same_on_batch: Optional[bool] = None,
+ return_transform: Optional[bool] = None,
+ keepdim: Optional[bool] = None,
+ random_apply: Union[int, bool, Tuple[int, int]] = False,
+ if_unsupported_ops: str = 'raise'
+ ) -> None:
+ super().__init__(*args, same_on_batch=same_on_batch, return_transform=return_transform, keepdim=keepdim)
+
+ self.random_apply: Union[Tuple[int, int], bool] = self._read_random_apply(random_apply, len(args))
+ self.return_label: Optional[bool] = None
+ self.apply_inverse_func: Type[ApplyInverseInterface] = InputApplyInverse
+ self.if_unsupported_ops = if_unsupported_ops
+
+ def _read_random_apply(
+ self, random_apply: Union[int, bool, Tuple[int, int]], max_length: int
+ ) -> Union[Tuple[int, int], bool]:
+ """Process the scenarios for random apply."""
+ if isinstance(random_apply, (bool,)) and random_apply is False:
+ random_apply = False
+ elif isinstance(random_apply, (bool,)) and random_apply is True:
+ random_apply = (max_length, max_length + 1)
+ elif isinstance(random_apply, (int,)):
+ random_apply = (random_apply, random_apply + 1)
+ elif (
+ isinstance(random_apply, (tuple,))
+ and len(random_apply) == 2
+ and isinstance(random_apply[0], (int,))
+ and isinstance(random_apply[1], (int,))
+ ):
+ random_apply = (random_apply[0], random_apply[1] + 1)
+ elif isinstance(random_apply, (tuple,)) and len(random_apply) == 1 and isinstance(random_apply[0], (int,)):
+ random_apply = (random_apply[0], max_length + 1)
+ else:
+ raise ValueError(f"Non-readable random_apply. Got {random_apply}.")
+ if random_apply is not False and not (
+ isinstance(random_apply, (tuple,))
+ and len(random_apply) == 2
+ and isinstance(random_apply[0], (int,))
+ and isinstance(random_apply[0], (int,))
+ ):
+ raise AssertionError(f"Expect a tuple of (int, int). Got {random_apply}.")
+ return random_apply
+
+ def get_random_forward_sequence(self, with_mix: bool = True) -> Tuple[Iterator[Tuple[str, nn.Module]], bool]:
+ """Get a forward sequence when random apply is in need.
+
+ Note:
+ Mix augmentations (e.g. RandomMixUp) will be only applied once even in a random forward.
+ """
+ num_samples = int(torch.randint(*self.random_apply, (1,)).item()) # type: ignore
+ multinomial_weights = torch.ones((len(self),))
+ # Mix augmentation can only be applied once per forward
+ mix_indices = self.get_mix_augmentation_indices(self.named_children())
+ # kick out the mix augmentations
+ multinomial_weights[mix_indices] = 0
+ indices = torch.multinomial(
+ multinomial_weights,
+ num_samples,
+ # enable replacement if non-mix augmentation is less than required
+ replacement=num_samples > multinomial_weights.sum().item(),
+ )
+
+ mix_added = False
+ if with_mix and len(mix_indices) != 0:
+ # Make the selection fair.
+ if (torch.rand(1) < ((len(mix_indices) + len(indices)) / len(self))).item():
+ indices[-1] = torch.multinomial((~multinomial_weights.bool()).float(), 1)
+ indices = indices[torch.randperm(len(indices))]
+ mix_added = True
+
+ return self.get_children_by_indices(indices), mix_added
+
+ def get_mix_augmentation_indices(self, named_modules: Iterator[Tuple[str, nn.Module]]) -> List[int]:
+ """Get all the mix augmentations since they are label-involved.
+
+ Special operations needed for label-involved augmentations.
+ """
+ indices = []
+ for idx, (_, child) in enumerate(named_modules):
+ if isinstance(child, (MixAugmentationBase,)):
+ indices.append(idx)
+ return indices
+
+ def get_forward_sequence(self, params: Optional[List[ParamItem]] = None) -> Iterator[Tuple[str, nn.Module]]:
+ if params is None:
+ # Mix augmentation can only be applied once per forward
+ mix_indices = self.get_mix_augmentation_indices(self.named_children())
+
+ if self.random_apply:
+ return self.get_random_forward_sequence()[0]
+
+ if len(mix_indices) > 1:
+ raise ValueError(
+ "Multiple mix augmentation is prohibited without enabling random_apply."
+ f"Detected {len(mix_indices)}."
+ )
+
+ return self.named_children()
+
+ return self.get_children_by_params(params)
+
+ def apply_to_input(
+ self,
+ input: TensorWithTransformMat,
+ label: Optional[torch.Tensor],
+ module: Optional[nn.Module],
+ param: ParamItem,
+ ) -> Tuple[TensorWithTransformMat, Optional[torch.Tensor]]:
+ if module is None:
+ module = self.get_submodule(param.name)
+ return self.apply_inverse_func.apply_trans(input, label, module, param) # type: ignore
+
+ def forward_parameters(self, batch_shape: torch.Size) -> List[ParamItem]:
+ named_modules: Iterator[Tuple[str, nn.Module]] = self.get_forward_sequence()
+
+ params: List[ParamItem] = []
+ mod_param: Union[dict, list]
+ for name, module in named_modules:
+ if isinstance(module, (_AugmentationBase, MixAugmentationBase)):
+ mod_param = module.forward_parameters(batch_shape)
+ param = ParamItem(name, mod_param)
+ elif isinstance(module, ImageSequential):
+ mod_param = module.forward_parameters(batch_shape)
+ param = ParamItem(name, mod_param)
+ else:
+ param = ParamItem(name, None)
+ params.append(param)
+ return params
+
+ def contains_label_operations(self, params: List[ParamItem]) -> bool:
+ """Check if current sequential contains label-involved operations like MixUp."""
+ for param in params:
+ if param.name.startswith("RandomMixUp") or param.name.startswith("RandomCutMix"):
+ return True
+ return False
+
+ def __packup_output__(
+ self, output: TensorWithTransformMat, label: Optional[torch.Tensor] = None
+ ) -> Union[TensorWithTransformMat, Tuple[TensorWithTransformMat, torch.Tensor]]:
+ if self.return_label:
+ return output, label # type: ignore
+ # Implicitly indicating the label cannot be optional since there is a mix aug
+ return output
+
+ def get_transformation_matrix(
+ self, input: torch.Tensor, params: Optional[List[ParamItem]] = None,
+ ) -> torch.Tensor:
+ """Compute the transformation matrix according to the provided parameters."""
+ if params is None:
+ raise NotImplementedError("requires params to be provided.")
+ named_modules: Iterator[Tuple[str, nn.Module]] = self.get_forward_sequence(params)
+
+ res_mat: torch.Tensor = kornia.eye_like(3, input)
+ for (_, module), param in zip(named_modules, params):
+ if isinstance(module, (_AugmentationBase, MixAugmentationBase)):
+ mat = module.compute_transformation(input, param.data) # type: ignore
+ res_mat = mat @ res_mat
+ elif isinstance(module, (ImageSequential,)):
+ mat = module.get_transformation_matrix(input, param.data) # type: ignore
+ res_mat = mat @ res_mat
+ return res_mat
+
+ def is_intensity_only(self, strict: bool = True) -> bool:
+ """Check if all transformations are intensity-based.
+
+ Args:
+ strict: if strict is False, it will allow non-augmentation nn.Modules to be passed.
+ e.g. `kornia.enhance.AdjustBrightness` will be recognized as non-intensity module
+ if strict is set to True.
+
+ Note: patch processing would break the continuity of labels (e.g. bbounding boxes, masks).
+ """
+ for arg in self.children():
+ if isinstance(arg, (ImageSequential,)) and not arg.is_intensity_only(strict):
+ return False
+ elif isinstance(arg, (ImageSequential,)):
+ pass
+ elif isinstance(arg, IntensityAugmentationBase2D):
+ pass
+ elif strict:
+ # disallow non-registered ops if in strict mode
+ # TODO: add an ops register module
+ return False
+ return True
+
+ def inverse(
+ self,
+ input: torch.Tensor,
+ params: Optional[List[ParamItem]] = None,
+ ) -> torch.Tensor:
+ """Inverse transformation.
+
+ Used to inverse a tensor according to the performed transformation by a forward pass, or with respect to
+ provided parameters.
+ """
+ if params is None:
+ if self._params is None:
+ raise ValueError(
+ "No parameters available for inversing, please run a forward pass first "
+ "or passing valid params into this function."
+ )
+ params = self._params
+
+ for (name, module), param in zip_longest(list(self.get_forward_sequence(params))[::-1], params[::-1]):
+ if isinstance(module, (_AugmentationBase, ImageSequential)):
+ param = params[name] if name in params else param
+ else:
+ param = None
+
+ if isinstance(module, IntensityAugmentationBase2D):
+ pass # Do nothing
+ elif isinstance(module, ImageSequential) and module.is_intensity_only():
+ pass # Do nothing
+ elif isinstance(module, ImageSequential):
+ input = module.inverse(input, param.data)
+ elif isinstance(module, (GeometricAugmentationBase2D,)):
+ input = self.apply_inverse_func.inverse(input, module, param)
+ else:
+ pass
+ # raise NotImplementedError(f"`inverse` is not implemented for {module}.")
+
+ return input
+
+ def forward( # type: ignore
+ self,
+ input: TensorWithTransformMat,
+ label: Optional[torch.Tensor] = None,
+ params: Optional[List[ParamItem]] = None,
+ ) -> Union[TensorWithTransformMat, Tuple[TensorWithTransformMat, torch.Tensor]]:
+ self.clear_state()
+ if params is None:
+ if isinstance(input, (tuple, list)):
+ inp = input[0]
+ else:
+ inp = input
+ _, out_shape = self.autofill_dim(inp, dim_range=(2, 4))
+ params = self.forward_parameters(out_shape)
+ if self.return_label is None:
+ self.return_label = label is not None or self.contains_label_operations(params)
+ for param in params:
+ module = self.get_submodule(param.name)
+ input, label = self.apply_to_input(input, label, module, param=param) # type: ignore
+ if isinstance(module, (_AugmentationBase, MixAugmentationBase, SequentialBase)):
+ param = ParamItem(param.name, module._params)
+ else:
+ param = ParamItem(param.name, None)
+ self.update_params(param)
+ return self.__packup_output__(input, label)
diff --git a/kornia/augmentation/container/patch.py b/kornia/augmentation/container/patch.py
new file mode 100644
index 0000000000000000000000000000000000000000..c04171fefe2de5bce98462b5e351545bfff87994
--- /dev/null
+++ b/kornia/augmentation/container/patch.py
@@ -0,0 +1,401 @@
+from itertools import cycle, islice
+from typing import Iterator, List, NamedTuple, Optional, Tuple, Union
+
+import torch
+import torch.nn as nn
+
+from kornia.augmentation.base import _AugmentationBase, MixAugmentationBase, TensorWithTransformMat
+from kornia.augmentation.container.base import SequentialBase
+from kornia.contrib.extract_patches import extract_tensor_patches
+
+from .image import ImageSequential, ParamItem
+
+__all__ = ["PatchSequential"]
+
+
+class PatchParamItem(NamedTuple):
+ indices: List[int]
+ param: ParamItem
+
+
+class PatchSequential(ImageSequential):
+ r"""Container for performing patch-level image data augmentation.
+
+ .. image:: https://kornia-tutorials.readthedocs.io/en/latest/_images/data_patch_sequential_7_0.png
+
+ PatchSequential breaks input images into patches by a given grid size, which will be resembled back
+ afterwards.
+
+ Different image processing and augmentation methods will be performed on each patch region as
+ in :cite:`lin2021patch`.
+
+ Args:
+ *args: a list of processing modules.
+ grid_size: controls the grid board separation.
+ padding: same or valid padding. If same padding, it will pad to include all pixels if the input
+ tensor cannot be divisible by grid_size. If valid padding, the redundant border will be removed.
+ same_on_batch: apply the same transformation across the batch.
+ If None, it will not overwrite the function-wise settings.
+ keepdim: whether to keep the output shape the same as input (True) or broadcast it
+ to the batch form (False). If None, it will not overwrite the function-wise settings.
+ patchwise_apply: apply image processing args will be applied patch-wisely.
+ if ``True``, the number of args must be equal to grid number.
+ if ``False``, the image processing args will be applied as a sequence to all patches.
+ random_apply: randomly select a sublist (order agnostic) of args to
+ apply transformation.
+ If ``int`` (batchwise mode only), a fixed number of transformations will be selected.
+ If ``(a,)`` (batchwise mode only), x number of transformations (a <= x <= len(args)) will be selected.
+ If ``(a, b)`` (batchwise mode only), x number of transformations (a <= x <= b) will be selected.
+ If ``True``, the whole list of args will be processed in a random order.
+ If ``False`` and not ``patchwise_apply``, the whole list of args will be processed in original order.
+ If ``False`` and ``patchwise_apply``, the whole list of args will be processed in original order
+ location-wisely.
+
+ .. note::
+ Transformation matrix returned only considers the transformation applied in ``kornia.augmentation`` module.
+ Those transformations in ``kornia.geometry`` will not be taken into account.
+
+ .. note::
+ See a working example `here `__.
+
+ Examples:
+ >>> import kornia.augmentation as K
+ >>> input = torch.randn(2, 3, 224, 224)
+ >>> seq = PatchSequential(
+ ... ImageSequential(
+ ... K.ColorJitter(0.1, 0.1, 0.1, 0.1, p=0.5),
+ ... K.RandomPerspective(0.2, p=0.5),
+ ... K.RandomSolarize(0.1, 0.1, p=0.5),
+ ... ),
+ ... K.RandomAffine(360, p=1.0),
+ ... ImageSequential(
+ ... K.ColorJitter(0.1, 0.1, 0.1, 0.1, p=0.5),
+ ... K.RandomPerspective(0.2, p=0.5),
+ ... K.RandomSolarize(0.1, 0.1, p=0.5),
+ ... ),
+ ... K.RandomSolarize(0.1, 0.1, p=0.1),
+ ... grid_size=(2,2),
+ ... patchwise_apply=True,
+ ... same_on_batch=True,
+ ... random_apply=False,
+ ... )
+ >>> out = seq(input)
+ >>> out.shape
+ torch.Size([2, 3, 224, 224])
+ >>> out1 = seq(input, params=seq._params)
+ >>> torch.equal(out, out1)
+ True
+ """
+
+ def __init__(
+ self,
+ *args: nn.Module,
+ grid_size: Tuple[int, int] = (4, 4),
+ padding: str = "same",
+ same_on_batch: Optional[bool] = None,
+ keepdim: Optional[bool] = None,
+ patchwise_apply: bool = True,
+ random_apply: Union[int, bool, Tuple[int, int]] = False,
+ ) -> None:
+ _random_apply: Optional[Union[int, Tuple[int, int]]]
+
+ if patchwise_apply and random_apply is True:
+ # will only apply [1, 4] augmentations per patch
+ _random_apply = (1, 4)
+ elif patchwise_apply and random_apply is False:
+ if len(args) != grid_size[0] * grid_size[1]:
+ raise ValueError(
+ "The number of processing modules must be equal with grid size."
+ f"Got {len(args)} and {grid_size[0] * grid_size[1]}. "
+ "Please set random_apply = True or patchwise_apply = False."
+ )
+ _random_apply = random_apply
+ elif patchwise_apply and isinstance(random_apply, (int, tuple)):
+ raise ValueError(f"Only boolean value allowed when `patchwise_apply` is set to True. Got {random_apply}.")
+ else:
+ _random_apply = random_apply
+ super().__init__(
+ *args, same_on_batch=same_on_batch, return_transform=False, keepdim=keepdim, random_apply=_random_apply
+ )
+ if padding not in ("same", "valid"):
+ raise ValueError(f"`padding` must be either `same` or `valid`. Got {padding}.")
+ self.grid_size = grid_size
+ self.padding = padding
+ self.patchwise_apply = patchwise_apply
+
+ def contains_label_operations(self, params: List[PatchParamItem]) -> bool: # type: ignore
+ for param in params:
+ if param.param.name.startswith("RandomMixUp") or param.param.name.startswith("RandomCutMix"):
+ return True
+ return False
+
+ def compute_padding(
+ self, input: torch.Tensor, padding: str, grid_size: Optional[Tuple[int, int]] = None
+ ) -> Tuple[int, int, int, int]:
+ if grid_size is None:
+ grid_size = self.grid_size
+ if padding == "valid":
+ ph, pw = input.size(-2) // grid_size[0], input.size(-1) // grid_size[1]
+ return (-pw // 2, pw // 2 - pw, -ph // 2, ph // 2 - ph)
+ if padding == 'same':
+ ph = input.size(-2) - input.size(-2) // grid_size[0] * grid_size[0]
+ pw = input.size(-1) - input.size(-1) // grid_size[1] * grid_size[1]
+ return (pw // 2, pw - pw // 2, ph // 2, ph - ph // 2)
+ raise NotImplementedError(f"Expect `padding` as either 'valid' or 'same'. Got {padding}.")
+
+ def extract_patches(
+ self,
+ input: torch.Tensor,
+ grid_size: Optional[Tuple[int, int]] = None,
+ pad: Optional[Tuple[int, int, int, int]] = None,
+ ) -> torch.Tensor:
+ """Extract patches from tensor.
+
+ Example:
+ >>> import kornia.augmentation as K
+ >>> pas = PatchSequential(K.ColorJitter(0.1, 0.1, 0.1, 0.1, p=1.0), patchwise_apply=False)
+ >>> pas.extract_patches(torch.arange(16).view(1, 1, 4, 4), grid_size=(2, 2))
+ tensor([[[[[ 0, 1],
+ [ 4, 5]]],
+
+
+ [[[ 2, 3],
+ [ 6, 7]]],
+
+
+ [[[ 8, 9],
+ [12, 13]]],
+
+
+ [[[10, 11],
+ [14, 15]]]]])
+ >>> pas.extract_patches(torch.arange(54).view(1, 1, 6, 9), grid_size=(2, 2), pad=(-1, -1, -2, -2))
+ tensor([[[[[19, 20, 21]]],
+
+
+ [[[22, 23, 24]]],
+
+
+ [[[28, 29, 30]]],
+
+
+ [[[31, 32, 33]]]]])
+ """
+ if pad is not None:
+ input = torch.nn.functional.pad(input, list(pad))
+ if grid_size is None:
+ grid_size = self.grid_size
+ window_size = (input.size(-2) // grid_size[-2], input.size(-1) // grid_size[-1])
+ stride = window_size
+ return extract_tensor_patches(input, window_size, stride)
+
+ def restore_from_patches(
+ self,
+ patches: torch.Tensor,
+ grid_size: Tuple[int, int] = (4, 4),
+ pad: Optional[Tuple[int, int, int, int]] = None,
+ ) -> torch.Tensor:
+ """Restore input from patches.
+
+ Example:
+ >>> import kornia.augmentation as K
+ >>> pas = PatchSequential(K.ColorJitter(0.1, 0.1, 0.1, 0.1, p=1.0), patchwise_apply=False)
+ >>> out = pas.extract_patches(torch.arange(16).view(1, 1, 4, 4), grid_size=(2, 2))
+ >>> pas.restore_from_patches(out, grid_size=(2, 2))
+ tensor([[[[ 0, 1, 2, 3],
+ [ 4, 5, 6, 7],
+ [ 8, 9, 10, 11],
+ [12, 13, 14, 15]]]])
+ """
+ if grid_size is None:
+ grid_size = self.grid_size
+ patches_tensor = patches.view(-1, grid_size[0], grid_size[1], *patches.shape[-3:])
+ restored_tensor = torch.cat(torch.chunk(patches_tensor, grid_size[0], dim=1), -2).squeeze(1)
+ restored_tensor = torch.cat(torch.chunk(restored_tensor, grid_size[1], dim=1), -1).squeeze(1)
+
+ if pad is not None:
+ restored_tensor = torch.nn.functional.pad(restored_tensor, [-i for i in pad])
+ return restored_tensor
+
+ def forward_parameters(self, batch_shape: torch.Size) -> List[PatchParamItem]: # type: ignore
+ out_param: List[PatchParamItem] = []
+ if not self.patchwise_apply:
+ params = self.generate_parameters(torch.Size([1, batch_shape[0] * batch_shape[1], *batch_shape[2:]]))
+ indices = torch.arange(0, batch_shape[0] * batch_shape[1])
+ [out_param.append(PatchParamItem(indices.tolist(), p)) for p, _ in params] # type: ignore
+ # "append" of "list" does not return a value
+ elif not self.same_on_batch:
+ params = self.generate_parameters(torch.Size([batch_shape[0] * batch_shape[1], 1, *batch_shape[2:]]))
+ [out_param.append(PatchParamItem([i], p)) for p, i in params] # type: ignore
+ # "append" of "list" does not return a value
+ else:
+ params = self.generate_parameters(torch.Size([batch_shape[1], batch_shape[0], *batch_shape[2:]]))
+ indices = torch.arange(0, batch_shape[0] * batch_shape[1], step=batch_shape[1])
+ [out_param.append(PatchParamItem((indices + i).tolist(), p)) for p, i in params] # type: ignore
+ # "append" of "list" does not return a value
+ return out_param
+
+ def generate_parameters(self, batch_shape: torch.Size) -> Iterator[Tuple[ParamItem, int]]:
+ """Get multiple forward sequence but maximumly one mix augmentation in between.
+
+ Args:
+ batch_shape: 5-dim shape arranged as :math:``(N, B, C, H, W)``, in which N represents
+ the number of sequence.
+ """
+ if not self.same_on_batch and self.random_apply:
+ # diff_on_batch and random_apply => patch-wise augmentation
+ with_mix = False
+ for i in range(batch_shape[0]):
+ seq, mix_added = self.get_random_forward_sequence(with_mix=with_mix)
+ with_mix = mix_added
+ for s in seq:
+ if isinstance(s[1], (_AugmentationBase, MixAugmentationBase, SequentialBase)):
+ yield ParamItem(s[0], s[1].forward_parameters(torch.Size(batch_shape[1:]))), i
+ else:
+ yield ParamItem(s[0], None), i
+ elif not self.same_on_batch and not self.random_apply:
+ for i, nchild in enumerate(self.named_children()):
+ if isinstance(nchild[1], (_AugmentationBase, MixAugmentationBase, SequentialBase)):
+ yield ParamItem(nchild[0], nchild[1].forward_parameters(torch.Size(batch_shape[1:]))), i
+ else:
+ yield ParamItem(nchild[0], None), i
+ elif not self.random_apply:
+ # same_on_batch + not random_apply => location-wise augmentation
+ for i, nchild in enumerate(islice(cycle(self.named_children()), batch_shape[0])):
+ if isinstance(nchild[1], (_AugmentationBase, MixAugmentationBase, SequentialBase)):
+ yield ParamItem(nchild[0], nchild[1].forward_parameters(torch.Size(batch_shape[1:]))), i
+ else:
+ yield ParamItem(nchild[0], None), i
+ else:
+ # same_on_batch + random_apply => location-wise augmentation
+ with_mix = False
+ for i in range(batch_shape[0]):
+ seq, mix_added = self.get_random_forward_sequence(with_mix=with_mix)
+ with_mix = mix_added
+ for s in seq:
+ if isinstance(s[1], (_AugmentationBase, MixAugmentationBase, SequentialBase)):
+ yield ParamItem(s[0], s[1].forward_parameters(torch.Size(batch_shape[1:]))), i
+ else:
+ yield ParamItem(s[0], None), i
+
+ def apply_by_param(
+ self, input: TensorWithTransformMat, label: Optional[torch.Tensor], params: PatchParamItem
+ ) -> Tuple[TensorWithTransformMat, Optional[torch.Tensor], PatchParamItem]:
+ _input: TensorWithTransformMat
+ if isinstance(input, (tuple,)):
+ in_shape = input[0].shape
+ _input = (input[0][params.indices], input[1][params.indices])
+ else:
+ in_shape = input.shape
+ _input = input[params.indices]
+
+ _label: Optional[torch.Tensor]
+ if label is not None:
+ _label = label[params.indices]
+ else:
+ _label = label
+
+ module = self.get_submodule(params.param.name)
+ output, out_label = self.apply_to_input(_input, _label, module, params.param)
+
+ if isinstance(module, (_AugmentationBase, MixAugmentationBase, SequentialBase)):
+ out_param = ParamItem(params.param.name, module._params)
+ else:
+ out_param = ParamItem(params.param.name, None)
+
+ if isinstance(output, (tuple,)) and isinstance(input, (tuple,)):
+ input[0][params.indices] = output[0]
+ input[1][params.indices] = output[1]
+ elif isinstance(output, (tuple,)) and not isinstance(input, (tuple,)):
+ input[params.indices] = output[0]
+ input = (input, output[1])
+ elif not isinstance(output, (tuple,)) and isinstance(input, (tuple,)):
+ input[0][params.indices] = output
+ elif not isinstance(output, (tuple,)) and not isinstance(input, (tuple,)):
+ input[params.indices] = output
+
+ # TODO: this label handling is naive that may not be able to handle complex cases.
+ _label = None
+ if label is not None and out_label is not None:
+ if len(out_label.shape) == 1:
+ # Weird the mypy error though it is as same as in the next block
+ _label = torch.ones(in_shape[0] * in_shape[1], device=out_label.device, dtype=out_label.dtype) * -1
+ _label = label
+ else:
+ _label = (
+ torch.ones(in_shape[0], *out_label.shape[1:], device=out_label.device, dtype=out_label.dtype) * -1
+ )
+ _label[:, 0] = label
+ _label[params.indices] = out_label
+ elif label is None and out_label is not None:
+ if len(out_label.shape) == 1:
+ _label = torch.ones(in_shape[0] * in_shape[1], device=out_label.device, dtype=out_label.dtype) * -1
+ else:
+ _label = (
+ torch.ones(in_shape[0], *out_label.shape[1:], device=out_label.device, dtype=out_label.dtype) * -1
+ )
+ _label[params.indices] = out_label
+
+ return input, _label, PatchParamItem(params.indices, param=out_param)
+
+ def forward_by_params(
+ self, input: torch.Tensor, label: Optional[torch.Tensor], params: List[PatchParamItem]
+ ) -> Union[TensorWithTransformMat, Tuple[TensorWithTransformMat, Optional[torch.Tensor]]]:
+ _input: TensorWithTransformMat
+ in_shape = input.shape
+ _input = input.reshape(-1, *in_shape[-3:])
+
+ if label is not None:
+ label = torch.cat([label] * in_shape[1], dim=0)
+
+ self.clear_state()
+ for patch_param in params:
+ _input, label, out_param = self.apply_by_param(_input, label, params=patch_param)
+ self.update_params(out_param)
+ if isinstance(_input, (tuple,)):
+ _input = (_input[0].reshape(in_shape), _input[1])
+ else:
+ _input = _input.reshape(in_shape)
+ return _input, label
+
+ def inverse( # type: ignore
+ self,
+ input: torch.Tensor,
+ params: List[ParamItem],
+ ) -> torch.Tensor:
+ """Inverse transformation.
+
+ Used to inverse a tensor according to the performed transformation by a forward pass, or with respect to
+ provided parameters.
+ """
+ if self.is_intensity_only():
+ return input
+
+ raise NotImplementedError("PatchSequential inverse cannot be used with geometric transformations.")
+
+ def forward( # type: ignore
+ self, input: torch.Tensor, label: Optional[torch.Tensor] = None, params: Optional[List[PatchParamItem]] = None
+ ) -> Union[TensorWithTransformMat, Tuple[TensorWithTransformMat, torch.Tensor]]:
+ """Input transformation will be returned if input is a tuple."""
+ # BCHW -> B(patch)CHW
+ if isinstance(input, (tuple,)):
+ raise ValueError("tuple input is not currently supported.")
+ _input: TensorWithTransformMat
+
+ pad = self.compute_padding(input, self.padding)
+ input = self.extract_patches(input, self.grid_size, pad)
+
+ if params is None:
+ params = self.forward_parameters(input.shape)
+
+ _input, label = self.forward_by_params(input, label, params)
+
+ if isinstance(_input, (tuple,)):
+ _input = (self.restore_from_patches(_input[0], self.grid_size, pad=pad), _input[1])
+ else:
+ _input = self.restore_from_patches(_input, self.grid_size, pad=pad)
+
+ self.return_label = label is not None or self.contains_label_operations(params)
+
+ return self.__packup_output__(_input, label)
diff --git a/kornia/augmentation/container/utils.py b/kornia/augmentation/container/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..7206e591958ae0156d025058bd4d871052ff1679
--- /dev/null
+++ b/kornia/augmentation/container/utils.py
@@ -0,0 +1,368 @@
+from abc import ABCMeta, abstractmethod
+from functools import partial
+from typing import Callable, cast, Dict, Iterator, List, Optional, Tuple, Type, Union
+
+import torch
+import torch.nn as nn
+
+import kornia # lazy loading for circular dependencies
+from kornia.augmentation.base import (
+ _AugmentationBase,
+ GeometricAugmentationBase2D,
+ MixAugmentationBase,
+ TensorWithTransformMat,
+)
+from kornia.constants import DataKey
+from kornia.geometry.bbox import transform_bbox
+from kornia.geometry.linalg import transform_points
+from kornia.utils.helpers import _torch_inverse_cast
+
+from .base import ParamItem
+
+
+def _get_geometric_only_param(
+ module: "kornia.augmentation.container.ImageSequential", param: List[ParamItem]
+) -> List[ParamItem]:
+ named_modules: Iterator[Tuple[str, nn.Module]] = module.get_forward_sequence(param)
+
+ res: List[ParamItem] = []
+ for (_, mod), p in zip(named_modules, param):
+ if isinstance(mod, (GeometricAugmentationBase2D,)):
+ res.append(p)
+ return res
+
+
+class ApplyInverseInterface(metaclass=ABCMeta):
+ """Abstract interface for applying and inversing transformations."""
+
+ @classmethod
+ @abstractmethod
+ def apply_trans(
+ cls,
+ input: torch.Tensor,
+ label: Optional[torch.Tensor],
+ module: nn.Module,
+ param: ParamItem,
+ ) -> Tuple[torch.Tensor, Optional[torch.Tensor]]:
+ """Apply a transformation with respect to the parameters.
+
+ Args:
+ input: the input tensor.
+ label: the optional label tensor.
+ module: any torch Module but only kornia augmentation modules will count
+ to apply transformations.
+ param: the corresponding parameters to the module.
+ """
+ raise NotImplementedError
+
+ @classmethod
+ @abstractmethod
+ def inverse(
+ cls,
+ input: torch.Tensor,
+ module: nn.Module,
+ param: Optional[ParamItem] = None
+ ) -> torch.Tensor:
+ """Inverse a transformation with respect to the parameters.
+
+ Args:
+ input: the input tensor.
+ module: any torch Module but only kornia augmentation modules will count
+ to apply transformations.
+ param: the corresponding parameters to the module.
+ """
+ raise NotImplementedError
+
+
+class ApplyInverseImpl(ApplyInverseInterface):
+ """Standard matrix apply and inverse methods."""
+
+ apply_func: Callable
+
+ @classmethod
+ def apply_trans(
+ cls, input: torch.Tensor, label: Optional[torch.Tensor], module: nn.Module, param: ParamItem
+ ) -> Tuple[torch.Tensor, Optional[torch.Tensor]]:
+ """Apply a transformation with respect to the parameters.
+
+ Args:
+ input: the input tensor.
+ label: the optional label tensor.
+ module: any torch Module but only kornia augmentation modules will count
+ to apply transformations.
+ param: the corresponding parameters to the module.
+ """
+
+ mat: Optional[torch.Tensor] = cls._get_transformation(input, module, param)
+
+ if mat is not None:
+ input = cls.apply_func(mat, input)
+
+ return input, label
+
+ @classmethod
+ def inverse(
+ cls, input: torch.Tensor, module: nn.Module, param: Optional[ParamItem] = None
+ ) -> torch.Tensor:
+ """Inverse a transformation with respect to the parameters.
+
+ Args:
+ input: the input tensor.
+ module: any torch Module but only kornia augmentation modules will count
+ to apply transformations.
+ param: the corresponding parameters to the module.
+ """
+ mat: Optional[torch.Tensor] = cls._get_transformation(input, module, param)
+
+ if mat is not None:
+ transform: torch.Tensor = cls._get_inverse_transformation(mat)
+ input = cls.apply_func(torch.as_tensor(transform, device=input.device, dtype=input.dtype), input)
+ return input
+
+ @classmethod
+ def _get_transformation(
+ cls, input: torch.Tensor, module: nn.Module, param: Optional[ParamItem] = None
+ ) -> Optional[torch.Tensor]:
+
+ if isinstance(module, (
+ GeometricAugmentationBase2D,
+ kornia.augmentation.container.ImageSequential,
+ )) and param is None:
+ raise ValueError(f"Parameters of transformation matrix for {module} has not been computed.")
+
+ if isinstance(module, GeometricAugmentationBase2D):
+ _param = cast(Dict[str, torch.Tensor], param.data) # type: ignore
+ mat = module.get_transformation_matrix(input, _param)
+ elif isinstance(module, kornia.augmentation.container.ImageSequential) and not module.is_intensity_only():
+ _param = cast(List[ParamItem], param.data) # type: ignore
+ mat = module.get_transformation_matrix(input, _param) # type: ignore
+ else:
+ return None # No need to update anything
+ return mat
+
+ @classmethod
+ def _get_inverse_transformation(cls, transform: torch.Tensor) -> torch.Tensor:
+ return _torch_inverse_cast(transform)
+
+
+class InputApplyInverse(ApplyInverseImpl):
+ """Apply and inverse transformations for (image) input tensors."""
+
+ @classmethod
+ def apply_trans( # type: ignore
+ cls,
+ input: TensorWithTransformMat,
+ label: Optional[torch.Tensor],
+ module: nn.Module,
+ param: ParamItem,
+ ) -> Tuple[TensorWithTransformMat, Optional[torch.Tensor]]:
+ """Apply a transformation with respect to the parameters.
+
+ Args:
+ input: the input tensor.
+ label: the optional label tensor.
+ module: any torch Module but only kornia augmentation modules will count
+ to apply transformations.
+ param: the corresponding parameters to the module.
+ """
+ if isinstance(module, (MixAugmentationBase,)):
+ input, label = module(input, label, params=param.data)
+ elif isinstance(module, (_AugmentationBase,)):
+ input = module(input, params=param.data)
+ elif isinstance(module, kornia.augmentation.container.ImageSequential):
+ temp = module.apply_inverse_func
+ temp2 = module.return_label
+ module.apply_inverse_func = InputApplyInverse
+ module.return_label = True
+ input, label = module(input, label, param.data)
+ module.apply_inverse_func = temp
+ module.return_label = temp2
+ else:
+ if param.data is not None:
+ raise AssertionError(f"Non-augmentaion operation {param.name} require empty parameters. Got {param}.")
+ # In case of return_transform = True
+ if isinstance(input, (tuple, list)):
+ input = (module(input[0]), input[1])
+ else:
+ input = module(input)
+ return input, label
+
+ @classmethod
+ def inverse(cls, input: torch.Tensor, module: nn.Module, param: Optional[ParamItem] = None) -> torch.Tensor:
+ """Inverse a transformation with respect to the parameters.
+
+ Args:
+ input: the input tensor.
+ module: any torch Module but only kornia augmentation modules will count
+ to apply transformations.
+ param: the corresponding parameters to the module.
+ """
+ if isinstance(module, GeometricAugmentationBase2D):
+ input = module.inverse(input, None if param is None else cast(Dict, param.data))
+ elif isinstance(module, kornia.augmentation.container.ImageSequential):
+ temp = module.apply_inverse_func
+ module.apply_inverse_func = InputApplyInverse
+ input = module.inverse(input, None if param is None else cast(List, param.data))
+ module.apply_inverse_func = temp
+ return input
+
+
+class MaskApplyInverse(ApplyInverseImpl):
+ """Apply and inverse transformations for mask tensors."""
+
+ @classmethod
+ def make_input_only_sequential(cls, module: "kornia.augmentation.container.ImageSequential") -> Callable:
+ """Disable all other additional inputs (e.g. ) for ImageSequential."""
+ def f(*args, **kwargs):
+ if_return_trans = module.return_transform
+ if_return_label = module.return_label
+ module.return_transform = False
+ module.return_label = False
+ out = module(*args, **kwargs)
+ module.return_transform = if_return_trans
+ module.return_label = if_return_label
+ return out
+ return f
+
+ @classmethod
+ def apply_trans(
+ cls, input: torch.Tensor, label: Optional[torch.Tensor], module: nn.Module, param: Optional[ParamItem] = None
+ ) -> Tuple[torch.Tensor, Optional[torch.Tensor]]:
+ """Apply a transformation with respect to the parameters.
+
+ Args:
+ input: the input tensor.
+ label: the optional label tensor.
+ module: any torch Module but only kornia augmentation modules will count
+ to apply transformations.
+ param: the corresponding parameters to the module.
+ """
+ if param is not None:
+ _param = param.data
+ else:
+ _param = None # type: ignore
+
+ if isinstance(module, GeometricAugmentationBase2D):
+ _param = cast(Dict[str, torch.Tensor], _param)
+ input = module(input, _param, return_transform=False)
+ elif isinstance(module, kornia.augmentation.container.ImageSequential) and not module.is_intensity_only():
+ _param = cast(List[ParamItem], _param)
+ temp = module.apply_inverse_func
+ module.apply_inverse_func = MaskApplyInverse
+ geo_param: List[ParamItem] = _get_geometric_only_param(module, _param)
+ input = cls.make_input_only_sequential(module)(input, None, geo_param)
+ module.apply_inverse_func = temp
+ else:
+ pass # No need to update anything
+ return input, label
+
+ @classmethod
+ def inverse(
+ cls, input: torch.Tensor, module: nn.Module, param: Optional[ParamItem] = None
+ ) -> torch.Tensor:
+ """Inverse a transformation with respect to the parameters.
+
+ Args:
+ input: the input tensor.
+ module: any torch Module but only kornia augmentation modules will count
+ to apply transformations.
+ param: the corresponding parameters to the module.
+ """
+ if isinstance(module, GeometricAugmentationBase2D):
+ input = module.inverse(input, None if param is None else cast(Dict, param.data))
+ elif isinstance(module, kornia.augmentation.container.ImageSequential):
+ temp = module.apply_inverse_func
+ module.apply_inverse_func = MaskApplyInverse
+ input = module.inverse(input, None if param is None else cast(List, param.data))
+ module.apply_inverse_func = temp
+ return input
+
+
+class BBoxXYXYApplyInverse(ApplyInverseImpl):
+ """Apply and inverse transformations for bounding box tensors.
+
+ This is for transform boxes in the format [xmin, ymin, xmax, ymax].
+ """
+
+ apply_func = partial(transform_bbox, mode="xyxy")
+
+
+class BBoxXYWHApplyInverse(ApplyInverseImpl):
+ """Apply and inverse transformations for bounding box tensors.
+
+ This is for transform boxes in the format [xmin, ymin, width, height].
+ """
+
+ apply_func = partial(transform_bbox, mode="xywh")
+
+
+class KeypointsApplyInverse(ApplyInverseImpl):
+ """Apply and inverse transformations for keypoints tensors."""
+
+ apply_func = transform_points
+
+
+class ApplyInverse:
+ """Apply and inverse transformations for any tensors (e.g. mask, box, points)."""
+
+ @classmethod
+ def _get_func_by_key(cls, dcate: Union[str, int, DataKey]) -> Type[ApplyInverseInterface]:
+ if DataKey.get(dcate) == DataKey.INPUT:
+ return InputApplyInverse
+ if DataKey.get(dcate) in [DataKey.MASK]:
+ return MaskApplyInverse
+ if DataKey.get(dcate) in [DataKey.BBOX, DataKey.BBOX_XYXY]:
+ return BBoxXYXYApplyInverse
+ if DataKey.get(dcate) in [DataKey.BBOX_XYHW]:
+ return BBoxXYWHApplyInverse
+ if DataKey.get(dcate) in [DataKey.KEYPOINTS]:
+ return KeypointsApplyInverse
+ raise NotImplementedError(f"input type of {dcate} is not implemented.")
+
+ @classmethod
+ def apply_by_key(
+ cls,
+ input: TensorWithTransformMat,
+ label: Optional[torch.Tensor],
+ module: nn.Module,
+ param: ParamItem,
+ dcate: Union[str, int, DataKey] = DataKey.INPUT,
+ ) -> Tuple[TensorWithTransformMat, Optional[torch.Tensor]]:
+ """Apply a transformation with respect to the parameters.
+
+ Args:
+ input: the input tensor.
+ label: the optional label tensor.
+ module: any torch Module but only kornia augmentation modules will count
+ to apply transformations.
+ param: the corresponding parameters to the module.
+ dcate: data category. 'input', 'mask', 'bbox', 'bbox_xyxy', 'bbox_xyhw', 'keypoints'.
+ By default, it is set to 'input'.
+ """
+ func: Type[ApplyInverseInterface] = cls._get_func_by_key(dcate)
+
+ if isinstance(input, (tuple,)):
+ # If the input is a tuple with (input, mat) or something else
+ return (func.apply_trans(input[0], label, module, param), *input[1:]) # type: ignore
+ return func.apply_trans(input, label, module=module, param=param)
+
+ @classmethod
+ def inverse_by_key(
+ cls,
+ input: torch.Tensor,
+ module: nn.Module,
+ param: Optional[ParamItem] = None,
+ dcate: Union[str, int, DataKey] = DataKey.INPUT,
+ ) -> torch.Tensor:
+ """Inverse a transformation with respect to the parameters.
+
+ Args:
+ input: the input tensor.
+ module: any torch Module but only kornia augmentation modules will count
+ to apply transformations.
+ param: the corresponding parameters to the module.
+ dcate: data category. 'input', 'mask', 'bbox', 'bbox_xyxy', 'bbox_xyhw', 'keypoints'.
+ By default, it is set to 'input'.
+ """
+ func: Type[ApplyInverseInterface] = cls._get_func_by_key(dcate)
+ return func.inverse(input, module, param)
diff --git a/kornia/augmentation/container/video.py b/kornia/augmentation/container/video.py
new file mode 100644
index 0000000000000000000000000000000000000000..84dfaa6df0aab98751b9aa7ff5d9ac9ccd30bae4
--- /dev/null
+++ b/kornia/augmentation/container/video.py
@@ -0,0 +1,243 @@
+from typing import cast, List, Optional, Tuple, Union
+
+import torch
+import torch.nn as nn
+
+import kornia
+from kornia.augmentation.base import _AugmentationBase, MixAugmentationBase, TensorWithTransformMat
+from kornia.augmentation.container.base import SequentialBase
+from kornia.augmentation.container.utils import InputApplyInverse, MaskApplyInverse
+
+from .image import ImageSequential, ParamItem
+
+__all__ = ["VideoSequential"]
+
+
+class VideoSequential(ImageSequential):
+ r"""VideoSequential for processing 5-dim video data like (B, T, C, H, W) and (B, C, T, H, W).
+
+ `VideoSequential` is used to replace `nn.Sequential` for processing video data augmentations.
+ By default, `VideoSequential` enabled `same_on_frame` to make sure the same augmentations happen
+ across temporal dimension. Meanwhile, it will not affect other augmentation behaviours like the
+ settings on `same_on_batch`, etc.
+
+ Args:
+ *args: a list of augmentation module.
+ data_format: only BCTHW and BTCHW are supported.
+ same_on_frame: apply the same transformation across the channel per frame.
+ random_apply: randomly select a sublist (order agnostic) of args to
+ apply transformation.
+ If int, a fixed number of transformations will be selected.
+ If (a,), x number of transformations (a <= x <= len(args)) will be selected.
+ If (a, b), x number of transformations (a <= x <= b) will be selected.
+ If None, the whole list of args will be processed as a sequence.
+
+ Note:
+ Transformation matrix returned only considers the transformation applied in ``kornia.augmentation`` module.
+ Those transformations in ``kornia.geometry`` will not be taken into account.
+
+ Example:
+ If set `same_on_frame` to True, we would expect the same augmentation has been applied to each
+ timeframe.
+
+ >>> input, label = torch.randn(2, 3, 1, 5, 6).repeat(1, 1, 4, 1, 1), torch.tensor([0, 1])
+ >>> aug_list = VideoSequential(
+ ... kornia.augmentation.ColorJitter(0.1, 0.1, 0.1, 0.1, p=1.0),
+ ... kornia.color.BgrToRgb(),
+ ... kornia.augmentation.RandomAffine(360, p=1.0),
+ ... random_apply=10,
+ ... data_format="BCTHW",
+ ... same_on_frame=True)
+ >>> output = aug_list(input)
+ >>> (output[0, :, 0] == output[0, :, 1]).all()
+ tensor(True)
+ >>> (output[0, :, 1] == output[0, :, 2]).all()
+ tensor(True)
+ >>> (output[0, :, 2] == output[0, :, 3]).all()
+ tensor(True)
+
+ If set `same_on_frame` to False:
+
+ >>> aug_list = VideoSequential(
+ ... kornia.augmentation.ColorJitter(0.1, 0.1, 0.1, 0.1, p=1.0),
+ ... kornia.augmentation.RandomAffine(360, p=1.0),
+ ... kornia.augmentation.RandomMixUp(p=1.0),
+ ... data_format="BCTHW",
+ ... same_on_frame=False)
+ >>> output, lab = aug_list(input)
+ >>> output.shape, lab.shape
+ (torch.Size([2, 3, 4, 5, 6]), torch.Size([2, 4, 3]))
+ >>> (output[0, :, 0] == output[0, :, 1]).all()
+ tensor(False)
+
+ Reproduce with provided params.
+ >>> out2, lab2 = aug_list(input, label, params=aug_list._params)
+ >>> torch.equal(output, out2)
+ True
+ """
+
+ def __init__(
+ self,
+ *args: nn.Module,
+ data_format: str = "BTCHW",
+ same_on_frame: bool = True,
+ random_apply: Union[int, bool, Tuple[int, int]] = False,
+ ) -> None:
+ super().__init__(*args, same_on_batch=None, return_transform=None, keepdim=None, random_apply=random_apply)
+ self.same_on_frame = same_on_frame
+ self.data_format = data_format.upper()
+ if self.data_format not in ["BCTHW", "BTCHW"]:
+ raise AssertionError(f"Only `BCTHW` and `BTCHW` are supported. Got `{data_format}`.")
+ self._temporal_channel: int
+ if self.data_format == "BCTHW":
+ self._temporal_channel = 2
+ elif self.data_format == "BTCHW":
+ self._temporal_channel = 1
+
+ def __infer_channel_exclusive_batch_shape__(self, batch_shape: torch.Size, chennel_index: int) -> torch.Size:
+ # Fix mypy complains: error: Incompatible return value type (got "Tuple[int, ...]", expected "Size")
+ return cast(torch.Size, batch_shape[:chennel_index] + batch_shape[chennel_index + 1:])
+
+ def __repeat_param_across_channels__(self, param: torch.Tensor, frame_num: int) -> torch.Tensor:
+ """Repeat parameters across channels.
+
+ The input is shaped as (B, ...), while to output (B * same_on_frame, ...), which
+ to guarantee that the same transformation would happen for each frame.
+
+ (B1, B2, ..., Bn) => (B1, ... B1, B2, ..., B2, ..., Bn, ..., Bn)
+ | ch_size | | ch_size | ..., | ch_size |
+ """
+ repeated = param[:, None, ...].repeat(1, frame_num, *([1] * len(param.shape[1:])))
+ return repeated.reshape(-1, *list(param.shape[1:])) # type: ignore
+
+ def _input_shape_convert_in(
+ self, input: torch.Tensor, label: Optional[torch.Tensor], frame_num: int
+ ) -> Tuple[torch.Tensor, Optional[torch.Tensor]]:
+ # Convert any shape to (B, T, C, H, W)
+ if self.data_format == "BCTHW":
+ # Convert (B, C, T, H, W) to (B, T, C, H, W)
+ input = input.transpose(1, 2)
+ if self.data_format == "BTCHW":
+ pass
+
+ if label is not None:
+ if label.shape == input.shape[:2]:
+ # if label is provided as (B, T)
+ label = label.view(-1)
+ elif label.shape == input.shape[:1]:
+ label = label[..., None].repeat(1, frame_num).view(-1)
+ elif label.shape == torch.Size([input.shape[0] * input.shape[1]]):
+ # Skip the conversion if label is provided as (B * T,)
+ pass
+ else:
+ raise NotImplementedError(f"Invalid label shape of {label.shape}.")
+ input = input.reshape(-1, *input.shape[2:])
+ return input, label
+
+ def _input_shape_convert_back(
+ self, input: torch.Tensor, label: Optional[torch.Tensor], frame_num: int
+ ) -> Tuple[torch.Tensor, Optional[torch.Tensor]]:
+ input = input.view(-1, frame_num, *input.shape[1:])
+ if self.data_format == "BCTHW":
+ input = input.transpose(1, 2)
+ if self.data_format == "BTCHW":
+ pass
+
+ if label is not None:
+ label = label.view(input.size(0), frame_num, -1)
+ return input, label
+
+ def forward_parameters(self, batch_shape: torch.Size) -> List[ParamItem]:
+ frame_num = batch_shape[self._temporal_channel]
+ named_modules = self.get_forward_sequence()
+ # Got param generation shape to (B, C, H, W). Ignoring T.
+ batch_shape = self.__infer_channel_exclusive_batch_shape__(batch_shape, self._temporal_channel)
+
+ if not self.same_on_frame:
+ # Overwrite param generation shape to (B * T, C, H, W).
+ batch_shape = torch.Size([batch_shape[0] * frame_num, *batch_shape[1:]])
+
+ params = []
+ for name, module in named_modules:
+ if isinstance(module, (SequentialBase,)):
+ seq_param = module.forward_parameters(batch_shape)
+ if self.same_on_frame:
+ raise ValueError("Sequential is currently unsupported for ``same_on_frame``.")
+ param = ParamItem(name, seq_param)
+ elif isinstance(module, (_AugmentationBase, MixAugmentationBase)):
+ mod_param = module.forward_parameters(batch_shape)
+ if self.same_on_frame:
+ for k, v in mod_param.items():
+ # TODO: revise colorjitter order param in the future to align the standard.
+ if not (k == "order" and isinstance(module, kornia.augmentation.ColorJitter)):
+ mod_param.update({k: self.__repeat_param_across_channels__(v, frame_num)})
+ param = ParamItem(name, mod_param)
+ else:
+ param = ParamItem(name, None)
+ params.append(param)
+ return params
+
+ def inverse(self, input: torch.Tensor, params: Optional[List[ParamItem]] = None) -> torch.Tensor:
+ """Inverse transformation.
+
+ Used to inverse a tensor according to the performed transformation by a forward pass, or with respect to
+ provided parameters.
+ """
+ if self.apply_inverse_func in (InputApplyInverse, MaskApplyInverse):
+ frame_num: int = input.size(self._temporal_channel)
+ input, _ = self._input_shape_convert_in(input, None, frame_num)
+ else:
+ batch_size: int = input.size(0)
+ input = input.view(-1, *input.shape[2:])
+
+ input = super().inverse(input, params)
+ if self.apply_inverse_func in (InputApplyInverse, MaskApplyInverse):
+ input, _ = self._input_shape_convert_back(input, None, frame_num)
+ else:
+ input = input.view(batch_size, -1, *input.shape[1:])
+
+ return input
+
+ def forward( # type: ignore
+ self, input: torch.Tensor, label: Optional[torch.Tensor] = None, params: Optional[List[ParamItem]] = None
+ ) -> Union[TensorWithTransformMat, Tuple[TensorWithTransformMat, torch.Tensor]]:
+ """Define the video computation performed."""
+ if len(input.shape) != 5:
+ raise AssertionError(f"Input must be a 5-dim tensor. Got {input.shape}.")
+
+ if params is None:
+ params = self.forward_parameters(input.shape)
+
+ # Size of T
+ if self.apply_inverse_func in (InputApplyInverse, MaskApplyInverse):
+ frame_num: int = input.size(self._temporal_channel)
+ input, label = self._input_shape_convert_in(input, label, frame_num)
+ else:
+ if label is not None:
+ raise ValueError(f"Invalid label value. Got {label}")
+ batch_size: int = input.size(0)
+ input = input.view(-1, *input.shape[2:])
+
+ out = super().forward(input, label, params) # type: ignore
+ if self.return_label:
+ output, label = cast(Tuple[TensorWithTransformMat, torch.Tensor], out)
+ else:
+ output = cast(TensorWithTransformMat, out)
+
+ if isinstance(output, (tuple, list)):
+ if self.apply_inverse_func in (InputApplyInverse, MaskApplyInverse):
+ _out, label = self._input_shape_convert_back(output[0], label, frame_num)
+ output = (_out, output[1])
+ else:
+ if label is not None:
+ raise ValueError(f"Invalid label value. Got {label}")
+ output = output[0].view(batch_size, -1, *output[0].shape[1:])
+ else:
+ if self.apply_inverse_func in (InputApplyInverse, MaskApplyInverse):
+ output, label = self._input_shape_convert_back(output, label, frame_num)
+ else:
+ if label is not None:
+ raise ValueError(f"Invalid label value. Got {label}")
+ output = output.view(batch_size, -1, *output.shape[1:])
+
+ return self.__packup_output__(output, label)
diff --git a/kornia/augmentation/mix_augmentation.py b/kornia/augmentation/mix_augmentation.py
new file mode 100644
index 0000000000000000000000000000000000000000..fb160cca7075cb8f9ee48febefd7f6683c884961
--- /dev/null
+++ b/kornia/augmentation/mix_augmentation.py
@@ -0,0 +1,281 @@
+from typing import cast, Dict, Optional, Tuple, Union
+
+import torch
+
+from kornia.geometry.bbox import bbox_to_mask, infer_bbox_shape
+
+from . import random_generator as rg
+from .base import MixAugmentationBase
+from .utils import _shape_validation
+
+
+class RandomMixUp(MixAugmentationBase):
+ r"""Apply MixUp augmentation to a batch of tensor images.
+
+ .. image:: _static/img/RandomMixUp.png
+
+ Implementation for `mixup: BEYOND EMPIRICAL RISK MINIMIZATION` :cite:`zhang2018mixup`.
+
+ The function returns (inputs, labels), in which the inputs is the tensor that contains the mixup images
+ while the labels is a :math:`(B, 3)` tensor that contains (label_batch, label_permuted_batch, lambda) for
+ each image.
+
+ The implementation is on top of the following repository:
+ `https://github.com/hongyi-zhang/mixup/blob/master/cifar/utils.py
+ `_.
+
+ The loss and accuracy are computed as:
+
+ .. code-block:: python
+
+ def loss_mixup(y, logits):
+ criterion = F.cross_entropy
+ loss_a = criterion(logits, y[:, 0].long(), reduction='none')
+ loss_b = criterion(logits, y[:, 1].long(), reduction='none')
+ return ((1 - y[:, 2]) * loss_a + y[:, 2] * loss_b).mean()
+
+ .. code-block:: python
+
+ def acc_mixup(y, logits):
+ pred = torch.argmax(logits, dim=1).to(y.device)
+ return (1 - y[:, 2]) * pred.eq(y[:, 0]).float() + y[:, 2] * pred.eq(y[:, 1]).float()
+
+ Args:
+ p (float): probability for applying an augmentation to a batch. This param controls the augmentation
+ probabilities batch-wisely.
+ lambda_val (float or torch.Tensor, optional): min-max value of mixup strength. Default is 0-1.
+ same_on_batch (bool): apply the same transformation across the batch.
+ This flag will not maintain permutation order. Default: False.
+ keepdim (bool): whether to keep the output shape the same as input (True) or broadcast it
+ to the batch form (False). Default: False
+
+ Inputs:
+ - Input image tensors, shape of :math:`(B, C, H, W)`.
+ - Label: raw labels, shape of :math:`(B)`.
+
+ Returns:
+ Tuple[torch.Tensor, torch.Tensor]:
+ - Adjusted image, shape of :math:`(B, C, H, W)`.
+ - Raw labels, permuted labels and lambdas for each mix, shape of :math:`(B, 3)`.
+
+ Note:
+ This implementation would randomly mixup images in a batch. Ideally, the larger batch size would be preferred.
+
+ Examples:
+ >>> rng = torch.manual_seed(1)
+ >>> input = torch.rand(2, 1, 3, 3)
+ >>> label = torch.tensor([0, 1])
+ >>> mixup = RandomMixUp()
+ >>> mixup(input, label)
+ (tensor([[[[0.7576, 0.2793, 0.4031],
+ [0.7347, 0.0293, 0.7999],
+ [0.3971, 0.7544, 0.5695]]],
+
+
+ [[[0.4388, 0.6387, 0.5247],
+ [0.6826, 0.3051, 0.4635],
+ [0.4550, 0.5725, 0.4980]]]]), tensor([[0.0000, 0.0000, 0.1980],
+ [1.0000, 1.0000, 0.4162]]))
+ """
+
+ def __init__(
+ self,
+ lambda_val: Optional[Union[torch.Tensor, Tuple[float, float]]] = None,
+ same_on_batch: bool = False,
+ p: float = 1.0,
+ keepdim: bool = False,
+ ) -> None:
+ super().__init__(p=1.0, p_batch=p, same_on_batch=same_on_batch, keepdim=keepdim)
+ self.lambda_val = lambda_val
+
+ def __repr__(self) -> str:
+ repr = f"lambda_val={self.lambda_val}"
+ return self.__class__.__name__ + f"({repr}, {super().__repr__()})"
+
+ def generate_parameters(self, batch_shape: torch.Size) -> Dict[str, torch.Tensor]:
+ if self.lambda_val is None:
+ lambda_val = torch.tensor([0.0, 1.0], device=self.device, dtype=self.dtype)
+ else:
+ lambda_val = (
+ cast(torch.Tensor, self.lambda_val)
+ if isinstance(self.lambda_val, torch.Tensor)
+ else torch.tensor(self.lambda_val, device=self.device, dtype=self.dtype)
+ )
+ return rg.random_mixup_generator(batch_shape[0], self.p, lambda_val, same_on_batch=self.same_on_batch)
+
+ def apply_transform( # type: ignore
+ self, input: torch.Tensor, label: torch.Tensor, params: Dict[str, torch.Tensor]
+ ) -> Tuple[torch.Tensor, torch.Tensor]:
+ input_permute = input.index_select(dim=0, index=params['mixup_pairs'].to(input.device))
+ labels_permute = label.index_select(dim=0, index=params['mixup_pairs'].to(label.device))
+
+ lam = params['mixup_lambdas'].view(-1, 1, 1, 1).expand_as(input).to(label.device)
+ inputs = input * (1 - lam) + input_permute * lam
+ out_labels = torch.stack(
+ [
+ label.to(input.dtype),
+ labels_permute.to(input.dtype),
+ params['mixup_lambdas'].to(label.device, input.dtype),
+ ],
+ dim=-1,
+ ).to(label.device)
+ return inputs, out_labels
+
+
+class RandomCutMix(MixAugmentationBase):
+ r"""Apply CutMix augmentation to a batch of tensor images.
+
+ .. image:: _static/img/RandomCutMix.png
+
+ Implementation for `CutMix: Regularization Strategy to Train Strong Classifiers with
+ Localizable Features` :cite:`yun2019cutmix`.
+
+ The function returns (inputs, labels), in which the inputs is the tensor that contains the mixup images
+ while the labels is a :math:`(\text{num_mixes}, B, 3)` tensor that contains (label_permuted_batch, lambda)
+ for each cutmix.
+
+ The implementation referred to the following repository: `https://github.com/clovaai/CutMix-PyTorch
+ `_.
+
+ The onehot label may be computed as:
+
+ .. code-block:: python
+
+ def onehot(size, target):
+ vec = torch.zeros(size, dtype=torch.float32)
+ vec[target] = 1.
+ return vec
+
+ .. code-block:: python
+
+ def cutmix_label(labels, out_labels, size):
+ lb_onehot = onehot(size, labels)
+ for out_label in out_labels:
+ label_permuted_batch, lam = out_label[:, 0], out_label[:, 1]
+ label_permuted_onehot = onehot(size, label_permuted_batch)
+ lb_onehot = lb_onehot * lam + label_permuted_onehot * (1. - lam)
+ return lb_onehot
+
+ Args:
+ height (int): the width of the input image.
+ width (int): the width of the input image.
+ p (float): probability for applying an augmentation to a batch. This param controls the augmentation
+ probabilities batch-wisely.
+ num_mix (int): cut mix times. Default is 1.
+ beta (float or torch.Tensor, optional): hyperparameter for generating cut size from beta distribution.
+ Beta cannot be set to 0 after torch 1.8.0. If None, it will be set to 1.
+ cut_size ((float, float) or torch.Tensor, optional): controlling the minimum and maximum cut ratio from [0, 1].
+ If None, it will be set to [0, 1], which means no restriction.
+ same_on_batch (bool): apply the same transformation across the batch.
+ This flag will not maintain permutation order. Default: False.
+ keepdim (bool): whether to keep the output shape the same as input (True) or broadcast it
+ to the batch form (False). Default: False
+
+ Inputs:
+ - Input image tensors, shape of :math:`(B, C, H, W)`.
+ - Raw labels, shape of :math:`(B)`.
+
+ Returns:
+ Tuple[torch.Tensor, torch.Tensor]:
+ - Adjusted image, shape of :math:`(B, C, H, W)`.
+ - Raw labels, permuted labels and lambdas for each mix, shape of :math:`(B, num_mix, 3)`.
+
+ Note:
+ This implementation would randomly cutmix images in a batch. Ideally, the larger batch size would be preferred.
+
+ Examples:
+ >>> rng = torch.manual_seed(3)
+ >>> input = torch.rand(2, 1, 3, 3)
+ >>> input[0] = torch.ones((1, 3, 3))
+ >>> label = torch.tensor([0, 1])
+ >>> cutmix = RandomCutMix(3, 3)
+ >>> cutmix(input, label)
+ (tensor([[[[0.8879, 0.4510, 1.0000],
+ [0.1498, 0.4015, 1.0000],
+ [1.0000, 1.0000, 1.0000]]],
+
+
+ [[[1.0000, 1.0000, 0.7995],
+ [1.0000, 1.0000, 0.0542],
+ [0.4594, 0.1756, 0.9492]]]]), tensor([[[0.0000, 1.0000, 0.4444],
+ [1.0000, 0.0000, 0.4444]]]))
+ """
+
+ def __init__(
+ self,
+ height: int,
+ width: int,
+ num_mix: int = 1,
+ cut_size: Optional[Union[torch.Tensor, Tuple[float, float]]] = None,
+ beta: Optional[Union[torch.Tensor, float]] = None,
+ same_on_batch: bool = False,
+ p: float = 1.0,
+ keepdim: bool = False,
+ ) -> None:
+ super().__init__(p=1.0, p_batch=p, same_on_batch=same_on_batch, keepdim=keepdim)
+ self.height = height
+ self.width = width
+ self.num_mix = num_mix
+ self.beta = beta
+ self.cut_size = cut_size
+
+ def __repr__(self) -> str:
+ repr = (
+ f"num_mix={self.num_mix}, beta={self.beta}, cut_size={self.cut_size}, "
+ f"height={self.height}, width={self.width}"
+ )
+ return self.__class__.__name__ + f"({repr}, {super().__repr__()})"
+
+ def generate_parameters(self, batch_shape: torch.Size) -> Dict[str, torch.Tensor]:
+ if self.beta is None:
+ beta = torch.tensor(1.0, device=self.device, dtype=self.dtype)
+ else:
+ beta = (
+ cast(torch.Tensor, self.beta)
+ if isinstance(self.beta, torch.Tensor)
+ else torch.tensor(self.beta, device=self.device, dtype=self.dtype)
+ )
+ if self.cut_size is None:
+ cut_size = torch.tensor([0.0, 1.0], device=self.device, dtype=self.dtype)
+ else:
+ cut_size = (
+ cast(torch.Tensor, self.cut_size)
+ if isinstance(self.cut_size, torch.Tensor)
+ else torch.tensor(self.cut_size, device=self.device, dtype=self.dtype)
+ )
+ return rg.random_cutmix_generator(
+ batch_shape[0],
+ width=self.width,
+ height=self.height,
+ p=self.p,
+ cut_size=cut_size,
+ num_mix=self.num_mix,
+ beta=beta,
+ same_on_batch=self.same_on_batch,
+ )
+
+ def apply_transform( # type: ignore
+ self, input: torch.Tensor, label: torch.Tensor, params: Dict[str, torch.Tensor] # type: ignore
+ ) -> Tuple[torch.Tensor, torch.Tensor]:
+ height, width = input.size(2), input.size(3)
+ num_mixes = params['mix_pairs'].size(0)
+ batch_size = params['mix_pairs'].size(1)
+
+ _shape_validation(params['mix_pairs'], [num_mixes, batch_size], 'mix_pairs')
+ _shape_validation(params['crop_src'], [num_mixes, batch_size, 4, 2], 'crop_src')
+
+ out_inputs = input.clone()
+ out_labels = []
+ for pair, crop in zip(params['mix_pairs'], params['crop_src']):
+ input_permute = input.index_select(dim=0, index=pair.to(input.device))
+ labels_permute = label.index_select(dim=0, index=pair.to(label.device))
+ w, h = infer_bbox_shape(crop)
+ lam = w.to(input.dtype) * h.to(input.dtype) / (width * height) # width_beta * height_beta
+ # compute mask to match input shape
+ mask = bbox_to_mask(crop, width, height).bool().unsqueeze(dim=1).repeat(1, input.size(1), 1, 1)
+ out_inputs[mask] = input_permute[mask]
+ out_labels.append(
+ torch.stack([label.to(input.dtype), labels_permute.to(input.dtype), lam.to(label.device)], dim=1)
+ )
+
+ return out_inputs, torch.stack(out_labels, dim=0)
diff --git a/kornia/augmentation/random_generator/__init__.py b/kornia/augmentation/random_generator/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4e53c2f9242a3c6f33d61d0128cba9ba36b2879a
--- /dev/null
+++ b/kornia/augmentation/random_generator/__init__.py
@@ -0,0 +1,2 @@
+from .random_generator import *
+from .random_generator3d import *
diff --git a/kornia/augmentation/random_generator/random_generator.py b/kornia/augmentation/random_generator/random_generator.py
new file mode 100644
index 0000000000000000000000000000000000000000..28201bebf3aa2c0128a7da4b13accd33b41608a7
--- /dev/null
+++ b/kornia/augmentation/random_generator/random_generator.py
@@ -0,0 +1,1101 @@
+from typing import cast, Dict, Optional, Tuple, Union
+
+import torch
+from torch.distributions import Bernoulli
+
+from kornia.geometry.bbox import bbox_generator
+from kornia.utils import _extract_device_dtype
+
+from ..utils import _adapted_beta, _adapted_sampling, _adapted_uniform, _common_param_check, _joint_range_check
+
+
+def random_prob_generator(
+ batch_size: int,
+ p: float = 0.5,
+ same_on_batch: bool = False,
+ device: torch.device = torch.device('cpu'),
+ dtype: torch.dtype = torch.float32,
+) -> torch.Tensor:
+ r"""Generate random probabilities for a batch of inputs.
+
+ Args:
+ batch_size (int): the number of images.
+ p (float): probability to generate an 1-d binary mask. Default value is 0.5.
+ same_on_batch (bool): apply the same transformation across the batch. Default: False.
+ device (torch.device): the device on which the random numbers will be generated. Default: cpu.
+ dtype (torch.dtype): the data type of the generated random numbers. Default: float32.
+
+ Returns:
+ torch.Tensor: parameters to be passed for transformation.
+ - probs (torch.Tensor): element-wise probabilities with a shape of (B,).
+
+ Note:
+ The generated random numbers are not reproducible across different devices and dtypes.
+ """
+ _common_param_check(batch_size, same_on_batch)
+ if not isinstance(p, (int, float)) or p > 1 or p < 0:
+ raise TypeError(f"The probability should be a float number within [0, 1]. Got {type(p)}.")
+
+ _bernoulli = Bernoulli(torch.tensor(float(p), device=device, dtype=dtype))
+ probs_mask: torch.Tensor = _adapted_sampling((batch_size,), _bernoulli, same_on_batch).bool()
+
+ return probs_mask
+
+
+def random_color_jitter_generator(
+ batch_size: int,
+ brightness: Optional[torch.Tensor] = None,
+ contrast: Optional[torch.Tensor] = None,
+ saturation: Optional[torch.Tensor] = None,
+ hue: Optional[torch.Tensor] = None,
+ same_on_batch: bool = False,
+ device: torch.device = torch.device('cpu'),
+ dtype: torch.dtype = torch.float32,
+) -> Dict[str, torch.Tensor]:
+ r"""Generate random color jiter parameters for a batch of images.
+
+ Args:
+ batch_size (int): the number of images.
+ brightness (torch.Tensor, optional): Brightness factor tensor of range (a, b).
+ The provided range must follow 0 <= a <= b <= 2. Default value is [0., 0.].
+ contrast (torch.Tensor, optional): Contrast factor tensor of range (a, b).
+ The provided range must follow 0 <= a <= b. Default value is [0., 0.].
+ saturation (torch.Tensor, optional): Saturation factor tensor of range (a, b).
+ The provided range must follow 0 <= a <= b. Default value is [0., 0.].
+ hue (torch.Tensor, optional): Saturation factor tensor of range (a, b).
+ The provided range must follow -0.5 <= a <= b < 0.5. Default value is [0., 0.].
+ same_on_batch (bool): apply the same transformation across the batch. Default: False.
+ device (torch.device): the device on which the random numbers will be generated. Default: cpu.
+ dtype (torch.dtype): the data type of the generated random numbers. Default: float32.
+
+ Returns:
+ params Dict[str, torch.Tensor]: parameters to be passed for transformation.
+ - brightness_factor (torch.Tensor): element-wise brightness factors with a shape of (B,).
+ - contrast_factor (torch.Tensor): element-wise contrast factors with a shape of (B,).
+ - hue_factor (torch.Tensor): element-wise hue factors with a shape of (B,).
+ - saturation_factor (torch.Tensor): element-wise saturation factors with a shape of (B,).
+ - order (torch.Tensor): applying orders of the color adjustments with a shape of (4). In which,
+ 0 is brightness adjustment; 1 is contrast adjustment;
+ 2 is saturation adjustment; 3 is hue adjustment.
+
+ Note:
+ The generated random numbers are not reproducible across different devices and dtypes.
+ """
+ _common_param_check(batch_size, same_on_batch)
+ _device, _dtype = _extract_device_dtype([brightness, contrast, hue, saturation])
+ brightness = torch.as_tensor([0.0, 0.0] if brightness is None else brightness, device=device, dtype=dtype)
+ contrast = torch.as_tensor([0.0, 0.0] if contrast is None else contrast, device=device, dtype=dtype)
+ hue = torch.as_tensor([0.0, 0.0] if hue is None else hue, device=device, dtype=dtype)
+ saturation = torch.as_tensor([0.0, 0.0] if saturation is None else saturation, device=device, dtype=dtype)
+
+ _joint_range_check(brightness, "brightness", (0, 2))
+ _joint_range_check(contrast, "contrast", (0, float('inf')))
+ _joint_range_check(hue, "hue", (-0.5, 0.5))
+ _joint_range_check(saturation, "saturation", (0, float('inf')))
+
+ brightness_factor = _adapted_uniform((batch_size,), brightness[0], brightness[1], same_on_batch)
+ contrast_factor = _adapted_uniform((batch_size,), contrast[0], contrast[1], same_on_batch)
+ hue_factor = _adapted_uniform((batch_size,), hue[0], hue[1], same_on_batch)
+ saturation_factor = _adapted_uniform((batch_size,), saturation[0], saturation[1], same_on_batch)
+
+ return dict(
+ brightness_factor=brightness_factor.to(device=_device, dtype=_dtype),
+ contrast_factor=contrast_factor.to(device=_device, dtype=_dtype),
+ hue_factor=hue_factor.to(device=_device, dtype=_dtype),
+ saturation_factor=saturation_factor.to(device=_device, dtype=_dtype),
+ order=torch.randperm(4, device=_device, dtype=_dtype).long(),
+ )
+
+
+def random_perspective_generator(
+ batch_size: int,
+ height: int,
+ width: int,
+ distortion_scale: torch.Tensor,
+ same_on_batch: bool = False,
+ device: torch.device = torch.device('cpu'),
+ dtype: torch.dtype = torch.float32,
+) -> Dict[str, torch.Tensor]:
+ r"""Get parameters for ``perspective`` for a random perspective transform.
+
+ Args:
+ batch_size (int): the tensor batch size.
+ height (int) : height of the image.
+ width (int): width of the image.
+ distortion_scale (torch.Tensor): it controls the degree of distortion and ranges from 0 to 1.
+ same_on_batch (bool): apply the same transformation across the batch. Default: False.
+ device (torch.device): the device on which the random numbers will be generated. Default: cpu.
+ dtype (torch.dtype): the data type of the generated random numbers. Default: float32.
+
+ Returns:
+ params Dict[str, torch.Tensor]: parameters to be passed for transformation.
+ - start_points (torch.Tensor): element-wise perspective source areas with a shape of (B, 4, 2).
+ - end_points (torch.Tensor): element-wise perspective target areas with a shape of (B, 4, 2).
+
+ Note:
+ The generated random numbers are not reproducible across different devices and dtypes.
+ """
+ _common_param_check(batch_size, same_on_batch)
+ if not (distortion_scale.dim() == 0 and 0 <= distortion_scale <= 1):
+ raise AssertionError(f"'distortion_scale' must be a scalar within [0, 1]. Got {distortion_scale}.")
+ if not (type(height) is int and height > 0 and type(width) is int and width > 0):
+ raise AssertionError(f"'height' and 'width' must be integers. Got {height}, {width}.")
+
+ start_points: torch.Tensor = torch.tensor(
+ [[[0.0, 0], [width - 1, 0], [width - 1, height - 1], [0, height - 1]]],
+ device=distortion_scale.device,
+ dtype=distortion_scale.dtype,
+ ).expand(batch_size, -1, -1)
+
+ # generate random offset not larger than half of the image
+ fx = distortion_scale * width / 2
+ fy = distortion_scale * height / 2
+
+ factor = torch.stack([fx, fy], dim=0).view(-1, 1, 2)
+
+ # TODO: This line somehow breaks the gradcheck
+ rand_val: torch.Tensor = _adapted_uniform(
+ start_points.shape,
+ torch.tensor(0, device=device, dtype=dtype),
+ torch.tensor(1, device=device, dtype=dtype),
+ same_on_batch,
+ ).to(device=distortion_scale.device, dtype=distortion_scale.dtype)
+
+ pts_norm = torch.tensor(
+ [[[1, 1], [-1, 1], [-1, -1], [1, -1]]], device=distortion_scale.device, dtype=distortion_scale.dtype
+ )
+ end_points = start_points + factor * rand_val * pts_norm
+
+ return dict(start_points=start_points, end_points=end_points)
+
+
+def random_affine_generator(
+ batch_size: int,
+ height: int,
+ width: int,
+ degrees: torch.Tensor,
+ translate: Optional[torch.Tensor] = None,
+ scale: Optional[torch.Tensor] = None,
+ shear: Optional[torch.Tensor] = None,
+ same_on_batch: bool = False,
+ device: torch.device = torch.device('cpu'),
+ dtype: torch.dtype = torch.float32,
+) -> Dict[str, torch.Tensor]:
+ r"""Get parameters for ``affine`` for a random affine transform.
+
+ Args:
+ batch_size (int): the tensor batch size.
+ height (int) : height of the image.
+ width (int): width of the image.
+ degrees (torch.Tensor): Range of degrees to select from like (min, max).
+ translate (tensor, optional): tuple of maximum absolute fraction for horizontal
+ and vertical translations. For example translate=(a, b), then horizontal shift
+ is randomly sampled in the range -img_width * a < dx < img_width * a and vertical shift is
+ randomly sampled in the range -img_height * b < dy < img_height * b. Will not translate by default.
+ scale (tensor, optional): scaling factor interval, e.g (a, b), then scale is
+ randomly sampled from the range a <= scale <= b. Will keep original scale by default.
+ shear (tensor, optional): Range of degrees to select from.
+ Shear is a 2x2 tensor, a x-axis shear in (shear[0][0], shear[0][1]) and y-axis shear in
+ (shear[1][0], shear[1][1]) will be applied. Will not apply shear by default.
+ same_on_batch (bool): apply the same transformation across the batch. Default: False.
+ device (torch.device): the device on which the random numbers will be generated. Default: cpu.
+ dtype (torch.dtype): the data type of the generated random numbers. Default: float32.
+
+ Returns:
+ params Dict[str, torch.Tensor]: parameters to be passed for transformation.
+ - translations (torch.Tensor): element-wise translations with a shape of (B, 2).
+ - center (torch.Tensor): element-wise center with a shape of (B, 2).
+ - scale (torch.Tensor): element-wise scales with a shape of (B, 2).
+ - angle (torch.Tensor): element-wise rotation angles with a shape of (B,).
+ - sx (torch.Tensor): element-wise x-axis shears with a shape of (B,).
+ - sy (torch.Tensor): element-wise y-axis shears with a shape of (B,).
+
+ Note:
+ The generated random numbers are not reproducible across different devices and dtypes.
+ """
+ _common_param_check(batch_size, same_on_batch)
+ _joint_range_check(degrees, "degrees")
+ if not (isinstance(width, (int,)) and isinstance(height, (int,)) and width > 0 and height > 0):
+ raise AssertionError(f"`width` and `height` must be positive integers. Got {width}, {height}.")
+
+ _device, _dtype = _extract_device_dtype([degrees, translate, scale, shear])
+ degrees = degrees.to(device=device, dtype=dtype)
+ angle = _adapted_uniform((batch_size,), degrees[0], degrees[1], same_on_batch)
+ angle = angle.to(device=_device, dtype=_dtype)
+
+ # compute tensor ranges
+ if scale is not None:
+ scale = scale.to(device=device, dtype=dtype)
+ if not (len(scale.shape) == 1 and len(scale) in (2, 4)):
+ raise AssertionError(f"`scale` shall have 2 or 4 elements. Got {scale}.")
+ _joint_range_check(cast(torch.Tensor, scale[:2]), "scale")
+ _scale = _adapted_uniform((batch_size,), scale[0], scale[1], same_on_batch).unsqueeze(1).repeat(1, 2)
+ if len(scale) == 4:
+ _joint_range_check(cast(torch.Tensor, scale[2:]), "scale_y")
+ _scale[:, 1] = _adapted_uniform((batch_size,), scale[2], scale[3], same_on_batch)
+ _scale = _scale.to(device=_device, dtype=_dtype)
+ else:
+ _scale = torch.ones((batch_size, 2), device=_device, dtype=_dtype)
+
+ if translate is not None:
+ translate = translate.to(device=device, dtype=dtype)
+ if not (0.0 <= translate[0] <= 1.0 and 0.0 <= translate[1] <= 1.0 and translate.shape == torch.Size([2])):
+ raise AssertionError(f"Expect translate contains two elements and ranges are in [0, 1]. Got {translate}.")
+ max_dx: torch.Tensor = translate[0] * width
+ max_dy: torch.Tensor = translate[1] * height
+ translations = torch.stack(
+ [
+ _adapted_uniform((batch_size,), -max_dx, max_dx, same_on_batch),
+ _adapted_uniform((batch_size,), -max_dy, max_dy, same_on_batch),
+ ],
+ dim=-1,
+ )
+ translations = translations.to(device=_device, dtype=_dtype)
+ else:
+ translations = torch.zeros((batch_size, 2), device=_device, dtype=_dtype)
+
+ center: torch.Tensor = torch.tensor([width, height], device=_device, dtype=_dtype).view(1, 2) / 2.0 - 0.5
+ center = center.expand(batch_size, -1)
+
+ if shear is not None:
+ shear = shear.to(device=device, dtype=dtype)
+ _joint_range_check(cast(torch.Tensor, shear)[0], "shear")
+ _joint_range_check(cast(torch.Tensor, shear)[1], "shear")
+ sx = _adapted_uniform((batch_size,), shear[0][0], shear[0][1], same_on_batch)
+ sy = _adapted_uniform((batch_size,), shear[1][0], shear[1][1], same_on_batch)
+ sx = sx.to(device=_device, dtype=_dtype)
+ sy = sy.to(device=_device, dtype=_dtype)
+ else:
+ sx = sy = torch.tensor([0] * batch_size, device=_device, dtype=_dtype)
+
+ return dict(translations=translations, center=center, scale=_scale, angle=angle, sx=sx, sy=sy)
+
+
+def random_rotation_generator(
+ batch_size: int,
+ degrees: torch.Tensor,
+ same_on_batch: bool = False,
+ device: torch.device = torch.device('cpu'),
+ dtype: torch.dtype = torch.float32,
+) -> Dict[str, torch.Tensor]:
+ r"""Get parameters for ``rotate`` for a random rotate transform.
+
+ Args:
+ batch_size (int): the tensor batch size.
+ degrees (torch.Tensor): range of degrees with shape (2) to select from.
+ same_on_batch (bool): apply the same transformation across the batch. Default: False.
+ device (torch.device): the device on which the random numbers will be generated. Default: cpu.
+ dtype (torch.dtype): the data type of the generated random numbers. Default: float32.
+
+ Returns:
+ params Dict[str, torch.Tensor]: parameters to be passed for transformation.
+ - degrees (torch.Tensor): element-wise rotation degrees with a shape of (B,).
+
+ Note:
+ The generated random numbers are not reproducible across different devices and dtypes.
+ """
+ _common_param_check(batch_size, same_on_batch)
+ _joint_range_check(degrees, "degrees")
+
+ _degrees = _adapted_uniform(
+ (batch_size,),
+ degrees[0].to(device=device, dtype=dtype),
+ degrees[1].to(device=device, dtype=dtype),
+ same_on_batch,
+ )
+ _degrees = _degrees.to(device=degrees.device, dtype=degrees.dtype)
+
+ return dict(degrees=_degrees)
+
+
+def random_crop_generator(
+ batch_size: int,
+ input_size: Tuple[int, int],
+ size: Union[Tuple[int, int], torch.Tensor],
+ resize_to: Optional[Tuple[int, int]] = None,
+ same_on_batch: bool = False,
+ device: torch.device = torch.device('cpu'),
+ dtype: torch.dtype = torch.float32,
+) -> Dict[str, torch.Tensor]:
+ r"""Get parameters for ```crop``` transformation for crop transform.
+
+ Args:
+ batch_size (int): the tensor batch size.
+ input_size (tuple): Input image shape, like (h, w).
+ size (tuple): Desired size of the crop operation, like (h, w).
+ If tensor, it must be (B, 2).
+ resize_to (tuple): Desired output size of the crop, like (h, w). If None, no resize will be performed.
+ same_on_batch (bool): apply the same transformation across the batch. Default: False.
+ device (torch.device): the device on which the random numbers will be generated. Default: cpu.
+ dtype (torch.dtype): the data type of the generated random numbers. Default: float32.
+
+ Returns:
+ params Dict[str, torch.Tensor]: parameters to be passed for transformation.
+ - src (torch.Tensor): cropping bounding boxes with a shape of (B, 4, 2).
+ - dst (torch.Tensor): output bounding boxes with a shape (B, 4, 2).
+
+ Note:
+ The generated random numbers are not reproducible across different devices and dtypes.
+
+ Example:
+ >>> _ = torch.manual_seed(0)
+ >>> crop_size = torch.tensor([[25, 28], [27, 29], [26, 28]])
+ >>> random_crop_generator(3, (30, 30), size=crop_size, same_on_batch=False)
+ {'src': tensor([[[ 1., 0.],
+ [28., 0.],
+ [28., 24.],
+ [ 1., 24.]],
+
+ [[ 1., 1.],
+ [29., 1.],
+ [29., 27.],
+ [ 1., 27.]],
+
+ [[ 0., 3.],
+ [27., 3.],
+ [27., 28.],
+ [ 0., 28.]]]), 'dst': tensor([[[ 0., 0.],
+ [27., 0.],
+ [27., 24.],
+ [ 0., 24.]],
+
+ [[ 0., 0.],
+ [28., 0.],
+ [28., 26.],
+ [ 0., 26.]],
+
+ [[ 0., 0.],
+ [27., 0.],
+ [27., 25.],
+ [ 0., 25.]]]), 'input_size': tensor([[30, 30],
+ [30, 30],
+ [30, 30]])}
+ """
+ _common_param_check(batch_size, same_on_batch)
+ _device, _dtype = _extract_device_dtype([size if isinstance(size, torch.Tensor) else None])
+ # Use float point instead
+ _dtype = _dtype if _dtype in [torch.float16, torch.float32, torch.float64] else dtype
+ if not isinstance(size, torch.Tensor):
+ size = torch.tensor(size, device=_device, dtype=_dtype).repeat(batch_size, 1)
+ else:
+ size = size.to(device=_device, dtype=_dtype)
+ if size.shape != torch.Size([batch_size, 2]):
+ raise AssertionError(
+ "If `size` is a tensor, it must be shaped as (B, 2). "
+ f"Got {size.shape} while expecting {torch.Size([batch_size, 2])}."
+ )
+ if not (input_size[0] > 0 and input_size[1] > 0 and (size > 0).all()):
+ raise AssertionError(f"Got non-positive input size or size. {input_size}, {size}.")
+ size = size.floor()
+
+ x_diff = input_size[1] - size[:, 1] + 1
+ y_diff = input_size[0] - size[:, 0] + 1
+
+ # Start point will be 0 if diff < 0
+ x_diff = x_diff.clamp(0)
+ y_diff = y_diff.clamp(0)
+
+ if batch_size == 0:
+ return dict(
+ src=torch.zeros([0, 4, 2], device=_device, dtype=_dtype),
+ dst=torch.zeros([0, 4, 2], device=_device, dtype=_dtype),
+ )
+
+ if same_on_batch:
+ # If same_on_batch, select the first then repeat.
+ x_start = _adapted_uniform((batch_size,), 0, x_diff[0].to(device=device, dtype=dtype), same_on_batch).floor()
+ y_start = _adapted_uniform((batch_size,), 0, y_diff[0].to(device=device, dtype=dtype), same_on_batch).floor()
+ else:
+ x_start = _adapted_uniform((1,), 0, x_diff.to(device=device, dtype=dtype), same_on_batch).floor()
+ y_start = _adapted_uniform((1,), 0, y_diff.to(device=device, dtype=dtype), same_on_batch).floor()
+ crop_src = bbox_generator(
+ x_start.view(-1).to(device=_device, dtype=_dtype),
+ y_start.view(-1).to(device=_device, dtype=_dtype),
+ torch.where(size[:, 1] == 0, torch.tensor(input_size[1], device=_device, dtype=_dtype), size[:, 1]),
+ torch.where(size[:, 0] == 0, torch.tensor(input_size[0], device=_device, dtype=_dtype), size[:, 0]),
+ )
+
+ if resize_to is None:
+ crop_dst = bbox_generator(
+ torch.tensor([0] * batch_size, device=_device, dtype=_dtype),
+ torch.tensor([0] * batch_size, device=_device, dtype=_dtype),
+ size[:, 1],
+ size[:, 0],
+ )
+ else:
+ if not (
+ len(resize_to) == 2
+ and isinstance(resize_to[0], (int,))
+ and isinstance(resize_to[1], (int,))
+ and resize_to[0] > 0
+ and resize_to[1] > 0
+ ):
+ raise AssertionError(f"`resize_to` must be a tuple of 2 positive integers. Got {resize_to}.")
+ crop_dst = torch.tensor(
+ [[[0, 0], [resize_to[1] - 1, 0], [resize_to[1] - 1, resize_to[0] - 1], [0, resize_to[0] - 1]]],
+ device=_device,
+ dtype=_dtype,
+ ).repeat(batch_size, 1, 1)
+
+ _input_size = torch.tensor(input_size, device=_device, dtype=torch.long).expand(batch_size, -1)
+
+ return dict(src=crop_src, dst=crop_dst, input_size=_input_size)
+
+
+def random_crop_size_generator(
+ batch_size: int,
+ size: Tuple[int, int],
+ scale: torch.Tensor,
+ ratio: torch.Tensor,
+ same_on_batch: bool = False,
+ device: torch.device = torch.device('cpu'),
+ dtype: torch.dtype = torch.float32,
+) -> Dict[str, torch.Tensor]:
+ r"""Get cropping heights and widths for ```crop``` transformation for resized crop transform.
+
+ Args:
+ batch_size (int): the tensor batch size.
+ size (Tuple[int, int]): expected output size of each edge.
+ scale (torch.Tensor): range of size of the origin size cropped with (2,) shape.
+ ratio (torch.Tensor): range of aspect ratio of the origin aspect ratio cropped with (2,) shape.
+ same_on_batch (bool): apply the same transformation across the batch. Default: False.
+ device (torch.device): the device on which the random numbers will be generated. Default: cpu.
+ dtype (torch.dtype): the data type of the generated random numbers. Default: float32.
+
+ Returns:
+ params Dict[str, torch.Tensor]: parameters to be passed for transformation.
+ - size (torch.Tensor): element-wise cropping sizes with a shape of (B, 2).
+
+ Note:
+ The generated random numbers are not reproducible across different devices and dtypes.
+
+ Examples:
+ >>> _ = torch.manual_seed(42)
+ >>> random_crop_size_generator(3, (30, 30), scale=torch.tensor([.7, 1.3]), ratio=torch.tensor([.9, 1.]))
+ {'size': tensor([[29., 29.],
+ [27., 28.],
+ [26., 29.]])}
+ """
+ _common_param_check(batch_size, same_on_batch)
+ _joint_range_check(scale, "scale")
+ _joint_range_check(ratio, "ratio")
+ if not (len(size) == 2 and type(size[0]) is int and size[1] > 0 and type(size[1]) is int and size[1] > 0):
+ raise AssertionError(f"'height' and 'width' must be integers. Got {size}.")
+
+ _device, _dtype = _extract_device_dtype([scale, ratio])
+
+ if batch_size == 0:
+ return dict(size=torch.zeros([0, 2], device=_device, dtype=_dtype))
+
+ scale = scale.to(device=device, dtype=dtype)
+ ratio = ratio.to(device=device, dtype=dtype)
+ # 10 trails for each element
+ area = _adapted_uniform((batch_size, 10), scale[0] * size[0] * size[1], scale[1] * size[0] * size[1], same_on_batch)
+ log_ratio = _adapted_uniform((batch_size, 10), torch.log(ratio[0]), torch.log(ratio[1]), same_on_batch)
+ aspect_ratio = torch.exp(log_ratio)
+
+ w = torch.sqrt(area * aspect_ratio).round().floor()
+ h = torch.sqrt(area / aspect_ratio).round().floor()
+ # Element-wise w, h condition
+ cond = ((0 < w) * (w < size[0]) * (0 < h) * (h < size[1])).int()
+
+ # torch.argmax is not reproducible across devices: https://github.com/pytorch/pytorch/issues/17738
+ # Here, we will select the first occurrence of the duplicated elements.
+ cond_bool, argmax_dim1 = ((cond.cumsum(1) == 1) & cond.bool()).max(1)
+ h_out = w[torch.arange(0, batch_size, device=device, dtype=torch.long), argmax_dim1]
+ w_out = h[torch.arange(0, batch_size, device=device, dtype=torch.long), argmax_dim1]
+
+ if not cond_bool.all():
+ # Fallback to center crop
+ in_ratio = float(size[0]) / float(size[1])
+ if in_ratio < ratio.min():
+ h_ct = torch.tensor(size[0], device=device, dtype=dtype)
+ w_ct = torch.round(h_ct / ratio.min())
+ elif in_ratio > ratio.min():
+ w_ct = torch.tensor(size[1], device=device, dtype=dtype)
+ h_ct = torch.round(w_ct * ratio.min())
+ else: # whole image
+ h_ct = torch.tensor(size[0], device=device, dtype=dtype)
+ w_ct = torch.tensor(size[1], device=device, dtype=dtype)
+ h_ct = h_ct.floor()
+ w_ct = w_ct.floor()
+
+ h_out = h_out.where(cond_bool, h_ct)
+ w_out = w_out.where(cond_bool, w_ct)
+
+ return dict(size=torch.stack([h_out, w_out], dim=1).to(device=_device, dtype=_dtype))
+
+
+def random_rectangles_params_generator(
+ batch_size: int,
+ height: int,
+ width: int,
+ scale: torch.Tensor,
+ ratio: torch.Tensor,
+ value: float = 0.0,
+ same_on_batch: bool = False,
+ device: torch.device = torch.device('cpu'),
+ dtype: torch.dtype = torch.float32,
+) -> Dict[str, torch.Tensor]:
+ r"""Get parameters for ```erasing``` transformation for erasing transform.
+
+ Args:
+ batch_size (int): the tensor batch size.
+ height (int) : height of the image.
+ width (int): width of the image.
+ scale (torch.Tensor): range of size of the origin size cropped. Shape (2).
+ ratio (torch.Tensor): range of aspect ratio of the origin aspect ratio cropped. Shape (2).
+ value (float): value to be filled in the erased area.
+ same_on_batch (bool): apply the same transformation across the batch. Default: False.
+ device (torch.device): the device on which the random numbers will be generated. Default: cpu.
+ dtype (torch.dtype): the data type of the generated random numbers. Default: float32.
+
+ Returns:
+ params Dict[str, torch.Tensor]: parameters to be passed for transformation.
+ - widths (torch.Tensor): element-wise erasing widths with a shape of (B,).
+ - heights (torch.Tensor): element-wise erasing heights with a shape of (B,).
+ - xs (torch.Tensor): element-wise erasing x coordinates with a shape of (B,).
+ - ys (torch.Tensor): element-wise erasing y coordinates with a shape of (B,).
+ - values (torch.Tensor): element-wise filling values with a shape of (B,).
+
+ Note:
+ The generated random numbers are not reproducible across different devices and dtypes.
+ """
+ _common_param_check(batch_size, same_on_batch)
+ _device, _dtype = _extract_device_dtype([ratio, scale])
+ if not (type(height) is int and height > 0 and type(width) is int and width > 0):
+ raise AssertionError(f"'height' and 'width' must be integers. Got {height}, {width}.")
+ if not (isinstance(value, (int, float)) and value >= 0 and value <= 1):
+ raise AssertionError(f"'value' must be a number between 0 - 1. Got {value}.")
+ _joint_range_check(scale, 'scale', bounds=(0, float('inf')))
+ _joint_range_check(ratio, 'ratio', bounds=(0, float('inf')))
+
+ images_area = height * width
+ target_areas = (
+ _adapted_uniform(
+ (batch_size,),
+ scale[0].to(device=device, dtype=dtype),
+ scale[1].to(device=device, dtype=dtype),
+ same_on_batch,
+ )
+ * images_area
+ )
+
+ if ratio[0] < 1.0 and ratio[1] > 1.0:
+ aspect_ratios1 = _adapted_uniform((batch_size,), ratio[0].to(device=device, dtype=dtype), 1, same_on_batch)
+ aspect_ratios2 = _adapted_uniform((batch_size,), 1, ratio[1].to(device=device, dtype=dtype), same_on_batch)
+ if same_on_batch:
+ rand_idxs = (
+ torch.round(
+ _adapted_uniform(
+ (1,),
+ torch.tensor(0, device=device, dtype=dtype),
+ torch.tensor(1, device=device, dtype=dtype),
+ same_on_batch,
+ )
+ )
+ .repeat(batch_size)
+ .bool()
+ )
+ else:
+ rand_idxs = torch.round(
+ _adapted_uniform(
+ (batch_size,),
+ torch.tensor(0, device=device, dtype=dtype),
+ torch.tensor(1, device=device, dtype=dtype),
+ same_on_batch,
+ )
+ ).bool()
+ aspect_ratios = torch.where(rand_idxs, aspect_ratios1, aspect_ratios2)
+ else:
+ aspect_ratios = _adapted_uniform(
+ (batch_size,),
+ ratio[0].to(device=device, dtype=dtype),
+ ratio[1].to(device=device, dtype=dtype),
+ same_on_batch,
+ )
+
+ # based on target areas and aspect ratios, rectangle params are computed
+ heights = torch.min(
+ torch.max(
+ torch.round((target_areas * aspect_ratios) ** (1 / 2)), torch.tensor(1.0, device=device, dtype=dtype)
+ ),
+ torch.tensor(height, device=device, dtype=dtype),
+ )
+
+ widths = torch.min(
+ torch.max(
+ torch.round((target_areas / aspect_ratios) ** (1 / 2)), torch.tensor(1.0, device=device, dtype=dtype)
+ ),
+ torch.tensor(width, device=device, dtype=dtype),
+ )
+
+ xs_ratio = _adapted_uniform(
+ (batch_size,),
+ torch.tensor(0, device=device, dtype=dtype),
+ torch.tensor(1, device=device, dtype=dtype),
+ same_on_batch,
+ )
+ ys_ratio = _adapted_uniform(
+ (batch_size,),
+ torch.tensor(0, device=device, dtype=dtype),
+ torch.tensor(1, device=device, dtype=dtype),
+ same_on_batch,
+ )
+
+ xs = xs_ratio * (torch.tensor(width, device=device, dtype=dtype) - widths + 1)
+ ys = ys_ratio * (torch.tensor(height, device=device, dtype=dtype) - heights + 1)
+
+ return dict(
+ widths=widths.floor().to(device=_device, dtype=_dtype),
+ heights=heights.floor().to(device=_device, dtype=_dtype),
+ xs=xs.floor().to(device=_device, dtype=_dtype),
+ ys=ys.floor().to(device=_device, dtype=_dtype),
+ values=torch.tensor([value] * batch_size, device=_device, dtype=_dtype),
+ )
+
+
+def center_crop_generator(
+ batch_size: int, height: int, width: int, size: Tuple[int, int], device: torch.device = torch.device('cpu')
+) -> Dict[str, torch.Tensor]:
+ r"""Get parameters for ```center_crop``` transformation for center crop transform.
+
+ Args:
+ batch_size (int): the tensor batch size.
+ height (int) : height of the image.
+ width (int): width of the image.
+ size (tuple): Desired output size of the crop, like (h, w).
+ device (torch.device): the device on which the random numbers will be generated. Default: cpu.
+
+ Returns:
+ params Dict[str, torch.Tensor]: parameters to be passed for transformation.
+ - src (torch.Tensor): cropping bounding boxes with a shape of (B, 4, 2).
+ - dst (torch.Tensor): output bounding boxes with a shape (B, 4, 2).
+
+ Note:
+ No random number will be generated.
+ """
+ _common_param_check(batch_size)
+ if not isinstance(size, (tuple, list)) and len(size) == 2:
+ raise ValueError(f"Input size must be a tuple/list of length 2. Got {size}")
+ if not (type(height) is int and height > 0 and type(width) is int and width > 0):
+ raise AssertionError(f"'height' and 'width' must be integers. Got {height}, {width}.")
+ if not (height >= size[0] and width >= size[1]):
+ raise AssertionError(f"Crop size must be smaller than input size. Got ({height}, {width}) and {size}.")
+
+ # unpack input sizes
+ dst_h, dst_w = size
+ src_h, src_w = height, width
+
+ # compute start/end offsets
+ dst_h_half = dst_h / 2
+ dst_w_half = dst_w / 2
+ src_h_half = src_h / 2
+ src_w_half = src_w / 2
+
+ start_x = int(src_w_half - dst_w_half)
+ start_y = int(src_h_half - dst_h_half)
+
+ end_x = start_x + dst_w - 1
+ end_y = start_y + dst_h - 1
+
+ # [y, x] origin
+ # top-left, top-right, bottom-right, bottom-left
+ points_src: torch.Tensor = torch.tensor(
+ [[[start_x, start_y], [end_x, start_y], [end_x, end_y], [start_x, end_y]]], device=device, dtype=torch.long
+ ).expand(batch_size, -1, -1)
+
+ # [y, x] destination
+ # top-left, top-right, bottom-right, bottom-left
+ points_dst: torch.Tensor = torch.tensor(
+ [[[0, 0], [dst_w - 1, 0], [dst_w - 1, dst_h - 1], [0, dst_h - 1]]], device=device, dtype=torch.long
+ ).expand(batch_size, -1, -1)
+
+ _input_size = torch.tensor((height, width), device=device, dtype=torch.long).expand(batch_size, -1)
+
+ return dict(src=points_src, dst=points_dst, input_size=_input_size)
+
+
+def random_motion_blur_generator(
+ batch_size: int,
+ kernel_size: Union[int, Tuple[int, int]],
+ angle: torch.Tensor,
+ direction: torch.Tensor,
+ same_on_batch: bool = False,
+ device: torch.device = torch.device('cpu'),
+ dtype: torch.dtype = torch.float32,
+) -> Dict[str, torch.Tensor]:
+ r"""Get parameters for motion blur.
+
+ Args:
+ batch_size (int): the tensor batch size.
+ kernel_size (int or (int, int)): motion kernel size (odd and positive) or range.
+ angle (torch.Tensor): angle of the motion blur in degrees (anti-clockwise rotation).
+ direction (torch.Tensor): forward/backward direction of the motion blur.
+ Lower values towards -1.0 will point the motion blur towards the back (with
+ angle provided via angle), while higher values towards 1.0 will point the motion
+ blur forward. A value of 0.0 leads to a uniformly (but still angled) motion blur.
+ same_on_batch (bool): apply the same transformation across the batch. Default: False.
+ device (torch.device): the device on which the random numbers will be generated. Default: cpu.
+ dtype (torch.dtype): the data type of the generated random numbers. Default: float32.
+
+ Returns:
+ params Dict[str, torch.Tensor]: parameters to be passed for transformation.
+ - ksize_factor (torch.Tensor): element-wise kernel size factors with a shape of (B,).
+ - angle_factor (torch.Tensor): element-wise angle factors with a shape of (B,).
+ - direction_factor (torch.Tensor): element-wise direction factors with a shape of (B,).
+
+ Note:
+ The generated random numbers are not reproducible across different devices and dtypes.
+ """
+ _common_param_check(batch_size, same_on_batch)
+ _joint_range_check(angle, 'angle')
+ _joint_range_check(direction, 'direction', (-1, 1))
+
+ _device, _dtype = _extract_device_dtype([angle, direction])
+
+ if isinstance(kernel_size, int):
+ if not (kernel_size >= 3 and kernel_size % 2 == 1):
+ raise AssertionError(f"`kernel_size` must be odd and greater than 3. Got {kernel_size}.")
+ ksize_factor = torch.tensor([kernel_size] * batch_size, device=device, dtype=dtype)
+ elif isinstance(kernel_size, tuple):
+ # kernel_size is fixed across the batch
+ if len(kernel_size) != 2:
+ raise AssertionError(f"`kernel_size` must be (2,) if it is a tuple. Got {kernel_size}.")
+ ksize_factor = (
+ _adapted_uniform((batch_size,), kernel_size[0] // 2, kernel_size[1] // 2, same_on_batch=True).int() * 2 + 1
+ )
+ else:
+ raise TypeError(f"Unsupported type: {type(kernel_size)}")
+
+ angle_factor = _adapted_uniform(
+ (batch_size,), angle[0].to(device=device, dtype=dtype), angle[1].to(device=device, dtype=dtype), same_on_batch
+ )
+
+ direction_factor = _adapted_uniform(
+ (batch_size,),
+ direction[0].to(device=device, dtype=dtype),
+ direction[1].to(device=device, dtype=dtype),
+ same_on_batch,
+ )
+
+ return dict(
+ ksize_factor=ksize_factor.to(device=_device, dtype=torch.int32),
+ angle_factor=angle_factor.to(device=_device, dtype=_dtype),
+ direction_factor=direction_factor.to(device=_device, dtype=_dtype),
+ )
+
+
+def random_solarize_generator(
+ batch_size: int,
+ thresholds: torch.Tensor = torch.tensor([0.4, 0.6]),
+ additions: torch.Tensor = torch.tensor([-0.1, 0.1]),
+ same_on_batch: bool = False,
+ device: torch.device = torch.device('cpu'),
+ dtype: torch.dtype = torch.float32,
+) -> Dict[str, torch.Tensor]:
+ r"""Generate random solarize parameters for a batch of images.
+
+ For each pixel in the image less than threshold, we add 'addition' amount to it and then clip the pixel value
+ to be between 0 and 1.0
+
+ Args:
+ batch_size (int): the number of images.
+ thresholds (torch.Tensor): Pixels less than threshold will selected. Otherwise, subtract 1.0 from the pixel.
+ Takes in a range tensor of (0, 1). Default value will be sampled from [0.4, 0.6].
+ additions (torch.Tensor): The value is between -0.5 and 0.5. Default value will be sampled from [-0.1, 0.1]
+ same_on_batch (bool): apply the same transformation across the batch. Default: False.
+ device (torch.device): the device on which the random numbers will be generated. Default: cpu.
+ dtype (torch.dtype): the data type of the generated random numbers. Default: float32.
+
+ Returns:
+ params Dict[str, torch.Tensor]: parameters to be passed for transformation.
+ - thresholds_factor (torch.Tensor): element-wise thresholds factors with a shape of (B,).
+ - additions_factor (torch.Tensor): element-wise additions factors with a shape of (B,).
+
+ Note:
+ The generated random numbers are not reproducible across different devices and dtypes.
+ """
+ _common_param_check(batch_size, same_on_batch)
+ _joint_range_check(thresholds, 'thresholds', (0, 1))
+ _joint_range_check(additions, 'additions', (-0.5, 0.5))
+
+ _device, _dtype = _extract_device_dtype([thresholds, additions])
+
+ thresholds_factor = _adapted_uniform(
+ (batch_size,),
+ thresholds[0].to(device=device, dtype=dtype),
+ thresholds[1].to(device=device, dtype=dtype),
+ same_on_batch,
+ )
+
+ additions_factor = _adapted_uniform(
+ (batch_size,),
+ additions[0].to(device=device, dtype=dtype),
+ additions[1].to(device=device, dtype=dtype),
+ same_on_batch,
+ )
+
+ return dict(
+ thresholds_factor=thresholds_factor.to(device=_device, dtype=_dtype),
+ additions_factor=additions_factor.to(device=_device, dtype=_dtype),
+ )
+
+
+def random_posterize_generator(
+ batch_size: int,
+ bits: torch.Tensor = torch.tensor([3, 5]),
+ same_on_batch: bool = False,
+ device: torch.device = torch.device('cpu'),
+ dtype: torch.dtype = torch.float32,
+) -> Dict[str, torch.Tensor]:
+ r"""Generate random posterize parameters for a batch of images.
+
+ Args:
+ batch_size (int): the number of images.
+ bits (int or tuple): Takes in an integer tuple tensor that ranged from 0 ~ 8. Default value is [3, 5].
+ same_on_batch (bool): apply the same transformation across the batch. Default: False.
+ device (torch.device): the device on which the random numbers will be generated. Default: cpu.
+ dtype (torch.dtype): the data type of the generated random numbers. Default: float32.
+
+ Returns:
+ params Dict[str, torch.Tensor]: parameters to be passed for transformation.
+ - bits_factor (torch.Tensor): element-wise bit factors with a shape of (B,).
+
+ Note:
+ The generated random numbers are not reproducible across different devices and dtypes.
+ """
+ _common_param_check(batch_size, same_on_batch)
+ _joint_range_check(bits, 'bits', (0, 8))
+ bits_factor = _adapted_uniform(
+ (batch_size,), bits[0].to(device=device, dtype=dtype), bits[1].to(device=device, dtype=dtype), same_on_batch
+ ).int()
+
+ return dict(bits_factor=bits_factor.to(device=bits.device, dtype=torch.int32))
+
+
+def random_sharpness_generator(
+ batch_size: int,
+ sharpness: torch.Tensor = torch.tensor([0, 1.0]),
+ same_on_batch: bool = False,
+ device: torch.device = torch.device('cpu'),
+ dtype: torch.dtype = torch.float32,
+) -> Dict[str, torch.Tensor]:
+ r"""Generate random sharpness parameters for a batch of images.
+
+ Args:
+ batch_size (int): the number of images.
+ sharpness (torch.Tensor): Must be above 0. Default value is sampled from (0, 1).
+ same_on_batch (bool): apply the same transformation across the batch. Default: False.
+ device (torch.device): the device on which the random numbers will be generated. Default: cpu.
+ dtype (torch.dtype): the data type of the generated random numbers. Default: float32.
+
+ Returns:
+ params Dict[str, torch.Tensor]: parameters to be passed for transformation.
+ - sharpness_factor (torch.Tensor): element-wise sharpness factors with a shape of (B,).
+
+ Note:
+ The generated random numbers are not reproducible across different devices and dtypes.
+ """
+ _common_param_check(batch_size, same_on_batch)
+ _joint_range_check(sharpness, 'sharpness', bounds=(0, float('inf')))
+
+ sharpness_factor = _adapted_uniform(
+ (batch_size,),
+ sharpness[0].to(device=device, dtype=dtype),
+ sharpness[1].to(device=device, dtype=dtype),
+ same_on_batch,
+ )
+
+ return dict(sharpness_factor=sharpness_factor.to(device=sharpness.device, dtype=sharpness.dtype))
+
+
+def random_mixup_generator(
+ batch_size: int,
+ p: float = 0.5,
+ lambda_val: Optional[torch.Tensor] = None,
+ same_on_batch: bool = False,
+ device: torch.device = torch.device('cpu'),
+ dtype: torch.dtype = torch.float32,
+) -> Dict[str, torch.Tensor]:
+ r"""Generate mixup indexes and lambdas for a batch of inputs.
+
+ Args:
+ batch_size (int): the number of images. If batchsize == 1, the output will be as same as the input.
+ p (flot): probability of applying mixup.
+ lambda_val (torch.Tensor, optional): min-max strength for mixup images, ranged from [0., 1.].
+ If None, it will be set to tensor([0., 1.]), which means no restrictions.
+ same_on_batch (bool): apply the same transformation across the batch. Default: False.
+ device (torch.device): the device on which the random numbers will be generated. Default: cpu.
+ dtype (torch.dtype): the data type of the generated random numbers. Default: float32.
+
+ Returns:
+ params Dict[str, torch.Tensor]: parameters to be passed for transformation.
+ - mix_pairs (torch.Tensor): element-wise probabilities with a shape of (B,).
+ - mixup_lambdas (torch.Tensor): element-wise probabilities with a shape of (B,).
+
+ Note:
+ The generated random numbers are not reproducible across different devices and dtypes.
+
+ Examples:
+ >>> rng = torch.manual_seed(0)
+ >>> random_mixup_generator(5, 0.7)
+ {'mixup_pairs': tensor([4, 0, 3, 1, 2]), 'mixup_lambdas': tensor([0.6323, 0.0000, 0.4017, 0.0223, 0.1689])}
+ """
+ _common_param_check(batch_size, same_on_batch)
+ _device, _dtype = _extract_device_dtype([lambda_val])
+ lambda_val = torch.as_tensor([0.0, 1.0] if lambda_val is None else lambda_val, device=device, dtype=dtype)
+ _joint_range_check(lambda_val, 'lambda_val', bounds=(0, 1))
+
+ batch_probs: torch.Tensor = random_prob_generator(
+ batch_size, p, same_on_batch=same_on_batch, device=device, dtype=dtype
+ )
+ mixup_pairs: torch.Tensor = torch.randperm(batch_size, device=device, dtype=dtype).long()
+ mixup_lambdas: torch.Tensor = _adapted_uniform(
+ (batch_size,), lambda_val[0], lambda_val[1], same_on_batch=same_on_batch
+ )
+ mixup_lambdas = mixup_lambdas * batch_probs
+
+ return dict(
+ mixup_pairs=mixup_pairs.to(device=_device, dtype=torch.long),
+ mixup_lambdas=mixup_lambdas.to(device=_device, dtype=_dtype),
+ )
+
+
+def random_cutmix_generator(
+ batch_size: int,
+ width: int,
+ height: int,
+ p: float = 0.5,
+ num_mix: int = 1,
+ beta: Optional[torch.Tensor] = None,
+ cut_size: Optional[torch.Tensor] = None,
+ same_on_batch: bool = False,
+ device: torch.device = torch.device('cpu'),
+ dtype: torch.dtype = torch.float32,
+) -> Dict[str, torch.Tensor]:
+ r"""Generate cutmix indexes and lambdas for a batch of inputs.
+
+ Args:
+ batch_size (int): the number of images. If batchsize == 1, the output will be as same as the input.
+ width (int): image width.
+ height (int): image height.
+ p (float): probability of applying cutmix.
+ num_mix (int): number of images to mix with. Default is 1.
+ beta (torch.Tensor, optional): hyperparameter for generating cut size from beta distribution.
+ If None, it will be set to 1.
+ cut_size (torch.Tensor, optional): controlling the minimum and maximum cut ratio from [0, 1].
+ If None, it will be set to [0, 1], which means no restriction.
+ same_on_batch (bool): apply the same transformation across the batch. Default: False.
+ device (torch.device): the device on which the random numbers will be generated. Default: cpu.
+ dtype (torch.dtype): the data type of the generated random numbers. Default: float32.
+
+ Returns:
+ params Dict[str, torch.Tensor]: parameters to be passed for transformation.
+ - mix_pairs (torch.Tensor): element-wise probabilities with a shape of (num_mix, B).
+ - crop_src (torch.Tensor): element-wise probabilities with a shape of (num_mix, B, 4, 2).
+
+ Note:
+ The generated random numbers are not reproducible across different devices and dtypes.
+
+ Examples:
+ >>> rng = torch.manual_seed(0)
+ >>> random_cutmix_generator(3, 224, 224, p=0.5, num_mix=2)
+ {'mix_pairs': tensor([[2, 0, 1],
+ [1, 2, 0]]), 'crop_src': tensor([[[[ 35., 25.],
+ [208., 25.],
+ [208., 198.],
+ [ 35., 198.]],
+
+ [[156., 137.],
+ [155., 137.],
+ [155., 136.],
+ [156., 136.]],
+
+ [[ 3., 12.],
+ [210., 12.],
+ [210., 219.],
+ [ 3., 219.]]],
+
+
+ [[[ 83., 125.],
+ [177., 125.],
+ [177., 219.],
+ [ 83., 219.]],
+
+ [[ 54., 8.],
+ [205., 8.],
+ [205., 159.],
+ [ 54., 159.]],
+
+ [[ 97., 70.],
+ [ 96., 70.],
+ [ 96., 69.],
+ [ 97., 69.]]]])}
+ """
+ _device, _dtype = _extract_device_dtype([beta, cut_size])
+ beta = torch.as_tensor(1.0 if beta is None else beta, device=device, dtype=dtype)
+ cut_size = torch.as_tensor([0.0, 1.0] if cut_size is None else cut_size, device=device, dtype=dtype)
+ if not (num_mix >= 1 and isinstance(num_mix, (int,))):
+ raise AssertionError(f"`num_mix` must be an integer greater than 1. Got {num_mix}.")
+ if not (type(height) is int and height > 0 and type(width) is int and width > 0):
+ raise AssertionError(f"'height' and 'width' must be integers. Got {height}, {width}.")
+ _joint_range_check(cut_size, 'cut_size', bounds=(0, 1))
+ _common_param_check(batch_size, same_on_batch)
+
+ if batch_size == 0:
+ return dict(
+ mix_pairs=torch.zeros([0, 3], device=_device, dtype=torch.long),
+ crop_src=torch.zeros([0, 4, 2], device=_device, dtype=torch.long),
+ )
+
+ batch_probs: torch.Tensor = random_prob_generator(
+ batch_size * num_mix, p, same_on_batch, device=device, dtype=dtype
+ )
+ mix_pairs: torch.Tensor = torch.rand(num_mix, batch_size, device=device, dtype=dtype).argsort(dim=1)
+ cutmix_betas: torch.Tensor = _adapted_beta((batch_size * num_mix,), beta, beta, same_on_batch=same_on_batch)
+ # Note: torch.clamp does not accept tensor, cutmix_betas.clamp(cut_size[0], cut_size[1]) throws:
+ # Argument 1 to "clamp" of "_TensorBase" has incompatible type "Tensor"; expected "float"
+ cutmix_betas = torch.min(torch.max(cutmix_betas, cut_size[0]), cut_size[1])
+ cutmix_rate = torch.sqrt(1.0 - cutmix_betas) * batch_probs
+
+ cut_height = (cutmix_rate * height).floor().to(device=device, dtype=_dtype)
+ cut_width = (cutmix_rate * width).floor().to(device=device, dtype=_dtype)
+ _gen_shape = (1,)
+
+ if same_on_batch:
+ _gen_shape = (cut_height.size(0),)
+ cut_height = cut_height[0]
+ cut_width = cut_width[0]
+
+ # Reserve at least 1 pixel for cropping.
+ x_start = (
+ _adapted_uniform(
+ _gen_shape,
+ torch.zeros_like(cut_width, device=device, dtype=dtype),
+ (width - cut_width - 1).to(device=device, dtype=dtype),
+ same_on_batch,
+ )
+ .floor()
+ .to(device=device, dtype=_dtype)
+ )
+ y_start = (
+ _adapted_uniform(
+ _gen_shape,
+ torch.zeros_like(cut_height, device=device, dtype=dtype),
+ (height - cut_height - 1).to(device=device, dtype=dtype),
+ same_on_batch,
+ )
+ .floor()
+ .to(device=device, dtype=_dtype)
+ )
+
+ crop_src = bbox_generator(x_start.squeeze(), y_start.squeeze(), cut_width, cut_height)
+
+ # (B * num_mix, 4, 2) => (num_mix, batch_size, 4, 2)
+ crop_src = crop_src.view(num_mix, batch_size, 4, 2)
+
+ return dict(
+ mix_pairs=mix_pairs.to(device=_device, dtype=torch.long),
+ crop_src=crop_src.floor().to(device=_device, dtype=_dtype),
+ )
diff --git a/kornia/augmentation/random_generator/random_generator3d.py b/kornia/augmentation/random_generator/random_generator3d.py
new file mode 100644
index 0000000000000000000000000000000000000000..1049dd8b3c1541f0903c1fd61db4321d781d6eef
--- /dev/null
+++ b/kornia/augmentation/random_generator/random_generator3d.py
@@ -0,0 +1,536 @@
+from typing import Dict, Optional, Tuple, Union
+
+import torch
+
+from kornia.geometry.bbox import bbox_generator3d
+from kornia.utils import _extract_device_dtype
+
+from ..utils import _adapted_uniform, _joint_range_check
+
+
+def random_rotation_generator3d(
+ batch_size: int,
+ degrees: torch.Tensor,
+ same_on_batch: bool = False,
+ device: torch.device = torch.device('cpu'),
+ dtype: torch.dtype = torch.float32,
+) -> Dict[str, torch.Tensor]:
+ r"""Get parameters for ``rotate`` for a random rotate transform.
+
+ Args:
+ batch_size (int): the tensor batch size.
+ degrees (torch.Tensor): Ranges of degrees (3, 2) for yaw, pitch and roll.
+ same_on_batch (bool): apply the same transformation across the batch. Default: False.
+ device (torch.device): the device on which the random numbers will be generated. Default: cpu.
+ dtype (torch.dtype): the data type of the generated random numbers. Default: float32.
+
+ Returns:
+ params Dict[str, torch.Tensor]: parameters to be passed for transformation.
+ - yaw (torch.Tensor): element-wise rotation yaws with a shape of (B,).
+ - pitch (torch.Tensor): element-wise rotation pitches with a shape of (B,).
+ - roll (torch.Tensor): element-wise rotation rolls with a shape of (B,).
+ """
+ if degrees.shape != torch.Size([3, 2]):
+ raise AssertionError(f"'degrees' must be the shape of (3, 2). Got {degrees.shape}.")
+ _device, _dtype = _extract_device_dtype([degrees])
+ degrees = degrees.to(device=device, dtype=dtype)
+ yaw = _adapted_uniform((batch_size,), degrees[0][0], degrees[0][1], same_on_batch)
+ pitch = _adapted_uniform((batch_size,), degrees[1][0], degrees[1][1], same_on_batch)
+ roll = _adapted_uniform((batch_size,), degrees[2][0], degrees[2][1], same_on_batch)
+
+ return dict(
+ yaw=yaw.to(device=_device, dtype=_dtype),
+ pitch=pitch.to(device=_device, dtype=_dtype),
+ roll=roll.to(device=_device, dtype=_dtype),
+ )
+
+
+def random_affine_generator3d(
+ batch_size: int,
+ depth: int,
+ height: int,
+ width: int,
+ degrees: torch.Tensor,
+ translate: Optional[torch.Tensor] = None,
+ scale: Optional[torch.Tensor] = None,
+ shears: Optional[torch.Tensor] = None,
+ same_on_batch: bool = False,
+ device: torch.device = torch.device('cpu'),
+ dtype: torch.dtype = torch.float32,
+) -> Dict[str, torch.Tensor]:
+ r"""Get parameters for ```3d affine``` transformation random affine transform.
+
+ Args:
+ batch_size (int): the tensor batch size.
+ depth (int) : depth of the image.
+ height (int) : height of the image.
+ width (int): width of the image.
+ degrees (torch.Tensor): Ranges of degrees with shape (3, 2) for yaw, pitch and roll.
+ translate (torch.Tensor, optional): maximum absolute fraction with shape (3,) for horizontal, vertical
+ and depthical translations (dx,dy,dz). Will not translate by default.
+ scale (torch.Tensor, optional): scaling factor interval, e.g (a, b), then scale is
+ randomly sampled from the range a <= scale <= b. Will keep original scale by default.
+ shear (sequence or float, optional): Range of degrees to select from.
+ Shaped as (6, 2) for 6 facet (xy, xz, yx, yz, zx, zy).
+ The shear to the i-th facet in the range (-shear[i, 0], shear[i, 1]) will be applied.
+ same_on_batch (bool): apply the same transformation across the batch. Default: False
+
+ Returns:
+ params Dict[str, torch.Tensor]: parameters to be passed for transformation.
+ - translations (torch.Tensor): element-wise translations with a shape of (B, 3).
+ - center (torch.Tensor): element-wise center with a shape of (B, 3).
+ - scale (torch.Tensor): element-wise scales with a shape of (B, 3).
+ - angle (torch.Tensor): element-wise rotation angles with a shape of (B, 3).
+ - sxy (torch.Tensor): element-wise x-y-facet shears with a shape of (B,).
+ - sxz (torch.Tensor): element-wise x-z-facet shears with a shape of (B,).
+ - syx (torch.Tensor): element-wise y-x-facet shears with a shape of (B,).
+ - syz (torch.Tensor): element-wise y-z-facet shears with a shape of (B,).
+ - szx (torch.Tensor): element-wise z-x-facet shears with a shape of (B,).
+ - szy (torch.Tensor): element-wise z-y-facet shears with a shape of (B,).
+
+ Note:
+ The generated random numbers are not reproducible across different devices and dtypes.
+ """
+ if not (
+ type(depth) is int and depth > 0 and type(height) is int and height > 0 and type(width) is int and width > 0
+ ):
+ raise AssertionError(f"'depth', 'height' and 'width' must be integers. Got {depth}, {height}, {width}.")
+
+ _device, _dtype = _extract_device_dtype([degrees, translate, scale, shears])
+ if degrees.shape != torch.Size([3, 2]):
+ raise AssertionError(f"'degrees' must be the shape of (3, 2). Got {degrees.shape}.")
+ degrees = degrees.to(device=device, dtype=dtype)
+ yaw = _adapted_uniform((batch_size,), degrees[0][0], degrees[0][1], same_on_batch)
+ pitch = _adapted_uniform((batch_size,), degrees[1][0], degrees[1][1], same_on_batch)
+ roll = _adapted_uniform((batch_size,), degrees[2][0], degrees[2][1], same_on_batch)
+ angles = torch.stack([yaw, pitch, roll], dim=1)
+
+ # compute tensor ranges
+ if scale is not None:
+ if scale.shape != torch.Size([3, 2]):
+ raise AssertionError(f"'scale' must be the shape of (3, 2). Got {scale.shape}.")
+ scale = scale.to(device=device, dtype=dtype)
+ scale = torch.stack(
+ [
+ _adapted_uniform((batch_size,), scale[0, 0], scale[0, 1], same_on_batch),
+ _adapted_uniform((batch_size,), scale[1, 0], scale[1, 1], same_on_batch),
+ _adapted_uniform((batch_size,), scale[2, 0], scale[2, 1], same_on_batch),
+ ],
+ dim=1,
+ )
+ else:
+ scale = torch.ones(batch_size, device=device, dtype=dtype).reshape(batch_size, 1).repeat(1, 3)
+
+ if translate is not None:
+ if translate.shape != torch.Size([3]):
+ raise AssertionError(f"'translate' must be the shape of (2). Got {translate.shape}.")
+ translate = translate.to(device=device, dtype=dtype)
+ max_dx: torch.Tensor = translate[0] * width
+ max_dy: torch.Tensor = translate[1] * height
+ max_dz: torch.Tensor = translate[2] * depth
+ # translations should be in x,y,z
+ translations = torch.stack(
+ [
+ _adapted_uniform((batch_size,), -max_dx, max_dx, same_on_batch),
+ _adapted_uniform((batch_size,), -max_dy, max_dy, same_on_batch),
+ _adapted_uniform((batch_size,), -max_dz, max_dz, same_on_batch),
+ ],
+ dim=1,
+ )
+ else:
+ translations = torch.zeros((batch_size, 3), device=device, dtype=dtype)
+
+ # center should be in x,y,z
+ center: torch.Tensor = torch.tensor([width, height, depth], device=device, dtype=dtype).view(1, 3) / 2.0 - 0.5
+ center = center.expand(batch_size, -1)
+
+ if shears is not None:
+ if shears.shape != torch.Size([6, 2]):
+ raise AssertionError(f"'shears' must be the shape of (6, 2). Got {shears.shape}.")
+ shears = shears.to(device=device, dtype=dtype)
+ sxy = _adapted_uniform((batch_size,), shears[0, 0], shears[0, 1], same_on_batch)
+ sxz = _adapted_uniform((batch_size,), shears[1, 0], shears[1, 1], same_on_batch)
+ syx = _adapted_uniform((batch_size,), shears[2, 0], shears[2, 1], same_on_batch)
+ syz = _adapted_uniform((batch_size,), shears[3, 0], shears[3, 1], same_on_batch)
+ szx = _adapted_uniform((batch_size,), shears[4, 0], shears[4, 1], same_on_batch)
+ szy = _adapted_uniform((batch_size,), shears[5, 0], shears[5, 1], same_on_batch)
+ else:
+ sxy = sxz = syx = syz = szx = szy = torch.tensor([0] * batch_size, device=device, dtype=dtype)
+
+ return dict(
+ translations=translations.to(device=_device, dtype=_dtype),
+ center=center.to(device=_device, dtype=_dtype),
+ scale=scale.to(device=_device, dtype=_dtype),
+ angles=angles.to(device=_device, dtype=_dtype),
+ sxy=sxy.to(device=_device, dtype=_dtype),
+ sxz=sxz.to(device=_device, dtype=_dtype),
+ syx=syx.to(device=_device, dtype=_dtype),
+ syz=syz.to(device=_device, dtype=_dtype),
+ szx=szx.to(device=_device, dtype=_dtype),
+ szy=szy.to(device=_device, dtype=_dtype),
+ )
+
+
+def random_motion_blur_generator3d(
+ batch_size: int,
+ kernel_size: Union[int, Tuple[int, int]],
+ angle: torch.Tensor,
+ direction: torch.Tensor,
+ same_on_batch: bool = False,
+ device: torch.device = torch.device('cpu'),
+ dtype: torch.dtype = torch.float32,
+) -> Dict[str, torch.Tensor]:
+ r"""Get parameters for motion blur.
+
+ Args:
+ batch_size (int): the tensor batch size.
+ kernel_size (int or (int, int)): motion kernel size (odd and positive) or range.
+ angle (torch.Tensor): yaw, pitch and roll range of the motion blur in degrees :math:`(3, 2)`.
+ direction (torch.Tensor): forward/backward direction of the motion blur.
+ Lower values towards -1.0 will point the motion blur towards the back (with
+ angle provided via angle), while higher values towards 1.0 will point the motion
+ blur forward. A value of 0.0 leads to a uniformly (but still angled) motion blur.
+ same_on_batch (bool): apply the same transformation across the batch. Default: False.
+ device (torch.device): the device on which the random numbers will be generated. Default: cpu.
+ dtype (torch.dtype): the data type of the generated random numbers. Default: float32.
+
+ Returns:
+ params Dict[str, torch.Tensor]: parameters to be passed for transformation.
+ - ksize_factor (torch.Tensor): element-wise kernel size factors with a shape of (B,).
+ - angle_factor (torch.Tensor): element-wise center with a shape of (B,).
+ - direction_factor (torch.Tensor): element-wise scales with a shape of (B,).
+
+ Note:
+ The generated random numbers are not reproducible across different devices and dtypes.
+ """
+ _device, _dtype = _extract_device_dtype([angle, direction])
+ _joint_range_check(direction, 'direction', (-1, 1))
+ if isinstance(kernel_size, int):
+ if not (kernel_size >= 3 and kernel_size % 2 == 1):
+ raise AssertionError(f"`kernel_size` must be odd and greater than 3. Got {kernel_size}.")
+ ksize_factor = torch.tensor([kernel_size] * batch_size, device=device, dtype=dtype).int()
+ elif isinstance(kernel_size, tuple):
+ if not (len(kernel_size) == 2 and kernel_size[0] >= 3 and kernel_size[0] <= kernel_size[1]):
+ raise AssertionError(f"`kernel_size` must be greater than 3. Got range {kernel_size}.")
+ # kernel_size is fixed across the batch
+ ksize_factor = (
+ _adapted_uniform((batch_size,), kernel_size[0] // 2, kernel_size[1] // 2, same_on_batch=True).int() * 2 + 1
+ )
+ else:
+ raise TypeError(f"Unsupported type: {type(kernel_size)}")
+
+ if angle.shape != torch.Size([3, 2]):
+ raise AssertionError(f"'angle' must be the shape of (3, 2). Got {angle.shape}.")
+ angle = angle.to(device=device, dtype=dtype)
+ yaw = _adapted_uniform((batch_size,), angle[0][0], angle[0][1], same_on_batch)
+ pitch = _adapted_uniform((batch_size,), angle[1][0], angle[1][1], same_on_batch)
+ roll = _adapted_uniform((batch_size,), angle[2][0], angle[2][1], same_on_batch)
+ angle_factor = torch.stack([yaw, pitch, roll], dim=1)
+
+ direction = direction.to(device=device, dtype=dtype)
+ direction_factor = _adapted_uniform((batch_size,), direction[0], direction[1], same_on_batch)
+
+ return dict(
+ ksize_factor=ksize_factor.to(device=_device),
+ angle_factor=angle_factor.to(device=_device, dtype=_dtype),
+ direction_factor=direction_factor.to(device=_device, dtype=_dtype),
+ )
+
+
+def center_crop_generator3d(
+ batch_size: int,
+ depth: int,
+ height: int,
+ width: int,
+ size: Tuple[int, int, int],
+ device: torch.device = torch.device('cpu'),
+) -> Dict[str, torch.Tensor]:
+ r"""Get parameters for ```center_crop3d``` transformation for center crop transform.
+
+ Args:
+ batch_size (int): the tensor batch size.
+ depth (int) : depth of the image.
+ height (int) : height of the image.
+ width (int): width of the image.
+ size (tuple): Desired output size of the crop, like (d, h, w).
+ device (torch.device): the device on which the random numbers will be generated. Default: cpu.
+
+ Returns:
+ params Dict[str, torch.Tensor]: parameters to be passed for transformation.
+ - src (torch.Tensor): cropping bounding boxes with a shape of (B, 8, 3).
+ - dst (torch.Tensor): output bounding boxes with a shape (B, 8, 3).
+
+ Note:
+ No random number will be generated.
+ """
+ if not isinstance(size, (tuple, list)) and len(size) == 3:
+ raise ValueError(f"Input size must be a tuple/list of length 3. Got {size}")
+ if not (
+ type(depth) is int and depth > 0 and type(height) is int and height > 0 and type(width) is int and width > 0
+ ):
+ raise AssertionError(f"'depth', 'height' and 'width' must be integers. Got {depth}, {height}, {width}.")
+ if not (depth >= size[0] and height >= size[1] and width >= size[2]):
+ raise AssertionError(f"Crop size must be smaller than input size. Got ({depth}, {height}, {width}) and {size}.")
+
+ if batch_size == 0:
+ return dict(src=torch.zeros([0, 8, 3]), dst=torch.zeros([0, 8, 3]))
+ # unpack input sizes
+ dst_d, dst_h, dst_w = size
+ src_d, src_h, src_w = (depth, height, width)
+
+ # compute start/end offsets
+ dst_d_half = dst_d / 2
+ dst_h_half = dst_h / 2
+ dst_w_half = dst_w / 2
+ src_d_half = src_d / 2
+ src_h_half = src_h / 2
+ src_w_half = src_w / 2
+
+ start_x = src_w_half - dst_w_half
+ start_y = src_h_half - dst_h_half
+ start_z = src_d_half - dst_d_half
+
+ end_x = start_x + dst_w - 1
+ end_y = start_y + dst_h - 1
+ end_z = start_z + dst_d - 1
+ # [x, y, z] origin
+ # top-left-front, top-right-front, bottom-right-front, bottom-left-front
+ # top-left-back, top-right-back, bottom-right-back, bottom-left-back
+ points_src: torch.Tensor = torch.tensor(
+ [
+ [
+ [start_x, start_y, start_z],
+ [end_x, start_y, start_z],
+ [end_x, end_y, start_z],
+ [start_x, end_y, start_z],
+ [start_x, start_y, end_z],
+ [end_x, start_y, end_z],
+ [end_x, end_y, end_z],
+ [start_x, end_y, end_z],
+ ]
+ ],
+ device=device,
+ dtype=torch.long,
+ ).expand(batch_size, -1, -1)
+
+ # [x, y, z] destination
+ # top-left-front, top-right-front, bottom-right-front, bottom-left-front
+ # top-left-back, top-right-back, bottom-right-back, bottom-left-back
+ points_dst: torch.Tensor = torch.tensor(
+ [
+ [
+ [0, 0, 0],
+ [dst_w - 1, 0, 0],
+ [dst_w - 1, dst_h - 1, 0],
+ [0, dst_h - 1, 0],
+ [0, 0, dst_d - 1],
+ [dst_w - 1, 0, dst_d - 1],
+ [dst_w - 1, dst_h - 1, dst_d - 1],
+ [0, dst_h - 1, dst_d - 1],
+ ]
+ ],
+ device=device,
+ dtype=torch.long,
+ ).expand(batch_size, -1, -1)
+ return dict(src=points_src, dst=points_dst)
+
+
+def random_crop_generator3d(
+ batch_size: int,
+ input_size: Tuple[int, int, int],
+ size: Union[Tuple[int, int, int], torch.Tensor],
+ resize_to: Optional[Tuple[int, int, int]] = None,
+ same_on_batch: bool = False,
+ device: torch.device = torch.device('cpu'),
+ dtype: torch.dtype = torch.float32,
+) -> Dict[str, torch.Tensor]:
+ r"""Get parameters for ```crop``` transformation for crop transform.
+
+ Args:
+ batch_size (int): the tensor batch size.
+ input_size (tuple): Input image shape, like (d, h, w).
+ size (tuple): Desired size of the crop operation, like (d, h, w).
+ If tensor, it must be (B, 3).
+ resize_to (tuple): Desired output size of the crop, like (d, h, w). If None, no resize will be performed.
+ same_on_batch (bool): apply the same transformation across the batch. Default: False.
+ device (torch.device): the device on which the random numbers will be generated. Default: cpu.
+ dtype (torch.dtype): the data type of the generated random numbers. Default: float32.
+
+ Returns:
+ params Dict[str, torch.Tensor]: parameters to be passed for transformation.
+ - src (torch.Tensor): cropping bounding boxes with a shape of (B, 8, 3).
+ - dst (torch.Tensor): output bounding boxes with a shape (B, 8, 3).
+
+ Note:
+ The generated random numbers are not reproducible across different devices and dtypes.
+ """
+ _device, _dtype = _extract_device_dtype([size if isinstance(size, torch.Tensor) else None])
+ if not isinstance(size, torch.Tensor):
+ size = torch.tensor(size, device=device, dtype=dtype).repeat(batch_size, 1)
+ else:
+ size = size.to(device=device, dtype=dtype)
+ if size.shape != torch.Size([batch_size, 3]):
+ raise AssertionError(
+ "If `size` is a tensor, it must be shaped as (B, 3). "
+ f"Got {size.shape} while expecting {torch.Size([batch_size, 3])}."
+ )
+ if not (
+ len(input_size) == 3
+ and isinstance(input_size[0], (int,))
+ and isinstance(input_size[1], (int,))
+ and isinstance(input_size[2], (int,))
+ and input_size[0] > 0
+ and input_size[1] > 0
+ and input_size[2] > 0
+ ):
+ raise AssertionError(f"`input_size` must be a tuple of 3 positive integers. Got {input_size}.")
+
+ x_diff = input_size[2] - size[:, 2] + 1
+ y_diff = input_size[1] - size[:, 1] + 1
+ z_diff = input_size[0] - size[:, 0] + 1
+
+ if (x_diff < 0).any() or (y_diff < 0).any() or (z_diff < 0).any():
+ raise ValueError(f"input_size {str(input_size)} cannot be smaller than crop size {str(size)} in any dimension.")
+
+ if batch_size == 0:
+ return dict(
+ src=torch.zeros([0, 8, 3], device=_device, dtype=_dtype),
+ dst=torch.zeros([0, 8, 3], device=_device, dtype=_dtype),
+ )
+
+ if same_on_batch:
+ # If same_on_batch, select the first then repeat.
+ x_start = _adapted_uniform((batch_size,), 0, x_diff[0], same_on_batch).floor()
+ y_start = _adapted_uniform((batch_size,), 0, y_diff[0], same_on_batch).floor()
+ z_start = _adapted_uniform((batch_size,), 0, z_diff[0], same_on_batch).floor()
+ else:
+ x_start = _adapted_uniform((1,), 0, x_diff, same_on_batch).floor()
+ y_start = _adapted_uniform((1,), 0, y_diff, same_on_batch).floor()
+ z_start = _adapted_uniform((1,), 0, z_diff, same_on_batch).floor()
+
+ crop_src = bbox_generator3d(
+ x_start.to(device=_device, dtype=_dtype).view(-1),
+ y_start.to(device=_device, dtype=_dtype).view(-1),
+ z_start.to(device=_device, dtype=_dtype).view(-1),
+ size[:, 2].to(device=_device, dtype=_dtype) - 1,
+ size[:, 1].to(device=_device, dtype=_dtype) - 1,
+ size[:, 0].to(device=_device, dtype=_dtype) - 1,
+ )
+
+ if resize_to is None:
+ crop_dst = bbox_generator3d(
+ torch.tensor([0] * batch_size, device=_device, dtype=_dtype),
+ torch.tensor([0] * batch_size, device=_device, dtype=_dtype),
+ torch.tensor([0] * batch_size, device=_device, dtype=_dtype),
+ size[:, 2].to(device=_device, dtype=_dtype) - 1,
+ size[:, 1].to(device=_device, dtype=_dtype) - 1,
+ size[:, 0].to(device=_device, dtype=_dtype) - 1,
+ )
+ else:
+ if not (
+ len(resize_to) == 3
+ and isinstance(resize_to[0], (int,))
+ and isinstance(resize_to[1], (int,))
+ and isinstance(resize_to[2], (int,))
+ and resize_to[0] > 0
+ and resize_to[1] > 0
+ and resize_to[2] > 0
+ ):
+ raise AssertionError(f"`resize_to` must be a tuple of 3 positive integers. Got {resize_to}.")
+ crop_dst = torch.tensor(
+ [
+ [
+ [0, 0, 0],
+ [resize_to[-1] - 1, 0, 0],
+ [resize_to[-1] - 1, resize_to[-2] - 1, 0],
+ [0, resize_to[-2] - 1, 0],
+ [0, 0, resize_to[-3] - 1],
+ [resize_to[-1] - 1, 0, resize_to[-3] - 1],
+ [resize_to[-1] - 1, resize_to[-2] - 1, resize_to[-3] - 1],
+ [0, resize_to[-2] - 1, resize_to[-3] - 1],
+ ]
+ ],
+ device=_device,
+ dtype=_dtype,
+ ).repeat(batch_size, 1, 1)
+
+ return dict(src=crop_src.to(device=_device), dst=crop_dst.to(device=_device))
+
+
+def random_perspective_generator3d(
+ batch_size: int,
+ depth: int,
+ height: int,
+ width: int,
+ distortion_scale: torch.Tensor,
+ same_on_batch: bool = False,
+ device: torch.device = torch.device('cpu'),
+ dtype: torch.dtype = torch.float32,
+) -> Dict[str, torch.Tensor]:
+ r"""Get parameters for ``perspective`` for a random perspective transform.
+
+ Args:
+ batch_size (int): the tensor batch size.
+ depth (int) : depth of the image.
+ height (int) : height of the image.
+ width (int): width of the image.
+ distortion_scale (torch.Tensor): it controls the degree of distortion and ranges from 0 to 1.
+ same_on_batch (bool): apply the same transformation across the batch. Default: False.
+ device (torch.device): the device on which the random numbers will be generated. Default: cpu.
+ dtype (torch.dtype): the data type of the generated random numbers. Default: float32.
+
+ Returns:
+ params Dict[str, torch.Tensor]: parameters to be passed for transformation.
+ - src (torch.Tensor): perspective source bounding boxes with a shape of (B, 8, 3).
+ - dst (torch.Tensor): perspective target bounding boxes with a shape (B, 8, 3).
+
+ Note:
+ The generated random numbers are not reproducible across different devices and dtypes.
+ """
+ if not (distortion_scale.dim() == 0 and 0 <= distortion_scale <= 1):
+ raise AssertionError(f"'distortion_scale' must be a scalar within [0, 1]. Got {distortion_scale}")
+ _device, _dtype = _extract_device_dtype([distortion_scale])
+ distortion_scale = distortion_scale.to(device=device, dtype=dtype)
+
+ start_points: torch.Tensor = torch.tensor(
+ [
+ [
+ [0.0, 0, 0],
+ [width - 1, 0, 0],
+ [width - 1, height - 1, 0],
+ [0, height - 1, 0],
+ [0.0, 0, depth - 1],
+ [width - 1, 0, depth - 1],
+ [width - 1, height - 1, depth - 1],
+ [0, height - 1, depth - 1],
+ ]
+ ],
+ device=device,
+ dtype=dtype,
+ ).expand(batch_size, -1, -1)
+
+ # generate random offset not larger than half of the image
+ fx = distortion_scale * width / 2
+ fy = distortion_scale * height / 2
+ fz = distortion_scale * depth / 2
+
+ factor = torch.stack([fx, fy, fz], dim=0).view(-1, 1, 3)
+
+ rand_val: torch.Tensor = _adapted_uniform(
+ start_points.shape,
+ torch.tensor(0, device=device, dtype=dtype),
+ torch.tensor(1, device=device, dtype=dtype),
+ same_on_batch,
+ )
+
+ pts_norm = torch.tensor(
+ [[[1, 1, 1], [-1, 1, 1], [-1, -1, 1], [1, -1, 1], [1, 1, -1], [-1, 1, -1], [-1, -1, -1], [1, -1, -1]]],
+ device=device,
+ dtype=dtype,
+ )
+ end_points = start_points + factor * rand_val * pts_norm
+
+ return dict(
+ start_points=start_points.to(device=_device, dtype=_dtype),
+ end_points=end_points.to(device=_device, dtype=_dtype),
+ )
diff --git a/kornia/augmentation/utils/__init__.py b/kornia/augmentation/utils/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..df141698dcb6861df859f51fc6f7a4d1b6f5a28b
--- /dev/null
+++ b/kornia/augmentation/utils/__init__.py
@@ -0,0 +1,47 @@
+from kornia.augmentation.utils.helpers import (
+ _adapted_beta,
+ _adapted_rsampling,
+ _adapted_sampling,
+ _adapted_uniform,
+ _infer_batch_shape,
+ _infer_batch_shape3d,
+ _shape_validation,
+ _transform_input,
+ _transform_input3d,
+ _transform_output_shape,
+ _validate_input,
+ _validate_input3d,
+ _validate_input_dtype,
+ _validate_input_shape,
+ _validate_shape,
+)
+from kornia.augmentation.utils.param_validation import (
+ _common_param_check,
+ _joint_range_check,
+ _range_bound,
+ _singular_range_check,
+ _tuple_range_reader,
+)
+
+__all__ = [
+ "_infer_batch_shape",
+ "_infer_batch_shape3d",
+ "_transform_input",
+ "_transform_input3d",
+ "_validate_input_dtype",
+ "_validate_shape",
+ "_validate_input_shape",
+ "_adapted_sampling",
+ "_adapted_rsampling",
+ "_adapted_uniform",
+ "_adapted_beta",
+ "_shape_validation",
+ "_common_param_check",
+ "_range_bound",
+ "_joint_range_check",
+ "_singular_range_check",
+ "_tuple_range_reader",
+ "_validate_input",
+ "_validate_input3d",
+ "_transform_output_shape",
+]
diff --git a/kornia/augmentation/utils/helpers.py b/kornia/augmentation/utils/helpers.py
new file mode 100644
index 0000000000000000000000000000000000000000..ccc29ea73bec618734a67654a5a5b7d2f2e4b657
--- /dev/null
+++ b/kornia/augmentation/utils/helpers.py
@@ -0,0 +1,274 @@
+from functools import wraps
+from typing import Callable, cast, List, Optional, Tuple, Union
+
+import torch
+from torch.distributions import Beta, Uniform
+
+from kornia.utils import _extract_device_dtype
+
+
+def _validate_input(f: Callable) -> Callable:
+ r"""Validate the 2D input of the wrapped function.
+
+ Args:
+ f: a function that takes the first argument as tensor.
+
+ Returns:
+ the wrapped function after input is validated.
+ """
+
+ @wraps(f)
+ def wrapper(input: torch.Tensor, *args, **kwargs):
+ if not torch.is_tensor(input):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(input)}")
+
+ _validate_shape(input.shape, required_shapes=('BCHW',))
+ _validate_input_dtype(input, accepted_dtypes=[torch.float16, torch.float32, torch.float64])
+
+ return f(input, *args, **kwargs)
+
+ return wrapper
+
+
+def _validate_input3d(f: Callable) -> Callable:
+ r"""Validate the 3D input of the wrapped function.
+
+ Args:
+ f: a function that takes the first argument as tensor.
+
+ Returns:
+ the wrapped function after input is validated.
+ """
+
+ @wraps(f)
+ def wrapper(input: torch.Tensor, *args, **kwargs):
+ if not torch.is_tensor(input):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(input)}")
+
+ input_shape = len(input.shape)
+ if input_shape != 5:
+ raise AssertionError(f'Expect input of 5 dimensions, got {input_shape} instead')
+ _validate_input_dtype(input, accepted_dtypes=[torch.float16, torch.float32, torch.float64])
+
+ return f(input, *args, **kwargs)
+
+ return wrapper
+
+
+def _infer_batch_shape(input: Union[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]) -> torch.Size:
+ r"""Infer input shape. Input may be either (tensor,) or (tensor, transform_matrix)"""
+ if isinstance(input, tuple):
+ tensor = _transform_input(input[0])
+ else:
+ tensor = _transform_input(input)
+ return tensor.shape
+
+
+def _infer_batch_shape3d(input: Union[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]) -> torch.Size:
+ r"""Infer input shape. Input may be either (tensor,) or (tensor, transform_matrix)"""
+ if isinstance(input, tuple):
+ tensor = _transform_input3d(input[0])
+ else:
+ tensor = _transform_input3d(input)
+ return tensor.shape
+
+
+def _transform_input(input: torch.Tensor) -> torch.Tensor:
+ r"""Reshape an input tensor to be (*, C, H, W). Accept either (H, W), (C, H, W) or (*, C, H, W).
+ Args:
+ input: torch.Tensor
+
+ Returns:
+ torch.Tensor
+ """
+ if not torch.is_tensor(input):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(input)}")
+
+ if len(input.shape) not in [2, 3, 4]:
+ raise ValueError(f"Input size must have a shape of either (H, W), (C, H, W) or (*, C, H, W). Got {input.shape}")
+
+ if len(input.shape) == 2:
+ input = input.unsqueeze(0)
+
+ if len(input.shape) == 3:
+ input = input.unsqueeze(0)
+
+ return input
+
+
+def _transform_input3d(input: torch.Tensor) -> torch.Tensor:
+ r"""Reshape an input tensor to be (*, C, D, H, W). Accept either (D, H, W), (C, D, H, W) or (*, C, D, H, W).
+ Args:
+ input: torch.Tensor
+
+ Returns:
+ torch.Tensor
+ """
+ if not torch.is_tensor(input):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(input)}")
+
+ if len(input.shape) not in [3, 4, 5]:
+ raise ValueError(
+ f"Input size must have a shape of either (D, H, W), (C, D, H, W) or (*, C, D, H, W). Got {input.shape}"
+ )
+
+ if len(input.shape) == 3:
+ input = input.unsqueeze(0)
+
+ if len(input.shape) == 4:
+ input = input.unsqueeze(0)
+
+ return input
+
+
+def _validate_input_dtype(input: torch.Tensor, accepted_dtypes: List) -> None:
+ r"""Check if the dtype of the input tensor is in the range of accepted_dtypes
+ Args:
+ input: torch.Tensor
+ accepted_dtypes: List. e.g. [torch.float32, torch.float64]
+ """
+ if input.dtype not in accepted_dtypes:
+ raise TypeError(f"Expected input of {accepted_dtypes}. Got {input.dtype}")
+
+
+def _transform_output_shape(
+ output: Union[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]], shape: Tuple
+) -> Union[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:
+ r"""Collapse the broadcasted batch dimensions an input tensor to be the specified shape.
+ Args:
+ input: torch.Tensor
+ shape: List/tuple of int
+
+ Returns:
+ torch.Tensor
+ """
+ is_tuple = isinstance(output, tuple)
+ out_tensor: torch.Tensor
+ trans_matrix: Optional[torch.Tensor]
+ if is_tuple:
+ out_tensor, trans_matrix = cast(Tuple[torch.Tensor, torch.Tensor], output)
+ else:
+ out_tensor = cast(torch.Tensor, output)
+ trans_matrix = None
+
+ if trans_matrix is not None:
+ if len(out_tensor.shape) > len(shape) and trans_matrix.shape[0] != 1:
+ raise AssertionError(
+ f'Dimension 0 of transformation matrix is ' f'expected to be 1, got {trans_matrix.shape[0]}'
+ )
+ trans_matrix = trans_matrix.squeeze(0)
+
+ for dim in range(len(out_tensor.shape) - len(shape)):
+ if out_tensor.shape[0] != 1:
+ raise AssertionError(f'Dimension {dim} of input is ' f'expected to be 1, got {out_tensor.shape[0]}')
+ out_tensor = out_tensor.squeeze(0)
+
+ return (out_tensor, trans_matrix) if is_tuple else out_tensor # type: ignore
+
+
+def _validate_shape(shape: Union[Tuple, torch.Size], required_shapes: Tuple[str, ...] = ("BCHW",)) -> None:
+ r"""Check if the dtype of the input tensor is in the range of accepted_dtypes
+ Args:
+ shape: tensor shape
+ required_shapes: List. e.g. ["BCHW", "BCDHW"]
+ """
+ passed = False
+ for required_shape in required_shapes:
+ if len(shape) == len(required_shape):
+ passed = True
+ break
+ if not passed:
+ raise TypeError(f"Expected input shape in {required_shape}. Got {shape}.")
+
+
+def _validate_input_shape(input: torch.Tensor, channel_index: int, number: int) -> bool:
+ r"""Validate if an input has the right shape. e.g. to check if an input is channel first.
+ If channel first, the second channel of an RGB input shall be fixed to 3. To verify using:
+ _validate_input_shape(input, 1, 3)
+ Args:
+ input: torch.Tensor
+ channel_index: int
+ number: int
+ Returns:
+ bool
+ """
+ return input.shape[channel_index] == number
+
+
+def _adapted_rsampling(
+ shape: Union[Tuple, torch.Size], dist: torch.distributions.Distribution, same_on_batch=False
+) -> torch.Tensor:
+ r"""The uniform reparameterized sampling function that accepts 'same_on_batch'.
+
+ If same_on_batch is True, all values generated will be exactly same given a batch_size (shape[0]).
+ By default, same_on_batch is set to False.
+ """
+ if same_on_batch:
+ return dist.rsample((1, *shape[1:])).repeat(shape[0], *[1] * (len(shape) - 1))
+ return dist.rsample(shape)
+
+
+def _adapted_sampling(
+ shape: Union[Tuple, torch.Size], dist: torch.distributions.Distribution, same_on_batch=False
+) -> torch.Tensor:
+ r"""The uniform sampling function that accepts 'same_on_batch'.
+
+ If same_on_batch is True, all values generated will be exactly same given a batch_size (shape[0]).
+ By default, same_on_batch is set to False.
+ """
+ if same_on_batch:
+ return dist.sample((1, *shape[1:])).repeat(shape[0], *[1] * (len(shape) - 1))
+ return dist.sample(shape)
+
+
+def _adapted_uniform(
+ shape: Union[Tuple, torch.Size],
+ low: Union[float, int, torch.Tensor],
+ high: Union[float, int, torch.Tensor],
+ same_on_batch: bool = False,
+) -> torch.Tensor:
+ r"""The uniform sampling function that accepts 'same_on_batch'.
+
+ If same_on_batch is True, all values generated will be exactly same given a batch_size (shape[0]).
+ By default, same_on_batch is set to False.
+
+ By default, sampling happens on the default device and dtype. If low/high is a tensor, sampling will happen
+ in the same device/dtype as low/high tensor.
+ """
+ device, dtype = _extract_device_dtype(
+ [low if isinstance(low, torch.Tensor) else None, high if isinstance(high, torch.Tensor) else None]
+ )
+ low = torch.as_tensor(low, device=device, dtype=dtype)
+ high = torch.as_tensor(high, device=device, dtype=dtype)
+ # validate_args=False to fix pytorch 1.7.1 error:
+ # ValueError: Uniform is not defined when low>= high.
+ dist = Uniform(low, high, validate_args=False)
+ return _adapted_rsampling(shape, dist, same_on_batch)
+
+
+def _adapted_beta(
+ shape: Union[Tuple, torch.Size],
+ a: Union[float, int, torch.Tensor],
+ b: Union[float, int, torch.Tensor],
+ same_on_batch: bool = False,
+) -> torch.Tensor:
+ r"""The beta sampling function that accepts 'same_on_batch'.
+
+ If same_on_batch is True, all values generated will be exactly same given a batch_size (shape[0]).
+ By default, same_on_batch is set to False.
+
+ By default, sampling happens on the default device and dtype. If a/b is a tensor, sampling will happen
+ in the same device/dtype as a/b tensor.
+ """
+ device, dtype = _extract_device_dtype(
+ [a if isinstance(a, torch.Tensor) else None, b if isinstance(b, torch.Tensor) else None]
+ )
+ a = torch.as_tensor(a, device=device, dtype=dtype)
+ b = torch.as_tensor(b, device=device, dtype=dtype)
+ dist = Beta(a, b, validate_args=False)
+ return _adapted_rsampling(shape, dist, same_on_batch)
+
+
+def _shape_validation(param: torch.Tensor, shape: Union[tuple, list], name: str) -> None:
+ if param.shape != torch.Size(shape):
+ raise AssertionError(f"Invalid shape for {name}. Expected {shape}. Got {param.shape}")
diff --git a/kornia/augmentation/utils/param_validation.py b/kornia/augmentation/utils/param_validation.py
new file mode 100644
index 0000000000000000000000000000000000000000..308f017b8985f42d5fe94ddb1e7a08335adffad5
--- /dev/null
+++ b/kornia/augmentation/utils/param_validation.py
@@ -0,0 +1,176 @@
+from typing import cast, List, Optional, Tuple, Union
+
+import torch
+
+
+def _common_param_check(batch_size: int, same_on_batch: Optional[bool] = None):
+ """Valid batch_size and same_on_batch params."""
+ if not (type(batch_size) is int and batch_size >= 0):
+ raise AssertionError(f"`batch_size` shall be a positive integer. Got {batch_size}.")
+ if same_on_batch is not None and type(same_on_batch) is not bool:
+ raise AssertionError(f"`same_on_batch` shall be boolean. Got {same_on_batch}.")
+
+
+def _range_bound(
+ factor: Union[torch.Tensor, float, Tuple[float, float], List[float]],
+ name: str,
+ center: float = 0.0,
+ bounds: Tuple[float, float] = (0, float('inf')),
+ check: Optional[str] = 'joint',
+ device: torch.device = torch.device('cpu'),
+ dtype: torch.dtype = torch.get_default_dtype(),
+) -> torch.Tensor:
+ r"""Check inputs and compute the corresponding factor bounds"""
+ if not isinstance(factor, (torch.Tensor)):
+ factor = torch.tensor(factor, device=device, dtype=dtype)
+ factor_bound: torch.Tensor
+
+ if factor.dim() == 0:
+ if factor < 0:
+ raise ValueError(f"If {name} is a single number number, it must be non negative. Got {factor}")
+ # Should be something other than clamp
+ # Currently, single value factor will not out of scope as long as the user provided it.
+ # Note: I personally think throw an error will be better than a coarse clamp.
+ factor_bound = factor.repeat(2) * torch.tensor([-1.0, 1.0], device=factor.device, dtype=factor.dtype) + center
+ factor_bound = factor_bound.clamp(bounds[0], bounds[1])
+ else:
+ factor_bound = torch.as_tensor(factor, device=device, dtype=dtype)
+
+ if check is not None:
+ if check == 'joint':
+ _joint_range_check(factor_bound, name, bounds)
+ elif check == 'singular':
+ _singular_range_check(factor_bound, name, bounds)
+ else:
+ raise NotImplementedError(f"methods '{check}' not implemented.")
+
+ return factor_bound
+
+
+def _joint_range_check(ranged_factor: torch.Tensor, name: str, bounds: Optional[Tuple[float, float]] = None) -> None:
+ """Check if bounds[0] <= ranged_factor[0] <= ranged_factor[1] <= bounds[1]"""
+ if bounds is None:
+ bounds = (float('-inf'), float('inf'))
+ if ranged_factor.dim() == 1 and len(ranged_factor) == 2:
+ if not bounds[0] <= ranged_factor[0] or not bounds[1] >= ranged_factor[1]:
+ raise ValueError(f"{name} out of bounds. Expected inside {bounds}, got {ranged_factor}.")
+
+ if not bounds[0] <= ranged_factor[0] <= ranged_factor[1] <= bounds[1]:
+ raise ValueError(f"{name}[0] should be smaller than {name}[1] got {ranged_factor}")
+ else:
+ raise TypeError(
+ f"{name} should be a tensor with length 2 whose values between {bounds}. " f"Got {ranged_factor}."
+ )
+
+
+def _singular_range_check(
+ ranged_factor: torch.Tensor,
+ name: str,
+ bounds: Optional[Tuple[float, float]] = None,
+ skip_none: bool = False,
+ mode: str = '2d',
+) -> None:
+ """Check if bounds[0] <= ranged_factor[0] <= bounds[1] and bounds[0] <= ranged_factor[1] <= bounds[1]"""
+ if mode == '2d':
+ dim_size = 2
+ elif mode == '3d':
+ dim_size = 3
+ else:
+ raise ValueError(f"'mode' shall be either 2d or 3d. Got {mode}")
+
+ if skip_none and ranged_factor is None:
+ return
+ if bounds is None:
+ bounds = (float('-inf'), float('inf'))
+ if ranged_factor.dim() == 1 and len(ranged_factor) == dim_size:
+ for f in ranged_factor:
+ if not bounds[0] <= f <= bounds[1]:
+ raise ValueError(f"{name} out of bounds. Expected inside {bounds}, got {ranged_factor}.")
+ else:
+ raise TypeError(
+ f"{name} should be a float number or a tuple with length {dim_size} whose values between {bounds}."
+ f"Got {ranged_factor}"
+ )
+
+
+def _tuple_range_reader(
+ input_range: Union[torch.Tensor, float, tuple],
+ target_size: int,
+ device: Optional[torch.device] = None,
+ dtype: Optional[torch.dtype] = None,
+) -> torch.Tensor:
+ """Given target_size, it will generate the corresponding (target_size, 2) range tensor for element-wise params.
+
+ Example:
+ >>> degree = torch.tensor([0.2, 0.3])
+ >>> _tuple_range_reader(degree, 3) # read degree for yaw, pitch and roll.
+ tensor([[0.2000, 0.3000],
+ [0.2000, 0.3000],
+ [0.2000, 0.3000]])
+ """
+ target_shape = torch.Size([target_size, 2])
+ if not torch.is_tensor(input_range):
+ if isinstance(input_range, (float, int)):
+ if input_range < 0:
+ raise ValueError(f"If input_range is only one number it must be a positive number. Got{input_range}")
+ input_range_tmp = torch.tensor([-input_range, input_range], device=device, dtype=dtype).repeat(
+ target_shape[0], 1
+ )
+
+ elif (
+ isinstance(input_range, (tuple, list))
+ and len(input_range) == 2
+ and isinstance(input_range[0], (float, int))
+ and isinstance(input_range[1], (float, int))
+ ):
+ input_range_tmp = torch.tensor(input_range, device=device, dtype=dtype).repeat(target_shape[0], 1)
+
+ elif (
+ isinstance(input_range, (tuple, list))
+ and len(input_range) == target_shape[0]
+ and all(isinstance(x, (float, int)) for x in input_range)
+ ):
+ input_range_tmp = torch.tensor([(-s, s) for s in input_range], device=device, dtype=dtype)
+
+ elif (
+ isinstance(input_range, (tuple, list))
+ and len(input_range) == target_shape[0]
+ and all(isinstance(x, (tuple, list)) for x in input_range)
+ ):
+ input_range_tmp = torch.tensor(input_range, device=device, dtype=dtype)
+
+ else:
+ raise TypeError(
+ "If not pass a tensor, it must be float, (float, float) for isotropic operation or a tuple of "
+ f"{target_size} floats or {target_size} (float, float) for independent operation. Got {input_range}."
+ )
+
+ else:
+ # https://mypy.readthedocs.io/en/latest/casts.html cast to please mypy gods
+ input_range = cast(torch.Tensor, input_range)
+ if (len(input_range.shape) == 0) or (len(input_range.shape) == 1 and len(input_range) == 1):
+ if input_range < 0:
+ raise ValueError(f"If input_range is only one number it must be a positive number. Got{input_range}")
+ input_range_tmp = input_range.repeat(2) * torch.tensor(
+ [-1.0, 1.0], device=input_range.device, dtype=input_range.dtype
+ )
+ input_range_tmp = input_range_tmp.repeat(target_shape[0], 1)
+
+ elif len(input_range.shape) == 1 and len(input_range) == 2:
+ input_range_tmp = input_range.repeat(target_shape[0], 1)
+
+ elif len(input_range.shape) == 1 and len(input_range) == target_shape[0]:
+ input_range_tmp = input_range.unsqueeze(1).repeat(1, 2) * torch.tensor(
+ [-1, 1], device=input_range.device, dtype=input_range.dtype
+ )
+
+ elif input_range.shape == target_shape:
+ input_range_tmp = input_range
+
+ else:
+ raise ValueError(
+ f"Degrees must be a {list(target_shape)} tensor for the degree range for independent operation."
+ f"Got {input_range}"
+ )
+
+ return input_range_tmp
diff --git a/kornia/color/__init__.py b/kornia/color/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..c3a2543fd192314211317e03be7d74f1c927ad57
--- /dev/null
+++ b/kornia/color/__init__.py
@@ -0,0 +1,106 @@
+from .gray import bgr_to_grayscale, BgrToGrayscale, grayscale_to_rgb, GrayscaleToRgb, rgb_to_grayscale, RgbToGrayscale
+from .hls import hls_to_rgb, HlsToRgb, rgb_to_hls, RgbToHls
+from .hsv import hsv_to_rgb, HsvToRgb, rgb_to_hsv, RgbToHsv
+from .lab import lab_to_rgb, LabToRgb, rgb_to_lab, RgbToLab
+from .luv import luv_to_rgb, LuvToRgb, rgb_to_luv, RgbToLuv
+from .raw import CFA, raw_to_rgb, RawToRgb, rgb_to_raw, RgbToRaw
+from .rgb import (
+ bgr_to_rgb,
+ bgr_to_rgba,
+ BgrToRgb,
+ BgrToRgba,
+ linear_rgb_to_rgb,
+ LinearRgbToRgb,
+ rgb_to_bgr,
+ rgb_to_linear_rgb,
+ rgb_to_rgba,
+ rgba_to_bgr,
+ rgba_to_rgb,
+ RgbaToBgr,
+ RgbaToRgb,
+ RgbToBgr,
+ RgbToLinearRgb,
+ RgbToRgba,
+)
+from .xyz import rgb_to_xyz, RgbToXyz, xyz_to_rgb, XyzToRgb
+from .ycbcr import rgb_to_ycbcr, RgbToYcbcr, ycbcr_to_rgb, YcbcrToRgb
+from .yuv import (
+ rgb_to_yuv,
+ rgb_to_yuv420,
+ rgb_to_yuv422,
+ RgbToYuv,
+ RgbToYuv420,
+ RgbToYuv422,
+ yuv420_to_rgb,
+ Yuv420ToRgb,
+ yuv422_to_rgb,
+ Yuv422ToRgb,
+ yuv_to_rgb,
+ YuvToRgb,
+)
+
+__all__ = [
+ "grayscale_to_rgb",
+ "rgb_to_grayscale",
+ "bgr_to_grayscale",
+ "bgr_to_rgb",
+ "rgb_to_bgr",
+ "rgb_to_rgba",
+ "rgb_to_hsv",
+ "hsv_to_rgb",
+ "rgb_to_hls",
+ "hls_to_rgb",
+ "rgb_to_ycbcr",
+ "ycbcr_to_rgb",
+ "rgb_to_yuv",
+ "rgb_to_yuv420",
+ "rgb_to_yuv422",
+ "yuv_to_rgb",
+ "yuv420_to_rgb",
+ "yuv422_to_rgb",
+ "rgb_to_xyz",
+ "xyz_to_rgb",
+ "rgb_to_lab",
+ "lab_to_rgb",
+ "RgbToGrayscale",
+ "BgrToGrayscale",
+ "BgrToRgb",
+ "RgbToBgr",
+ "RgbToRgba",
+ "RgbToHsv",
+ "HsvToRgb",
+ "RgbToHls",
+ "HlsToRgb",
+ "RgbToYcbcr",
+ "YcbcrToRgb",
+ "RgbToYuv",
+ "RgbToYuv420",
+ "RgbToYuv422",
+ "YuvToRgb",
+ "Yuv420ToRgb",
+ "Yuv422ToRgb",
+ "RgbToXyz",
+ "XyzToRgb",
+ "RgbToLuv",
+ "LuvToRgb",
+ "LabToRgb",
+ "RgbToLab",
+ "RgbToRaw",
+ "RawToRgb",
+ "raw_to_rgb",
+ "rgb_to_raw",
+ "CFA",
+ "GrayscaleToRgb",
+ "luv_to_rgb",
+ "rgb_to_luv",
+ "bgr_to_rgba",
+ "BgrToRgba",
+ "linear_rgb_to_rgb",
+ "LinearRgbToRgb",
+ "rgb_to_linear_rgb",
+ "rgba_to_rgb",
+ "rgba_to_bgr",
+ "RgbaToRgb",
+ "RgbaToBgr",
+ "RgbToLinearRgb",
+]
diff --git a/kornia/color/gray.py b/kornia/color/gray.py
new file mode 100644
index 0000000000000000000000000000000000000000..6a084391990821202986b851f265b66004566384
--- /dev/null
+++ b/kornia/color/gray.py
@@ -0,0 +1,180 @@
+import torch
+import torch.nn as nn
+
+from kornia.color.rgb import bgr_to_rgb
+
+
+def grayscale_to_rgb(image: torch.Tensor) -> torch.Tensor:
+ r"""Convert a grayscale image to RGB version of image.
+
+ .. image:: _static/img/grayscale_to_rgb.png
+
+ The image data is assumed to be in the range of (0, 1).
+
+ Args:
+ image: grayscale image to be converted to RGB with shape :math:`(*,1,H,W)`.
+
+ Returns:
+ RGB version of the image with shape :math:`(*,3,H,W)`.
+
+ Example:
+ >>> input = torch.randn(2, 1, 4, 5)
+ >>> gray = grayscale_to_rgb(input) # 2x3x4x5
+ """
+ if not isinstance(image, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. " f"Got {type(image)}")
+
+ if image.dim() < 3 or image.size(-3) != 1:
+ raise ValueError(f"Input size must have a shape of (*, 1, H, W). " f"Got {image.shape}.")
+
+ rgb: torch.Tensor = torch.cat([image, image, image], dim=-3)
+
+ # TODO: we should find a better way to raise this kind of warnings
+ # if not torch.is_floating_point(image):
+ # warnings.warn(f"Input image is not of float dtype. Got {image.dtype}")
+
+ return rgb
+
+
+def rgb_to_grayscale(
+ image: torch.Tensor, rgb_weights: torch.Tensor = torch.tensor([0.299, 0.587, 0.114])
+) -> torch.Tensor:
+ r"""Convert a RGB image to grayscale version of image.
+
+ .. image:: _static/img/rgb_to_grayscale.png
+
+ The image data is assumed to be in the range of (0, 1).
+
+ Args:
+ image: RGB image to be converted to grayscale with shape :math:`(*,3,H,W)`.
+ rgb_weights: Weights that will be applied on each channel (RGB).
+ The sum of the weights should add up to one.
+ Returns:
+ grayscale version of the image with shape :math:`(*,1,H,W)`.
+
+ .. note::
+ See a working example `here `__.
+
+ Example:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> gray = rgb_to_grayscale(input) # 2x1x4x5
+ """
+ if not isinstance(image, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(image)}")
+
+ if len(image.shape) < 3 or image.shape[-3] != 3:
+ raise ValueError(f"Input size must have a shape of (*, 3, H, W). Got {image.shape}")
+
+ if not isinstance(rgb_weights, torch.Tensor):
+ raise TypeError(f"rgb_weights is not a torch.Tensor. Got {type(rgb_weights)}")
+
+ if rgb_weights.shape[-1] != 3:
+ raise ValueError(f"rgb_weights must have a shape of (*, 3). Got {rgb_weights.shape}")
+
+ r: torch.Tensor = image[..., 0:1, :, :]
+ g: torch.Tensor = image[..., 1:2, :, :]
+ b: torch.Tensor = image[..., 2:3, :, :]
+
+ if not torch.is_floating_point(image) and (image.dtype != rgb_weights.dtype):
+ raise TypeError(
+ f"Input image and rgb_weights should be of same dtype. Got {image.dtype} and {rgb_weights.dtype}"
+ )
+
+ w_r, w_g, w_b = rgb_weights.to(image).unbind()
+ return w_r * r + w_g * g + w_b * b
+
+
+def bgr_to_grayscale(image: torch.Tensor) -> torch.Tensor:
+ r"""Convert a BGR image to grayscale.
+
+ The image data is assumed to be in the range of (0, 1). First flips to RGB, then converts.
+
+ Args:
+ image: BGR image to be converted to grayscale with shape :math:`(*,3,H,W)`.
+
+ Returns:
+ grayscale version of the image with shape :math:`(*,1,H,W)`.
+
+ Example:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> gray = bgr_to_grayscale(input) # 2x1x4x5
+ """
+ if not isinstance(image, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(image)}")
+
+ if len(image.shape) < 3 or image.shape[-3] != 3:
+ raise ValueError(f"Input size must have a shape of (*, 3, H, W). Got {image.shape}")
+
+ image_rgb = bgr_to_rgb(image)
+ return rgb_to_grayscale(image_rgb)
+
+
+class GrayscaleToRgb(nn.Module):
+ r"""Module to convert a grayscale image to RGB version of image.
+
+ The image data is assumed to be in the range of (0, 1).
+
+ Shape:
+ - image: :math:`(*, 1, H, W)`
+ - output: :math:`(*, 3, H, W)`
+
+ reference:
+ https://docs.opencv.org/4.0.1/de/d25/imgproc_color_conversions.html
+
+ Example:
+ >>> input = torch.rand(2, 1, 4, 5)
+ >>> rgb = GrayscaleToRgb()
+ >>> output = rgb(input) # 2x3x4x5
+ """
+
+ def forward(self, image: torch.Tensor) -> torch.Tensor: # type: ignore
+ return grayscale_to_rgb(image)
+
+
+class RgbToGrayscale(nn.Module):
+ r"""Module to convert a RGB image to grayscale version of image.
+
+ The image data is assumed to be in the range of (0, 1).
+
+ Shape:
+ - image: :math:`(*, 3, H, W)`
+ - output: :math:`(*, 1, H, W)`
+
+ reference:
+ https://docs.opencv.org/4.0.1/de/d25/imgproc_color_conversions.html
+
+ Example:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> gray = RgbToGrayscale()
+ >>> output = gray(input) # 2x1x4x5
+ """
+
+ def __init__(self, rgb_weights: torch.Tensor = torch.tensor([0.299, 0.587, 0.114])) -> None:
+ super().__init__()
+ self.rgb_weights = rgb_weights
+
+ def forward(self, image: torch.Tensor) -> torch.Tensor: # type: ignore
+ return rgb_to_grayscale(image, rgb_weights=self.rgb_weights)
+
+
+class BgrToGrayscale(nn.Module):
+ r"""Module to convert a BGR image to grayscale version of image.
+
+ The image data is assumed to be in the range of (0, 1). First flips to RGB, then converts.
+
+ Shape:
+ - image: :math:`(*, 3, H, W)`
+ - output: :math:`(*, 1, H, W)`
+
+ reference:
+ https://docs.opencv.org/4.0.1/de/d25/imgproc_color_conversions.html
+
+ Example:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> gray = BgrToGrayscale()
+ >>> output = gray(input) # 2x1x4x5
+ """
+
+ def forward(self, image: torch.Tensor) -> torch.Tensor: # type: ignore
+ return bgr_to_grayscale(image)
diff --git a/kornia/color/hls.py b/kornia/color/hls.py
new file mode 100644
index 0000000000000000000000000000000000000000..b7b99a8a86c60d60365a742cd4074b621fc9fa09
--- /dev/null
+++ b/kornia/color/hls.py
@@ -0,0 +1,195 @@
+import math
+
+import torch
+import torch.nn as nn
+
+
+def rgb_to_hls(image: torch.Tensor, eps: float = 1e-8) -> torch.Tensor:
+ r"""Convert a RGB image to HLS.
+
+ .. image:: _static/img/rgb_to_hls.png
+
+ The image data is assumed to be in the range of (0, 1).
+
+ NOTE: this method cannot be compiled with JIT in pytohrch < 1.7.0
+
+ Args:
+ image: RGB image to be converted to HLS with shape :math:`(*, 3, H, W)`.
+ eps: epsilon value to avoid div by zero.
+
+ Returns:
+ HLS version of the image with shape :math:`(*, 3, H, W)`.
+
+ Example:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> output = rgb_to_hls(input) # 2x3x4x5
+ """
+ if not isinstance(image, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(image)}")
+
+ if len(image.shape) < 3 or image.shape[-3] != 3:
+ raise ValueError(f"Input size must have a shape of (*, 3, H, W). Got {image.shape}")
+
+ if not torch.jit.is_scripting():
+ # weird way to use globals compiling with JIT even in the code not used by JIT...
+ # __setattr__ can be removed if pytorch version is > 1.6.0 and then use:
+ # rgb_to_hls.RGB2HSL_IDX = hls_to_rgb.RGB2HSL_IDX.to(image.device)
+ rgb_to_hls.__setattr__('RGB2HSL_IDX', rgb_to_hls.RGB2HSL_IDX.to(image)) # type: ignore
+ _RGB2HSL_IDX: torch.Tensor = rgb_to_hls.RGB2HSL_IDX # type: ignore
+ else:
+ _RGB2HSL_IDX = torch.tensor([[[0.0]], [[1.0]], [[2.0]]], device=image.device, dtype=image.dtype) # 3x1x1
+
+ # maxc: torch.Tensor # not supported by JIT
+ # imax: torch.Tensor # not supported by JIT
+ maxc, imax = image.max(-3)
+ minc: torch.Tensor = image.min(-3)[0]
+
+ # h: torch.Tensor # not supported by JIT
+ # l: torch.Tensor # not supported by JIT
+ # s: torch.Tensor # not supported by JIT
+ # image_hls: torch.Tensor # not supported by JIT
+ if image.requires_grad:
+ l_ = maxc + minc
+ s = maxc - minc
+ # weird behaviour with undefined vars in JIT...
+ # scripting requires image_hls be defined even if it is not used :S
+ h = l_ # assign to any tensor...
+ image_hls = l_ # assign to any tensor...
+ else:
+ # define the resulting image to avoid the torch.stack([h, l, s])
+ # so, h, l and s require inplace operations
+ # NOTE: stack() increases in a 10% the cost in colab
+ image_hls = torch.empty_like(image)
+ h = torch.select(image_hls, -3, 0)
+ l_ = torch.select(image_hls, -3, 1)
+ s = torch.select(image_hls, -3, 2)
+ torch.add(maxc, minc, out=l_) # l = max + min
+ torch.sub(maxc, minc, out=s) # s = max - min
+
+ # precompute image / (max - min)
+ im: torch.Tensor = image / (s + eps).unsqueeze(-3)
+
+ # epsilon cannot be inside the torch.where to avoid precision issues
+ s /= torch.where(l_ < 1.0, l_, 2.0 - l_) + eps # saturation
+ l_ /= 2 # luminance
+
+ # note that r,g and b were previously div by (max - min)
+ r: torch.Tensor = torch.select(im, -3, 0)
+ g: torch.Tensor = torch.select(im, -3, 1)
+ b: torch.Tensor = torch.select(im, -3, 2)
+ # h[imax == 0] = (((g - b) / (max - min)) % 6)[imax == 0]
+ # h[imax == 1] = (((b - r) / (max - min)) + 2)[imax == 1]
+ # h[imax == 2] = (((r - g) / (max - min)) + 4)[imax == 2]
+ cond: torch.Tensor = imax.unsqueeze(-3) == _RGB2HSL_IDX
+ if image.requires_grad:
+ h = torch.mul((g - b) % 6, torch.select(cond, -3, 0))
+ else:
+ torch.mul((g - b).remainder(6), torch.select(cond, -3, 0), out=h)
+ h += torch.add(b - r, 2) * torch.select(cond, -3, 1)
+ h += torch.add(r - g, 4) * torch.select(cond, -3, 2)
+ # h = 2.0 * math.pi * (60.0 * h) / 360.0
+ h *= math.pi / 3.0 # hue [0, 2*pi]
+
+ if image.requires_grad:
+ return torch.stack([h, l_, s], dim=-3)
+ return image_hls
+
+
+def hls_to_rgb(image: torch.Tensor) -> torch.Tensor:
+ r"""Convert a HLS image to RGB.
+
+ The image data is assumed to be in the range of (0, 1).
+
+ Args:
+ image: HLS image to be converted to RGB with shape :math:`(*, 3, H, W)`.
+
+ Returns:
+ RGB version of the image with shape :math:`(*, 3, H, W)`.
+
+ Example:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> output = hls_to_rgb(input) # 2x3x4x5
+ """
+ if not isinstance(image, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(image)}")
+
+ if len(image.shape) < 3 or image.shape[-3] != 3:
+ raise ValueError(f"Input size must have a shape of (*, 3, H, W). Got {image.shape}")
+
+ if not torch.jit.is_scripting():
+ # weird way to use globals compiling with JIT even in the code not used by JIT...
+ # __setattr__ can be removed if pytorch version is > 1.6.0 and then use:
+ # hls_to_rgb.HLS2RGB = hls_to_rgb.HLS2RGB.to(image.device)
+ hls_to_rgb.__setattr__('HLS2RGB', hls_to_rgb.HLS2RGB.to(image)) # type: ignore
+ _HLS2RGB: torch.Tensor = hls_to_rgb.HLS2RGB # type: ignore
+ else:
+ _HLS2RGB = torch.tensor([[[0.0]], [[8.0]], [[4.0]]], device=image.device, dtype=image.dtype) # 3x1x1
+
+ im: torch.Tensor = image.unsqueeze(-4)
+ h: torch.Tensor = torch.select(im, -3, 0)
+ l: torch.Tensor = torch.select(im, -3, 1)
+ s: torch.Tensor = torch.select(im, -3, 2)
+ h = h * (6 / math.pi) # h * 360 / (2 * math.pi) / 30
+ a = s * torch.min(l, 1.0 - l)
+
+ # kr = (0 + h) % 12
+ # kg = (8 + h) % 12
+ # kb = (4 + h) % 12
+ k: torch.Tensor = (h + _HLS2RGB) % 12
+
+ # l - a * max(min(min(k - 3.0, 9.0 - k), 1), -1)
+ mink = torch.min(k - 3.0, 9.0 - k)
+ return torch.addcmul(l, a, mink.clamp_(min=-1.0, max=1.0), value=-1)
+
+
+# tricks to speed up a little bit the conversions by presetting small tensors
+# (in the functions they are moved to the proper device)
+hls_to_rgb.__setattr__('HLS2RGB', torch.tensor([[[0.0]], [[8.0]], [[4.0]]])) # 3x1x1
+rgb_to_hls.__setattr__('RGB2HSL_IDX', torch.tensor([[[0.0]], [[1.0]], [[2.0]]])) # 3x1x1
+
+
+class RgbToHls(nn.Module):
+ r"""Convert an image from RGB to HLS.
+
+ The image data is assumed to be in the range of (0, 1).
+
+ Returns:
+ HLS version of the image.
+
+ Shape:
+ - image: :math:`(*, 3, H, W)`
+ - output: :math:`(*, 3, H, W)`
+
+ Examples:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> hls = RgbToHls()
+ >>> output = hls(input) # 2x3x4x5
+ """
+
+ def forward(self, image: torch.Tensor) -> torch.Tensor:
+ return rgb_to_hls(image)
+
+
+class HlsToRgb(nn.Module):
+ r"""Convert an image from HLS to RGB.
+
+ The image data is assumed to be in the range of (0, 1).
+
+ Returns:
+ RGB version of the image.
+
+ Shape:
+ - input: :math:`(*, 3, H, W)`
+ - output: :math:`(*, 3, H, W)`
+
+ Reference:
+ https://en.wikipedia.org/wiki/HSL_and_HSV
+
+ Examples:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> rgb = HlsToRgb()
+ >>> output = rgb(input) # 2x3x4x5
+ """
+
+ def forward(self, image: torch.Tensor) -> torch.Tensor:
+ return hls_to_rgb(image)
diff --git a/kornia/color/hsv.py b/kornia/color/hsv.py
new file mode 100644
index 0000000000000000000000000000000000000000..7d6bd067703ac6d7fed5bf2b90d9ba469f204a72
--- /dev/null
+++ b/kornia/color/hsv.py
@@ -0,0 +1,146 @@
+import math
+
+import torch
+import torch.nn as nn
+
+
+def rgb_to_hsv(image: torch.Tensor, eps: float = 1e-8) -> torch.Tensor:
+ r"""Convert an image from RGB to HSV.
+
+ .. image:: _static/img/rgb_to_hsv.png
+
+ The image data is assumed to be in the range of (0, 1).
+
+ Args:
+ image: RGB Image to be converted to HSV with shape of :math:`(*, 3, H, W)`.
+ eps: scalar to enforce numarical stability.
+
+ Returns:
+ HSV version of the image with shape of :math:`(*, 3, H, W)`.
+ The H channel values are in the range 0..2pi. S and V are in the range 0..1.
+
+ .. note::
+ See a working example `here `__.
+
+ Example:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> output = rgb_to_hsv(input) # 2x3x4x5
+ """
+ if not isinstance(image, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(image)}")
+
+ if len(image.shape) < 3 or image.shape[-3] != 3:
+ raise ValueError(f"Input size must have a shape of (*, 3, H, W). Got {image.shape}")
+
+ max_rgb, argmax_rgb = image.max(-3)
+ min_rgb, argmin_rgb = image.min(-3)
+ deltac = max_rgb - min_rgb
+
+ v = max_rgb
+ s = deltac / (max_rgb + eps)
+
+ deltac = torch.where(deltac == 0, torch.ones_like(deltac), deltac)
+ rc, gc, bc = torch.unbind((max_rgb.unsqueeze(-3) - image), dim=-3)
+
+ h1 = (bc - gc)
+ h2 = (rc - bc) + 2.0 * deltac
+ h3 = (gc - rc) + 4.0 * deltac
+
+ h = torch.stack((h1, h2, h3), dim=-3) / deltac.unsqueeze(-3)
+ h = torch.gather(h, dim=-3, index=argmax_rgb.unsqueeze(-3)).squeeze(-3)
+ h = (h / 6.0) % 1.0
+ h = 2. * math.pi * h # we return 0/2pi output
+
+ return torch.stack((h, s, v), dim=-3)
+
+
+def hsv_to_rgb(image: torch.Tensor) -> torch.Tensor:
+ r"""Convert an image from HSV to RGB.
+
+ The H channel values are assumed to be in the range 0..2pi. S and V are in the range 0..1.
+
+ Args:
+ image: HSV Image to be converted to HSV with shape of :math:`(*, 3, H, W)`.
+
+ Returns:
+ RGB version of the image with shape of :math:`(*, 3, H, W)`.
+
+ Example:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> output = hsv_to_rgb(input) # 2x3x4x5
+ """
+ if not isinstance(image, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(image)}")
+
+ if len(image.shape) < 3 or image.shape[-3] != 3:
+ raise ValueError(f"Input size must have a shape of (*, 3, H, W). Got {image.shape}")
+
+ h: torch.Tensor = image[..., 0, :, :] / (2 * math.pi)
+ s: torch.Tensor = image[..., 1, :, :]
+ v: torch.Tensor = image[..., 2, :, :]
+
+ hi: torch.Tensor = torch.floor(h * 6) % 6
+ f: torch.Tensor = ((h * 6) % 6) - hi
+ one: torch.Tensor = torch.tensor(1.0, device=image.device, dtype=image.dtype)
+ p: torch.Tensor = v * (one - s)
+ q: torch.Tensor = v * (one - f * s)
+ t: torch.Tensor = v * (one - (one - f) * s)
+
+ hi = hi.long()
+ indices: torch.Tensor = torch.stack([hi, hi + 6, hi + 12], dim=-3)
+ out = torch.stack((v, q, p, p, t, v, t, v, v, q, p, p, p, p, t, v, v, q), dim=-3)
+ out = torch.gather(out, -3, indices)
+
+ return out
+
+
+class RgbToHsv(nn.Module):
+ r"""Convert an image from RGB to HSV.
+
+ The image data is assumed to be in the range of (0, 1).
+
+ Args:
+ eps: scalar to enforce numarical stability.
+
+ Returns:
+ HSV version of the image.
+
+ Shape:
+ - image: :math:`(*, 3, H, W)`
+ - output: :math:`(*, 3, H, W)`
+
+ Example:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> hsv = RgbToHsv()
+ >>> output = hsv(input) # 2x3x4x5
+ """
+
+ def __init__(self, eps: float = 1e-6) -> None:
+ super().__init__()
+ self.eps = eps
+
+ def forward(self, image: torch.Tensor) -> torch.Tensor:
+ return rgb_to_hsv(image, self.eps)
+
+
+class HsvToRgb(nn.Module):
+ r"""Convert an image from HSV to RGB.
+
+ H channel values are assumed to be in the range 0..2pi. S and V are in the range 0..1.
+
+ Returns:
+ RGB version of the image.
+
+ Shape:
+ - image: :math:`(*, 3, H, W)`
+ - output: :math:`(*, 3, H, W)`
+
+ Example:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> rgb = HsvToRgb()
+ >>> output = rgb(input) # 2x3x4x5
+ """
+
+ def forward(self, image: torch.Tensor) -> torch.Tensor:
+ return hsv_to_rgb(image)
diff --git a/kornia/color/lab.py b/kornia/color/lab.py
new file mode 100644
index 0000000000000000000000000000000000000000..e019d90d0381c5fdf71636bbdd52e00b12fc197a
--- /dev/null
+++ b/kornia/color/lab.py
@@ -0,0 +1,178 @@
+import torch
+import torch.nn as nn
+
+from .rgb import linear_rgb_to_rgb, rgb_to_linear_rgb
+from .xyz import rgb_to_xyz, xyz_to_rgb
+
+"""
+The RGB to Lab color transformations were translated from scikit image's rgb2lab and lab2rgb
+
+https://github.com/scikit-image/scikit-image/blob/a48bf6774718c64dade4548153ae16065b595ca9/skimage/color/colorconv.py
+
+"""
+
+
+def rgb_to_lab(image: torch.Tensor) -> torch.Tensor:
+ r"""Convert a RGB image to Lab.
+
+ .. image:: _static/img/rgb_to_lab.png
+
+ The image data is assumed to be in the range of :math:`[0, 1]`. Lab
+ color is computed using the D65 illuminant and Observer 2.
+
+ Args:
+ image: RGB Image to be converted to Lab with shape :math:`(*, 3, H, W)`.
+
+ Returns:
+ Lab version of the image with shape :math:`(*, 3, H, W)`.
+ The L channel values are in the range 0..100. a and b are in the range -127..127.
+
+ Example:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> output = rgb_to_lab(input) # 2x3x4x5
+ """
+ if not isinstance(image, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(image)}")
+
+ if len(image.shape) < 3 or image.shape[-3] != 3:
+ raise ValueError(f"Input size must have a shape of (*, 3, H, W). Got {image.shape}")
+
+ # Convert from sRGB to Linear RGB
+ lin_rgb = rgb_to_linear_rgb(image)
+
+ xyz_im: torch.Tensor = rgb_to_xyz(lin_rgb)
+
+ # normalize for D65 white point
+ xyz_ref_white = torch.tensor([0.95047, 1.0, 1.08883], device=xyz_im.device, dtype=xyz_im.dtype)[..., :, None, None]
+ xyz_normalized = torch.div(xyz_im, xyz_ref_white)
+
+ threshold = 0.008856
+ power = torch.pow(xyz_normalized.clamp(min=threshold), 1 / 3.0)
+ scale = 7.787 * xyz_normalized + 4.0 / 29.0
+ xyz_int = torch.where(xyz_normalized > threshold, power, scale)
+
+ x: torch.Tensor = xyz_int[..., 0, :, :]
+ y: torch.Tensor = xyz_int[..., 1, :, :]
+ z: torch.Tensor = xyz_int[..., 2, :, :]
+
+ L: torch.Tensor = (116.0 * y) - 16.0
+ a: torch.Tensor = 500.0 * (x - y)
+ _b: torch.Tensor = 200.0 * (y - z)
+
+ out: torch.Tensor = torch.stack([L, a, _b], dim=-3)
+
+ return out
+
+
+def lab_to_rgb(image: torch.Tensor, clip: bool = True) -> torch.Tensor:
+ r"""Convert a Lab image to RGB.
+
+ Args:
+ image: Lab image to be converted to RGB with shape :math:`(*, 3, H, W)`.
+ clip: Whether to apply clipping to insure output RGB values in range :math:`[0, 1]`.
+
+ Returns:
+ Lab version of the image with shape :math:`(*, 3, H, W)`.
+
+ Example:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> output = lab_to_rgb(input) # 2x3x4x5
+ """
+ if not isinstance(image, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(image)}")
+
+ if len(image.shape) < 3 or image.shape[-3] != 3:
+ raise ValueError(f"Input size must have a shape of (*, 3, H, W). Got {image.shape}")
+
+ L: torch.Tensor = image[..., 0, :, :]
+ a: torch.Tensor = image[..., 1, :, :]
+ _b: torch.Tensor = image[..., 2, :, :]
+
+ fy = (L + 16.0) / 116.0
+ fx = (a / 500.0) + fy
+ fz = fy - (_b / 200.0)
+
+ # if color data out of range: Z < 0
+ fz = fz.clamp(min=0.0)
+
+ fxyz = torch.stack([fx, fy, fz], dim=-3)
+
+ # Convert from Lab to XYZ
+ power = torch.pow(fxyz, 3.0)
+ scale = (fxyz - 4.0 / 29.0) / 7.787
+ xyz = torch.where(fxyz > 0.2068966, power, scale)
+
+ # For D65 white point
+ xyz_ref_white = torch.tensor([0.95047, 1.0, 1.08883], device=xyz.device, dtype=xyz.dtype)[..., :, None, None]
+ xyz_im = xyz * xyz_ref_white
+
+ rgbs_im: torch.Tensor = xyz_to_rgb(xyz_im)
+
+ # https://github.com/richzhang/colorization-pytorch/blob/66a1cb2e5258f7c8f374f582acc8b1ef99c13c27/util/util.py#L107
+ # rgbs_im = torch.where(rgbs_im < 0, torch.zeros_like(rgbs_im), rgbs_im)
+
+ # Convert from RGB Linear to sRGB
+ rgb_im = linear_rgb_to_rgb(rgbs_im)
+
+ # Clip to 0,1 https://www.w3.org/Graphics/Color/srgb
+ if clip:
+ rgb_im = torch.clamp(rgb_im, min=0.0, max=1.0)
+
+ return rgb_im
+
+
+class RgbToLab(nn.Module):
+ r"""Convert an image from RGB to Lab.
+
+ The image data is assumed to be in the range of :math:`[0, 1]`. Lab
+ color is computed using the D65 illuminant and Observer 2.
+
+ Returns:
+ Lab version of the image.
+
+ Shape:
+ - image: :math:`(*, 3, H, W)`
+ - output: :math:`(*, 3, H, W)`
+
+ Examples:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> lab = RgbToLab()
+ >>> output = lab(input) # 2x3x4x5
+
+ Reference:
+ [1] https://docs.opencv.org/4.0.1/de/d25/imgproc_color_conversions.html
+
+ [2] https://www.easyrgb.com/en/math.php
+
+ [3] https://github.com/torch/image/blob/dc061b98fb7e946e00034a5fc73e883a299edc7f/generic/image.c#L1467
+ """
+
+ def forward(self, image: torch.Tensor) -> torch.Tensor:
+ return rgb_to_lab(image)
+
+
+class LabToRgb(nn.Module):
+ r"""Convert an image from Lab to RGB.
+
+ Returns:
+ RGB version of the image. Range may not be in :math:`[0, 1]`.
+
+ Shape:
+ - image: :math:`(*, 3, H, W)`
+ - output: :math:`(*, 3, H, W)`
+
+ Examples:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> rgb = LabToRgb()
+ >>> output = rgb(input) # 2x3x4x5
+
+ References:
+ [1] https://docs.opencv.org/4.0.1/de/d25/imgproc_color_conversions.html
+
+ [2] https://www.easyrgb.com/en/math.php
+
+ [3] https://github.com/torch/image/blob/dc061b98fb7e946e00034a5fc73e883a299edc7f/generic/image.c#L1518
+ """
+
+ def forward(self, image: torch.Tensor, clip: bool = True) -> torch.Tensor:
+ return lab_to_rgb(image, clip)
diff --git a/kornia/color/luv.py b/kornia/color/luv.py
new file mode 100644
index 0000000000000000000000000000000000000000..492acdebf3718a224eb8f855a9c70e7b5b1c3950
--- /dev/null
+++ b/kornia/color/luv.py
@@ -0,0 +1,173 @@
+from typing import Tuple
+
+import torch
+import torch.nn as nn
+
+from .rgb import linear_rgb_to_rgb, rgb_to_linear_rgb
+from .xyz import rgb_to_xyz, xyz_to_rgb
+
+"""
+The RGB to Luv color transformations were translated from scikit image's rgb2luv and luv2rgb
+
+https://github.com/scikit-image/scikit-image/blob/a48bf6774718c64dade4548153ae16065b595ca9/skimage/color/colorconv.py
+
+"""
+
+
+def rgb_to_luv(image: torch.Tensor, eps: float = 1e-12) -> torch.Tensor:
+ r"""Convert a RGB image to Luv.
+
+ .. image:: _static/img/rgb_to_luv.png
+
+ The image data is assumed to be in the range of :math:`[0, 1]`. Luv
+ color is computed using the D65 illuminant and Observer 2.
+
+ Args:
+ image: RGB Image to be converted to Luv with shape :math:`(*, 3, H, W)`.
+ eps: for numerically stability when dividing.
+
+ Returns:
+ Luv version of the image with shape :math:`(*, 3, H, W)`.
+
+ Example:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> output = rgb_to_luv(input) # 2x3x4x5
+ """
+ if not isinstance(image, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(image)}")
+
+ if len(image.shape) < 3 or image.shape[-3] != 3:
+ raise ValueError(f"Input size must have a shape of (*, 3, H, W). Got {image.shape}")
+
+ # Convert from sRGB to Linear RGB
+ lin_rgb = rgb_to_linear_rgb(image)
+
+ xyz_im: torch.Tensor = rgb_to_xyz(lin_rgb)
+
+ x: torch.Tensor = xyz_im[..., 0, :, :]
+ y: torch.Tensor = xyz_im[..., 1, :, :]
+ z: torch.Tensor = xyz_im[..., 2, :, :]
+
+ threshold = 0.008856
+ L: torch.Tensor = torch.where(y > threshold, 116.0 * torch.pow(y.clamp(min=threshold), 1.0 / 3.0) - 16.0, 903.3 * y)
+
+ # Compute reference white point
+ xyz_ref_white: Tuple[float, float, float] = (0.95047, 1.0, 1.08883)
+ u_w: float = (4 * xyz_ref_white[0]) / (xyz_ref_white[0] + 15 * xyz_ref_white[1] + 3 * xyz_ref_white[2])
+ v_w: float = (9 * xyz_ref_white[1]) / (xyz_ref_white[0] + 15 * xyz_ref_white[1] + 3 * xyz_ref_white[2])
+
+ u_p: torch.Tensor = (4 * x) / (x + 15 * y + 3 * z + eps)
+ v_p: torch.Tensor = (9 * y) / (x + 15 * y + 3 * z + eps)
+
+ u: torch.Tensor = 13 * L * (u_p - u_w)
+ v: torch.Tensor = 13 * L * (v_p - v_w)
+
+ out = torch.stack([L, u, v], dim=-3)
+
+ return out
+
+
+def luv_to_rgb(image: torch.Tensor, eps: float = 1e-12) -> torch.Tensor:
+ r"""Convert a Luv image to RGB.
+
+ Args:
+ image: Luv image to be converted to RGB with shape :math:`(*, 3, H, W)`.
+ eps: for numerically stability when dividing.
+
+ Returns:
+ Luv version of the image with shape :math:`(*, 3, H, W)`.
+
+ Example:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> output = luv_to_rgb(input) # 2x3x4x5
+ """
+ if not isinstance(image, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(image)}")
+
+ if len(image.shape) < 3 or image.shape[-3] != 3:
+ raise ValueError(f"Input size must have a shape of (*, 3, H, W). Got {image.shape}")
+
+ L: torch.Tensor = image[..., 0, :, :]
+ u: torch.Tensor = image[..., 1, :, :]
+ v: torch.Tensor = image[..., 2, :, :]
+
+ # Convert from Luv to XYZ
+ y: torch.Tensor = torch.where(L > 7.999625, torch.pow((L + 16) / 116, 3.0), L / 903.3)
+
+ # Compute white point
+ xyz_ref_white: Tuple[float, float, float] = (0.95047, 1.0, 1.08883)
+ u_w: float = (4 * xyz_ref_white[0]) / (xyz_ref_white[0] + 15 * xyz_ref_white[1] + 3 * xyz_ref_white[2])
+ v_w: float = (9 * xyz_ref_white[1]) / (xyz_ref_white[0] + 15 * xyz_ref_white[1] + 3 * xyz_ref_white[2])
+
+ a: torch.Tensor = u_w + u / (13 * L + eps)
+ d: torch.Tensor = v_w + v / (13 * L + eps)
+ c: torch.Tensor = 3 * y * (5 * d - 3)
+
+ z: torch.Tensor = ((a - 4) * c - 15 * a * d * y) / (12 * d + eps)
+ x: torch.Tensor = -(c / (d + eps) + 3.0 * z)
+
+ xyz_im: torch.Tensor = torch.stack([x, y, z], -3)
+
+ rgbs_im: torch.Tensor = xyz_to_rgb(xyz_im)
+
+ # Convert from RGB Linear to sRGB
+ rgb_im = linear_rgb_to_rgb(rgbs_im)
+
+ return rgb_im
+
+
+class RgbToLuv(nn.Module):
+ r"""Convert an image from RGB to Luv.
+
+ The image data is assumed to be in the range of :math:`[0, 1]`. Luv
+ color is computed using the D65 illuminant and Observer 2.
+
+ Returns:
+ Luv version of the image.
+
+ Shape:
+ - image: :math:`(*, 3, H, W)`
+ - output: :math:`(*, 3, H, W)`
+
+ Examples:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> luv = RgbToLuv()
+ >>> output = luv(input) # 2x3x4x5
+
+ Reference:
+ [1] https://docs.opencv.org/4.0.1/de/d25/imgproc_color_conversions.html
+
+ [2] https://www.easyrgb.com/en/math.php
+
+ [3] http://www.poynton.com/ColorFAQ.html
+ """
+
+ def forward(self, image: torch.Tensor) -> torch.Tensor:
+ return rgb_to_luv(image)
+
+
+class LuvToRgb(nn.Module):
+ r"""Convert an image from Luv to RGB.
+
+ Returns:
+ RGB version of the image.
+
+ Shape:
+ - image: :math:`(*, 3, H, W)`
+ - output: :math:`(*, 3, H, W)`
+
+ Examples:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> rgb = LuvToRgb()
+ >>> output = rgb(input) # 2x3x4x5
+
+ References:
+ [1] https://docs.opencv.org/4.0.1/de/d25/imgproc_color_conversions.html
+
+ [2] https://www.easyrgb.com/en/math.php
+
+ [3] http://www.poynton.com/ColorFAQ.html
+ """
+
+ def forward(self, image: torch.Tensor) -> torch.Tensor:
+ return luv_to_rgb(image)
diff --git a/kornia/color/raw.py b/kornia/color/raw.py
new file mode 100644
index 0000000000000000000000000000000000000000..a55a98de901456677c29cb4ae8c5d7c945dd03b8
--- /dev/null
+++ b/kornia/color/raw.py
@@ -0,0 +1,257 @@
+from enum import Enum
+
+import torch
+import torch.nn as nn
+
+
+class CFA(Enum):
+ r"""Defines the configuration of the color filter array.
+
+ So far only bayer images is supported and the enum sets the pixel order for bayer. Note that this can change due
+ to things like rotations and cropping of images. Take care if including the translations in pipeline.
+ This implementations is optimized to be reasonably fast, look better than simple nearest neighbour.
+ On top of this care is taken to make it reversible going raw -> rgb -> raw. the raw samples remain intact
+ during conversion and only unknown samples are interpolated.
+
+ The names are based on the OpenCV convention where the BG indicates pixel 1,1 (counting from 0,0) is
+ blue and its neighbour to the right is green. In that case the top left pixel is red. Other options are GB, RG and
+ GR
+
+ reference:
+ https://en.wikipedia.org/wiki/Color_filter_array
+ """
+
+ BG = 0
+ GB = 1
+ RG = 2
+ GR = 3
+
+
+def raw_to_rgb(image: torch.Tensor, cfa: CFA) -> torch.Tensor:
+ r"""Convert a raw bayer image to RGB version of image.
+
+ We are assuming a CFA with 2 green, 1 red, 1 blue. A bilinear interpolation is used for R/G and a fix convolution
+ for the green pixels. To simplify calculations we expect the Height Width to be evenly divisible by 2.
+
+ The image data is assumed to be in the range of (0, 1). Image H/W is assumed to be evenly divisible by 2.
+ for simplicity reasons
+
+ Args:
+ image: raw image to be converted to RGB with shape :math:`(*,1,H,W)`.
+ cfa: The configuration of the color filter.
+ Returns:
+ RGB version of the image with shape :math:`(*,3,H,W)`.
+
+ Example:
+ >>> rawinput = torch.randn(2, 1, 4, 6)
+ >>> rgb = raw_to_rgb(rawinput, CFA.RG) # 2x3x4x6
+ """
+ if not isinstance(image, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. " f"Got {type(image)}")
+
+ if image.dim() < 3 or image.size(-3) != 1:
+ raise ValueError(f"Input size must have a shape of (*, 1, H, W). " f"Got {image.shape}.")
+
+ if len(image.shape) < 2 or image.shape[-2] % 2 == 1 or image.shape[-1] % 2 == 1:
+ raise ValueError(f"Input H&W must be evenly disible by 2. Got {image.shape}")
+
+ imagesize = image.size()
+
+ image = image.view(-1, 1, image.shape[-2], image.shape[-1])
+
+ # BG is defined as pel 1,1 being blue, that is the top left is actually green. This matches
+ # opencv naming so makes sense to keep
+ if cfa == CFA.BG:
+ r = image[..., :, ::2, ::2]
+ b = image[..., :, 1::2, 1::2]
+ rpad = (0, 1, 0, 1)
+ bpad = (1, 0, 1, 0)
+ elif cfa == CFA.GB:
+ r = image[..., :, ::2, 1::2]
+ b = image[..., :, 1::2, ::2]
+ rpad = (1, 0, 0, 1)
+ bpad = (0, 1, 1, 0)
+ elif cfa == CFA.RG:
+ r = image[..., :, 1::2, 1::2]
+ b = image[..., :, ::2, ::2]
+ rpad = (1, 0, 1, 0)
+ bpad = (0, 1, 0, 1)
+ elif cfa == CFA.GR:
+ r = image[..., :, 1::2, ::2]
+ b = image[..., :, ::2, 1::2]
+ rpad = (0, 1, 1, 0)
+ bpad = (1, 0, 0, 1)
+ else:
+ raise ValueError(f"Unsupported CFA " f"Got {cfa}.")
+
+ # upscaling r and b with bi-linear gives reasonable quality
+ # Note that depending on where these are sampled we need to pad appropriately
+ # the bilinear filter will pretty much be based on for example this layout (RG)
+ # (which needs to be padded bottom right)
+ # +-+-+
+ # |B| |
+ # | | |
+ # +-+-+
+ # While in this layout we need to pad with additional B samples top left to
+ # make sure we interpolate from the correct position
+ # +-+-+
+ # | | |
+ # | |B|
+ # +-+-+
+ # For an image like this (3x2 blue pixels)
+ # +------+
+ # |B B B |
+ # | |
+ # |B B B |
+ # | |
+ # +------+
+ # It needs to be expanded to this (4x3 pixels scaled to 7x5 for correct interpolation)
+ # +-------+
+ # |B B B b|
+ # | |
+ # |B B B b|
+ # | |
+ # |b b b b|
+ # +-------+
+ # and we crop the area afterwards. This is since the interpolation will be between first and last pixel
+ # evenly spaced between them while the B/R samples will be missing in the corners were they are assumed to exist
+ # Further we need to do align_corners to start the interpolation from the middle of the samples in the corners, that
+ # way we get to keep the known blue samples across the whole image
+ rpadded = torch.nn.functional.pad(r, list(rpad), 'replicate')
+ bpadded = torch.nn.functional.pad(b, list(bpad), 'replicate')
+ # use explicit padding instead of conv2d padding to be able to use reflect which mirror the correct colors
+ # for a 2x2 bayer filter
+ gpadded = torch.nn.functional.pad(image, [1, 1, 1, 1], 'reflect')
+
+ ru = torch.nn.functional.interpolate(rpadded, size=(image.shape[-2] + 1, image.shape[-1] + 1),
+ mode='bilinear', align_corners=True)
+ bu = torch.nn.functional.interpolate(bpadded, size=(image.shape[-2] + 1, image.shape[-1] + 1),
+ mode='bilinear', align_corners=True)
+
+ # remove the extra padding
+ ru = torch.nn.functional.pad(ru, [-x for x in rpad])
+ bu = torch.nn.functional.pad(bu, [-x for x in bpad])
+
+ # all unknown pixels are the average of the nearby green samples
+ kernel = torch.tensor([[[[0.0, 0.25, 0.0], [0.25, 0.0, 0.25], [0.0, 0.25, 0.0]]]],
+ dtype=image.dtype, device=image.device)
+
+ # This is done on all samples but result for the known green samples is then overwritten by the input
+ gu = torch.nn.functional.conv2d(gpadded, kernel)
+
+ # overwrite the already known samples which otherwise have values from r/b
+ # this depends on the CFA configuration
+ if cfa == CFA.BG:
+ gu[:, :, ::2, 1::2] = image[:, :, ::2, 1::2]
+ gu[:, :, 1::2, ::2] = image[:, :, 1::2, ::2]
+ elif cfa == CFA.GB:
+ gu[:, :, ::2, ::2] = image[:, :, ::2, ::2]
+ gu[:, :, 1::2, 1::2] = image[:, :, 1::2, 1::2]
+ elif cfa == CFA.RG:
+ gu[:, :, 1::2, ::2] = image[:, :, 1::2, ::2]
+ gu[:, :, ::2, 1::2] = image[:, :, ::2, 1::2]
+ elif cfa == CFA.GR:
+ gu[:, :, 1::2, 1::2] = image[:, :, 1::2, 1::2]
+ gu[:, :, ::2, ::2] = image[:, :, ::2, ::2]
+ else:
+ raise ValueError(f"Unsupported CFA " f"Got {cfa}.")
+
+ ru = ru.view(imagesize)
+ gu = gu.view(imagesize)
+ bu = bu.view(imagesize)
+
+ rgb: torch.Tensor = torch.cat([ru, gu, bu], dim=-3)
+
+ return rgb
+
+
+def rgb_to_raw(image: torch.Tensor, cfa: CFA) -> torch.Tensor:
+ r"""Convert a RGB image to RAW version of image with the specified color filter array.
+
+ The image data is assumed to be in the range of (0, 1).
+
+ Args:
+ image: RGB image to be converted to bayer raw with shape :math:`(*,3,H,W)`.
+ cfa: Which color filter array do we want the output to mimic. I.e. which pixels are red/green/blue.
+
+ Returns:
+ raw version of the image with shape :math:`(*,1,H,W)`.
+
+ Example:
+ >>> rgbinput = torch.rand(2, 3, 4, 6)
+ >>> raw = rgb_to_raw(rgbinput, CFA.BG) # 2x1x4x6
+ """
+ if not isinstance(image, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(image)}")
+
+ if len(image.shape) < 3 or image.shape[-3] != 3:
+ raise ValueError(f"Input size must have a shape of (*, 3, H, W). Got {image.shape}")
+
+ # pick the tensor with green pixels
+ # clone to make sure grad works
+ output: torch.Tensor = image[..., 1:2, :, :].clone()
+
+ # overwrite the r/b positions (depending on the cfa configuration) with blue/red pixels
+ if cfa == CFA.BG:
+ output[..., :, ::2, ::2] = image[..., 0:1, ::2, ::2] # red
+ output[..., :, 1::2, 1::2] = image[..., 2:3, 1::2, 1::2] # blue
+ elif cfa == CFA.GB:
+ output[..., :, ::2, 1::2] = image[..., 0:1, ::2, 1::2] # red
+ output[..., :, 1::2, ::2] = image[..., 2:3, 1::2, ::2] # blue
+ elif cfa == CFA.RG:
+ output[..., :, 1::2, 1::2] = image[..., 0:1, 1::2, 1::2] # red
+ output[..., :, ::2, ::2] = image[..., 2:3, ::2, ::2] # blue
+ elif cfa == CFA.GR:
+ output[..., :, 1::2, ::2] = image[..., 0:1, 1::2, ::2] # red
+ output[..., :, ::2, 1::2] = image[..., 2:3, ::2, 1::2] # blue
+
+ return output
+
+
+class RawToRgb(nn.Module):
+ r"""Module to convert a bayer raw image to RGB version of image.
+
+ The image data is assumed to be in the range of (0, 1).
+
+ Shape:
+ - image: :math:`(*, 1, H, W)`
+ - output: :math:`(*, 3, H, W)`
+
+ Example:
+ >>> rawinput = torch.rand(2, 1, 4, 6)
+ >>> rgb = RawToRgb(CFA.RG)
+ >>> output = rgb(rawinput) # 2x3x4x5
+ """
+
+ def __init__(self, cfa: CFA) -> None:
+ super().__init__()
+ self.cfa = cfa
+
+ def forward(self, image: torch.Tensor) -> torch.Tensor:
+ return raw_to_rgb(image, cfa=self.cfa)
+
+
+class RgbToRaw(nn.Module):
+ r"""Module to convert a RGB image to bayer raw version of image.
+
+ The image data is assumed to be in the range of (0, 1).
+
+ Shape:
+ - image: :math:`(*, 3, H, W)`
+ - output: :math:`(*, 1, H, W)`
+
+ reference:
+ https://docs.opencv.org/4.0.1/de/d25/imgproc_color_conversions.html
+
+ Example:
+ >>> rgbinput = torch.rand(2, 3, 4, 6)
+ >>> raw = RgbToRaw(CFA.GB)
+ >>> output = raw(rgbinput) # 2x1x4x6
+ """
+
+ def __init__(self, cfa: CFA) -> None:
+ super().__init__()
+ self.cfa = cfa
+
+ def forward(self, image: torch.Tensor) -> torch.Tensor:
+ return rgb_to_raw(image, cfa=self.cfa)
diff --git a/kornia/color/rgb.py b/kornia/color/rgb.py
new file mode 100644
index 0000000000000000000000000000000000000000..c5486681497a72e8cb635bc76d93a33cb7677866
--- /dev/null
+++ b/kornia/color/rgb.py
@@ -0,0 +1,441 @@
+from typing import cast, Union
+
+import torch
+import torch.nn as nn
+
+
+def rgb_to_bgr(image: torch.Tensor) -> torch.Tensor:
+ r"""Convert a RGB image to BGR.
+
+ .. image:: _static/img/rgb_to_bgr.png
+
+ Args:
+ image: RGB Image to be converted to BGRof of shape :math:`(*,3,H,W)`.
+
+ Returns:
+ BGR version of the image with shape of shape :math:`(*,3,H,W)`.
+
+ Example:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> output = rgb_to_bgr(input) # 2x3x4x5
+ """
+ if not isinstance(image, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(image)}")
+
+ if len(image.shape) < 3 or image.shape[-3] != 3:
+ raise ValueError(f"Input size must have a shape of (*, 3, H, W).Got {image.shape}")
+
+ return bgr_to_rgb(image)
+
+
+def bgr_to_rgb(image: torch.Tensor) -> torch.Tensor:
+ r"""Convert a BGR image to RGB.
+
+ Args:
+ image: BGR Image to be converted to BGR of shape :math:`(*,3,H,W)`.
+
+ Returns:
+ RGB version of the image with shape of shape :math:`(*,3,H,W)`.
+
+ Example:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> output = bgr_to_rgb(input) # 2x3x4x5
+ """
+ if not isinstance(image, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(image)}")
+
+ if len(image.shape) < 3 or image.shape[-3] != 3:
+ raise ValueError(f"Input size must have a shape of (*, 3, H, W).Got {image.shape}")
+
+ # flip image channels
+ out: torch.Tensor = image.flip(-3)
+ return out
+
+
+def rgb_to_rgba(image: torch.Tensor, alpha_val: Union[float, torch.Tensor]) -> torch.Tensor:
+ r"""Convert an image from RGB to RGBA.
+
+ Args:
+ image: RGB Image to be converted to RGBA of shape :math:`(*,3,H,W)`.
+ alpha_val (float, torch.Tensor): A float number for the alpha value or a tensor
+ of shape :math:`(*,1,H,W)`.
+
+ Returns:
+ RGBA version of the image with shape :math:`(*,4,H,W)`.
+
+ .. note:: The current functionality is NOT supported by Torchscript.
+
+ Example:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> output = rgb_to_rgba(input, 1.) # 2x4x4x5
+ """
+ if not isinstance(image, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(image)}")
+
+ if len(image.shape) < 3 or image.shape[-3] != 3:
+ raise ValueError(f"Input size must have a shape of (*, 3, H, W).Got {image.shape}")
+
+ if not isinstance(alpha_val, (float, torch.Tensor)):
+ raise TypeError(f"alpha_val type is not a float or torch.Tensor. Got {type(alpha_val)}")
+
+ # add one channel
+ r, g, b = torch.chunk(image, image.shape[-3], dim=-3)
+
+ a: torch.Tensor = cast(torch.Tensor, alpha_val)
+
+ if isinstance(alpha_val, float):
+ a = torch.full_like(r, fill_value=float(alpha_val))
+
+ return torch.cat([r, g, b, a], dim=-3)
+
+
+def bgr_to_rgba(image: torch.Tensor, alpha_val: Union[float, torch.Tensor]) -> torch.Tensor:
+ r"""Convert an image from BGR to RGBA.
+
+ Args:
+ image: BGR Image to be converted to RGBA of shape :math:`(*,3,H,W)`.
+ alpha_val: A float number for the alpha value or a tensor
+ of shape :math:`(*,1,H,W)`.
+
+ Returns:
+ RGBA version of the image with shape :math:`(*,4,H,W)`.
+
+ .. note:: The current functionality is NOT supported by Torchscript.
+
+ Example:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> output = bgr_to_rgba(input, 1.) # 2x4x4x5
+ """
+ if not isinstance(image, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(image)}")
+
+ if len(image.shape) < 3 or image.shape[-3] != 3:
+ raise ValueError(f"Input size must have a shape of (*, 3, H, W).Got {image.shape}")
+
+ if not isinstance(alpha_val, (float, torch.Tensor)):
+ raise TypeError(f"alpha_val type is not a float or torch.Tensor. Got {type(alpha_val)}")
+
+ # convert first to RGB, then add alpha channel
+ x_rgb: torch.Tensor = bgr_to_rgb(image)
+ return rgb_to_rgba(x_rgb, alpha_val)
+
+
+def rgba_to_rgb(image: torch.Tensor) -> torch.Tensor:
+ r"""Convert an image from RGBA to RGB.
+
+ Args:
+ image: RGBA Image to be converted to RGB of shape :math:`(*,4,H,W)`.
+
+ Returns:
+ RGB version of the image with shape :math:`(*,3,H,W)`.
+
+ Example:
+ >>> input = torch.rand(2, 4, 4, 5)
+ >>> output = rgba_to_rgb(input) # 2x3x4x5
+ """
+ if not isinstance(image, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(image)}")
+
+ if len(image.shape) < 3 or image.shape[-3] != 4:
+ raise ValueError(f"Input size must have a shape of (*, 4, H, W).Got {image.shape}")
+
+ # unpack channels
+ r, g, b, a = torch.chunk(image, image.shape[-3], dim=-3)
+
+ # compute new channels
+ a_one = torch.tensor(1.0) - a
+ r_new: torch.Tensor = a_one * r + a * r
+ g_new: torch.Tensor = a_one * g + a * g
+ b_new: torch.Tensor = a_one * b + a * b
+
+ return torch.cat([r_new, g_new, b_new], dim=-3)
+
+
+def rgba_to_bgr(image: torch.Tensor) -> torch.Tensor:
+ r"""Convert an image from RGBA to BGR.
+
+ Args:
+ image: RGBA Image to be converted to BGR of shape :math:`(*,4,H,W)`.
+
+ Returns:
+ RGB version of the image with shape :math:`(*,3,H,W)`.
+
+ Example:
+ >>> input = torch.rand(2, 4, 4, 5)
+ >>> output = rgba_to_bgr(input) # 2x3x4x5
+ """
+ if not isinstance(image, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(image)}")
+
+ if len(image.shape) < 3 or image.shape[-3] != 4:
+ raise ValueError(f"Input size must have a shape of (*, 4, H, W).Got {image.shape}")
+
+ # convert to RGB first, then to BGR
+ x_rgb: torch.Tensor = rgba_to_rgb(image)
+ return rgb_to_bgr(x_rgb)
+
+
+def rgb_to_linear_rgb(image: torch.Tensor) -> torch.Tensor:
+ r"""Convert an sRGB image to linear RGB. Used in colorspace conversions.
+
+ .. image:: _static/img/rgb_to_linear_rgb.png
+
+ Args:
+ image: sRGB Image to be converted to linear RGB of shape :math:`(*,3,H,W)`.
+
+ Returns:
+ linear RGB version of the image with shape of :math:`(*,3,H,W)`.
+
+ Example:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> output = rgb_to_linear_rgb(input) # 2x3x4x5
+ """
+
+ if not isinstance(image, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(image)}")
+
+ if len(image.shape) < 3 or image.shape[-3] != 3:
+ raise ValueError(f"Input size must have a shape of (*, 3, H, W).Got {image.shape}")
+
+ lin_rgb: torch.Tensor = torch.where(image > 0.04045, torch.pow(((image + 0.055) / 1.055), 2.4), image / 12.92)
+
+ return lin_rgb
+
+
+def linear_rgb_to_rgb(image: torch.Tensor) -> torch.Tensor:
+ r"""Convert a linear RGB image to sRGB. Used in colorspace conversions.
+
+ Args:
+ image: linear RGB Image to be converted to sRGB of shape :math:`(*,3,H,W)`.
+
+ Returns:
+ sRGB version of the image with shape of shape :math:`(*,3,H,W)`.
+
+ Example:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> output = linear_rgb_to_rgb(input) # 2x3x4x5
+ """
+
+ if not isinstance(image, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(image)}")
+
+ if len(image.shape) < 3 or image.shape[-3] != 3:
+ raise ValueError(f"Input size must have a shape of (*, 3, H, W).Got {image.shape}")
+
+ threshold = 0.0031308
+ rgb: torch.Tensor = torch.where(
+ image > threshold, 1.055 * torch.pow(image.clamp(min=threshold), 1 / 2.4) - 0.055, 12.92 * image
+ )
+
+ return rgb
+
+
+class BgrToRgb(nn.Module):
+ r"""Convert image from BGR to RGB.
+
+ The image data is assumed to be in the range of (0, 1).
+
+ Returns:
+ RGB version of the image.
+
+ Shape:
+ - image: :math:`(*, 3, H, W)`
+ - output: :math:`(*, 3, H, W)`
+
+ Example:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> rgb = BgrToRgb()
+ >>> output = rgb(input) # 2x3x4x5
+ """
+
+ def forward(self, image: torch.Tensor) -> torch.Tensor:
+ return bgr_to_rgb(image)
+
+
+class RgbToBgr(nn.Module):
+ r"""Convert an image from RGB to BGR.
+
+ The image data is assumed to be in the range of (0, 1).
+
+ Returns:
+ BGR version of the image.
+
+ Shape:
+ - image: :math:`(*, 3, H, W)`
+ - output: :math:`(*, 3, H, W)`
+
+ Example:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> bgr = RgbToBgr()
+ >>> output = bgr(input) # 2x3x4x5
+ """
+
+ def forward(self, image: torch.Tensor) -> torch.Tensor:
+ return rgb_to_bgr(image)
+
+
+class RgbToRgba(nn.Module):
+ r"""Convert an image from RGB to RGBA.
+
+ Add an alpha channel to existing RGB image.
+
+ Args:
+ alpha_val: A float number for the alpha value or a tensor
+ of shape :math:`(*,1,H,W)`.
+
+ Returns:
+ torch.Tensor: RGBA version of the image with shape :math:`(*,4,H,W)`.
+
+ Shape:
+ - image: :math:`(*, 3, H, W)`
+ - output: :math:`(*, 4, H, W)`
+
+ .. note:: The current functionality is NOT supported by Torchscript.
+
+ Example:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> rgba = RgbToRgba(1.)
+ >>> output = rgba(input) # 2x4x4x5
+ """
+
+ def __init__(self, alpha_val: Union[float, torch.Tensor]) -> None:
+ super().__init__()
+ self.alpha_val = alpha_val
+
+ def forward(self, image: torch.Tensor) -> torch.Tensor:
+ return rgb_to_rgba(image, self.alpha_val)
+
+
+class BgrToRgba(nn.Module):
+ r"""Convert an image from BGR to RGBA.
+
+ Add an alpha channel to existing RGB image.
+
+ Args:
+ alpha_val: A float number for the alpha value or a tensor
+ of shape :math:`(*,1,H,W)`.
+
+ Returns:
+ RGBA version of the image with shape :math:`(*,4,H,W)`.
+
+ Shape:
+ - image: :math:`(*, 3, H, W)`
+ - output: :math:`(*, 4, H, W)`
+
+ .. note:: The current functionality is NOT supported by Torchscript.
+
+ Example:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> rgba = BgrToRgba(1.)
+ >>> output = rgba(input) # 2x4x4x5
+ """
+
+ def __init__(self, alpha_val: Union[float, torch.Tensor]) -> None:
+ super().__init__()
+ self.alpha_val = alpha_val
+
+ def forward(self, image: torch.Tensor) -> torch.Tensor:
+ return rgb_to_rgba(image, self.alpha_val)
+
+
+class RgbaToRgb(nn.Module):
+ r"""Convert an image from RGBA to RGB.
+
+ Remove an alpha channel from RGB image.
+
+ Returns:
+ RGB version of the image.
+
+ Shape:
+ - image: :math:`(*, 4, H, W)`
+ - output: :math:`(*, 3, H, W)`
+
+ Example:
+ >>> input = torch.rand(2, 4, 4, 5)
+ >>> rgba = RgbaToRgb()
+ >>> output = rgba(input) # 2x3x4x5
+ """
+
+ def forward(self, image: torch.Tensor) -> torch.Tensor:
+ return rgba_to_rgb(image)
+
+
+class RgbaToBgr(nn.Module):
+ r"""Convert an image from RGBA to BGR.
+
+ Remove an alpha channel from BGR image.
+
+ Returns:
+ BGR version of the image.
+
+ Shape:
+ - image: :math:`(*, 4, H, W)`
+ - output: :math:`(*, 3, H, W)`
+
+ Example:
+ >>> input = torch.rand(2, 4, 4, 5)
+ >>> rgba = RgbaToBgr()
+ >>> output = rgba(input) # 2x3x4x5
+ """
+
+ def forward(self, image: torch.Tensor) -> torch.Tensor:
+ return rgba_to_bgr(image)
+
+
+class RgbToLinearRgb(nn.Module):
+ r"""Convert an image from sRGB to linear RGB.
+
+ Reverses the gamma correction of sRGB to get linear RGB values for colorspace conversions.
+ The image data is assumed to be in the range of :math:`[0, 1]`
+
+ Returns:
+ Linear RGB version of the image.
+
+ Shape:
+ - image: :math:`(*, 3, H, W)`
+ - output: :math:`(*, 3, H, W)`
+
+ Example:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> rgb_lin = RgbToLinearRgb()
+ >>> output = rgb_lin(input) # 2x3x4x5
+
+ References:
+ [1] https://stackoverflow.com/questions/35952564/convert-rgb-to-srgb
+
+ [2] https://www.cambridgeincolour.com/tutorials/gamma-correction.htm
+
+ [3] https://en.wikipedia.org/wiki/SRGB
+ """
+
+ def forward(self, image: torch.Tensor) -> torch.Tensor:
+ return rgb_to_linear_rgb(image)
+
+
+class LinearRgbToRgb(nn.Module):
+ r"""Convert a linear RGB image to sRGB.
+
+ Applies gamma correction to linear RGB values, at the end of colorspace conversions, to get sRGB.
+
+ Returns:
+ sRGB version of the image.
+
+ Shape:
+ - image: :math:`(*, 3, H, W)`
+ - output: :math:`(*, 3, H, W)`
+
+ Example:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> srgb = LinearRgbToRgb()
+ >>> output = srgb(input) # 2x3x4x5
+
+ References:
+ [1] https://stackoverflow.com/questions/35952564/convert-rgb-to-srgb
+
+ [2] https://www.cambridgeincolour.com/tutorials/gamma-correction.htm
+
+ [3] https://en.wikipedia.org/wiki/SRGB
+ """
+
+ def forward(self, image: torch.Tensor) -> torch.Tensor:
+ return linear_rgb_to_rgb(image)
diff --git a/kornia/color/xyz.py b/kornia/color/xyz.py
new file mode 100644
index 0000000000000000000000000000000000000000..f54ad6c90942bdde3501397f6e427367f68347d3
--- /dev/null
+++ b/kornia/color/xyz.py
@@ -0,0 +1,116 @@
+import torch
+import torch.nn as nn
+
+
+def rgb_to_xyz(image: torch.Tensor) -> torch.Tensor:
+ r"""Convert a RGB image to XYZ.
+
+ .. image:: _static/img/rgb_to_xyz.png
+
+ Args:
+ image: RGB Image to be converted to XYZ with shape :math:`(*, 3, H, W)`.
+
+ Returns:
+ XYZ version of the image with shape :math:`(*, 3, H, W)`.
+
+ Example:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> output = rgb_to_xyz(input) # 2x3x4x5
+ """
+ if not isinstance(image, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(image)}")
+
+ if len(image.shape) < 3 or image.shape[-3] != 3:
+ raise ValueError(f"Input size must have a shape of (*, 3, H, W). Got {image.shape}")
+
+ r: torch.Tensor = image[..., 0, :, :]
+ g: torch.Tensor = image[..., 1, :, :]
+ b: torch.Tensor = image[..., 2, :, :]
+
+ x: torch.Tensor = 0.412453 * r + 0.357580 * g + 0.180423 * b
+ y: torch.Tensor = 0.212671 * r + 0.715160 * g + 0.072169 * b
+ z: torch.Tensor = 0.019334 * r + 0.119193 * g + 0.950227 * b
+
+ out: torch.Tensor = torch.stack([x, y, z], -3)
+
+ return out
+
+
+def xyz_to_rgb(image: torch.Tensor) -> torch.Tensor:
+ r"""Convert a XYZ image to RGB.
+
+ Args:
+ image: XYZ Image to be converted to RGB with shape :math:`(*, 3, H, W)`.
+
+ Returns:
+ RGB version of the image with shape :math:`(*, 3, H, W)`.
+
+ Example:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> output = xyz_to_rgb(input) # 2x3x4x5
+ """
+ if not isinstance(image, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(image)}")
+
+ if len(image.shape) < 3 or image.shape[-3] != 3:
+ raise ValueError(f"Input size must have a shape of (*, 3, H, W). Got {image.shape}")
+
+ x: torch.Tensor = image[..., 0, :, :]
+ y: torch.Tensor = image[..., 1, :, :]
+ z: torch.Tensor = image[..., 2, :, :]
+
+ r: torch.Tensor = 3.2404813432005266 * x + -1.5371515162713185 * y + -0.4985363261688878 * z
+ g: torch.Tensor = -0.9692549499965682 * x + 1.8759900014898907 * y + 0.0415559265582928 * z
+ b: torch.Tensor = 0.0556466391351772 * x + -0.2040413383665112 * y + 1.0573110696453443 * z
+
+ out: torch.Tensor = torch.stack([r, g, b], dim=-3)
+
+ return out
+
+
+class RgbToXyz(nn.Module):
+ r"""Convert an image from RGB to XYZ.
+
+ The image data is assumed to be in the range of (0, 1).
+
+ Returns:
+ XYZ version of the image.
+
+ Shape:
+ - image: :math:`(*, 3, H, W)`
+ - output: :math:`(*, 3, H, W)`
+
+ Examples:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> xyz = RgbToXyz()
+ >>> output = xyz(input) # 2x3x4x5
+
+ Reference:
+ [1] https://docs.opencv.org/4.0.1/de/d25/imgproc_color_conversions.html
+ """
+
+ def forward(self, image: torch.Tensor) -> torch.Tensor:
+ return rgb_to_xyz(image)
+
+
+class XyzToRgb(nn.Module):
+ r"""Converts an image from XYZ to RGB.
+
+ Returns:
+ RGB version of the image.
+
+ Shape:
+ - image: :math:`(*, 3, H, W)`
+ - output: :math:`(*, 3, H, W)`
+
+ Examples:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> rgb = XyzToRgb()
+ >>> output = rgb(input) # 2x3x4x5
+
+ Reference:
+ [1] https://docs.opencv.org/4.0.1/de/d25/imgproc_color_conversions.html
+ """
+
+ def forward(self, image: torch.Tensor) -> torch.Tensor:
+ return xyz_to_rgb(image)
diff --git a/kornia/color/ycbcr.py b/kornia/color/ycbcr.py
new file mode 100644
index 0000000000000000000000000000000000000000..19f8f0d1f69c5c74c0d85fb9fb359969d495b570
--- /dev/null
+++ b/kornia/color/ycbcr.py
@@ -0,0 +1,113 @@
+import torch
+import torch.nn as nn
+
+
+def rgb_to_ycbcr(image: torch.Tensor) -> torch.Tensor:
+ r"""Convert an RGB image to YCbCr.
+
+ .. image:: _static/img/rgb_to_ycbcr.png
+
+ Args:
+ image: RGB Image to be converted to YCbCr with shape :math:`(*, 3, H, W)`.
+
+ Returns:
+ YCbCr version of the image with shape :math:`(*, 3, H, W)`.
+
+ Examples:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> output = rgb_to_ycbcr(input) # 2x3x4x5
+ """
+ if not isinstance(image, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(image)}")
+
+ if len(image.shape) < 3 or image.shape[-3] != 3:
+ raise ValueError(f"Input size must have a shape of (*, 3, H, W). Got {image.shape}")
+
+ r: torch.Tensor = image[..., 0, :, :]
+ g: torch.Tensor = image[..., 1, :, :]
+ b: torch.Tensor = image[..., 2, :, :]
+
+ delta: float = 0.5
+ y: torch.Tensor = 0.299 * r + 0.587 * g + 0.114 * b
+ cb: torch.Tensor = (b - y) * 0.564 + delta
+ cr: torch.Tensor = (r - y) * 0.713 + delta
+ return torch.stack([y, cb, cr], -3)
+
+
+def ycbcr_to_rgb(image: torch.Tensor) -> torch.Tensor:
+ r"""Convert an YCbCr image to RGB.
+
+ The image data is assumed to be in the range of (0, 1).
+
+ Args:
+ image: YCbCr Image to be converted to RGB with shape :math:`(*, 3, H, W)`.
+
+ Returns:
+ RGB version of the image with shape :math:`(*, 3, H, W)`.
+
+ Examples:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> output = ycbcr_to_rgb(input) # 2x3x4x5
+ """
+ if not isinstance(image, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(image)}")
+
+ if len(image.shape) < 3 or image.shape[-3] != 3:
+ raise ValueError(f"Input size must have a shape of (*, 3, H, W). Got {image.shape}")
+
+ y: torch.Tensor = image[..., 0, :, :]
+ cb: torch.Tensor = image[..., 1, :, :]
+ cr: torch.Tensor = image[..., 2, :, :]
+
+ delta: float = 0.5
+ cb_shifted: torch.Tensor = cb - delta
+ cr_shifted: torch.Tensor = cr - delta
+
+ r: torch.Tensor = y + 1.403 * cr_shifted
+ g: torch.Tensor = y - 0.714 * cr_shifted - 0.344 * cb_shifted
+ b: torch.Tensor = y + 1.773 * cb_shifted
+ return torch.stack([r, g, b], -3)
+
+
+class RgbToYcbcr(nn.Module):
+ r"""Convert an image from RGB to YCbCr.
+
+ The image data is assumed to be in the range of (0, 1).
+
+ Returns:
+ YCbCr version of the image.
+
+ Shape:
+ - image: :math:`(*, 3, H, W)`
+ - output: :math:`(*, 3, H, W)`
+
+ Examples:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> ycbcr = RgbToYcbcr()
+ >>> output = ycbcr(input) # 2x3x4x5
+ """
+
+ def forward(self, image: torch.Tensor) -> torch.Tensor:
+ return rgb_to_ycbcr(image)
+
+
+class YcbcrToRgb(nn.Module):
+ r"""Convert an image from YCbCr to Rgb.
+
+ The image data is assumed to be in the range of (0, 1).
+
+ Returns:
+ RGB version of the image.
+
+ Shape:
+ - image: :math:`(*, 3, H, W)`
+ - output: :math:`(*, 3, H, W)`
+
+ Examples:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> rgb = YcbcrToRgb()
+ >>> output = rgb(input) # 2x3x4x5
+ """
+
+ def forward(self, image: torch.Tensor) -> torch.Tensor:
+ return ycbcr_to_rgb(image)
diff --git a/kornia/color/yuv.py b/kornia/color/yuv.py
new file mode 100644
index 0000000000000000000000000000000000000000..905a2057d736eb7c349637d9dd8e91a48eeb82b2
--- /dev/null
+++ b/kornia/color/yuv.py
@@ -0,0 +1,374 @@
+from typing import Tuple
+
+import torch
+import torch.nn as nn
+
+
+def rgb_to_yuv(image: torch.Tensor) -> torch.Tensor:
+ r"""Convert an RGB image to YUV.
+
+ .. image:: _static/img/rgb_to_yuv.png
+
+ The image data is assumed to be in the range of (0, 1).
+
+ Args:
+ image: RGB Image to be converted to YUV with shape :math:`(*, 3, H, W)`.
+
+ Returns:
+ YUV version of the image with shape :math:`(*, 3, H, W)`.
+
+ Example:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> output = rgb_to_yuv(input) # 2x3x4x5
+ """
+ if not isinstance(image, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(image)}")
+
+ if len(image.shape) < 3 or image.shape[-3] != 3:
+ raise ValueError(f"Input size must have a shape of (*, 3, H, W). Got {image.shape}")
+
+ r: torch.Tensor = image[..., 0, :, :]
+ g: torch.Tensor = image[..., 1, :, :]
+ b: torch.Tensor = image[..., 2, :, :]
+
+ y: torch.Tensor = 0.299 * r + 0.587 * g + 0.114 * b
+ u: torch.Tensor = -0.147 * r - 0.289 * g + 0.436 * b
+ v: torch.Tensor = 0.615 * r - 0.515 * g - 0.100 * b
+
+ out: torch.Tensor = torch.stack([y, u, v], -3)
+
+ return out
+
+
+def rgb_to_yuv420(image: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+ r"""Convert an RGB image to YUV 420 (subsampled).
+
+ The image data is assumed to be in the range of (0, 1). Input need to be padded to be evenly divisible by 2
+ horizontal and vertical. This function will output chroma siting (0.5,0.5)
+
+ Args:
+ image: RGB Image to be converted to YUV with shape :math:`(*, 3, H, W)`.
+
+ Returns:
+ A Tensor containing the Y plane with shape :math:`(*, 1, H, W)`
+ A Tensor containing the UV planes with shape :math:`(*, 2, H/2, W/2)`
+
+ Example:
+ >>> input = torch.rand(2, 3, 4, 6)
+ >>> output = rgb_to_yuv420(input) # (2x1x4x6, 2x2x2x3)
+ """
+ if not isinstance(image, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(image)}")
+
+ if len(image.shape) < 3 or image.shape[-3] != 3:
+ raise ValueError(f"Input size must have a shape of (*, 3, H, W). Got {image.shape}")
+
+ if len(image.shape) < 2 or image.shape[-2] % 2 == 1 or image.shape[-1] % 2 == 1:
+ raise ValueError(f"Input H&W must be evenly disible by 2. Got {image.shape}")
+
+ yuvimage = rgb_to_yuv(image)
+
+ return (yuvimage[..., :1, :, :], torch.nn.functional.avg_pool2d(yuvimage[..., 1:3, :, :], (2, 2)))
+
+
+def rgb_to_yuv422(image: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+ r"""Convert an RGB image to YUV 422 (subsampled).
+
+ The image data is assumed to be in the range of (0, 1). Input need to be padded to be evenly divisible by 2
+ vertical. This function will output chroma siting (0.5)
+
+ Args:
+ image: RGB Image to be converted to YUV with shape :math:`(*, 3, H, W)`.
+
+ Returns:
+ A Tensor containing the Y plane with shape :math:`(*, 1, H, W)`
+ A Tensor containing the UV planes with shape :math:`(*, 2, H, W/2)`
+
+ Example:
+ >>> input = torch.rand(2, 3, 4, 6)
+ >>> output = rgb_to_yuv420(input) # (2x1x4x6, 2x1x4x3)
+ """
+ if not isinstance(image, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(image)}")
+
+ if len(image.shape) < 3 or image.shape[-3] != 3:
+ raise ValueError(f"Input size must have a shape of (*, 3, H, W). Got {image.shape}")
+
+ if len(image.shape) < 2 or image.shape[-2] % 2 == 1 or image.shape[-1] % 2 == 1:
+ raise ValueError(f"Input H&W must be evenly disible by 2. Got {image.shape}")
+
+ yuvimage = rgb_to_yuv(image)
+
+ return (yuvimage[..., :1, :, :], torch.nn.functional.avg_pool2d(yuvimage[..., 1:3, :, :], (1, 2)))
+
+
+def yuv_to_rgb(image: torch.Tensor) -> torch.Tensor:
+ r"""Convert an YUV image to RGB.
+
+ The image data is assumed to be in the range of (0, 1) for luma and (-0.5, 0.5) for chroma.
+
+ Args:
+ image: YUV Image to be converted to RGB with shape :math:`(*, 3, H, W)`.
+
+ Returns:
+ RGB version of the image with shape :math:`(*, 3, H, W)`.
+
+ Example:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> output = yuv_to_rgb(input) # 2x3x4x5
+ """
+ if not isinstance(image, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(image)}")
+
+ if len(image.shape) < 3 or image.shape[-3] != 3:
+ raise ValueError(f"Input size must have a shape of (*, 3, H, W). Got {image.shape}")
+
+ y: torch.Tensor = image[..., 0, :, :]
+ u: torch.Tensor = image[..., 1, :, :]
+ v: torch.Tensor = image[..., 2, :, :]
+
+ r: torch.Tensor = y + 1.14 * v # coefficient for g is 0
+ g: torch.Tensor = y + -0.396 * u - 0.581 * v
+ b: torch.Tensor = y + 2.029 * u # coefficient for b is 0
+
+ out: torch.Tensor = torch.stack([r, g, b], -3)
+
+ return out
+
+
+def yuv420_to_rgb(imagey: torch.Tensor, imageuv: torch.Tensor) -> torch.Tensor:
+ r"""Convert an YUV420 image to RGB.
+
+ The image data is assumed to be in the range of (0, 1) for luma and (-0.5, 0.5) for chroma.
+ Input need to be padded to be evenly divisible by 2 horizontal and vertical.
+ This function assumed chroma siting is (0.5, 0.5)
+
+ Args:
+ imagey: Y (luma) Image plane to be converted to RGB with shape :math:`(*, 1, H, W)`.
+ imageuv: UV (chroma) Image planes to be converted to RGB with shape :math:`(*, 2, H/2, W/2)`.
+
+ Returns:
+ RGB version of the image with shape :math:`(*, 3, H, W)`.
+
+ Example:
+ >>> inputy = torch.rand(2, 1, 4, 6)
+ >>> inputuv = torch.rand(2, 2, 2, 3)
+ >>> output = yuv420_to_rgb(inputy, inputuv) # 2x3x4x6
+ """
+
+ if not isinstance(imagey, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(imagey)}")
+
+ if not isinstance(imageuv, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(imageuv)}")
+
+ if len(imagey.shape) < 3 or imagey.shape[-3] != 1:
+ raise ValueError(f"Input imagey size must have a shape of (*, 1, H, W). Got {imagey.shape}")
+
+ if len(imageuv.shape) < 3 or imageuv.shape[-3] != 2:
+ raise ValueError(f"Input imageuv size must have a shape of (*, 2, H/2, W/2). Got {imageuv.shape}")
+
+ if len(imagey.shape) < 2 or imagey.shape[-2] % 2 == 1 or imagey.shape[-1] % 2 == 1:
+ raise ValueError(f"Input H&W must be evenly disible by 2. Got {imagey.shape}")
+
+ if (len(imageuv.shape) < 2 or len(imagey.shape) < 2 or imagey.shape[-2] / imageuv.shape[-2] != 2
+ or imagey.shape[-1] / imageuv.shape[-1] != 2):
+ raise ValueError(f"Input imageuv H&W must be half the size of the luma plane. "
+ f"Got {imagey.shape} and {imageuv.shape}")
+
+ # first upsample
+ yuv444image = torch.cat([imagey, imageuv.repeat_interleave(2, dim=-1).repeat_interleave(2, dim=-2)], dim=-3)
+ # then convert the yuv444 tensor
+
+ return yuv_to_rgb(yuv444image)
+
+
+def yuv422_to_rgb(imagey: torch.Tensor, imageuv: torch.Tensor) -> torch.Tensor:
+ r"""Convert an YUV422 image to RGB.
+
+ The image data is assumed to be in the range of (0, 1) for luma and (-0.5, 0.5) for chroma.
+ Input need to be padded to be evenly divisible by 2 vertical. This function assumed chroma siting is (0.5)
+
+ Args:
+ imagey: Y (luma) Image plane to be converted to RGB with shape :math:`(*, 1, H, W)`.
+ imageuv: UV (luma) Image planes to be converted to RGB with shape :math:`(*, 2, H, W/2)`.
+
+ Returns:
+ RGB version of the image with shape :math:`(*, 3, H, W)`.
+
+ Example:
+ >>> inputy = torch.rand(2, 1, 4, 6)
+ >>> inputuv = torch.rand(2, 2, 2, 3)
+ >>> output = yuv420_to_rgb(inputy, inputuv) # 2x3x4x5
+ """
+
+ if not isinstance(imagey, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(imagey)}")
+
+ if not isinstance(imageuv, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(imageuv)}")
+
+ if len(imagey.shape) < 3 or imagey.shape[-3] != 1:
+ raise ValueError(f"Input imagey size must have a shape of (*, 1, H, W). Got {imagey.shape}")
+
+ if len(imageuv.shape) < 3 or imageuv.shape[-3] != 2:
+ raise ValueError(f"Input imageuv size must have a shape of (*, 2, H, W/2). Got {imageuv.shape}")
+
+ if len(imagey.shape) < 2 or imagey.shape[-2] % 2 == 1 or imagey.shape[-1] % 2 == 1:
+ raise ValueError(f"Input H&W must be evenly disible by 2. Got {imagey.shape}")
+
+ if len(imageuv.shape) < 2 or len(imagey.shape) < 2 or imagey.shape[-1] / imageuv.shape[-1] != 2:
+ raise ValueError(f"Input imageuv W must be half the size of the luma plane. "
+ f"Got {imagey.shape} and {imageuv.shape}")
+
+ # first upsample
+ yuv444image = torch.cat([imagey, imageuv.repeat_interleave(2, dim=-1)], dim=-3)
+ # then convert the yuv444 tensor
+ return yuv_to_rgb(yuv444image)
+
+
+class RgbToYuv(nn.Module):
+ r"""Convert an image from RGB to YUV.
+
+ The image data is assumed to be in the range of (0, 1).
+
+ Returns:
+ YUV version of the image.
+
+ Shape:
+ - image: :math:`(*, 3, H, W)`
+ - output: :math:`(*, 3, H, W)`
+
+ Examples:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> yuv = RgbToYuv()
+ >>> output = yuv(input) # 2x3x4x5
+
+ Reference::
+ [1] https://es.wikipedia.org/wiki/YUV#RGB_a_Y'UV
+ """
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor:
+ return rgb_to_yuv(input)
+
+
+class RgbToYuv420(nn.Module):
+ r"""Convert an image from RGB to YUV420.
+
+ The image data is assumed to be in the range of (0, 1). Width and Height evenly divisible by 2.
+
+ Returns:
+ YUV420 version of the image.
+
+ Shape:
+ - image: :math:`(*, 3, H, W)`
+ - output: :math:`(*, 1, H, W)` and :math:`(*, 2, H/2, W/2)`
+
+ Examples:
+ >>> yuvinput = torch.rand(2, 3, 4, 6)
+ >>> yuv = RgbToYuv420()
+ >>> output = yuv(yuvinput) # # (2x1x4x6, 2x1x2x3)
+
+ Reference::
+ [1] https://es.wikipedia.org/wiki/YUV#RGB_a_Y'UV
+ """
+
+ def forward(self, yuvinput: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]: # skipcq: PYL-R0201
+ return rgb_to_yuv420(yuvinput)
+
+
+class RgbToYuv422(nn.Module):
+ r"""Convert an image from RGB to YUV422.
+
+ The image data is assumed to be in the range of (0, 1). Width evenly disvisible by 2.
+
+ Returns:
+ YUV422 version of the image.
+
+ Shape:
+ - image: :math:`(*, 3, H, W)`
+ - output: :math:`(*, 1, H, W)` and :math:`(*, 2, H, W/2)`
+
+ Examples:
+ >>> yuvinput = torch.rand(2, 3, 4, 6)
+ >>> yuv = RgbToYuv422()
+ >>> output = yuv(yuvinput) # # (2x1x4x6, 2x2x4x3)
+
+ Reference::
+ [1] https://es.wikipedia.org/wiki/YUV#RGB_a_Y'UV
+ """
+
+ def forward(self, yuvinput: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]: # skipcq: PYL-R0201
+ return rgb_to_yuv422(yuvinput)
+
+
+class YuvToRgb(nn.Module):
+ r"""Convert an image from YUV to RGB.
+
+ The image data is assumed to be in the range of (0, 1) for luma and (-0.5, 0.5) for chroma.
+
+ Returns:
+ RGB version of the image.
+
+ Shape:
+ - image: :math:`(*, 3, H, W)`
+ - output: :math:`(*, 3, H, W)`
+
+ Examples:
+ >>> input = torch.rand(2, 3, 4, 5)
+ >>> rgb = YuvToRgb()
+ >>> output = rgb(input) # 2x3x4x5
+ """
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor:
+ return yuv_to_rgb(input)
+
+
+class Yuv420ToRgb(nn.Module):
+ r"""Convert an image from YUV to RGB.
+
+ The image data is assumed to be in the range of (0, 1) for luma and (-0.5, 0.5) for chroma.
+ Width and Height evenly divisible by 2.
+
+ Returns:
+ RGB version of the image.
+
+ Shape:
+ - imagey: :math:`(*, 1, H, W)`
+ - imageuv: :math:`(*, 2, H/2, W/2)`
+ - output: :math:`(*, 3, H, W)`
+
+ Examples:
+ >>> inputy = torch.rand(2, 1, 4, 6)
+ >>> inputuv = torch.rand(2, 2, 2, 3)
+ >>> rgb = Yuv420ToRgb()
+ >>> output = rgb(inputy, inputuv) # 2x3x4x6
+ """
+
+ def forward(self, inputy: torch.Tensor, inputuv: torch.Tensor) -> torch.Tensor: # skipcq: PYL-R0201
+ return yuv420_to_rgb(inputy, inputuv)
+
+
+class Yuv422ToRgb(nn.Module):
+ r"""Convert an image from YUV to RGB.
+
+ The image data is assumed to be in the range of (0, 1) for luma and (-0.5, 0.5) for chroma.
+ Width evenly divisible by 2.
+
+ Returns:
+ RGB version of the image.
+
+ Shape:
+ - imagey: :math:`(*, 1, H, W)`
+ - imageuv: :math:`(*, 2, H, W/2)`
+ - output: :math:`(*, 3, H, W)`
+
+ Examples:
+ >>> inputy = torch.rand(2, 1, 4, 6)
+ >>> inputuv = torch.rand(2, 2, 4, 3)
+ >>> rgb = Yuv422ToRgb()
+ >>> output = rgb(inputy, inputuv) # 2x3x4x6
+ """
+
+ def forward(self, inputy: torch.Tensor, inputuv: torch.Tensor) -> torch.Tensor: # skipcq: PYL-R0201
+ return yuv422_to_rgb(inputy, inputuv)
diff --git a/kornia/constants.py b/kornia/constants.py
new file mode 100644
index 0000000000000000000000000000000000000000..647f7070ab8ce77c960cf59f5d803dd973ea6c09
--- /dev/null
+++ b/kornia/constants.py
@@ -0,0 +1,62 @@
+from enum import Enum, EnumMeta
+from typing import cast, TypeVar, Union
+
+import torch
+
+__all__ = ['pi', 'Resample', 'BorderType', 'SamplePadding']
+
+pi = torch.tensor(3.14159265358979323846)
+T = TypeVar('T', bound='ConstantBase')
+
+
+class ConstantBase:
+ @classmethod
+ def get(cls, value: Union[str, int, T]) -> T: # type: ignore
+ if type(value) is str:
+ return cls[value.upper()] # type: ignore
+ if type(value) is int:
+ return cls(value) # type: ignore
+ if type(value) is cls:
+ return value # type: ignore
+ raise TypeError()
+
+
+class EnumMetaFlags(EnumMeta):
+ def __contains__(self, other: Union[str, int, T]) -> bool: # type: ignore
+ if type(other) is str:
+ other = cast(str, other)
+ return any(val.name == other.upper() for val in self) # type: ignore
+ if type(other) is int:
+ return any(val.value == other for val in self) # type: ignore
+ return any(val == other for val in self) # type: ignore
+
+ def __repr__(self):
+ return ' | '.join(f"{self.__name__}.{val.name}" for val in self)
+
+
+class Resample(ConstantBase, Enum, metaclass=EnumMetaFlags):
+ NEAREST = 0
+ BILINEAR = 1
+ BICUBIC = 2
+
+
+class BorderType(ConstantBase, Enum, metaclass=EnumMetaFlags):
+ CONSTANT = 0
+ REFLECT = 1
+ REPLICATE = 2
+ CIRCULAR = 3
+
+
+class SamplePadding(ConstantBase, Enum, metaclass=EnumMetaFlags):
+ ZEROS = 0
+ BORDER = 1
+ REFLECTION = 2
+
+
+class DataKey(ConstantBase, Enum, metaclass=EnumMetaFlags):
+ INPUT = 0
+ MASK = 1
+ BBOX = 2
+ BBOX_XYXY = 3
+ BBOX_XYHW = 4
+ KEYPOINTS = 5
diff --git a/kornia/contrib/__init__.py b/kornia/contrib/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..66245b314aa9b2a9705791c71adffc074c26ca16
--- /dev/null
+++ b/kornia/contrib/__init__.py
@@ -0,0 +1,20 @@
+from .classification import ClassificationHead
+from .connected_components import connected_components
+from .extract_patches import combine_tensor_patches, CombineTensorPatches, extract_tensor_patches, ExtractTensorPatches
+from .image_stitching import ImageStitcher
+from .lambda_module import Lambda
+from .vit import VisionTransformer
+from .vit_mobile import MobileViT
+
+__all__ = [
+ "connected_components",
+ "extract_tensor_patches",
+ "ExtractTensorPatches",
+ "combine_tensor_patches",
+ "CombineTensorPatches",
+ "VisionTransformer",
+ "MobileViT",
+ "ClassificationHead",
+ "Lambda",
+ "ImageStitcher",
+]
diff --git a/kornia/contrib/classification.py b/kornia/contrib/classification.py
new file mode 100644
index 0000000000000000000000000000000000000000..81270299f262268d431d4031f0f364507dc6ac45
--- /dev/null
+++ b/kornia/contrib/classification.py
@@ -0,0 +1,26 @@
+"""Module containing utilities for classification."""
+import torch
+from torch import nn
+
+
+class ClassificationHead(nn.Module):
+ """Module to be used as a classification head.
+
+ Args:
+ embed_size: the logits tensor coming from the networks.
+ num_classes: an integer representing the numbers of classes to classify.
+
+ Example:
+ >>> feat = torch.rand(1, 256, 256)
+ >>> head = ClassificationHead(256, 10)
+ >>> head(feat).shape
+ torch.Size([1, 10])
+ """
+ def __init__(self, embed_size: int = 768, num_classes: int = 10) -> None:
+ super().__init__()
+ self.norm = nn.LayerNorm(embed_size)
+ self.linear = nn.Linear(embed_size, num_classes)
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ out = x.mean(-2)
+ return self.linear(self.norm(out))
diff --git a/kornia/contrib/connected_components.py b/kornia/contrib/connected_components.py
new file mode 100644
index 0000000000000000000000000000000000000000..9da31f042bcaa264458e618536dff030322fe8d6
--- /dev/null
+++ b/kornia/contrib/connected_components.py
@@ -0,0 +1,56 @@
+import torch
+import torch.nn.functional as F
+
+
+def connected_components(image: torch.Tensor, num_iterations: int = 100) -> torch.Tensor:
+ r"""Computes the Connected-component labelling (CCL) algorithm.
+
+ .. image:: https://github.com/kornia/data/raw/main/cells_segmented.png
+
+ The implementation is an adaptation of the following repository:
+
+ https://gist.github.com/efirdc/5d8bd66859e574c683a504a4690ae8bc
+
+ .. warning::
+ This is an experimental API subject to changes and optimization improvements.
+
+ .. note::
+ See a working example `here `__.
+
+ Args:
+ image: the binarized input image with shape :math:`(*, 1, H, W)`.
+ The image must be in floating point with range [0, 1].
+ num_iterations: the number of iterations to make the algorithm to converge.
+
+ Return:
+ The labels image with the same shape of the input image.
+
+ Example:
+ >>> img = torch.rand(2, 1, 4, 5)
+ >>> img_labels = connected_components(img, num_iterations=100)
+ """
+ if not isinstance(image, torch.Tensor):
+ raise TypeError(f"Input imagetype is not a torch.Tensor. Got: {type(image)}")
+
+ if not isinstance(num_iterations, int) or num_iterations < 1:
+ raise TypeError("Input num_iterations must be a positive integer.")
+
+ if len(image.shape) < 3 or image.shape[-3] != 1:
+ raise ValueError(f"Input image shape must be (*,1,H,W). Got: {image.shape}")
+
+ H, W = image.shape[-2:]
+ image_view = image.view(-1, 1, H, W)
+
+ # precompute a mask with the valid values
+ mask = image_view == 1
+
+ # allocate the output tensors for labels
+ B, _, _, _ = image_view.shape
+ out = torch.arange(B * H * W, device=image.device, dtype=image.dtype).view((-1, 1, H, W))
+ out[~mask] = 0
+
+ for _ in range(num_iterations):
+ out[mask] = F.max_pool2d(out, kernel_size=3, stride=1, padding=1)[mask]
+
+ return out.view_as(image)
diff --git a/kornia/contrib/extract_patches.py b/kornia/contrib/extract_patches.py
new file mode 100644
index 0000000000000000000000000000000000000000..7dfbb0d32ce7a56dd0629c711b67005bf202f7b7
--- /dev/null
+++ b/kornia/contrib/extract_patches.py
@@ -0,0 +1,235 @@
+from typing import Optional, Tuple, Union
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.nn.modules.utils import _pair
+
+
+class ExtractTensorPatches(nn.Module):
+ r"""Module that extract patches from tensors and stack them.
+
+ In the simplest case, the output value of the operator with input size
+ :math:`(B, C, H, W)` is :math:`(B, N, C, H_{out}, W_{out})`.
+
+ where
+ - :math:`B` is the batch size.
+ - :math:`N` denotes the total number of extracted patches stacked in
+ - :math:`C` denotes the number of input channels.
+ - :math:`H`, :math:`W` the input height and width of the input in pixels.
+ - :math:`H_{out}`, :math:`W_{out}` denote to denote to the patch size
+ defined in the function signature.
+ left-right and top-bottom order.
+
+ * :attr:`window_size` is the size of the sliding window and controls the
+ shape of the output tensor and defines the shape of the output patch.
+ * :attr:`stride` controls the stride to apply to the sliding window and
+ regulates the overlapping between the extracted patches.
+ * :attr:`padding` controls the amount of implicit zeros-paddings on both
+ sizes at each dimension.
+
+ The parameters :attr:`window_size`, :attr:`stride` and :attr:`padding` can
+ be either:
+
+ - a single ``int`` -- in which case the same value is used for the
+ height and width dimension.
+ - a ``tuple`` of two ints -- in which case, the first `int` is used for
+ the height dimension, and the second `int` for the width dimension.
+
+ Args:
+ window_size: the size of the sliding window and the output patch size.
+ stride: stride of the sliding window.
+ padding: Zero-padding added to both side of the input.
+
+ Shape:
+ - Input: :math:`(B, C, H, W)`
+ - Output: :math:`(B, N, C, H_{out}, W_{out})`
+
+ Returns:
+ the tensor with the extracted patches.
+
+ Examples:
+ >>> input = torch.arange(9.).view(1, 1, 3, 3)
+ >>> patches = extract_tensor_patches(input, (2, 3))
+ >>> input
+ tensor([[[[0., 1., 2.],
+ [3., 4., 5.],
+ [6., 7., 8.]]]])
+ >>> patches[:, -1]
+ tensor([[[[3., 4., 5.],
+ [6., 7., 8.]]]])
+ """
+
+ def __init__(
+ self,
+ window_size: Union[int, Tuple[int, int]],
+ stride: Optional[Union[int, Tuple[int, int]]] = 1,
+ padding: Optional[Union[int, Tuple[int, int]]] = 0,
+ ) -> None:
+ super().__init__()
+ self.window_size: Tuple[int, int] = _pair(window_size)
+ self.stride: Tuple[int, int] = _pair(stride)
+ self.padding: Tuple[int, int] = _pair(padding)
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor: # type: ignore
+ return extract_tensor_patches(input, self.window_size, stride=self.stride, padding=self.padding)
+
+
+class CombineTensorPatches(nn.Module):
+ r"""Module that combine patches from tensors.
+
+ In the simplest case, the output value of the operator with input size
+ :math:`(B, N, C, H_{out}, W_{out})` is :math:`(B, C, H, W)`.
+
+ where
+ - :math:`B` is the batch size.
+ - :math:`N` denotes the total number of extracted patches stacked in
+ - :math:`C` denotes the number of input channels.
+ - :math:`H`, :math:`W` the input height and width of the input in pixels.
+ - :math:`H_{out}`, :math:`W_{out}` denote to denote to the patch size
+ defined in the function signature.
+ left-right and top-bottom order.
+
+ * :attr:`window_size` is the size of the sliding window and controls the
+ shape of the output tensor and defines the shape of the output patch.
+ * :attr:`stride` controls the stride to apply to the sliding window and
+ regulates the overlapping between the extracted patches.
+ * :attr:`padding` controls the amount of implicit zeros-paddings on both
+ sizes at each dimension.
+
+ The parameters :attr:`window_size`, :attr:`stride` and :attr:`padding` can
+ be either:
+
+ - a single ``int`` -- in which case the same value is used for the
+ height and width dimension.
+ - a ``tuple`` of two ints -- in which case, the first `int` is used for
+ the height dimension, and the second `int` for the width dimension.
+
+ Args:
+ patches: patched tensor.
+ window_size: the size of the sliding window and the output patch size.
+ unpadding: remove the padding added to both side of the input.
+
+ Shape:
+ - Input: :math:`(B, N, C, H_{out}, W_{out})`
+ - Output: :math:`(B, C, H, W)`
+
+ Example:
+ >>> out = extract_tensor_patches(torch.arange(16).view(1, 1, 4, 4), window_size=(2, 2), stride=(2, 2))
+ >>> combine_tensor_patches(out, window_size=(2, 2), stride=(2, 2))
+ tensor([[[[ 0, 1, 2, 3],
+ [ 4, 5, 6, 7],
+ [ 8, 9, 10, 11],
+ [12, 13, 14, 15]]]])
+ """
+
+ def __init__(
+ self,
+ window_size: Union[int, Tuple[int, int]],
+ unpadding: Union[int, Tuple[int, int]] = 0,
+ ) -> None:
+ super().__init__()
+ self.window_size: Tuple[int, int] = _pair(window_size)
+ pad: Tuple[int, int] = _pair(unpadding)
+ self.unpadding: Tuple[int, int, int, int] = (pad[0], pad[0], pad[1], pad[1])
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor: # type: ignore
+ return combine_tensor_patches(input, self.window_size, stride=self.window_size, unpadding=self.unpadding)
+
+
+def combine_tensor_patches(
+ patches: torch.Tensor,
+ window_size: Tuple[int, int] = (4, 4),
+ stride: Tuple[int, int] = (4, 4),
+ unpadding: Optional[Tuple[int, int, int, int]] = None,
+) -> torch.Tensor:
+ r"""Restore input from patches.
+
+ Args:
+ patches: patched tensor with shape :math:`(B, N, C, H_{out}, W_{out})`.
+ window_size: the size of the sliding window and the output patch size.
+ stride: stride of the sliding window.
+ unpadding: remove the padding added to both side of the input.
+
+ Return:
+ The combined patches in an image tensor with shape :math:`(B, C, H, W)`.
+
+ Example:
+ >>> out = extract_tensor_patches(torch.arange(16).view(1, 1, 4, 4), window_size=(2, 2), stride=(2, 2))
+ >>> combine_tensor_patches(out, window_size=(2, 2), stride=(2, 2))
+ tensor([[[[ 0, 1, 2, 3],
+ [ 4, 5, 6, 7],
+ [ 8, 9, 10, 11],
+ [12, 13, 14, 15]]]])
+ """
+ if stride[0] != window_size[0] or stride[1] != window_size[1]:
+ raise NotImplementedError(
+ f"Only stride == window_size is supported. Got {stride} and {window_size}."
+ "Please feel free to drop a PR to Kornia Github."
+ )
+ if unpadding is not None:
+ window_size = (
+ window_size[0] + (unpadding[0] + unpadding[1]) // window_size[0],
+ window_size[1] + (unpadding[2] + unpadding[3]) // window_size[1]
+ )
+ patches_tensor = patches.view(-1, window_size[0], window_size[1], *patches.shape[-3:])
+ restored_tensor = torch.cat(torch.chunk(patches_tensor, window_size[0], dim=1), -2).squeeze(1)
+ restored_tensor = torch.cat(torch.chunk(restored_tensor, window_size[1], dim=1), -1).squeeze(1)
+
+ if unpadding is not None:
+ restored_tensor = torch.nn.functional.pad(restored_tensor, [-i for i in unpadding])
+ return restored_tensor
+
+
+def _extract_tensor_patchesnd(
+ input: torch.Tensor, window_sizes: Tuple[int, ...], strides: Tuple[int, ...]
+) -> torch.Tensor:
+ batch_size, num_channels = input.size()[:2]
+ dims = range(2, input.dim())
+ for dim, patch_size, stride in zip(dims, window_sizes, strides):
+ input = input.unfold(dim, patch_size, stride)
+ input = input.permute(0, *dims, 1, *(dim + len(dims) for dim in dims)).contiguous()
+ return input.view(batch_size, -1, num_channels, *window_sizes)
+
+
+def extract_tensor_patches(
+ input: torch.Tensor,
+ window_size: Union[int, Tuple[int, int]],
+ stride: Union[int, Tuple[int, int]] = 1,
+ padding: Union[int, Tuple[int, int]] = 0,
+) -> torch.Tensor:
+ r"""Function that extract patches from tensors and stack them.
+
+ See :class:`~kornia.contrib.ExtractTensorPatches` for details.
+
+ Args:
+ input: tensor image where to extract the patches with shape :math:`(B, C, H, W)`.
+ window_size: the size of the sliding window and the output patch size.
+ stride: stride of the sliding window.
+ padding: Zero-padding added to both side of the input.
+
+ Returns:
+ the tensor with the extracted patches with shape :math:`(B, N, C, H_{out}, W_{out})`.
+
+ Examples:
+ >>> input = torch.arange(9.).view(1, 1, 3, 3)
+ >>> patches = extract_tensor_patches(input, (2, 3))
+ >>> input
+ tensor([[[[0., 1., 2.],
+ [3., 4., 5.],
+ [6., 7., 8.]]]])
+ >>> patches[:, -1]
+ tensor([[[[3., 4., 5.],
+ [6., 7., 8.]]]])
+ """
+ if not torch.is_tensor(input):
+ raise TypeError(f"Input input type is not a torch.Tensor. Got {type(input)}")
+
+ if not len(input.shape) == 4:
+ raise ValueError(f"Invalid input shape, we expect BxCxHxW. Got: {input.shape}")
+
+ if padding:
+ pad_vert, pad_horz = _pair(padding)
+ input = F.pad(input, [pad_horz, pad_horz, pad_vert, pad_vert])
+
+ return _extract_tensor_patchesnd(input, _pair(window_size), _pair(stride))
diff --git a/kornia/contrib/image_stitching.py b/kornia/contrib/image_stitching.py
new file mode 100644
index 0000000000000000000000000000000000000000..f6862285c03fbae7b98b8a9d2d6589735f315126
--- /dev/null
+++ b/kornia/contrib/image_stitching.py
@@ -0,0 +1,138 @@
+from typing import Dict, List, Optional, Tuple
+
+import torch
+import torch.nn as nn
+
+from kornia.color import rgb_to_grayscale
+from kornia.feature import LocalFeatureMatcher, LoFTR
+from kornia.geometry.homography import find_homography_dlt_iterated
+from kornia.geometry.ransac import RANSAC
+from kornia.geometry.transform import warp_perspective
+
+
+class ImageStitcher(nn.Module):
+ """Stitch two images with overlapping fields of view.
+
+ Args:
+ matcher: image feature matching module.
+ estimator: method to compute homography, either "vanilla" or "ransac".
+ "ransac" is slower with a better accuracy.
+ blending_method: method to blend two images together.
+ Only "naive" is currently supported.
+
+ Note:
+ Current implementation requires strict image ordering from left to right.
+
+ .. code-block:: python
+
+ IS = ImageStitcher(KF.LoFTR(pretrained='outdoor'), estimator='ransac').cuda()
+ # Compute the stitched result with less GPU memory cost.
+ with torch.inference_mode():
+ out = IS(img_left, img_right)
+ # Show the result
+ plt.imshow(K.tensor_to_image(out))
+ """
+
+ def __init__(
+ self, matcher: nn.Module, estimator: str = 'ransac', blending_method: str = "naive",
+ ) -> None:
+ super().__init__()
+ self.matcher = matcher
+ self.estimator = estimator
+ self.blending_method = blending_method
+ if estimator not in ['ransac', 'vanilla']:
+ raise NotImplementedError(f"Unsupported estimator {estimator}. Use โransacโ or โvanillaโ instead.")
+ if estimator == "ransac":
+ self.ransac = RANSAC('homography')
+
+ def _estimate_homography(self, keypoints1: torch.Tensor, keypoints2: torch.Tensor) -> torch.Tensor:
+ """Estimate homography by the matched keypoints.
+
+ Args:
+ keypoints1: matched keypoint set from an image, shaped as :math:`(N, 2)`.
+ keypoints2: matched keypoint set from the other image, shaped as :math:`(N, 2)`.
+ """
+ homo: torch.Tensor
+ if self.estimator == "vanilla":
+ homo = find_homography_dlt_iterated(
+ keypoints2[None],
+ keypoints1[None],
+ torch.ones_like(keypoints1[None, :, 0])
+ )
+ elif self.estimator == "ransac":
+ homo, _ = self.ransac(keypoints2, keypoints1)
+ homo = homo[None]
+ else:
+ raise NotImplementedError(f"Unsupported estimator {self.estimator}. Use โransacโ or โvanillaโ instead.")
+ return homo
+
+ def estimate_transform(self, **kwargs) -> torch.Tensor:
+ """Compute the corresponding homography."""
+ homos: List[torch.Tensor] = []
+ kp1, kp2, idx = kwargs['keypoints0'], kwargs['keypoints1'], kwargs['batch_indexes']
+ for i in range(len(idx.unique())):
+ homos.append(self._estimate_homography(kp1[idx == i], kp2[idx == i]))
+ if len(homos) == 0:
+ raise RuntimeError("Compute homography failed. No matched keypoints found.")
+ return torch.cat(homos)
+
+ def blend_image(self, src_img: torch.Tensor, dst_img: torch.Tensor, mask: torch.Tensor) -> torch.Tensor:
+ """Blend two images together."""
+ out: torch.Tensor
+ if self.blending_method == "naive":
+ out = torch.where(mask == 1, src_img, dst_img)
+ else:
+ raise NotImplementedError(f"Unsupported blending method {self.blending_method}. Use โnaiveโ.")
+ return out
+
+ def preprocess(self, image_1: torch.Tensor, image_2: torch.Tensor) -> Dict[str, torch.Tensor]:
+ """Preprocess input to the required format."""
+ # TODO: probably perform histogram matching here.
+ if isinstance(self.matcher, LoFTR) or isinstance(self.matcher, LocalFeatureMatcher):
+ input_dict: Dict[str, torch.Tensor] = { # LofTR works on grayscale images only
+ "image0": rgb_to_grayscale(image_1),
+ "image1": rgb_to_grayscale(image_2)
+ }
+ else:
+ raise NotImplementedError(f"The preprocessor for {self.matcher} has not been implemented.")
+ return input_dict
+
+ def postprocess(self, image: torch.Tensor, mask: torch.Tensor) -> torch.Tensor:
+ # NOTE: assumes no batch mode. This method keeps all valid regions after stitching.
+ mask_: torch.Tensor = mask.sum((0, 1))
+ index: int = int(mask_.bool().any(0).long().argmin().item())
+ if index == 0: # If no redundant space
+ return image
+ return image[..., :index]
+
+ def on_matcher(self, data) -> dict:
+ return self.matcher(data)
+
+ def stitch_pair(
+ self, images_left: torch.Tensor, images_right: torch.Tensor,
+ mask_left: Optional[torch.Tensor] = None, mask_right: Optional[torch.Tensor] = None
+ ) -> Tuple[torch.Tensor, torch.Tensor]:
+ # Compute the transformed images
+ input_dict: Dict[str, torch.Tensor] = self.preprocess(images_left, images_right)
+ out_shape: Tuple[int, int] = (images_left.shape[-2], images_left.shape[-1] + images_right.shape[-1])
+ correspondences: dict = self.on_matcher(input_dict)
+ homo: torch.Tensor = self.estimate_transform(**correspondences)
+ src_img = warp_perspective(images_right, homo, out_shape)
+ dst_img = torch.cat([images_left, torch.zeros_like(images_right)], dim=-1)
+
+ # Compute the transformed masks
+ if mask_left is None:
+ mask_left = torch.ones_like(images_left)
+ if mask_right is None:
+ mask_right = torch.ones_like(images_right)
+ # 'nearest' to ensure no floating points in the mask
+ src_mask = warp_perspective(mask_right, homo, out_shape, mode='nearest')
+ dst_mask = torch.cat([mask_left, torch.zeros_like(mask_right)], dim=-1)
+ return self.blend_image(src_img, dst_img, src_mask), (dst_mask + src_mask).bool().to(src_mask.dtype)
+
+ def forward(self, *imgs: torch.Tensor) -> torch.Tensor:
+ img_out = imgs[0]
+ mask_left = torch.ones_like(img_out)
+ for i in range(len(imgs) - 1):
+ img_out, mask_left = self.stitch_pair(img_out, imgs[i + 1], mask_left)
+ return self.postprocess(img_out, mask_left)
diff --git a/kornia/contrib/lambda_module.py b/kornia/contrib/lambda_module.py
new file mode 100644
index 0000000000000000000000000000000000000000..073ac531c49b48f8651ed7b6f22380ffd2bb5e0f
--- /dev/null
+++ b/kornia/contrib/lambda_module.py
@@ -0,0 +1,32 @@
+from typing import Callable
+
+import torch
+import torch.nn as nn
+
+
+class Lambda(nn.Module):
+ """Applies user-defined lambda as a transform.
+
+ Args:
+ func: Callable function.
+
+ Returns:
+ The output of the user-defined lambda.
+
+ Example:
+ >>> import kornia
+ >>> x = torch.rand(1, 3, 5, 5)
+ >>> f = Lambda(lambda x: kornia.color.rgb_to_grayscale(x))
+ >>> f(x).shape
+ torch.Size([1, 1, 5, 5])
+ """
+
+ def __init__(self, func: Callable) -> None:
+ super().__init__()
+ if not callable(func):
+ raise TypeError(f"Argument lambd should be callable, got {repr(type(func).__name__)}")
+
+ self.func = func
+
+ def forward(self, img: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+ return self.func(img, *args, **kwargs)
diff --git a/kornia/contrib/vit.py b/kornia/contrib/vit.py
new file mode 100644
index 0000000000000000000000000000000000000000..b8d46a2d9f33d6fa8602500d48114eb6709a0bd1
--- /dev/null
+++ b/kornia/contrib/vit.py
@@ -0,0 +1,231 @@
+"""Module that implement Vision Transformer (ViT).
+
+Paper: https://paperswithcode.com/paper/an-image-is-worth-16x16-words-transformers-1
+
+Based on: https://towardsdatascience.com/implementing-visualttransformer-in-pytorch-184f9f16f632
+Added some tricks from https://github.com/rwightman/pytorch-image-models/blob/master/timm/models/vision_transformer.py
+"""
+from typing import List, Optional, Tuple
+
+import torch
+from torch import nn
+
+__all__ = [
+ "VisionTransformer"
+]
+
+
+class ResidualAdd(nn.Module):
+ def __init__(self, fn) -> None:
+ super().__init__()
+ self.fn = fn
+
+ def forward(self, x, **kwargs) -> None:
+ res = x
+ x = self.fn(x, **kwargs)
+ x += res
+ return x
+
+
+class FeedForward(nn.Sequential):
+ def __init__(self,
+ in_features: int,
+ hidden_features: int,
+ out_features: int,
+ dropout_rate: float = 0.) -> None:
+ super().__init__(
+ nn.Linear(in_features, hidden_features),
+ nn.GELU(),
+ nn.Dropout(dropout_rate),
+ nn.Linear(hidden_features, out_features),
+ nn.Dropout(dropout_rate) # added one extra as in timm
+ )
+
+
+class MultiHeadAttention(nn.Module):
+ def __init__(self, emb_size: int, num_heads: int, att_drop: float, proj_drop: float) -> None:
+ super().__init__()
+ self.emb_size = emb_size
+ self.num_heads = num_heads
+ head_size = emb_size // num_heads # fom timm
+ self.scale = head_size ** -0.5 # from timm
+
+ # fuse the queries, keys and values in one matrix
+ self.qkv = nn.Linear(emb_size, emb_size * 3, bias=False)
+ self.att_drop = nn.Dropout(att_drop)
+ self.projection = nn.Linear(emb_size, emb_size)
+ self.projection_drop = nn.Dropout(proj_drop) # added timm trick
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ B, N, C = x.shape
+ # split keys, queries and values in num_heads
+ # NOTE: the line below differs from timm
+ # timm: qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
+ qkv = self.qkv(x).reshape(B, N, 3, -1, C).permute(2, 0, 3, 1, 4)
+ q, k, v = qkv[0], qkv[1], qkv[2]
+
+ # sum up over the last axis
+ att = torch.einsum('bhqd, bhkd -> bhqk', q, k) * self.scale
+ att = att.softmax(dim=-1)
+ att = self.att_drop(att)
+
+ # sum up over the third axis
+ out = torch.einsum('bhal, bhlv -> bhav ', att, v)
+ out = out.permute(0, 2, 1, 3).contiguous().view(B, N, -1)
+ out = self.projection(out)
+ out = self.projection_drop(out)
+ return out
+
+
+class TransformerEncoderBlock(nn.Sequential):
+ def __init__(self,
+ embed_dim: int,
+ num_heads: int,
+ dropout_rate: float,
+ dropout_attn: float) -> None:
+ super().__init__(
+ ResidualAdd(nn.Sequential(
+ nn.LayerNorm(embed_dim),
+ MultiHeadAttention(embed_dim, num_heads, dropout_attn, dropout_rate),
+ nn.Dropout(dropout_rate)
+ )),
+ ResidualAdd(nn.Sequential(
+ nn.LayerNorm(embed_dim),
+ FeedForward(embed_dim, embed_dim, embed_dim, dropout_rate=dropout_rate),
+ nn.Dropout(dropout_rate)
+ )))
+
+
+class TransformerEncoder(nn.Module):
+ def __init__(
+ self,
+ embed_dim: int = 768,
+ depth: int = 12,
+ num_heads: int = 12,
+ dropout_rate: float = 0.,
+ dropout_attn: float = 0.,
+ ) -> None:
+ super().__init__()
+ self.blocks = nn.Sequential(*(
+ TransformerEncoderBlock(embed_dim, num_heads, dropout_rate, dropout_attn)
+ for _ in range(depth)
+ ))
+ self.results: List[torch.Tensor] = []
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ self.results = []
+ out = x
+ for m in self.blocks.children():
+ out = m(out)
+ self.results.append(out)
+ return out
+
+
+class PatchEmbedding(nn.Module):
+ """Compute the 2d image patch embedding ready to pass to transformer encoder."""
+ def __init__(
+ self,
+ in_channels: int = 3,
+ out_channels: int = 768,
+ patch_size: int = 16,
+ image_size: int = 224,
+ backbone: Optional[nn.Module] = None,
+ ) -> None:
+ super().__init__()
+ self.in_channels = in_channels
+ self.out_channels = out_channels
+ self.patch_size = patch_size
+
+ # logic needed in case a backbone is passed
+ self.backbone = backbone or nn.Conv2d(in_channels, out_channels, kernel_size=patch_size, stride=patch_size)
+ if backbone is not None:
+ out_channels, feat_size = self._compute_feats_dims((in_channels, image_size, image_size))
+ self.out_channels = out_channels
+ else:
+ feat_size = (image_size // patch_size) ** 2
+
+ self.cls_token = nn.Parameter(torch.randn(1, 1, out_channels))
+ self.positions = nn.Parameter(torch.randn(feat_size + 1, out_channels))
+
+ def _compute_feats_dims(self, image_size: Tuple[int, int, int]) -> Tuple[int, int]:
+ out = self.backbone(torch.zeros(1, *image_size)).detach()
+ return out.shape[-3], out.shape[-2] * out.shape[-1]
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ x = self.backbone(x)
+ B, N, _, _ = x.shape
+ x = x.view(B, N, -1).permute(0, 2, 1) # BxNxE
+ cls_tokens = self.cls_token.repeat(B, 1, 1) # Bx1xE
+ # prepend the cls token to the input
+ x = torch.cat([cls_tokens, x], dim=1) # Bx(N+1)xE
+ # add position embedding
+ x += self.positions
+ return x
+
+
+class VisionTransformer(nn.Module):
+ """Vision transformer (ViT) module.
+
+ The module is expected to be used as operator for different vision tasks.
+
+ The method is inspired from existing implementations of the paper :cite:`dosovitskiy2020vit`.
+
+ .. warning::
+ This is an experimental API subject to changes in favor of flexibility.
+
+ Args:
+ image_size: the size of the input image.
+ patch_size: the size of the patch to compute the embedding.
+ in_channels: the number of channels for the input.
+ embed_dim: the embedding dimension inside the transformer encoder.
+ depth: the depth of the transformer.
+ num_heads: the number of attention heads.
+ dropout_rate: dropout rate.
+ dropout_attn: attention dropout rate.
+ backbone: an nn.Module to compute the image patches embeddings.
+
+ Example:
+ >>> img = torch.rand(1, 3, 224, 224)
+ >>> vit = VisionTransformer(image_size=224, patch_size=16)
+ >>> vit(img).shape
+ torch.Size([1, 197, 768])
+ """
+ def __init__(
+ self,
+ image_size: int = 224,
+ patch_size: int = 16,
+ in_channels: int = 3,
+ embed_dim: int = 768,
+ depth: int = 12,
+ num_heads: int = 12,
+ dropout_rate: float = 0.,
+ dropout_attn: float = 0.,
+ backbone: Optional[nn.Module] = None,
+ ) -> None:
+ super().__init__()
+ self.image_size = image_size
+ self.patch_size = patch_size
+ self.in_channels = in_channels
+ self.embed_size = embed_dim
+
+ self.patch_embedding = PatchEmbedding(in_channels, embed_dim, patch_size, image_size, backbone)
+ hidden_dim = self.patch_embedding.out_channels
+ self.encoder = TransformerEncoder(hidden_dim, depth, num_heads, dropout_rate, dropout_attn)
+
+ @property
+ def encoder_results(self):
+ return self.encoder.results
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ if not isinstance(x, torch.Tensor):
+ raise TypeError(f"Input x type is not a torch.Tensor. Got: {type(x)}")
+
+ if self.image_size not in (*x.shape[-2:],) and x.shape[-3] != self.in_channels:
+ raise ValueError(
+ f"Input image shape must be Bx{self.in_channels}x{self.image_size}x{self.image_size}. "
+ f"Got: {x.shape}"
+ )
+
+ out = self.patch_embedding(x)
+ out = self.encoder(out)
+ return out
diff --git a/kornia/contrib/vit_mobile.py b/kornia/contrib/vit_mobile.py
new file mode 100644
index 0000000000000000000000000000000000000000..b6dc80b791d3f7a34943448d5fc57ded495443d5
--- /dev/null
+++ b/kornia/contrib/vit_mobile.py
@@ -0,0 +1,308 @@
+from typing import Tuple
+
+import torch
+from torch import nn
+
+
+class SiLU(nn.Module):
+ """Module SiLU (Sigmoid Linear Units)
+
+ This implementation is to support pytorch < 1.8, and will be deprecated after 1.8.
+
+ Paper: https://arxiv.org/abs/1702.03118
+ """
+ def forward(self, x):
+ return x * torch.sigmoid(x)
+
+
+def conv_1x1_bn(inp: int, oup: int) -> nn.Module:
+ return nn.Sequential(
+ nn.Conv2d(inp, oup, 1, 1, 0, bias=False),
+ nn.BatchNorm2d(oup),
+ SiLU()
+ )
+
+
+def conv_nxn_bn(inp: int, oup: int, kernal_size: int = 3, stride: int = 1) -> nn.Module:
+ return nn.Sequential(
+ nn.Conv2d(inp, oup, kernal_size, stride, 1, bias=False),
+ nn.BatchNorm2d(oup),
+ SiLU()
+ )
+
+
+class PreNorm(nn.Module):
+ def __init__(self, dim: int, fn: nn.Module) -> None:
+ super().__init__()
+ self.norm = nn.LayerNorm(dim)
+ self.fn = fn
+
+ def forward(self, x: torch.Tensor, **kwargs) -> nn.Module:
+ return self.fn(self.norm(x), **kwargs)
+
+
+class FeedForward(nn.Module):
+ def __init__(self, dim: int, hidden_dim: int, dropout: float = 0.) -> None:
+ super().__init__()
+ self.net = nn.Sequential(
+ nn.Linear(dim, hidden_dim),
+ SiLU(),
+ nn.Dropout(dropout),
+ nn.Linear(hidden_dim, dim),
+ nn.Dropout(dropout)
+ )
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ return self.net(x)
+
+
+class Attention(nn.Module):
+ def __init__(self, dim: int, heads: int = 8, dim_head: int = 64, dropout: float = 0.) -> None:
+ super().__init__()
+ inner_dim = dim_head * heads
+ project_out = not (heads == 1 and dim_head == dim)
+
+ self.heads = heads
+ self.scale = dim_head ** -0.5
+
+ self.attend = nn.Softmax(dim=-1)
+ self.to_qkv = nn.Linear(dim, inner_dim * 3, bias=False)
+
+ self.to_out = nn.Sequential(
+ nn.Linear(inner_dim, dim),
+ nn.Dropout(dropout)
+ ) if project_out else nn.Identity()
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ qkv = self.to_qkv(x).chunk(3, dim=-1)
+
+ B, P, N, HD = qkv[0].shape
+ q, k, v = map(lambda t: t.contiguous().view(B, P, self.heads, N, HD // self.heads), qkv)
+
+ dots = torch.matmul(q, k.transpose(-1, -2)) * self.scale
+ attn = self.attend(dots)
+ out = torch.matmul(attn, v)
+ B, P, H, N, D = out.shape
+ out = out.view(B, P, N, H * D)
+ return self.to_out(out)
+
+
+class Transformer(nn.Module):
+ """Transformer block described in ViT.
+
+ Paper: https://arxiv.org/abs/2010.11929
+ Based on: https://github.com/lucidrains/vit-pytorch
+
+ Args:
+ dim: input dimension.
+ depth: depth for transformer block.
+ heads: number of heads in multi-head attention layer.
+ dim_head: head size.
+ mlp_dim: dimension of the FeedForward layer.
+ dropout: dropout ratio, defaults to 0.
+ """
+
+ def __init__(self, dim: int, depth: int, heads: int, dim_head: int, mlp_dim: int, dropout: float = 0.) -> None:
+ super().__init__()
+ self.layers = nn.ModuleList([])
+ for _ in range(depth):
+ self.layers.append(nn.ModuleList([
+ PreNorm(dim, Attention(dim, heads, dim_head, dropout)),
+ PreNorm(dim, FeedForward(dim, mlp_dim, dropout))
+ ]))
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ for attn, ff in self.layers:
+ x = attn(x) + x
+ x = ff(x) + x
+ return x
+
+
+class MV2Block(nn.Module):
+ """MV2 block described in MobileNetV2.
+
+ Paper: https://arxiv.org/pdf/1801.04381
+ Based on: https://github.com/tonylins/pytorch-mobilenet-v2
+
+ Args:
+ inp: input channel.
+ oup: output channel.
+ stride: stride for convolution, defaults to 1, set to 2 if down-sample.
+ expansion: expansion ratio for hidden dimension, defaults to 4.
+ """
+
+ def __init__(self, inp: int, oup: int, stride: int = 1, expansion: int = 4) -> None:
+ super().__init__()
+ self.stride = stride
+
+ hidden_dim = int(inp * expansion)
+ self.use_res_connect = self.stride == 1 and inp == oup
+
+ if expansion == 1:
+ self.conv = nn.Sequential(
+ # depthwise
+ nn.Conv2d(hidden_dim, hidden_dim, 3, stride, 1, groups=hidden_dim, bias=False),
+ nn.BatchNorm2d(hidden_dim),
+ SiLU(),
+ # pointwise
+ nn.Conv2d(hidden_dim, oup, 1, 1, 0, bias=False),
+ nn.BatchNorm2d(oup),
+ )
+ else:
+ self.conv = nn.Sequential(
+ # pointwise
+ nn.Conv2d(inp, hidden_dim, 1, 1, 0, bias=False),
+ nn.BatchNorm2d(hidden_dim),
+ SiLU(),
+ # depthwise
+ nn.Conv2d(hidden_dim, hidden_dim, 3, stride, 1, groups=hidden_dim, bias=False),
+ nn.BatchNorm2d(hidden_dim),
+ SiLU(),
+ # pointwise
+ nn.Conv2d(hidden_dim, oup, 1, 1, 0, bias=False),
+ nn.BatchNorm2d(oup),
+ )
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ if self.use_res_connect:
+ return x + self.conv(x)
+ else:
+ return self.conv(x)
+
+
+class MobileViTBlock(nn.Module):
+ """MobileViT block mentioned in MobileViT.
+
+ Args:
+ dim: input dimension of Transformer.
+ depth: depth of Transformer.
+ channel: input channel.
+ kernel_size: kernel size.
+ patch_size: patch size for folding and unfloding.
+ mlp_dim: dimension of the FeedForward layer in Transformer.
+ dropout: dropout ratio, defaults to 0.
+ """
+
+ def __init__(
+ self,
+ dim: int,
+ depth: int,
+ channel: int,
+ kernel_size: int,
+ patch_size: Tuple[int, int],
+ mlp_dim: int,
+ dropout: float = 0.
+ ) -> None:
+ super().__init__()
+ self.ph, self.pw = patch_size
+
+ self.conv1 = conv_nxn_bn(channel, channel, kernel_size)
+ self.conv2 = conv_1x1_bn(channel, dim)
+
+ self.transformer = Transformer(dim, depth, 4, 8, mlp_dim, dropout)
+
+ self.conv3 = conv_1x1_bn(dim, channel)
+ self.conv4 = conv_nxn_bn(2 * channel, channel, kernel_size)
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ y = x.clone()
+
+ # Local representations
+ x = self.conv1(x)
+ x = self.conv2(x)
+
+ # Global representations
+ b, d, h, w = x.shape
+ x = x.view(b, self.ph * self.pw, (h // self.ph) * (w // self.pw), d)
+ x = self.transformer(x)
+ x = x.view(b, d, h, w)
+
+ # Fusion
+ x = self.conv3(x)
+ x = torch.cat((x, y), 1)
+ x = self.conv4(x)
+ return x
+
+
+class MobileViT(nn.Module):
+ """Module MobileViT. Default arguments is for MobileViT XXS.
+
+ Paper: https://arxiv.org/abs/2110.02178
+ Based on: https://github.com/chinhsuanwu/mobilevit-pytorch
+
+ Args:
+ mode: 'xxs', 'xs' or 's', defaults to 'xxs'.
+ in_channels: the number of channels for the input image.
+ patch_size: image_size must be divisible by patch_size.
+ dropout: dropout ratio in Transformer.
+
+ Example:
+ >>> img = torch.rand(1, 3, 256, 256)
+ >>> mvit = MobileViT(mode='xxs')
+ >>> mvit(img).shape
+ torch.Size([1, 320, 8, 8])
+ """
+
+ def __init__(
+ self,
+ mode: str = 'xxs',
+ in_channels: int = 3,
+ patch_size: Tuple[int, int] = (2, 2),
+ dropout: float = 0.
+ ) -> None:
+ super().__init__()
+ if mode == 'xxs':
+ expansion = 2
+ dims = [64, 80, 96]
+ channels = [16, 16, 24, 24, 48, 48, 64, 64, 80, 80, 320]
+ elif mode == 'xs':
+ expansion = 4
+ dims = [96, 120, 144]
+ channels = [16, 32, 48, 48, 64, 64, 80, 80, 96, 96, 384]
+ elif mode == 's':
+ expansion = 4
+ dims = [144, 192, 240]
+ channels = [16, 32, 64, 64, 96, 96, 128, 128, 160, 160, 640]
+
+ kernel_size = 3
+ depth = [2, 4, 3]
+
+ self.conv1 = conv_nxn_bn(in_channels, channels[0], stride=2)
+
+ self.mv2 = nn.ModuleList([])
+ self.mv2.append(MV2Block(channels[0], channels[1], 1, expansion))
+ self.mv2.append(MV2Block(channels[1], channels[2], 2, expansion))
+ self.mv2.append(MV2Block(channels[2], channels[3], 1, expansion))
+ self.mv2.append(MV2Block(channels[2], channels[3], 1, expansion)) # Repeat
+ self.mv2.append(MV2Block(channels[3], channels[4], 2, expansion))
+ self.mv2.append(MV2Block(channels[5], channels[6], 2, expansion))
+ self.mv2.append(MV2Block(channels[7], channels[8], 2, expansion))
+
+ self.mvit = nn.ModuleList([])
+ self.mvit.append(MobileViTBlock(dims[0], depth[0], channels[5],
+ kernel_size, patch_size, int(dims[0] * 2), dropout=dropout))
+ self.mvit.append(MobileViTBlock(dims[1], depth[1], channels[7],
+ kernel_size, patch_size, int(dims[1] * 4), dropout=dropout))
+ self.mvit.append(MobileViTBlock(dims[2], depth[2], channels[9],
+ kernel_size, patch_size, int(dims[2] * 4), dropout=dropout))
+
+ self.conv2 = conv_1x1_bn(channels[-2], channels[-1])
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ x = self.conv1(x)
+ x = self.mv2[0](x)
+
+ x = self.mv2[1](x)
+ x = self.mv2[2](x)
+ x = self.mv2[3](x) # Repeat
+
+ x = self.mv2[4](x)
+ x = self.mvit[0](x)
+
+ x = self.mv2[5](x)
+ x = self.mvit[1](x)
+
+ x = self.mv2[6](x)
+ x = self.mvit[2](x)
+ x = self.conv2(x)
+ return x
diff --git a/kornia/enhance/__init__.py b/kornia/enhance/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e20b291962c2b4a610a08588486fc1fc0c0558c5
--- /dev/null
+++ b/kornia/enhance/__init__.py
@@ -0,0 +1,57 @@
+from .adjust import (
+ adjust_brightness,
+ adjust_contrast,
+ adjust_gamma,
+ adjust_hue,
+ adjust_hue_raw,
+ adjust_saturation,
+ adjust_saturation_raw,
+ AdjustBrightness,
+ AdjustContrast,
+ AdjustGamma,
+ AdjustHue,
+ AdjustSaturation,
+ equalize,
+ equalize3d,
+ invert,
+ Invert,
+ posterize,
+ sharpness,
+ solarize,
+)
+from .core import add_weighted, AddWeighted
+from .equalization import equalize_clahe
+from .histogram import histogram, histogram2d, image_histogram2d
+from .normalize import denormalize, Denormalize, normalize, Normalize, normalize_min_max
+from .zca import linear_transform, zca_mean, zca_whiten, ZCAWhitening
+
+__all__ = [
+ "adjust_brightness",
+ "adjust_contrast",
+ "adjust_gamma",
+ "adjust_hue",
+ "adjust_saturation",
+ "adjust_hue_raw",
+ "adjust_saturation_raw",
+ "solarize",
+ "equalize",
+ "equalize3d",
+ "posterize",
+ "sharpness",
+ "invert",
+ "AdjustBrightness",
+ "AdjustContrast",
+ "AdjustGamma",
+ "AdjustHue",
+ "AdjustSaturation",
+ "Invert",
+ "add_weighted",
+ "AddWeighted",
+ "equalize_clahe",
+ "histogram",
+ "histogram2d",
+ "image_histogram2d",
+ "normalize", "normalize_min_max", "denormalize", "Normalize",
+ "Denormalize",
+ "zca_mean", "zca_whiten", "linear_transform", "ZCAWhitening",
+]
diff --git a/kornia/enhance/adjust.py b/kornia/enhance/adjust.py
new file mode 100644
index 0000000000000000000000000000000000000000..18f566b472826011df47710c369df2f5c274ab02
--- /dev/null
+++ b/kornia/enhance/adjust.py
@@ -0,0 +1,994 @@
+from math import pi
+from typing import Optional, Union
+
+import torch
+import torch.nn as nn
+
+from kornia.color.hsv import hsv_to_rgb, rgb_to_hsv
+from kornia.utils.helpers import _torch_histc_cast
+from kornia.utils.image import perform_keep_shape_image, perform_keep_shape_video
+
+
+def adjust_saturation_raw(input: torch.Tensor, saturation_factor: Union[float, torch.Tensor]) -> torch.Tensor:
+ r"""Adjust color saturation of an image. Expecting input to be in hsv format already."""
+
+ if not isinstance(input, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(input)}")
+
+ if not isinstance(saturation_factor, (float, torch.Tensor)):
+ raise TypeError(
+ f"The saturation_factor should be a float number or torch.Tensor." f"Got {type(saturation_factor)}"
+ )
+
+ if isinstance(saturation_factor, float):
+ saturation_factor = torch.as_tensor(saturation_factor)
+
+ saturation_factor = saturation_factor.to(input.device).to(input.dtype)
+
+ # TODO: find a proper way to check bound values in batched tensors.
+ # if (saturation_factor < 0).any():
+ # raise ValueError(f"Saturation factor must be non-negative. Got {saturation_factor}")
+
+ for _ in range(len(input.shape) - len(saturation_factor.shape)):
+ saturation_factor = torch.unsqueeze(saturation_factor, dim=-1)
+
+ # unpack the hsv values
+ h, s, v = torch.chunk(input, chunks=3, dim=-3)
+
+ # transform the hue value and appl module
+ s_out: torch.Tensor = torch.clamp(s * saturation_factor, min=0, max=1)
+
+ # pack back back the corrected hue
+ out: torch.Tensor = torch.cat([h, s_out, v], dim=-3)
+
+ return out
+
+
+def adjust_saturation(input: torch.Tensor, saturation_factor: Union[float, torch.Tensor]) -> torch.Tensor:
+ r"""Adjust color saturation of an image.
+
+ .. image:: _static/img/adjust_saturation.png
+
+ The input image is expected to be an RGB image in the range of [0, 1].
+
+ Args:
+ input: Image/Tensor to be adjusted in the shape of :math:`(*, 3, H, W)`.
+ saturation_factor: How much to adjust the saturation. 0 will give a black
+ and white image, 1 will give the original image while 2 will enhance the saturation by a factor of 2.
+
+ Return:
+ Adjusted image in the shape of :math:`(*, 3, H, W)`.
+
+ .. note::
+ See a working example `here `__.
+
+ Example:
+ >>> x = torch.ones(1, 3, 3, 3)
+ >>> adjust_saturation(x, 2.).shape
+ torch.Size([1, 3, 3, 3])
+
+ >>> x = torch.ones(2, 3, 3, 3)
+ >>> y = torch.tensor([1., 2.])
+ >>> adjust_saturation(x, y).shape
+ torch.Size([2, 3, 3, 3])
+ """
+
+ # convert the rgb image to hsv
+ x_hsv: torch.Tensor = rgb_to_hsv(input)
+
+ # perform the conversion
+ x_adjusted: torch.Tensor = adjust_saturation_raw(x_hsv, saturation_factor)
+
+ # convert back to rgb
+ out: torch.Tensor = hsv_to_rgb(x_adjusted)
+
+ return out
+
+
+def adjust_hue_raw(input: torch.Tensor, hue_factor: Union[float, torch.Tensor]) -> torch.Tensor:
+ r"""Adjust hue of an image. Expecting input to be in hsv format already."""
+
+ if not isinstance(input, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(input)}")
+
+ if not isinstance(hue_factor, (float, torch.Tensor)):
+ raise TypeError(
+ f"The hue_factor should be a float number or torch.Tensor in the range between"
+ f" [-PI, PI]. Got {type(hue_factor)}"
+ )
+
+ if isinstance(hue_factor, float):
+ hue_factor = torch.as_tensor(hue_factor)
+
+ hue_factor = hue_factor.to(input.device, input.dtype)
+
+ # TODO: find a proper way to check bound values in batched tensors.
+ # if ((hue_factor < -pi) | (hue_factor > pi)).any():
+ # raise ValueError(f"Hue-factor must be in the range [-PI, PI]. Got {hue_factor}")
+
+ for _ in range(len(input.shape) - len(hue_factor.shape)):
+ hue_factor = torch.unsqueeze(hue_factor, dim=-1)
+
+ # unpack the hsv values
+ h, s, v = torch.chunk(input, chunks=3, dim=-3)
+
+ # transform the hue value and appl module
+ divisor: float = 2 * pi
+ h_out: torch.Tensor = torch.fmod(h + hue_factor, divisor)
+
+ # pack back back the corrected hue
+ out: torch.Tensor = torch.cat([h_out, s, v], dim=-3)
+
+ return out
+
+
+def adjust_hue(input: torch.Tensor, hue_factor: Union[float, torch.Tensor]) -> torch.Tensor:
+ r"""Adjust hue of an image.
+
+ .. image:: _static/img/adjust_hue.png
+
+ The input image is expected to be an RGB image in the range of [0, 1].
+
+ Args:
+ input: Image to be adjusted in the shape of :math:`(*, 3, H, W)`.
+ hue_factor: How much to shift the hue channel. Should be in [-PI, PI]. PI
+ and -PI give complete reversal of hue channel in HSV space in positive and negative
+ direction respectively. 0 means no shift. Therefore, both -PI and PI will give an
+ image with complementary colors while 0 gives the original image.
+
+ Return:
+ Adjusted image in the shape of :math:`(*, 3, H, W)`.
+
+ .. note::
+ See a working example `here `__.
+
+ Example:
+ >>> x = torch.ones(1, 3, 2, 2)
+ >>> adjust_hue(x, 3.141516).shape
+ torch.Size([1, 3, 2, 2])
+
+ >>> x = torch.ones(2, 3, 3, 3)
+ >>> y = torch.ones(2) * 3.141516
+ >>> adjust_hue(x, y).shape
+ torch.Size([2, 3, 3, 3])
+ """
+
+ # convert the rgb image to hsv
+ x_hsv: torch.Tensor = rgb_to_hsv(input)
+
+ # perform the conversion
+ x_adjusted: torch.Tensor = adjust_hue_raw(x_hsv, hue_factor)
+
+ # convert back to rgb
+ out: torch.Tensor = hsv_to_rgb(x_adjusted)
+
+ return out
+
+
+def adjust_gamma(
+ input: torch.Tensor, gamma: Union[float, torch.Tensor], gain: Union[float, torch.Tensor] = 1.0
+) -> torch.Tensor:
+ r"""Perform gamma correction on an image.
+
+ .. image:: _static/img/adjust_contrast.png
+
+ The input image is expected to be in the range of [0, 1].
+
+ Args:
+ input: Image to be adjusted in the shape of :math:`(*, H, W)`.
+ gamma: Non negative real number, same as ฮณ\gammaฮณ in the equation.
+ gamma larger than 1 make the shadows darker, while gamma smaller than 1 make
+ dark regions lighter.
+ gain: The constant multiplier.
+
+ Return:
+ Adjusted image in the shape of :math:`(*, H, W)`.
+
+ .. note::
+ See a working example `here `__.
+
+ Example:
+ >>> x = torch.ones(1, 1, 2, 2)
+ >>> adjust_gamma(x, 1.0, 2.0)
+ tensor([[[[1., 1.],
+ [1., 1.]]]])
+
+ >>> x = torch.ones(2, 5, 3, 3)
+ >>> y1 = torch.ones(2) * 1.0
+ >>> y2 = torch.ones(2) * 2.0
+ >>> adjust_gamma(x, y1, y2).shape
+ torch.Size([2, 5, 3, 3])
+ """
+
+ if not isinstance(input, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(input)}")
+
+ if not isinstance(gamma, (float, torch.Tensor)):
+ raise TypeError(f"The gamma should be a positive float or torch.Tensor. Got {type(gamma)}")
+
+ if not isinstance(gain, (float, torch.Tensor)):
+ raise TypeError(f"The gain should be a positive float or torch.Tensor. Got {type(gain)}")
+
+ if isinstance(gamma, float):
+ gamma = torch.tensor([gamma])
+
+ if isinstance(gain, float):
+ gain = torch.tensor([gain])
+
+ gamma = gamma.to(input.device).to(input.dtype)
+ gain = gain.to(input.device).to(input.dtype)
+
+ if (gamma < 0.0).any():
+ raise ValueError(f"Gamma must be non-negative. Got {gamma}")
+
+ if (gain < 0.0).any():
+ raise ValueError(f"Gain must be non-negative. Got {gain}")
+
+ for _ in range(len(input.shape) - len(gamma.shape)):
+ gamma = torch.unsqueeze(gamma, dim=-1)
+
+ for _ in range(len(input.shape) - len(gain.shape)):
+ gain = torch.unsqueeze(gain, dim=-1)
+
+ # Apply the gamma correction
+ x_adjust: torch.Tensor = gain * torch.pow(input, gamma)
+
+ # Truncate between pixel values
+ out: torch.Tensor = torch.clamp(x_adjust, 0.0, 1.0)
+
+ return out
+
+
+def adjust_contrast(input: torch.Tensor, contrast_factor: Union[float, torch.Tensor]) -> torch.Tensor:
+ r"""Adjust Contrast of an image.
+
+ .. image:: _static/img/adjust_contrast.png
+
+ This implementation aligns OpenCV, not PIL. Hence, the output differs from TorchVision.
+ The input image is expected to be in the range of [0, 1].
+
+ Args:
+ input: Image to be adjusted in the shape of :math:`(*, H, W)`.
+ contrast_factor: Contrast adjust factor per element
+ in the batch. 0 generates a completely black image, 1 does not modify
+ the input image while any other non-negative number modify the
+ brightness by this factor.
+
+ Return:
+ Adjusted image in the shape of :math:`(*, H, W)`.
+
+ .. note::
+ See a working example `here `__.
+
+ Example:
+ >>> x = torch.ones(1, 1, 2, 2)
+ >>> adjust_contrast(x, 0.5)
+ tensor([[[[0.5000, 0.5000],
+ [0.5000, 0.5000]]]])
+
+ >>> x = torch.ones(2, 5, 3, 3)
+ >>> y = torch.tensor([0.65, 0.50])
+ >>> adjust_contrast(x, y).shape
+ torch.Size([2, 5, 3, 3])
+ """
+
+ if not isinstance(input, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(input)}")
+
+ if not isinstance(contrast_factor, (float, torch.Tensor)):
+ raise TypeError(f"The factor should be either a float or torch.Tensor. " f"Got {type(contrast_factor)}")
+
+ if isinstance(contrast_factor, float):
+ contrast_factor = torch.tensor([contrast_factor])
+
+ contrast_factor = contrast_factor.to(input.device).to(input.dtype)
+
+ if (contrast_factor < 0).any():
+ raise ValueError(f"Contrast factor must be non-negative. Got {contrast_factor}")
+
+ for _ in range(len(input.shape) - len(contrast_factor.shape)):
+ contrast_factor = torch.unsqueeze(contrast_factor, dim=-1)
+
+ # Apply contrast factor to each channel
+ x_adjust: torch.Tensor = input * contrast_factor
+
+ # Truncate between pixel values
+ out: torch.Tensor = torch.clamp(x_adjust, 0.0, 1.0)
+
+ return out
+
+
+def adjust_brightness(input: torch.Tensor, brightness_factor: Union[float, torch.Tensor]) -> torch.Tensor:
+ r"""Adjust Brightness of an image.
+
+ .. image:: _static/img/adjust_brightness.png
+
+ This implementation aligns OpenCV, not PIL. Hence, the output differs from TorchVision.
+ The input image is expected to be in the range of [0, 1].
+
+ Args:
+ input: image to be adjusted in the shape of :math:`(*, H, W)`.
+ brightness_factor: Brightness adjust factor per element
+ in the batch. 0 does not modify the input image while any other number modify the
+ brightness.
+
+ Return:
+ Adjusted image in the shape of :math:`(*, H, W)`.
+
+ .. note::
+ See a working example `here `__.
+
+ Example:
+ >>> x = torch.ones(1, 1, 2, 2)
+ >>> adjust_brightness(x, 1.)
+ tensor([[[[1., 1.],
+ [1., 1.]]]])
+
+ >>> x = torch.ones(2, 5, 3, 3)
+ >>> y = torch.tensor([0.25, 0.50])
+ >>> adjust_brightness(x, y).shape
+ torch.Size([2, 5, 3, 3])
+ """
+
+ if not isinstance(input, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(input)}")
+
+ if not isinstance(brightness_factor, (float, torch.Tensor)):
+ raise TypeError(f"The factor should be either a float or torch.Tensor. " f"Got {type(brightness_factor)}")
+
+ if isinstance(brightness_factor, float):
+ brightness_factor = torch.tensor([brightness_factor])
+
+ brightness_factor = brightness_factor.to(input.device).to(input.dtype)
+
+ for _ in range(len(input.shape) - len(brightness_factor.shape)):
+ brightness_factor = torch.unsqueeze(brightness_factor, dim=-1)
+
+ # Apply brightness factor to each channel
+ x_adjust: torch.Tensor = input + brightness_factor
+
+ # Truncate between pixel values
+ out: torch.Tensor = torch.clamp(x_adjust, 0.0, 1.0)
+
+ return out
+
+
+def _solarize(input: torch.Tensor, thresholds: Union[float, torch.Tensor] = 0.5) -> torch.Tensor:
+ r"""For each pixel in the image, select the pixel if the value is less than the threshold.
+ Otherwise, subtract 1.0 from the pixel.
+
+ Args:
+ input (torch.Tensor): image or batched images to solarize.
+ thresholds (float or torch.Tensor): solarize thresholds.
+ If int or one element tensor, input will be solarized across the whole batch.
+ If 1-d tensor, input will be solarized element-wise, len(thresholds) == len(input).
+
+ Returns:
+ torch.Tensor: Solarized images.
+ """
+ if not isinstance(input, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(input)}")
+
+ if not isinstance(thresholds, (float, torch.Tensor)):
+ raise TypeError(f"The factor should be either a float or torch.Tensor. " f"Got {type(thresholds)}")
+
+ if isinstance(thresholds, torch.Tensor) and len(thresholds.shape) != 0:
+ if not (input.size(0) == len(thresholds) and len(thresholds.shape) == 1):
+ raise AssertionError(f"thresholds must be a 1-d vector of shape ({input.size(0)},). Got {thresholds}")
+ # TODO: I am not happy about this line, but no easy to do batch-wise operation
+ thresholds = thresholds.to(input.device).to(input.dtype)
+ thresholds = torch.stack([x.expand(*input.shape[-3:]) for x in thresholds])
+
+ return torch.where(input < thresholds, input, 1.0 - input)
+
+
+def solarize(
+ input: torch.Tensor,
+ thresholds: Union[float, torch.Tensor] = 0.5,
+ additions: Optional[Union[float, torch.Tensor]] = None,
+) -> torch.Tensor:
+ r"""For each pixel in the image less than threshold.
+
+ .. image:: _static/img/solarize.png
+
+ We add 'addition' amount to it and then clip the pixel value to be between 0 and 1.0.
+ The value of 'addition' is between -0.5 and 0.5.
+
+ Args:
+ input: image tensor with shapes like :math:`(*, C, H, W)` to solarize.
+ thresholds: solarize thresholds.
+ If int or one element tensor, input will be solarized across the whole batch.
+ If 1-d tensor, input will be solarized element-wise, len(thresholds) == len(input).
+ additions: between -0.5 and 0.5.
+ If None, no addition will be performed.
+ If int or one element tensor, same addition will be added across the whole batch.
+ If 1-d tensor, additions will be added element-wisely, len(additions) == len(input).
+
+ Returns:
+ The solarized images with shape :math:`(*, C, H, W)`.
+
+ Example:
+ >>> x = torch.rand(1, 4, 3, 3)
+ >>> out = solarize(x, thresholds=0.5, additions=0.)
+ >>> out.shape
+ torch.Size([1, 4, 3, 3])
+
+ >>> x = torch.rand(2, 4, 3, 3)
+ >>> thresholds = torch.tensor([0.8, 0.5])
+ >>> additions = torch.tensor([-0.25, 0.25])
+ >>> solarize(x, thresholds, additions).shape
+ torch.Size([2, 4, 3, 3])
+ """
+ if not isinstance(input, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(input)}")
+
+ if not isinstance(thresholds, (float, torch.Tensor)):
+ raise TypeError(f"The factor should be either a float or torch.Tensor. " f"Got {type(thresholds)}")
+
+ if isinstance(thresholds, float):
+ thresholds = torch.tensor(thresholds)
+
+ if additions is not None:
+ if not isinstance(additions, (float, torch.Tensor)):
+ raise TypeError(f"The factor should be either a float or torch.Tensor. " f"Got {type(additions)}")
+
+ if isinstance(additions, float):
+ additions = torch.tensor(additions)
+
+ if not torch.all((additions < 0.5) * (additions > -0.5)):
+ raise AssertionError(f"The value of 'addition' is between -0.5 and 0.5. Got {additions}.")
+
+ if isinstance(additions, torch.Tensor) and len(additions.shape) != 0:
+ if not (input.size(0) == len(additions) and len(additions.shape) == 1):
+ raise AssertionError(f"additions must be a 1-d vector of shape ({input.size(0)},). Got {additions}")
+ # TODO: I am not happy about this line, but no easy to do batch-wise operation
+ additions = additions.to(input.device).to(input.dtype)
+ additions = torch.stack([x.expand(*input.shape[-3:]) for x in additions])
+ input = input + additions
+ input = input.clamp(0.0, 1.0)
+
+ return _solarize(input, thresholds)
+
+
+@perform_keep_shape_image
+def posterize(input: torch.Tensor, bits: Union[int, torch.Tensor]) -> torch.Tensor:
+ r"""Reduce the number of bits for each color channel.
+
+ .. image:: _static/img/posterize.png
+
+ Non-differentiable function, ``torch.uint8`` involved.
+
+ Args:
+ input: image tensor with shape :math:`(*, C, H, W)` to posterize.
+ bits: number of high bits. Must be in range [0, 8].
+ If int or one element tensor, input will be posterized by this bits.
+ If 1-d tensor, input will be posterized element-wisely, len(bits) == input.shape[-3].
+ If n-d tensor, input will be posterized element-channel-wisely, bits.shape == input.shape[:len(bits.shape)]
+
+ Returns:
+ Image with reduced color channels with shape :math:`(*, C, H, W)`.
+
+ Example:
+ >>> x = torch.rand(1, 6, 3, 3)
+ >>> out = posterize(x, bits=8)
+ >>> torch.testing.assert_allclose(x, out)
+
+ >>> x = torch.rand(2, 6, 3, 3)
+ >>> bits = torch.tensor([4, 2])
+ >>> posterize(x, bits).shape
+ torch.Size([2, 6, 3, 3])
+ """
+ if not isinstance(input, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(input)}")
+
+ if not isinstance(bits, (int, torch.Tensor)):
+ raise TypeError(f"bits type is not an int or torch.Tensor. Got {type(bits)}")
+
+ if isinstance(bits, int):
+ bits = torch.tensor(bits)
+
+ # TODO: find a better way to check boundaries on tensors
+ # if not torch.all((bits >= 0) * (bits <= 8)) and bits.dtype == torch.int:
+ # raise ValueError(f"bits must be integers within range [0, 8]. Got {bits}.")
+
+ # TODO: Make a differentiable version
+ # Current version:
+ # Ref: https://github.com/open-mmlab/mmcv/pull/132/files#diff-309c9320c7f71bedffe89a70ccff7f3bR19
+ # Ref: https://github.com/tensorflow/tpu/blob/master/models/official/efficientnet/autoaugment.py#L222
+ # Potential approach: implementing kornia.LUT with floating points
+ # https://github.com/albumentations-team/albumentations/blob/master/albumentations/augmentations/functional.py#L472
+ def _left_shift(input: torch.Tensor, shift: torch.Tensor):
+ return ((input * 255).to(torch.uint8) * (2 ** shift)).to(input.dtype) / 255.0
+
+ def _right_shift(input: torch.Tensor, shift: torch.Tensor):
+ return (input * 255).to(torch.uint8) / (2 ** shift).to(input.dtype) / 255.0
+
+ def _posterize_one(input: torch.Tensor, bits: torch.Tensor):
+ # Single bits value condition
+ if bits == 0:
+ return torch.zeros_like(input)
+ if bits == 8:
+ return input.clone()
+ bits = 8 - bits
+ return _left_shift(_right_shift(input, bits), bits)
+
+ if len(bits.shape) == 0 or (len(bits.shape) == 1 and len(bits) == 1):
+ return _posterize_one(input, bits)
+
+ res = []
+ if len(bits.shape) == 1:
+ if bits.shape[0] != input.shape[0]:
+ raise AssertionError(
+ f"Batch size must be equal between bits and input. Got {bits.shape[0]}, {input.shape[0]}."
+ )
+
+ for i in range(input.shape[0]):
+ res.append(_posterize_one(input[i], bits[i]))
+ return torch.stack(res, dim=0)
+
+ if bits.shape != input.shape[: len(bits.shape)]:
+ raise AssertionError(
+ "Batch and channel must be equal between bits and input. "
+ f"Got {bits.shape}, {input.shape[:len(bits.shape)]}."
+ )
+ _input = input.view(-1, *input.shape[len(bits.shape):])
+ _bits = bits.flatten()
+ for i in range(input.shape[0]):
+ res.append(_posterize_one(_input[i], _bits[i]))
+ return torch.stack(res, dim=0).reshape(*input.shape)
+
+
+@perform_keep_shape_image
+def sharpness(input: torch.Tensor, factor: Union[float, torch.Tensor]) -> torch.Tensor:
+ r"""Apply sharpness to the input tensor.
+
+ .. image:: _static/img/sharpness.png
+
+ Implemented Sharpness function from PIL using torch ops. This implementation refers to:
+ https://github.com/tensorflow/tpu/blob/master/models/official/efficientnet/autoaugment.py#L326
+
+ Args:
+ input: image tensor with shape :math:`(*, C, H, W)` to sharpen.
+ factor: factor of sharpness strength. Must be above 0.
+ If float or one element tensor, input will be sharpened by the same factor across the whole batch.
+ If 1-d tensor, input will be sharpened element-wisely, len(factor) == len(input).
+
+ Returns:
+ Sharpened image or images with shape :math:`(*, C, H, W)`.
+
+ Example:
+ >>> x = torch.rand(1, 1, 5, 5)
+ >>> sharpness(x, 0.5).shape
+ torch.Size([1, 1, 5, 5])
+ """
+ if not isinstance(factor, torch.Tensor):
+ factor = torch.tensor(factor, device=input.device, dtype=input.dtype)
+
+ if len(factor.size()) != 0 and factor.shape != torch.Size([input.size(0)]):
+ raise AssertionError(
+ "Input batch size shall match with factor size if factor is not a 0-dim tensor. "
+ f"Got {input.size(0)} and {factor.shape}"
+ )
+
+ kernel = (
+ torch.tensor([[1, 1, 1], [1, 5, 1], [1, 1, 1]], dtype=input.dtype, device=input.device)
+ .view(1, 1, 3, 3)
+ .repeat(input.size(1), 1, 1, 1)
+ / 13
+ )
+
+ # This shall be equivalent to depthwise conv2d:
+ # Ref: https://discuss.pytorch.org/t/depthwise-and-separable-convolutions-in-pytorch/7315/2
+ degenerate = torch.nn.functional.conv2d(input, kernel, bias=None, stride=1, groups=input.size(1))
+ degenerate = torch.clamp(degenerate, 0.0, 1.0)
+
+ # For the borders of the resulting image, fill in the values of the original image.
+ mask = torch.ones_like(degenerate)
+ padded_mask = torch.nn.functional.pad(mask, [1, 1, 1, 1])
+ padded_degenerate = torch.nn.functional.pad(degenerate, [1, 1, 1, 1])
+ result = torch.where(padded_mask == 1, padded_degenerate, input)
+
+ if len(factor.size()) == 0:
+ return _blend_one(result, input, factor)
+ return torch.stack([_blend_one(result[i], input[i], factor[i]) for i in range(len(factor))])
+
+
+def _blend_one(input1: torch.Tensor, input2: torch.Tensor, factor: torch.Tensor) -> torch.Tensor:
+ r"""Blend two images into one.
+
+ Args:
+ input1: image tensor with shapes like :math:`(H, W)` or :math:`(D, H, W)`.
+ input2: image tensor with shapes like :math:`(H, W)` or :math:`(D, H, W)`.
+ factor: factor 0-dim tensor.
+
+ Returns:
+ : image tensor with the batch in the zero position.
+ """
+ if not isinstance(input1, torch.Tensor):
+ raise AssertionError(f"`input1` must be a tensor. Got {input1}.")
+ if not isinstance(input2, torch.Tensor):
+ raise AssertionError(f"`input1` must be a tensor. Got {input2}.")
+
+ if isinstance(factor, torch.Tensor) and len(factor.size()) != 0:
+ raise AssertionError(f"Factor shall be a float or single element tensor. Got {factor}.")
+ if factor == 0.0:
+ return input1
+ if factor == 1.0:
+ return input2
+ diff = (input2 - input1) * factor
+ res = input1 + diff
+ if factor > 0.0 and factor < 1.0:
+ return res
+ return torch.clamp(res, 0, 1)
+
+
+def _build_lut(histo, step):
+ # Compute the cumulative sum, shifting by step // 2
+ # and then normalization by step.
+ step_trunc = torch.div(step, 2, rounding_mode='trunc')
+ lut = torch.div(torch.cumsum(histo, 0) + step_trunc, step, rounding_mode='trunc')
+ # Shift lut, prepending with 0.
+ lut = torch.cat([torch.zeros(1, device=lut.device, dtype=lut.dtype), lut[:-1]])
+ # Clip the counts to be in range. This is done
+ # in the C code for image.point.
+ return torch.clamp(lut, 0, 255)
+
+
+# Code taken from: https://github.com/pytorch/vision/pull/796
+def _scale_channel(im: torch.Tensor) -> torch.Tensor:
+ r"""Scale the data in the channel to implement equalize.
+
+ Args:
+ input: image tensor with shapes like :math:`(H, W)` or :math:`(D, H, W)`.
+
+ Returns:
+ image tensor with the batch in the zero position.
+ """
+ min_ = im.min()
+ max_ = im.max()
+
+ if min_.item() < 0.0 and not torch.isclose(min_, torch.tensor(0.0, dtype=min_.dtype)):
+ raise ValueError(f"Values in the input tensor must greater or equal to 0.0. Found {min_.item()}.")
+
+ if max_.item() > 1.0 and not torch.isclose(max_, torch.tensor(1.0, dtype=max_.dtype)):
+ raise ValueError(f"Values in the input tensor must lower or equal to 1.0. Found {max_.item()}.")
+
+ ndims = len(im.shape)
+ if ndims not in (2, 3):
+ raise TypeError(f"Input tensor must have 2 or 3 dimensions. Found {ndims}.")
+
+ im = im * 255.
+ # Compute the histogram of the image channel.
+ histo = _torch_histc_cast(im, bins=256, min=0, max=255)
+ # For the purposes of computing the step, filter out the nonzeros.
+ nonzero_histo = torch.reshape(histo[histo != 0], [-1])
+ step = torch.div(torch.sum(nonzero_histo) - nonzero_histo[-1], 255, rounding_mode='trunc')
+
+ # If step is zero, return the original image. Otherwise, build
+ # lut from the full histogram and step and then index from it.
+ if step == 0:
+ result = im
+ else:
+ # can't index using 2d index. Have to flatten and then reshape
+ result = torch.gather(_build_lut(histo, step), 0, im.flatten().long())
+ result = result.reshape_as(im)
+
+ return result / 255.0
+
+
+@perform_keep_shape_image
+def equalize(input: torch.Tensor) -> torch.Tensor:
+ r"""Apply equalize on the input tensor.
+
+ .. image:: _static/img/equalize.png
+
+ Implements Equalize function from PIL using PyTorch ops based on uint8 format:
+ https://github.com/tensorflow/tpu/blob/5f71c12a020403f863434e96982a840578fdd127/models/official/efficientnet/autoaugment.py#L355
+
+ Args:
+ input: image tensor to equalize with shape :math:`(*, C, H, W)`.
+
+ Returns:
+ Equalized image tensor with shape :math:`(*, C, H, W)`.
+
+ Example:
+ >>> x = torch.rand(1, 2, 3, 3)
+ >>> equalize(x).shape
+ torch.Size([1, 2, 3, 3])
+ """
+ res = []
+ for image in input:
+ # Assumes RGB for now. Scales each channel independently
+ # and then stacks the result.
+ scaled_image = torch.stack([_scale_channel(image[i, :, :]) for i in range(len(image))])
+ res.append(scaled_image)
+ return torch.stack(res)
+
+
+@perform_keep_shape_video
+def equalize3d(input: torch.Tensor) -> torch.Tensor:
+ r"""Equalize the values for a 3D volumetric tensor.
+
+ Implements Equalize function for a sequence of images using PyTorch ops based on uint8 format:
+ https://github.com/tensorflow/tpu/blob/master/models/official/efficientnet/autoaugment.py#L352
+
+ Args:
+ input: image tensor with shape :math:`(*, C, D, H, W)` to equalize.
+
+ Returns:
+ Equalized volume with shape :math:`(B, C, D, H, W)`.
+ """
+ res = []
+ for volume in input:
+ # Assumes RGB for now. Scales each channel independently
+ # and then stacks the result.
+ scaled_input = torch.stack([_scale_channel(volume[i, :, :, :]) for i in range(len(volume))])
+ res.append(scaled_input)
+
+ return torch.stack(res)
+
+
+def invert(input: torch.Tensor, max_val: torch.Tensor = torch.tensor(1.0)) -> torch.Tensor:
+ r"""Invert the values of an input tensor by its maximum value.
+
+ .. image:: _static/img/invert.png
+
+ Args:
+ input: The input tensor to invert with an arbitatry shape.
+ max_val: The expected maximum value in the input tensor. The shape has to
+ according to the input tensor shape, or at least has to work with broadcasting.
+
+ Example:
+ >>> img = torch.rand(1, 2, 4, 4)
+ >>> invert(img).shape
+ torch.Size([1, 2, 4, 4])
+
+ >>> img = 255. * torch.rand(1, 2, 3, 4, 4)
+ >>> invert(img, torch.tensor(255.)).shape
+ torch.Size([1, 2, 3, 4, 4])
+
+ >>> img = torch.rand(1, 3, 4, 4)
+ >>> invert(img, torch.tensor([[[[1.]]]])).shape
+ torch.Size([1, 3, 4, 4])
+ """
+ if not isinstance(input, torch.Tensor):
+ raise AssertionError(f"Input is not a torch.Tensor. Got: {type(input)}")
+ if not isinstance(max_val, torch.Tensor):
+ raise AssertionError(f"max_val is not a torch.Tensor. Got: {type(max_val)}")
+ return max_val.to(input.dtype) - input
+
+
+class AdjustSaturation(nn.Module):
+ r"""Adjust color saturation of an image.
+
+ The input image is expected to be an RGB image in the range of [0, 1].
+
+ Args:
+ saturation_factor: How much to adjust the saturation. 0 will give a black
+ and white image, 1 will give the original image while 2 will enhance the saturation by a factor of 2.
+
+ Shape:
+ - Input: Image/Tensor to be adjusted in the shape of :math:`(*, 3, H, W)`.
+ - Output: Adjusted image in the shape of :math:`(*, 3, H, W)`.
+
+ Example:
+ >>> x = torch.ones(1, 3, 3, 3)
+ >>> AdjustSaturation(2.)(x)
+ tensor([[[[1., 1., 1.],
+ [1., 1., 1.],
+ [1., 1., 1.]],
+
+ [[1., 1., 1.],
+ [1., 1., 1.],
+ [1., 1., 1.]],
+
+ [[1., 1., 1.],
+ [1., 1., 1.],
+ [1., 1., 1.]]]])
+
+ >>> x = torch.ones(2, 3, 3, 3)
+ >>> y = torch.ones(2)
+ >>> out = AdjustSaturation(y)(x)
+ >>> torch.nn.functional.mse_loss(x, out)
+ tensor(0.)
+ """
+
+ def __init__(self, saturation_factor: Union[float, torch.Tensor]) -> None:
+ super().__init__()
+ self.saturation_factor: Union[float, torch.Tensor] = saturation_factor
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor:
+ return adjust_saturation(input, self.saturation_factor)
+
+
+class AdjustHue(nn.Module):
+ r"""Adjust hue of an image.
+
+ The input image is expected to be an RGB image in the range of [0, 1].
+
+ Args:
+ hue_factor: How much to shift the hue channel. Should be in [-PI, PI]. PI
+ and -PI give complete reversal of hue channel in HSV space in positive and negative
+ direction respectively. 0 means no shift. Therefore, both -PI and PI will give an
+ image with complementary colors while 0 gives the original image.
+
+ Shape:
+ - Input: Image/Tensor to be adjusted in the shape of :math:`(*, 3, H, W)`.
+ - Output: Adjusted image in the shape of :math:`(*, 3, H, W)`.
+
+ Example:
+ >>> x = torch.ones(1, 3, 3, 3)
+ >>> AdjustHue(3.141516)(x)
+ tensor([[[[1., 1., 1.],
+ [1., 1., 1.],
+ [1., 1., 1.]],
+
+ [[1., 1., 1.],
+ [1., 1., 1.],
+ [1., 1., 1.]],
+
+ [[1., 1., 1.],
+ [1., 1., 1.],
+ [1., 1., 1.]]]])
+
+ >>> x = torch.ones(2, 3, 3, 3)
+ >>> y = torch.ones(2) * 3.141516
+ >>> AdjustHue(y)(x).shape
+ torch.Size([2, 3, 3, 3])
+ """
+
+ def __init__(self, hue_factor: Union[float, torch.Tensor]) -> None:
+ super().__init__()
+ self.hue_factor: Union[float, torch.Tensor] = hue_factor
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor:
+ return adjust_hue(input, self.hue_factor)
+
+
+class AdjustGamma(nn.Module):
+ r"""Perform gamma correction on an image.
+
+ The input image is expected to be in the range of [0, 1].
+
+ Args:
+ gamma: Non negative real number, same as ฮณ\gammaฮณ in the equation.
+ gamma larger than 1 make the shadows darker, while gamma smaller than 1 make
+ dark regions lighter.
+ gain: The constant multiplier.
+
+ Shape:
+ - Input: Image to be adjusted in the shape of :math:`(*, N)`.
+ - Output: Adjusted image in the shape of :math:`(*, N)`.
+
+ Example:
+ >>> x = torch.ones(1, 1, 3, 3)
+ >>> AdjustGamma(1.0, 2.0)(x)
+ tensor([[[[1., 1., 1.],
+ [1., 1., 1.],
+ [1., 1., 1.]]]])
+
+ >>> x = torch.ones(2, 5, 3, 3)
+ >>> y1 = torch.ones(2) * 1.0
+ >>> y2 = torch.ones(2) * 2.0
+ >>> AdjustGamma(y1, y2)(x).shape
+ torch.Size([2, 5, 3, 3])
+ """
+
+ def __init__(self, gamma: Union[float, torch.Tensor], gain: Union[float, torch.Tensor] = 1.0) -> None:
+ super().__init__()
+ self.gamma: Union[float, torch.Tensor] = gamma
+ self.gain: Union[float, torch.Tensor] = gain
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor:
+ return adjust_gamma(input, self.gamma, self.gain)
+
+
+class AdjustContrast(nn.Module):
+ r"""Adjust Contrast of an image.
+
+ This implementation aligns OpenCV, not PIL. Hence, the output differs from TorchVision.
+ The input image is expected to be in the range of [0, 1].
+
+ Args:
+ contrast_factor: Contrast adjust factor per element
+ in the batch. 0 generates a completely black image, 1 does not modify
+ the input image while any other non-negative number modify the
+ brightness by this factor.
+
+ Shape:
+ - Input: Image/Input to be adjusted in the shape of :math:`(*, N)`.
+ - Output: Adjusted image in the shape of :math:`(*, N)`.
+
+ Example:
+ >>> x = torch.ones(1, 1, 3, 3)
+ >>> AdjustContrast(0.5)(x)
+ tensor([[[[0.5000, 0.5000, 0.5000],
+ [0.5000, 0.5000, 0.5000],
+ [0.5000, 0.5000, 0.5000]]]])
+
+ >>> x = torch.ones(2, 5, 3, 3)
+ >>> y = torch.ones(2)
+ >>> AdjustContrast(y)(x).shape
+ torch.Size([2, 5, 3, 3])
+ """
+
+ def __init__(self, contrast_factor: Union[float, torch.Tensor]) -> None:
+ super().__init__()
+ self.contrast_factor: Union[float, torch.Tensor] = contrast_factor
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor:
+ return adjust_contrast(input, self.contrast_factor)
+
+
+class AdjustBrightness(nn.Module):
+ r"""Adjust Brightness of an image.
+
+ This implementation aligns OpenCV, not PIL. Hence, the output differs from TorchVision.
+ The input image is expected to be in the range of [0, 1].
+
+ Args:
+ brightness_factor: Brightness adjust factor per element
+ in the batch. 0 does not modify the input image while any other number modify the
+ brightness.
+
+ Shape:
+ - Input: Image/Input to be adjusted in the shape of :math:`(*, N)`.
+ - Output: Adjusted image in the shape of :math:`(*, N)`.
+
+ Example:
+ >>> x = torch.ones(1, 1, 3, 3)
+ >>> AdjustBrightness(1.)(x)
+ tensor([[[[1., 1., 1.],
+ [1., 1., 1.],
+ [1., 1., 1.]]]])
+
+ >>> x = torch.ones(2, 5, 3, 3)
+ >>> y = torch.ones(2)
+ >>> AdjustBrightness(y)(x).shape
+ torch.Size([2, 5, 3, 3])
+ """
+
+ def __init__(self, brightness_factor: Union[float, torch.Tensor]) -> None:
+ super().__init__()
+ self.brightness_factor: Union[float, torch.Tensor] = brightness_factor
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor:
+ return adjust_brightness(input, self.brightness_factor)
+
+
+class Invert(nn.Module):
+ r"""Invert the values of an input tensor by its maximum value.
+
+ Args:
+ input: The input tensor to invert with an arbitatry shape.
+ max_val: The expected maximum value in the input tensor. The shape has to
+ according to the input tensor shape, or at least has to work with broadcasting. Default: 1.0.
+
+ Example:
+ >>> img = torch.rand(1, 2, 4, 4)
+ >>> Invert()(img).shape
+ torch.Size([1, 2, 4, 4])
+
+ >>> img = 255. * torch.rand(1, 2, 3, 4, 4)
+ >>> Invert(torch.tensor(255.))(img).shape
+ torch.Size([1, 2, 3, 4, 4])
+
+ >>> img = torch.rand(1, 3, 4, 4)
+ >>> Invert(torch.tensor([[[[1.]]]]))(img).shape
+ torch.Size([1, 3, 4, 4])
+ """
+
+ def __init__(self, max_val: torch.Tensor = torch.tensor(1.0)) -> None:
+ super().__init__()
+ if not isinstance(max_val, nn.Parameter):
+ self.register_buffer("max_val", max_val)
+ else:
+ self.max_val = max_val
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor:
+ return invert(input, self.max_val)
diff --git a/kornia/enhance/core.py b/kornia/enhance/core.py
new file mode 100644
index 0000000000000000000000000000000000000000..8400a0b923b52b1a710966a00e1f066564407853
--- /dev/null
+++ b/kornia/enhance/core.py
@@ -0,0 +1,85 @@
+import torch
+import torch.nn as nn
+
+
+def add_weighted(src1: torch.Tensor, alpha: float, src2: torch.Tensor, beta: float, gamma: float) -> torch.Tensor:
+ r"""Calculate the weighted sum of two Tensors.
+
+ .. image:: _static/img/add_weighted.png
+
+ The function calculates the weighted sum of two Tensors as follows:
+
+ .. math::
+ out = src1 * alpha + src2 * beta + gamma
+
+ Args:
+ src1: Tensor of shape :math:`(*, H, W)`.
+ alpha: weight of the src1 elements.
+ src2: Tensor of same size and channel number as src1 :math:`(*, H, W)`.
+ beta: weight of the src2 elements.
+ gamma: scalar added to each sum.
+
+ Returns:
+ Weighted Tensor of shape :math:`(B, C, H, W)`.
+
+ Example:
+ >>> input1 = torch.rand(1, 1, 5, 5)
+ >>> input2 = torch.rand(1, 1, 5, 5)
+ >>> output = add_weighted(input1, 0.5, input2, 0.5, 1.0)
+ >>> output.shape
+ torch.Size([1, 1, 5, 5])
+
+ """
+ if not isinstance(src1, torch.Tensor):
+ raise TypeError(f"src1 should be a tensor. Got {type(src1)}")
+
+ if not isinstance(src2, torch.Tensor):
+ raise TypeError(f"src2 should be a tensor. Got {type(src2)}")
+
+ if not isinstance(alpha, float):
+ raise TypeError(f"alpha should be a float. Got {type(alpha)}")
+
+ if not isinstance(beta, float):
+ raise TypeError(f"beta should be a float. Got {type(beta)}")
+
+ if not isinstance(gamma, float):
+ raise TypeError(f"gamma should be a float. Got {type(gamma)}")
+
+ return src1 * alpha + src2 * beta + gamma
+
+
+class AddWeighted(nn.Module):
+ r"""Calculate the weighted sum of two Tensors.
+
+ The function calculates the weighted sum of two Tensors as follows:
+
+ .. math::
+ out = src1 * alpha + src2 * beta + gamma
+
+ Args:
+ alpha: weight of the src1 elements.
+ beta: weight of the src2 elements.
+ gamma: scalar added to each sum.
+
+ Shape:
+ - Input1: Tensor of shape :math:`(B, C, H, W)`.
+ - Input2: Tensor of shape :math:`(B, C, H, W)`.
+ - Output: Weighted tensor of shape :math:`(B, C, H, W)`.
+
+ Example:
+ >>> input1 = torch.rand(1, 1, 5, 5)
+ >>> input2 = torch.rand(1, 1, 5, 5)
+ >>> output = AddWeighted(0.5, 0.5, 1.0)(input1, input2)
+ >>> output.shape
+ torch.Size([1, 1, 5, 5])
+
+ """
+
+ def __init__(self, alpha: float, beta: float, gamma: float) -> None:
+ super().__init__()
+ self.alpha = alpha
+ self.beta = beta
+ self.gamma = gamma
+
+ def forward(self, src1: torch.Tensor, src2: torch.Tensor) -> torch.Tensor: # type: ignore
+ return add_weighted(src1, self.alpha, src2, self.beta, self.gamma)
diff --git a/kornia/enhance/equalization.py b/kornia/enhance/equalization.py
new file mode 100644
index 0000000000000000000000000000000000000000..5287d8ee632e321dd101818ac702dd5caae559b8
--- /dev/null
+++ b/kornia/enhance/equalization.py
@@ -0,0 +1,382 @@
+"""In this module several equalization methods are exposed: he, ahe, clahe."""
+
+import math
+from typing import Tuple
+
+import torch
+import torch.nn.functional as F
+
+from kornia.utils.helpers import _torch_histc_cast
+from kornia.utils.image import perform_keep_shape_image
+
+from .histogram import histogram
+
+
+def _compute_tiles(
+ imgs: torch.Tensor, grid_size: Tuple[int, int], even_tile_size: bool = False
+) -> Tuple[torch.Tensor, torch.Tensor]:
+ r"""Compute tiles on an image according to a grid size.
+
+ Note that padding can be added to the image in order to crop properly the image.
+ So, the grid_size (GH, GW) x tile_size (TH, TW) >= image_size (H, W)
+
+ Args:
+ imgs: batch of 2D images with shape (B, C, H, W) or (C, H, W).
+ grid_size: number of tiles to be cropped in each direction (GH, GW)
+ even_tile_size: Determine if the width and height of the tiles must be even.
+
+ Returns:
+ tensor with tiles (B, GH, GW, C, TH, TW). B = 1 in case of a single image is provided.
+ tensor with the padded batch of 2D imageswith shape (B, C, H', W').
+
+ """
+ batch: torch.Tensor = imgs # B x C x H x W
+
+ # compute stride and kernel size
+ h, w = batch.shape[-2:]
+ kernel_vert: int = math.ceil(h / grid_size[0])
+ kernel_horz: int = math.ceil(w / grid_size[1])
+
+ if even_tile_size:
+ kernel_vert += 1 if kernel_vert % 2 else 0
+ kernel_horz += 1 if kernel_horz % 2 else 0
+
+ # add padding (with that kernel size we could need some extra cols and rows...)
+ pad_vert = kernel_vert * grid_size[0] - h
+ pad_horz = kernel_horz * grid_size[1] - w
+
+ # add the padding in the last coluns and rows
+ if pad_vert > batch.shape[-2] or pad_horz > batch.shape[-1]:
+ raise ValueError('Cannot compute tiles on the image according to the given grid size')
+
+ if pad_vert > 0 or pad_horz > 0:
+ batch = F.pad(batch, [0, pad_horz, 0, pad_vert], mode='reflect') # B x C x H' x W'
+
+ # compute tiles
+ c: int = batch.shape[-3]
+ tiles: torch.Tensor = (
+ batch.unfold(1, c, c) # unfold(dimension, size, step)
+ .unfold(2, kernel_vert, kernel_vert)
+ .unfold(3, kernel_horz, kernel_horz)
+ .squeeze(1)
+ ).contiguous() # GH x GW x C x TH x TW
+
+ if tiles.shape[-5] != grid_size[0]:
+ raise AssertionError
+
+ if tiles.shape[-4] != grid_size[1]:
+ raise AssertionError
+
+ return tiles, batch
+
+
+def _compute_interpolation_tiles(padded_imgs: torch.Tensor, tile_size: Tuple[int, int]) -> torch.Tensor:
+ r"""Compute interpolation tiles on a properly padded set of images.
+
+ Note that images must be padded. So, the tile_size (TH, TW) * grid_size (GH, GW) = image_size (H, W)
+
+ Args:
+ padded_imgs: batch of 2D images with shape (B, C, H, W) already padded to extract tiles
+ of size (TH, TW).
+ tile_size: shape of the current tiles (TH, TW).
+
+ Returns:
+ tensor with the interpolation tiles (B, 2GH, 2GW, C, TH/2, TW/2).
+
+ """
+ if padded_imgs.dim() != 4:
+ raise AssertionError("Images Tensor must be 4D.")
+
+ if padded_imgs.shape[-2] % tile_size[0] != 0:
+ raise AssertionError("Images are not correctly padded.")
+
+ if padded_imgs.shape[-1] % tile_size[1] != 0:
+ raise AssertionError("Images are not correctly padded.")
+
+ # tiles to be interpolated are built by dividing in 4 each already existing
+ interp_kernel_vert: int = tile_size[0] // 2
+ interp_kernel_horz: int = tile_size[1] // 2
+
+ c: int = padded_imgs.shape[-3]
+ interp_tiles: torch.Tensor = (
+ padded_imgs.unfold(1, c, c)
+ .unfold(2, interp_kernel_vert, interp_kernel_vert)
+ .unfold(3, interp_kernel_horz, interp_kernel_horz)
+ .squeeze(1)
+ ).contiguous() # 2GH x 2GW x C x TH/2 x TW/2
+
+ if interp_tiles.shape[-3] != c:
+ raise AssertionError
+
+ if interp_tiles.shape[-2] != tile_size[0] / 2:
+ raise AssertionError
+
+ if interp_tiles.shape[-1] != tile_size[1] / 2:
+ raise AssertionError
+
+ return interp_tiles
+
+
+def _my_histc(tiles: torch.Tensor, bins: int) -> torch.Tensor:
+ return _torch_histc_cast(tiles, bins=bins, min=0, max=1)
+
+
+def _compute_luts(
+ tiles_x_im: torch.Tensor, num_bins: int = 256, clip: float = 40.0, diff: bool = False
+) -> torch.Tensor:
+ r"""Compute luts for a batched set of tiles.
+
+ Same approach as in OpenCV (https://github.com/opencv/opencv/blob/master/modules/imgproc/src/clahe.cpp)
+
+ Args:
+ tiles_x_im: set of tiles per image to apply the lut. (B, GH, GW, C, TH, TW)
+ num_bins: number of bins. default: 256
+ clip: threshold value for contrast limiting. If it is 0 then the clipping is disabled.
+ diff: denote if the differentiable histagram will be used. Default: False
+
+ Returns:
+ Lut for each tile (B, GH, GW, C, 256).
+
+ """
+ if tiles_x_im.dim() != 6:
+ raise AssertionError("Tensor must be 6D.")
+
+ b, gh, gw, c, th, tw = tiles_x_im.shape
+ pixels: int = th * tw
+ tiles: torch.Tensor = tiles_x_im.view(-1, pixels) # test with view # T x (THxTW)
+ if not diff:
+ if torch.jit.is_scripting():
+ histos = torch.stack([_torch_histc_cast(tile, bins=num_bins, min=0, max=1) for tile in tiles])
+ else:
+ histos = torch.stack(list(map(_my_histc, tiles, [num_bins] * len(tiles))))
+ else:
+ bins: torch.Tensor = torch.linspace(0, 1, num_bins, device=tiles.device)
+ histos = histogram(tiles, bins, torch.tensor(0.001)).squeeze()
+ histos *= pixels
+
+ if clip > 0.0:
+ max_val: float = max(clip * pixels // num_bins, 1)
+ histos.clamp_(max=max_val)
+ clipped: torch.Tensor = pixels - histos.sum(1)
+ residual: torch.Tensor = torch.remainder(clipped, num_bins)
+ redist: torch.Tensor = (clipped - residual).div(num_bins)
+ histos += redist[None].transpose(0, 1)
+ # trick to avoid using a loop to assign the residual
+ v_range: torch.Tensor = torch.arange(num_bins, device=histos.device)
+ mat_range: torch.Tensor = v_range.repeat(histos.shape[0], 1)
+ histos += mat_range < residual[None].transpose(0, 1)
+
+ lut_scale: float = (num_bins - 1) / pixels
+ luts: torch.Tensor = torch.cumsum(histos, 1) * lut_scale
+ luts = luts.clamp(0, num_bins - 1)
+ if not diff:
+ luts = luts.floor() # to get the same values as converting to int maintaining the type
+ luts = luts.view((b, gh, gw, c, num_bins))
+ return luts
+
+
+def _map_luts(interp_tiles: torch.Tensor, luts: torch.Tensor) -> torch.Tensor:
+ r"""Assign the required luts to each tile.
+
+ Args:
+ interp_tiles: set of interpolation tiles. (B, 2GH, 2GW, C, TH/2, TW/2)
+ luts: luts for each one of the original tiles. (B, GH, GW, C, 256)
+
+ Returns:
+ mapped luts (B, 2GH, 2GW, 4, C, 256)
+
+ """
+ if interp_tiles.dim() != 6:
+ raise AssertionError("interp_tiles tensor must be 6D.")
+
+ if luts.dim() != 5:
+ raise AssertionError("luts tensor must be 5D.")
+
+ # gh, gw -> 2x the number of tiles used to compute the histograms
+ # th, tw -> /2 the sizes of the tiles used to compute the histograms
+ num_imgs, gh, gw, c, _, _ = interp_tiles.shape
+
+ # precompute idxs for non corner regions (doing it in cpu seems slightly faster)
+ j_idxs = torch.empty(0, 4, dtype=torch.long)
+ if gh > 2:
+ j_floor = torch.arange(1, gh - 1).view(gh - 2, 1).div(2, rounding_mode="trunc")
+ j_idxs = torch.tensor([[0, 0, 1, 1], [-1, -1, 0, 0]] * ((gh - 2) // 2)) # reminder + j_idxs[:, 0:2] -= 1
+ j_idxs += j_floor
+
+ i_idxs = torch.empty(0, 4, dtype=torch.long)
+ if gw > 2:
+ i_floor = torch.arange(1, gw - 1).view(gw - 2, 1).div(2, rounding_mode="trunc")
+ i_idxs = torch.tensor([[0, 1, 0, 1], [-1, 0, -1, 0]] * ((gw - 2) // 2)) # reminder + i_idxs[:, [0, 2]] -= 1
+ i_idxs += i_floor
+
+ # selection of luts to interpolate each patch
+ # create a tensor with dims: interp_patches height and width x 4 x num channels x bins in the histograms
+ # the tensor is init to -1 to denote non init hists
+ luts_x_interp_tiles: torch.Tensor = torch.full( # B x GH x GW x 4 x C x 256
+ (num_imgs, gh, gw, 4, c, luts.shape[-1]), -1, dtype=interp_tiles.dtype, device=interp_tiles.device
+ )
+ # corner regions
+ luts_x_interp_tiles[:, 0:: gh - 1, 0:: gw - 1, 0] = luts[:, 0:: max(gh // 2 - 1, 1), 0:: max(gw // 2 - 1, 1)]
+ # border region (h)
+ luts_x_interp_tiles[:, 1:-1, 0:: gw - 1, 0] = luts[:, j_idxs[:, 0], 0:: max(gw // 2 - 1, 1)]
+ luts_x_interp_tiles[:, 1:-1, 0:: gw - 1, 1] = luts[:, j_idxs[:, 2], 0:: max(gw // 2 - 1, 1)]
+ # border region (w)
+ luts_x_interp_tiles[:, 0:: gh - 1, 1:-1, 0] = luts[:, 0:: max(gh // 2 - 1, 1), i_idxs[:, 0]]
+ luts_x_interp_tiles[:, 0:: gh - 1, 1:-1, 1] = luts[:, 0:: max(gh // 2 - 1, 1), i_idxs[:, 1]]
+ # internal region
+ luts_x_interp_tiles[:, 1:-1, 1:-1, :] = luts[
+ :, j_idxs.repeat(max(gh - 2, 1), 1, 1).permute(1, 0, 2), i_idxs.repeat(max(gw - 2, 1), 1, 1)
+ ]
+
+ return luts_x_interp_tiles
+
+
+def _compute_equalized_tiles(interp_tiles: torch.Tensor, luts: torch.Tensor) -> torch.Tensor:
+ r"""Equalize the tiles.
+
+ Args:
+ interp_tiles: set of interpolation tiles, values must be in the range [0, 1].
+ (B, 2GH, 2GW, C, TH/2, TW/2)
+ luts: luts for each one of the original tiles. (B, GH, GW, C, 256)
+
+ Returns:
+ equalized tiles (B, 2GH, 2GW, C, TH/2, TW/2)
+
+ """
+ if interp_tiles.dim() != 6:
+ raise AssertionError("interp_tiles tensor must be 6D.")
+
+ if luts.dim() != 5:
+ raise AssertionError("luts tensor must be 5D.")
+
+ mapped_luts: torch.Tensor = _map_luts(interp_tiles, luts) # Bx2GHx2GWx4xCx256
+
+ # gh, gw -> 2x the number of tiles used to compute the histograms
+ # th, tw -> /2 the sizes of the tiles used to compute the histograms
+ num_imgs, gh, gw, c, th, tw = interp_tiles.shape
+
+ # equalize tiles
+ flatten_interp_tiles: torch.Tensor = (interp_tiles * 255).long().flatten(-2, -1) # B x GH x GW x 4 x C x (THxTW)
+ flatten_interp_tiles = flatten_interp_tiles.unsqueeze(-3).expand(num_imgs, gh, gw, 4, c, th * tw)
+ preinterp_tiles_equalized = (
+ torch.gather(mapped_luts, 5, flatten_interp_tiles) # B x GH x GW x 4 x C x TH x TW
+ .to(interp_tiles)
+ .reshape(num_imgs, gh, gw, 4, c, th, tw)
+ )
+
+ # interp tiles
+ tiles_equalized: torch.Tensor = torch.zeros_like(interp_tiles)
+
+ # compute the interpolation weights (shapes are 2 x TH x TW because they must be applied to 2 interp tiles)
+ ih = (
+ torch.arange(2 * th - 1, -1, -1, dtype=interp_tiles.dtype, device=interp_tiles.device)
+ .div(2.0 * th - 1)[None]
+ .transpose(-2, -1)
+ .expand(2 * th, tw)
+ )
+ ih = ih.unfold(0, th, th).unfold(1, tw, tw) # 2 x 1 x TH x TW
+ iw = (
+ torch.arange(2 * tw - 1, -1, -1, dtype=interp_tiles.dtype, device=interp_tiles.device)
+ .div(2.0 * tw - 1)
+ .expand(th, 2 * tw)
+ )
+ iw = iw.unfold(0, th, th).unfold(1, tw, tw) # 1 x 2 x TH x TW
+
+ # compute row and column interpolation weights
+ tiw = iw.expand((gw - 2) // 2, 2, th, tw).reshape(gw - 2, 1, th, tw).unsqueeze(0) # 1 x GW-2 x 1 x TH x TW
+ tih = ih.repeat((gh - 2) // 2, 1, 1, 1).unsqueeze(1) # GH-2 x 1 x 1 x TH x TW
+
+ # internal regions
+ tl, tr, bl, br = preinterp_tiles_equalized[:, 1:-1, 1:-1].unbind(3)
+ t = torch.addcmul(tr, tiw, torch.sub(tl, tr))
+ b = torch.addcmul(br, tiw, torch.sub(bl, br))
+ tiles_equalized[:, 1:-1, 1:-1] = torch.addcmul(b, tih, torch.sub(t, b))
+
+ # corner regions
+ tiles_equalized[:, 0:: gh - 1, 0:: gw - 1] = preinterp_tiles_equalized[:, 0:: gh - 1, 0:: gw - 1, 0]
+
+ # border region (h)
+ t, b, _, _ = preinterp_tiles_equalized[:, 1:-1, 0].unbind(2)
+ tiles_equalized[:, 1:-1, 0] = torch.addcmul(b, tih.squeeze(1), torch.sub(t, b))
+ t, b, _, _ = preinterp_tiles_equalized[:, 1:-1, gh - 1].unbind(2)
+ tiles_equalized[:, 1:-1, gh - 1] = torch.addcmul(b, tih.squeeze(1), torch.sub(t, b))
+
+ # border region (w)
+ l, r, _, _ = preinterp_tiles_equalized[:, 0, 1:-1].unbind(2)
+ tiles_equalized[:, 0, 1:-1] = torch.addcmul(r, tiw, torch.sub(l, r))
+ l, r, _, _ = preinterp_tiles_equalized[:, gw - 1, 1:-1].unbind(2)
+ tiles_equalized[:, gw - 1, 1:-1] = torch.addcmul(r, tiw, torch.sub(l, r))
+
+ # same type as the input
+ return tiles_equalized.div(255.0)
+
+
+@perform_keep_shape_image
+def equalize_clahe(input: torch.Tensor,
+ clip_limit: float = 40.0,
+ grid_size: Tuple[int, int] = (8, 8),
+ slow_and_differentiable: bool = False) -> torch.Tensor:
+ r"""Apply clahe equalization on the input tensor.
+
+ .. image:: _static/img/equalize_clahe.png
+
+ NOTE: Lut computation uses the same approach as in OpenCV, in next versions this can change.
+
+ Args:
+ input: images tensor to equalize with values in the range [0, 1] and shape :math:`(*, C, H, W)`.
+ clip_limit: threshold value for contrast limiting. If 0 clipping is disabled.
+ grid_size: number of tiles to be cropped in each direction (GH, GW).
+ slow_and_differentiable: flag to select implementation
+
+ Returns:
+ Equalized image or images with shape as the input.
+
+ Examples:
+ >>> img = torch.rand(1, 10, 20)
+ >>> res = equalize_clahe(img)
+ >>> res.shape
+ torch.Size([1, 10, 20])
+
+ >>> img = torch.rand(2, 3, 10, 20)
+ >>> res = equalize_clahe(img)
+ >>> res.shape
+ torch.Size([2, 3, 10, 20])
+
+ """
+ if not isinstance(clip_limit, float):
+ raise TypeError(f"Input clip_limit type is not float. Got {type(clip_limit)}")
+
+ if not isinstance(grid_size, tuple):
+ raise TypeError(f"Input grid_size type is not Tuple. Got {type(grid_size)}")
+
+ if len(grid_size) != 2:
+ raise TypeError(f"Input grid_size is not a Tuple with 2 elements. Got {len(grid_size)}")
+
+ if isinstance(grid_size[0], float) or isinstance(grid_size[1], float):
+ raise TypeError("Input grid_size type is not valid, must be a Tuple[int, int].")
+
+ if grid_size[0] <= 0 or grid_size[1] <= 0:
+ raise ValueError("Input grid_size elements must be positive. Got {grid_size}")
+
+ imgs: torch.Tensor = input # B x C x H x W
+
+ # hist_tiles: torch.Tensor # B x GH x GW x C x TH x TW # not supported by JIT
+ # img_padded: torch.Tensor # B x C x H' x W' # not supported by JIT
+ # the size of the tiles must be even in order to divide them into 4 tiles for the interpolation
+ hist_tiles, img_padded = _compute_tiles(imgs, grid_size, True)
+ tile_size: Tuple[int, int] = (hist_tiles.shape[-2], hist_tiles.shape[-1])
+ interp_tiles: torch.Tensor = _compute_interpolation_tiles(img_padded, tile_size) # B x 2GH x 2GW x C x TH/2 x TW/2
+ luts: torch.Tensor = _compute_luts(hist_tiles, clip=clip_limit, diff=slow_and_differentiable) # B x GH x GW x C x B
+ equalized_tiles: torch.Tensor = _compute_equalized_tiles(interp_tiles, luts) # B x 2GH x 2GW x C x TH/2 x TW/2
+
+ # reconstruct the images form the tiles
+ # try permute + contiguous + view
+ eq_imgs: torch.Tensor = equalized_tiles.permute(0, 3, 1, 4, 2, 5).reshape_as(img_padded)
+ h, w = imgs.shape[-2:]
+ eq_imgs = eq_imgs[..., :h, :w] # crop imgs if they were padded
+
+ # remove batch if the input was not in batch form
+ if input.dim() != eq_imgs.dim():
+ eq_imgs = eq_imgs.squeeze(0)
+
+ return eq_imgs
diff --git a/kornia/enhance/histogram.py b/kornia/enhance/histogram.py
new file mode 100644
index 0000000000000000000000000000000000000000..4088b37e5c31ecde840eb6a188405da36f4e04e5
--- /dev/null
+++ b/kornia/enhance/histogram.py
@@ -0,0 +1,251 @@
+from typing import Optional, Tuple
+
+import torch
+
+
+def marginal_pdf(
+ values: torch.Tensor, bins: torch.Tensor, sigma: torch.Tensor, epsilon: float = 1e-10
+) -> Tuple[torch.Tensor, torch.Tensor]:
+ """Calculate the marginal probability distribution function of the input tensor based on the number of
+ histogram bins.
+
+ Args:
+ values: shape [BxNx1].
+ bins: shape [NUM_BINS].
+ sigma: shape [1], gaussian smoothing factor.
+ epsilon: scalar, for numerical stability.
+
+ Returns:
+ Tuple[torch.Tensor, torch.Tensor]:
+ - torch.Tensor: shape [BxN].
+ - torch.Tensor: shape [BxNxNUM_BINS].
+ """
+
+ if not isinstance(values, torch.Tensor):
+ raise TypeError(f"Input values type is not a torch.Tensor. Got {type(values)}")
+
+ if not isinstance(bins, torch.Tensor):
+ raise TypeError(f"Input bins type is not a torch.Tensor. Got {type(bins)}")
+
+ if not isinstance(sigma, torch.Tensor):
+ raise TypeError(f"Input sigma type is not a torch.Tensor. Got {type(sigma)}")
+
+ if not values.dim() == 3:
+ raise ValueError("Input values must be a of the shape BxNx1." " Got {}".format(values.shape))
+
+ if not bins.dim() == 1:
+ raise ValueError("Input bins must be a of the shape NUM_BINS" " Got {}".format(bins.shape))
+
+ if not sigma.dim() == 0:
+ raise ValueError("Input sigma must be a of the shape 1" " Got {}".format(sigma.shape))
+
+ residuals = values - bins.unsqueeze(0).unsqueeze(0)
+ kernel_values = torch.exp(-0.5 * (residuals / sigma).pow(2))
+
+ pdf = torch.mean(kernel_values, dim=1)
+ normalization = torch.sum(pdf, dim=1).unsqueeze(1) + epsilon
+ pdf = pdf / normalization
+
+ return pdf, kernel_values
+
+
+def joint_pdf(kernel_values1: torch.Tensor, kernel_values2: torch.Tensor, epsilon: float = 1e-10) -> torch.Tensor:
+ """Calculate the joint probability distribution function of the input tensors based on the number of histogram
+ bins.
+
+ Args:
+ kernel_values1: shape [BxNxNUM_BINS].
+ kernel_values2: shape [BxNxNUM_BINS].
+ epsilon: scalar, for numerical stability.
+
+ Returns:
+ shape [BxNUM_BINSxNUM_BINS].
+ """
+
+ if not isinstance(kernel_values1, torch.Tensor):
+ raise TypeError(f"Input kernel_values1 type is not a torch.Tensor. Got {type(kernel_values1)}")
+
+ if not isinstance(kernel_values2, torch.Tensor):
+ raise TypeError(f"Input kernel_values2 type is not a torch.Tensor. Got {type(kernel_values2)}")
+
+ if not kernel_values1.dim() == 3:
+ raise ValueError("Input kernel_values1 must be a of the shape BxN." " Got {}".format(kernel_values1.shape))
+
+ if not kernel_values2.dim() == 3:
+ raise ValueError("Input kernel_values2 must be a of the shape BxN." " Got {}".format(kernel_values2.shape))
+
+ if kernel_values1.shape != kernel_values2.shape:
+ raise ValueError(
+ "Inputs kernel_values1 and kernel_values2 must have the same shape."
+ " Got {} and {}".format(kernel_values1.shape, kernel_values2.shape)
+ )
+
+ joint_kernel_values = torch.matmul(kernel_values1.transpose(1, 2), kernel_values2)
+ normalization = torch.sum(joint_kernel_values, dim=(1, 2)).view(-1, 1, 1) + epsilon
+ pdf = joint_kernel_values / normalization
+
+ return pdf
+
+
+def histogram(x: torch.Tensor, bins: torch.Tensor, bandwidth: torch.Tensor, epsilon: float = 1e-10) -> torch.Tensor:
+ """Estimate the histogram of the input tensor.
+
+ The calculation uses kernel density estimation which requires a bandwidth (smoothing) parameter.
+
+ Args:
+ x: Input tensor to compute the histogram with shape :math:`(B, D)`.
+ bins: The number of bins to use the histogram :math:`(N_{bins})`.
+ bandwidth: Gaussian smoothing factor with shape shape [1].
+ epsilon: A scalar, for numerical stability.
+
+ Returns:
+ Computed histogram of shape :math:`(B, N_{bins})`.
+
+ Examples:
+ >>> x = torch.rand(1, 10)
+ >>> bins = torch.torch.linspace(0, 255, 128)
+ >>> hist = histogram(x, bins, bandwidth=torch.tensor(0.9))
+ >>> hist.shape
+ torch.Size([1, 128])
+ """
+
+ pdf, _ = marginal_pdf(x.unsqueeze(2), bins, bandwidth, epsilon)
+
+ return pdf
+
+
+def histogram2d(
+ x1: torch.Tensor, x2: torch.Tensor, bins: torch.Tensor, bandwidth: torch.Tensor, epsilon: float = 1e-10
+) -> torch.Tensor:
+ """Estimate the 2d histogram of the input tensor.
+
+ The calculation uses kernel density estimation which requires a bandwidth (smoothing) parameter.
+
+ Args:
+ x1: Input tensor to compute the histogram with shape :math:`(B, D1)`.
+ x2: Input tensor to compute the histogram with shape :math:`(B, D2)`.
+ bins: The number of bins to use the histogram :math:`(N_{bins})`.
+ bandwidth: Gaussian smoothing factor with shape shape [1].
+ epsilon: A scalar, for numerical stability. Default: 1e-10.
+
+ Returns:
+ Computed histogram of shape :math:`(B, N_{bins}), N_{bins})`.
+
+ Examples:
+ >>> x1 = torch.rand(2, 32)
+ >>> x2 = torch.rand(2, 32)
+ >>> bins = torch.torch.linspace(0, 255, 128)
+ >>> hist = histogram2d(x1, x2, bins, bandwidth=torch.tensor(0.9))
+ >>> hist.shape
+ torch.Size([2, 128, 128])
+ """
+
+ _, kernel_values1 = marginal_pdf(x1.unsqueeze(2), bins, bandwidth, epsilon)
+ _, kernel_values2 = marginal_pdf(x2.unsqueeze(2), bins, bandwidth, epsilon)
+
+ pdf = joint_pdf(kernel_values1, kernel_values2)
+
+ return pdf
+
+
+def image_histogram2d(
+ image: torch.Tensor,
+ min: float = 0.0,
+ max: float = 255.0,
+ n_bins: int = 256,
+ bandwidth: Optional[float] = None,
+ centers: Optional[torch.Tensor] = None,
+ return_pdf: bool = False,
+ kernel: str = "triangular",
+ eps: float = 1e-10,
+) -> Tuple[torch.Tensor, torch.Tensor]:
+ """Estimate the histogram of the input image(s).
+
+ The calculation uses triangular kernel density estimation.
+
+ Args:
+ image: Input tensor to compute the histogram with shape
+ :math:`(H, W)`, :math:`(C, H, W)` or :math:`(B, C, H, W)`.
+ min: Lower end of the interval (inclusive).
+ max: Upper end of the interval (inclusive). Ignored when
+ :attr:`centers` is specified.
+ n_bins: The number of histogram bins. Ignored when
+ :attr:`centers` is specified.
+ bandwidth: Smoothing factor. If not specified or equal to -1,
+ :math:`(bandwidth = (max - min) / n_bins)`.
+ centers: Centers of the bins with shape :math:`(n_bins,)`.
+ If not specified or empty, it is calculated as centers of
+ equal width bins of [min, max] range.
+ return_pdf: If True, also return probability densities for
+ each bin.
+ kernel: kernel to perform kernel density estimation
+ ``(`triangular`, `gaussian`, `uniform`, `epanechnikov`)``.
+
+ Returns:
+ Computed histogram of shape :math:`(bins)`, :math:`(C, bins)`,
+ :math:`(B, C, bins)`.
+ Computed probability densities of shape :math:`(bins)`, :math:`(C, bins)`,
+ :math:`(B, C, bins)`, if return_pdf is ``True``. Tensor of zeros with shape
+ of the histogram otherwise.
+ """
+ if image is not None and not isinstance(image, torch.Tensor):
+ raise TypeError(f"Input image type is not a torch.Tensor. Got {type(image)}.")
+
+ if centers is not None and not isinstance(centers, torch.Tensor):
+ raise TypeError(f"Bins' centers type is not a torch.Tensor. Got {type(centers)}.")
+
+ if centers is not None and len(centers.shape) > 0 and centers.dim() != 1:
+ raise ValueError(f"Bins' centers must be a torch.Tensor of the shape (n_bins,). Got {centers.shape}.")
+
+ if not isinstance(min, float):
+ raise TypeError(f'Type of lower end of the range is not a float. Got {type(min)}.')
+
+ if not isinstance(max, float):
+ raise TypeError(f"Type of upper end of the range is not a float. Got {type(min)}.")
+
+ if not isinstance(n_bins, int):
+ raise TypeError(f"Type of number of bins is not an int. Got {type(n_bins)}.")
+
+ if bandwidth is not None and not isinstance(bandwidth, float):
+ raise TypeError(f"Bandwidth type is not a float. Got {type(bandwidth)}.")
+
+ if not isinstance(return_pdf, bool):
+ raise TypeError(f"Return_pdf type is not a bool. Got {type(return_pdf)}.")
+
+ if bandwidth is None:
+ bandwidth = (max - min) / n_bins
+ if centers is None:
+ centers = min + bandwidth * (torch.arange(n_bins, device=image.device, dtype=image.dtype).float() + 0.5)
+ centers = centers.reshape(-1, 1, 1, 1, 1)
+ u = torch.abs(image.unsqueeze(0) - centers) / bandwidth
+ if kernel == "triangular":
+ mask = (u <= 1).to(u.dtype)
+ kernel_values = (1 - u) * mask
+ elif kernel == "gaussian":
+ kernel_values = torch.exp(-0.5 * u ** 2)
+ elif kernel == "uniform":
+ mask = (u <= 1).to(u.dtype)
+ kernel_values = torch.ones_like(u, dtype=u.dtype, device=u.device) * mask
+ elif kernel == "epanechnikov":
+ mask = (u <= 1).to(u.dtype)
+ kernel_values = (1 - u ** 2) * mask
+ else:
+ raise ValueError(f"Kernel must be 'triangular', 'gaussian', " f"'uniform' or 'epanechnikov'. Got {kernel}.")
+
+ hist = torch.sum(kernel_values, dim=(-2, -1)).permute(1, 2, 0)
+ if return_pdf:
+ normalization = torch.sum(hist, dim=-1, keepdim=True) + eps
+ pdf = hist / normalization
+ if image.dim() == 2:
+ hist = hist.squeeze()
+ pdf = pdf.squeeze()
+ elif image.dim() == 3:
+ hist = hist.squeeze(0)
+ pdf = pdf.squeeze(0)
+ return hist, pdf
+
+ if image.dim() == 2:
+ hist = hist.squeeze()
+ elif image.dim() == 3:
+ hist = hist.squeeze(0)
+ return hist, torch.zeros_like(hist, dtype=hist.dtype, device=hist.device)
diff --git a/kornia/enhance/normalize.py b/kornia/enhance/normalize.py
new file mode 100644
index 0000000000000000000000000000000000000000..7711d89f56cb6df24bc8a1d34eb9265bcedf1a16
--- /dev/null
+++ b/kornia/enhance/normalize.py
@@ -0,0 +1,289 @@
+"""Module containing functionals for intensity normalisation."""
+
+from typing import List, Tuple, Union
+
+import torch
+import torch.nn as nn
+
+__all__ = ["normalize", "normalize_min_max", "denormalize", "Normalize", "Denormalize"]
+
+
+class Normalize(nn.Module):
+ r"""Normalize a tensor image with mean and standard deviation.
+
+ .. math::
+ \text{input[channel] = (input[channel] - mean[channel]) / std[channel]}
+
+ Where `mean` is :math:`(M_1, ..., M_n)` and `std` :math:`(S_1, ..., S_n)` for `n` channels,
+
+ Args:
+ mean: Mean for each channel.
+ std: Standard deviations for each channel.
+
+ Shape:
+ - Input: Image tensor of size :math:`(*, C, ...)`.
+ - Output: Normalised tensor with same size as input :math:`(*, C, ...)`.
+
+ Examples:
+ >>> x = torch.rand(1, 4, 3, 3)
+ >>> out = Normalize(0.0, 255.)(x)
+ >>> out.shape
+ torch.Size([1, 4, 3, 3])
+
+ >>> x = torch.rand(1, 4, 3, 3)
+ >>> mean = torch.zeros(4)
+ >>> std = 255. * torch.ones(4)
+ >>> out = Normalize(mean, std)(x)
+ >>> out.shape
+ torch.Size([1, 4, 3, 3])
+ """
+
+ def __init__(
+ self,
+ mean: Union[torch.Tensor, Tuple[float], List[float], float],
+ std: Union[torch.Tensor, Tuple[float], List[float], float],
+ ) -> None:
+ super().__init__()
+
+ if isinstance(mean, float):
+ mean = torch.tensor([mean])
+
+ if isinstance(std, float):
+ std = torch.tensor([std])
+
+ if isinstance(mean, (tuple, list)):
+ mean = torch.tensor(mean)
+
+ if isinstance(std, (tuple, list)):
+ std = torch.tensor(std)
+
+ self.mean = mean
+ self.std = std
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor:
+ return normalize(input, self.mean, self.std)
+
+ def __repr__(self):
+ repr = f"(mean={self.mean}, std={self.std})"
+ return self.__class__.__name__ + repr
+
+
+def normalize(data: torch.Tensor, mean: torch.Tensor, std: torch.Tensor) -> torch.Tensor:
+ r"""Normalize an image/video tensor with mean and standard deviation.
+
+ .. math::
+ \text{input[channel] = (input[channel] - mean[channel]) / std[channel]}
+
+ Where `mean` is :math:`(M_1, ..., M_n)` and `std` :math:`(S_1, ..., S_n)` for `n` channels,
+
+ Args:
+ data: Image tensor of size :math:`(B, C, *)`.
+ mean: Mean for each channel.
+ std: Standard deviations for each channel.
+
+ Return:
+ Normalised tensor with same size as input :math:`(B, C, *)`.
+
+ Examples:
+ >>> x = torch.rand(1, 4, 3, 3)
+ >>> out = normalize(x, torch.tensor([0.0]), torch.tensor([255.]))
+ >>> out.shape
+ torch.Size([1, 4, 3, 3])
+
+ >>> x = torch.rand(1, 4, 3, 3)
+ >>> mean = torch.zeros(4)
+ >>> std = 255. * torch.ones(4)
+ >>> out = normalize(x, mean, std)
+ >>> out.shape
+ torch.Size([1, 4, 3, 3])
+ """
+ shape = data.shape
+ if len(mean.shape) == 0 or mean.shape[0] == 1:
+ mean = mean.expand(shape[1])
+ if len(std.shape) == 0 or std.shape[0] == 1:
+ std = std.expand(shape[1])
+
+ # Allow broadcast on channel dimension
+ if mean.shape and mean.shape[0] != 1:
+ if mean.shape[0] != data.shape[1] and mean.shape[:2] != data.shape[:2]:
+ raise ValueError(f"mean length and number of channels do not match. Got {mean.shape} and {data.shape}.")
+
+ # Allow broadcast on channel dimension
+ if std.shape and std.shape[0] != 1:
+ if std.shape[0] != data.shape[1] and std.shape[:2] != data.shape[:2]:
+ raise ValueError(f"std length and number of channels do not match. Got {std.shape} and {data.shape}.")
+
+ mean = torch.as_tensor(mean, device=data.device, dtype=data.dtype)
+ std = torch.as_tensor(std, device=data.device, dtype=data.dtype)
+
+ if mean.shape:
+ mean = mean[..., :, None]
+ if std.shape:
+ std = std[..., :, None]
+
+ out: torch.Tensor = (data.view(shape[0], shape[1], -1) - mean) / std
+
+ return out.view(shape)
+
+
+class Denormalize(nn.Module):
+ r"""Denormalize a tensor image with mean and standard deviation.
+
+ .. math::
+ \text{input[channel] = (input[channel] * std[channel]) + mean[channel]}
+
+ Where `mean` is :math:`(M_1, ..., M_n)` and `std` :math:`(S_1, ..., S_n)` for `n` channels,
+
+ Args:
+ mean: Mean for each channel.
+ std: Standard deviations for each channel.
+
+ Shape:
+ - Input: Image tensor of size :math:`(*, C, ...)`.
+ - Output: Denormalised tensor with same size as input :math:`(*, C, ...)`.
+
+ Examples:
+ >>> x = torch.rand(1, 4, 3, 3)
+ >>> out = Denormalize(0.0, 255.)(x)
+ >>> out.shape
+ torch.Size([1, 4, 3, 3])
+
+ >>> x = torch.rand(1, 4, 3, 3, 3)
+ >>> mean = torch.zeros(1, 4)
+ >>> std = 255. * torch.ones(1, 4)
+ >>> out = Denormalize(mean, std)(x)
+ >>> out.shape
+ torch.Size([1, 4, 3, 3, 3])
+ """
+
+ def __init__(self, mean: Union[torch.Tensor, float], std: Union[torch.Tensor, float]) -> None:
+
+ super().__init__()
+
+ self.mean = mean
+ self.std = std
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor:
+ return denormalize(input, self.mean, self.std)
+
+ def __repr__(self):
+ repr = f"(mean={self.mean}, std={self.std})"
+ return self.__class__.__name__ + repr
+
+
+def denormalize(data: torch.Tensor, mean: Union[torch.Tensor, float], std: Union[torch.Tensor, float]) -> torch.Tensor:
+ r"""Denormalize an image/video tensor with mean and standard deviation.
+
+ .. math::
+ \text{input[channel] = (input[channel] * std[channel]) + mean[channel]}
+
+ Where `mean` is :math:`(M_1, ..., M_n)` and `std` :math:`(S_1, ..., S_n)` for `n` channels,
+
+ Args:
+ input: Image tensor of size :math:`(B, C, *)`.
+ mean: Mean for each channel.
+ std: Standard deviations for each channel.
+
+ Return:
+ Denormalised tensor with same size as input :math:`(B, C, *)`.
+
+ Examples:
+ >>> x = torch.rand(1, 4, 3, 3)
+ >>> out = denormalize(x, 0.0, 255.)
+ >>> out.shape
+ torch.Size([1, 4, 3, 3])
+
+ >>> x = torch.rand(1, 4, 3, 3, 3)
+ >>> mean = torch.zeros(1, 4)
+ >>> std = 255. * torch.ones(1, 4)
+ >>> out = denormalize(x, mean, std)
+ >>> out.shape
+ torch.Size([1, 4, 3, 3, 3])
+ """
+ shape = data.shape
+
+ if isinstance(mean, float):
+ mean = torch.tensor([mean] * shape[1], device=data.device, dtype=data.dtype)
+
+ if isinstance(std, float):
+ std = torch.tensor([std] * shape[1], device=data.device, dtype=data.dtype)
+
+ if not isinstance(data, torch.Tensor):
+ raise TypeError(f"data should be a tensor. Got {type(data)}")
+
+ if not isinstance(mean, torch.Tensor):
+ raise TypeError(f"mean should be a tensor or a float. Got {type(mean)}")
+
+ if not isinstance(std, torch.Tensor):
+ raise TypeError(f"std should be a tensor or float. Got {type(std)}")
+
+ # Allow broadcast on channel dimension
+ if mean.shape and mean.shape[0] != 1:
+ if mean.shape[0] != data.shape[-3] and mean.shape[:2] != data.shape[:2]:
+ raise ValueError(f"mean length and number of channels do not match. Got {mean.shape} and {data.shape}.")
+
+ # Allow broadcast on channel dimension
+ if std.shape and std.shape[0] != 1:
+ if std.shape[0] != data.shape[-3] and std.shape[:2] != data.shape[:2]:
+ raise ValueError(f"std length and number of channels do not match. Got {std.shape} and {data.shape}.")
+
+ mean = torch.as_tensor(mean, device=data.device, dtype=data.dtype)
+ std = torch.as_tensor(std, device=data.device, dtype=data.dtype)
+
+ if mean.shape:
+ mean = mean[..., :, None]
+ if std.shape:
+ std = std[..., :, None]
+
+ out: torch.Tensor = (data.view(shape[0], shape[1], -1) * std) + mean
+
+ return out.view(shape)
+
+
+def normalize_min_max(x: torch.Tensor, min_val: float = 0.0, max_val: float = 1.0, eps: float = 1e-6) -> torch.Tensor:
+ r"""Normalise an image/video tensor by MinMax and re-scales the value between a range.
+
+ The data is normalised using the following formulation:
+
+ .. math::
+ y_i = (b - a) * \frac{x_i - \text{min}(x)}{\text{max}(x) - \text{min}(x)} + a
+
+ where :math:`a` is :math:`\text{min_val}` and :math:`b` is :math:`\text{max_val}`.
+
+ Args:
+ x: The image tensor to be normalised with shape :math:`(B, C, *)`.
+ min_val: The minimum value for the new range.
+ max_val: The maximum value for the new range.
+ eps: Float number to avoid zero division.
+
+ Returns:
+ The normalised image tensor with same shape as input :math:`(B, C, *)`.
+
+ Example:
+ >>> x = torch.rand(1, 5, 3, 3)
+ >>> x_norm = normalize_min_max(x, min_val=-1., max_val=1.)
+ >>> x_norm.min()
+ tensor(-1.)
+ >>> x_norm.max()
+ tensor(1.0000)
+ """
+ if not isinstance(x, torch.Tensor):
+ raise TypeError(f"data should be a tensor. Got: {type(x)}.")
+
+ if not isinstance(min_val, float):
+ raise TypeError(f"'min_val' should be a float. Got: {type(min_val)}.")
+
+ if not isinstance(max_val, float):
+ raise TypeError(f"'b' should be a float. Got: {type(max_val)}.")
+
+ if len(x.shape) < 3:
+ raise ValueError(f"Input shape must be at least a 3d tensor. Got: {x.shape}.")
+
+ shape = x.shape
+ B, C = shape[0], shape[1]
+
+ x_min: torch.Tensor = x.view(B, C, -1).min(-1)[0].view(B, C, 1)
+ x_max: torch.Tensor = x.view(B, C, -1).max(-1)[0].view(B, C, 1)
+
+ x_out: torch.Tensor = (max_val - min_val) * (x.view(B, C, -1) - x_min) / (x_max - x_min + eps) + min_val
+ return x_out.view(shape)
diff --git a/kornia/enhance/zca.py b/kornia/enhance/zca.py
new file mode 100644
index 0000000000000000000000000000000000000000..1a425278ac72b47d6e46ca28040633ae5f131fc4
--- /dev/null
+++ b/kornia/enhance/zca.py
@@ -0,0 +1,384 @@
+from typing import List, Optional, Tuple
+
+import torch
+import torch.nn as nn
+
+from kornia.utils.helpers import _torch_svd_cast
+
+__all__ = ["zca_mean", "zca_whiten", "linear_transform", "ZCAWhitening"]
+
+
+class ZCAWhitening(nn.Module):
+ r"""Compute the ZCA whitening matrix transform and the mean vector and applies the transform to the data.
+
+ The data tensor is flattened, and the mean :math:`\mathbf{\mu}`
+ and covariance matrix :math:`\mathbf{\Sigma}` are computed from
+ the flattened data :math:`\mathbf{X} \in \mathbb{R}^{N \times D}`, where
+ :math:`N` is the sample size and :math:`D` is flattened dimensionality
+ (e.g. for a tensor with size 5x3x2x2 :math:`N = 5` and :math:`D = 12`). The ZCA whitening
+ transform is given by:
+
+ .. math::
+
+ \mathbf{X}_{\text{zca}} = (\mathbf{X - \mu})(US^{-\frac{1}{2}}U^T)^T
+
+ where :math:`U` are the eigenvectors of :math:`\Sigma` and :math:`S` contain the corresponding
+ eigenvalues of :math:`\Sigma`. After the transform is applied, the output is reshaped to same shape.
+
+ args:
+
+ dim: Determines the dimension that represents the samples axis.
+ eps: a small number used for numerical stability.
+ unbiased: Whether to use the biased estimate of the covariance matrix.
+ compute_inv: Compute the inverse transform matrix.
+ detach_transforms: Detaches gradient from the ZCA fitting.
+
+ shape:
+ - x: :math:`(D_0,...,D_{\text{dim}},...,D_N)` is a batch of N-D tensors.
+ - x_whiten: :math:`(D_0,...,D_{\text{dim}},...,D_N)` same shape as input.
+
+ .. note::
+ See a working example `here `__.
+
+ Examples:
+ >>> x = torch.tensor([[0,1],[1,0],[-1,0],[0,-1]], dtype = torch.float32)
+ >>> zca = ZCAWhitening().fit(x)
+ >>> x_whiten = zca(x)
+ >>> zca = ZCAWhitening()
+ >>> x_whiten = zca(x, include_fit = True) # Includes the fitting step
+ >>> x_whiten = zca(x) # Can run now without the fitting set
+ >>> # Enable backprop through ZCA fitting process
+ >>> zca = ZCAWhitening(detach_transforms = False)
+ >>> x_whiten = zca(x, include_fit = True) # Includes the fitting step
+
+ Note:
+
+ This implementation uses :py:meth:`~torch.svd` which yields NaNs in the backwards step
+ if the singular values are not unique. See `here `_ for
+ more information.
+
+ References:
+
+ [1] `Stanford PCA & ZCA whitening tutorial `__.
+
+ Examples:
+ >>> x = torch.tensor([[0,1],[1,0],[-1,0],[0,-1]], dtype = torch.float32)
+ >>> transform_matrix, mean_vector,_ = zca_mean(x) # Returns transformation matrix and data mean
+ >>> x = torch.rand(3,20,2,2)
+ >>> transform_matrix, mean_vector, inv_transform = zca_mean(x, dim = 1, return_inverse = True)
+ >>> # transform_matrix.size() equals (12,12) and the mean vector.size equal (1,12)
+
+ """
+
+ if not isinstance(inp, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(inp)}")
+
+ if not isinstance(eps, float):
+ raise TypeError(f"eps type is not a float. Got{type(eps)}")
+
+ if not isinstance(unbiased, bool):
+ raise TypeError(f"unbiased type is not bool. Got{type(unbiased)}")
+
+ if not isinstance(dim, int):
+ raise TypeError(f"Argument 'dim' must be of type int. Got {type(dim)}")
+
+ if not isinstance(return_inverse, bool):
+ raise TypeError(f"Argument return_inverse must be of type bool {type(return_inverse)}")
+
+ inp_size = inp.size()
+
+ if dim >= len(inp_size) or dim < -len(inp_size):
+ raise IndexError(
+ "Dimension out of range (expected to be in range of [{},{}], but got {}".format(
+ -len(inp_size), len(inp_size) - 1, dim
+ )
+ )
+
+ if dim < 0:
+ dim = len(inp_size) + dim
+
+ feat_dims = torch.cat([torch.arange(0, dim), torch.arange(dim + 1, len(inp_size))])
+
+ new_order: List[int] = torch.cat([torch.tensor([dim]), feat_dims]).tolist()
+
+ inp_permute = inp.permute(new_order)
+
+ N = inp_size[dim]
+ feature_sizes = torch.tensor(inp_size[0:dim] + inp_size[dim + 1::])
+ num_features: int = int(torch.prod(feature_sizes).item())
+
+ mean: torch.Tensor = torch.mean(inp_permute, dim=0, keepdim=True)
+
+ mean = mean.reshape((1, num_features))
+
+ inp_center_flat: torch.Tensor = inp_permute.reshape((N, num_features)) - mean
+
+ cov = inp_center_flat.t().mm(inp_center_flat)
+
+ if unbiased:
+ cov = cov / float(N - 1)
+ else:
+ cov = cov / float(N)
+
+ U, S, _ = _torch_svd_cast(cov)
+
+ S = S.reshape(-1, 1)
+ S_inv_root: torch.Tensor = torch.rsqrt(S + eps)
+ T: torch.Tensor = (U).mm(S_inv_root * U.t())
+
+ T_inv: Optional[torch.Tensor] = None
+ if return_inverse:
+ T_inv = (U).mm(torch.sqrt(S + eps) * U.t())
+
+ return T, mean, T_inv
+
+
+def zca_whiten(inp: torch.Tensor, dim: int = 0, unbiased: bool = True, eps: float = 1e-6) -> torch.Tensor:
+ r"""Apply ZCA whitening transform.
+
+ See :class:`~kornia.color.ZCAWhitening` for details.
+
+ Args:
+ inp: input data tensor.
+ dim: Specifies the dimension that serves as the samples dimension.
+ unbiased: Whether to use the unbiased estimate of the covariance matrix.
+ eps: a small number used for numerical stability.
+
+ Returns:
+ Whiten Input data.
+
+ .. note::
+ See a working example `here `__.
+
+ Examples:
+ >>> x = torch.tensor([[0,1],[1,0],[-1,0]], dtype = torch.float32)
+ >>> zca_whiten(x)
+ tensor([[ 0.0000, 1.1547],
+ [ 1.0000, -0.5773],
+ [-1.0000, -0.5773]])
+ """
+
+ if not isinstance(inp, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(inp)}")
+
+ if not isinstance(eps, float):
+ raise TypeError(f"eps type is not a float. Got{type(eps)}")
+
+ if not isinstance(unbiased, bool):
+ raise TypeError(f"unbiased type is not bool. Got{type(unbiased)}")
+
+ if not isinstance(dim, int):
+ raise TypeError(f"Argument 'dim' must be of type int. Got {type(dim)}")
+
+ transform, mean, _ = zca_mean(inp, dim, unbiased, eps, False)
+
+ inp_whiten = linear_transform(inp, transform, mean, dim)
+
+ return inp_whiten
+
+
+def linear_transform(
+ inp: torch.Tensor, transform_matrix: torch.Tensor, mean_vector: torch.Tensor, dim: int = 0
+) -> torch.Tensor:
+ r"""
+
+ Given a transformation matrix and a mean vector, this function will flatten
+ the input tensor along the given dimension and subtract the mean vector
+ from it. Then the dot product with the transformation matrix will be computed
+ and then the resulting tensor is reshaped to the original input shape.
+
+ .. math::
+
+ \mathbf{X}_{T} = (\mathbf{X - \mu})(T)
+
+ Args:
+ inp: Input data :math:`X`.
+ transform_matrix: Transform matrix :math:`T`.
+ mean_vector: mean vector :math:`\mu`.
+ dim: Batch dimension.
+
+ Shapes:
+ - inp: :math:`(D_0,...,D_{\text{dim}},...,D_N)` is a batch of N-D tensors.
+ - transform_matrix: :math:`(\Pi_{d=0,d\neq \text{dim}}^N D_d, \Pi_{d=0,d\neq \text{dim}}^N D_d)`
+ - mean_vector: :math:`(1, \Pi_{d=0,d\neq \text{dim}}^N D_d)`
+
+ Returns:
+ Transformed data.
+
+ Example:
+ >>> # Example where dim = 3
+ >>> inp = torch.ones((10,3,4,5))
+ >>> transform_mat = torch.ones((10*3*4,10*3*4))
+ >>> mean = 2*torch.ones((1,10*3*4))
+ >>> out = linear_transform(inp, transform_mat, mean, 3)
+ >>> print(out.shape, out.unique()) # Should a be (10,3,4,5) tensor of -120s
+ torch.Size([10, 3, 4, 5]) tensor([-120.])
+
+ >>> # Example where dim = 0
+ >>> inp = torch.ones((10,2))
+ >>> transform_mat = torch.ones((2,2))
+ >>> mean = torch.zeros((1,2))
+ >>> out = linear_transform(inp, transform_mat, mean)
+ >>> print(out.shape, out.unique()) # Should a be (10,2) tensor of 2s
+ torch.Size([10, 2]) tensor([2.])
+ """
+
+ inp_size = inp.size()
+
+ if dim >= len(inp_size) or dim < -len(inp_size):
+ raise IndexError(
+ "Dimension out of range (expected to be in range of [{},{}], but got {}".format(
+ -len(inp_size), len(inp_size) - 1, dim
+ )
+ )
+
+ if dim < 0:
+ dim = len(inp_size) + dim
+
+ feat_dims = torch.cat([torch.arange(0, dim), torch.arange(dim + 1, len(inp_size))])
+
+ perm = torch.cat([torch.tensor([dim]), feat_dims])
+ perm_inv = torch.argsort(perm)
+
+ new_order: List[int] = perm.tolist()
+ inv_order: List[int] = perm_inv.tolist()
+
+ feature_sizes = torch.tensor(inp_size[0:dim] + inp_size[dim + 1::])
+ num_features: int = int(torch.prod(feature_sizes).item())
+
+ inp_permute = inp.permute(new_order)
+ inp_flat = inp_permute.reshape((-1, num_features))
+
+ inp_center = inp_flat - mean_vector
+ inp_transformed = inp_center.mm(transform_matrix)
+
+ inp_transformed = inp_transformed.reshape(inp_permute.size())
+
+ inp_transformed = inp_transformed.permute(inv_order)
+
+ return inp_transformed
diff --git a/kornia/feature/__init__.py b/kornia/feature/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..364621b036b14e8749916eeafb495cfa9ae2f804
--- /dev/null
+++ b/kornia/feature/__init__.py
@@ -0,0 +1,116 @@
+from .affine_shape import LAFAffineShapeEstimator, LAFAffNetShapeEstimator, PatchAffineShapeEstimator
+from .defmo import DeFMO
+from .hardnet import HardNet, HardNet8
+from .integrated import (
+ get_laf_descriptors,
+ GFTTAffNetHardNet,
+ LAFDescriptor,
+ LocalFeature,
+ LocalFeatureMatcher,
+ SIFTFeature,
+)
+from .laf import (
+ denormalize_laf,
+ ellipse_to_laf,
+ extract_patches_from_pyramid,
+ extract_patches_simple,
+ get_laf_center,
+ get_laf_orientation,
+ get_laf_scale,
+ laf_from_center_scale_ori,
+ laf_from_three_points,
+ laf_is_inside_image,
+ laf_to_boundary_points,
+ laf_to_three_points,
+ make_upright,
+ normalize_laf,
+ perspective_transform_lafs,
+ raise_error_if_laf_is_not_valid,
+ scale_laf,
+ set_laf_orientation,
+)
+from .loftr import LoFTR
+from .matching import DescriptorMatcher, match_mnn, match_nn, match_smnn, match_snn
+from .mkd import MKDDescriptor
+from .orientation import LAFOrienter, OriNet, PatchDominantGradientOrientation
+from .responses import (
+ BlobDoG,
+ BlobHessian,
+ CornerGFTT,
+ CornerHarris,
+ dog_response,
+ gftt_response,
+ harris_response,
+ hessian_response,
+)
+from .scale_space_detector import PassLAF, ScaleSpaceDetector
+from .siftdesc import SIFTDescriptor
+from .sosnet import SOSNet
+from .tfeat import TFeat
+
+__all__ = [
+ "match_nn",
+ "match_mnn",
+ "match_snn",
+ "match_smnn",
+ "DescriptorMatcher",
+ "get_laf_descriptors",
+ "LAFDescriptor",
+ "LocalFeature",
+ "SIFTFeature",
+ "GFTTAffNetHardNet",
+ "LocalFeatureMatcher",
+ "SOSNet",
+ "harris_response",
+ "gftt_response",
+ "hessian_response",
+ "dog_response",
+ "CornerHarris",
+ "CornerGFTT",
+ "BlobHessian",
+ "BlobDoG",
+ "extract_patches_from_pyramid",
+ "extract_patches_simple",
+ "normalize_laf",
+ "denormalize_laf",
+ "laf_to_boundary_points",
+ "ellipse_to_laf",
+ "make_upright",
+ "get_laf_scale",
+ "get_laf_center",
+ "get_laf_orientation",
+ "set_laf_orientation",
+ "get_laf_descriptors",
+ "scale_laf",
+ "SIFTDescriptor",
+ "MKDDescriptor",
+ "HardNet",
+ "HardNet8",
+ "DeFMO",
+ "TFeat",
+ "OriNet",
+ "LAFAffNetShapeEstimator",
+ "PassLAF",
+ "ScaleSpaceDetector",
+ "LAFAffineShapeEstimator",
+ "PatchAffineShapeEstimator",
+ "LAFOrienter",
+ "PatchDominantGradientOrientation",
+ "raise_error_if_laf_is_not_valid",
+ "laf_is_inside_image",
+ "laf_from_center_scale_ori",
+ "laf_to_three_points",
+ "laf_from_three_points",
+ "match_nn",
+ "match_mnn",
+ "match_snn",
+ "match_smnn",
+ "LocalFeatureMatcher",
+ "LocalFeature",
+ "SIFTFeature",
+ "GFTTAffNetHardNet",
+ "LAFDescriptor",
+ "DescriptorMatcher",
+ "LoFTR",
+ "perspective_transform_lafs",
+]
diff --git a/kornia/feature/affine_shape.py b/kornia/feature/affine_shape.py
new file mode 100644
index 0000000000000000000000000000000000000000..6bd562c1e2114a6aaa46317acaa226bee4379fcb
--- /dev/null
+++ b/kornia/feature/affine_shape.py
@@ -0,0 +1,227 @@
+import math
+from typing import Dict, Optional
+
+import torch
+import torch.nn as nn
+
+from kornia.filters.kernels import get_gaussian_kernel2d
+from kornia.filters.sobel import SpatialGradient
+
+from .laf import (
+ ellipse_to_laf,
+ extract_patches_from_pyramid,
+ get_laf_scale,
+ make_upright,
+ raise_error_if_laf_is_not_valid,
+ scale_laf,
+)
+
+urls: Dict[str, str] = {}
+urls["affnet"] = "https://github.com/ducha-aiki/affnet/raw/master/pretrained/AffNet.pth"
+
+
+class PatchAffineShapeEstimator(nn.Module):
+ r"""Module, which estimates the second moment matrix of the patch gradients.
+
+ The method determines the affine shape of the local feature as in :cite:`baumberg2000`.
+
+ Args:
+ patch_size: the input image patch size.
+ eps: for safe division.
+ """
+
+ def __init__(self, patch_size: int = 19, eps: float = 1e-10):
+ super().__init__()
+ self.patch_size: int = patch_size
+ self.gradient: nn.Module = SpatialGradient('sobel', 1)
+ self.eps: float = eps
+ sigma: float = float(self.patch_size) / math.sqrt(2.0)
+ self.weighting: torch.Tensor = get_gaussian_kernel2d((self.patch_size, self.patch_size), (sigma, sigma), True)
+
+ def __repr__(self):
+ return self.__class__.__name__ + '(' 'patch_size=' + str(self.patch_size) + ', ' + 'eps=' + str(self.eps) + ')'
+
+ def forward(self, patch: torch.Tensor) -> torch.Tensor:
+ """Args:
+ patch: (torch.Tensor) shape [Bx1xHxW]
+ Returns:
+ torch.Tensor: ellipse_shape shape [Bx1x3]"""
+ if not isinstance(patch, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(patch)}")
+ if not len(patch.shape) == 4:
+ raise ValueError(f"Invalid input shape, we expect Bx1xHxW. Got: {patch.shape}")
+ _, CH, W, H = patch.size()
+ if (W != self.patch_size) or (H != self.patch_size) or (CH != 1):
+ raise TypeError(
+ "input shape should be must be [Bx1x{}x{}]. "
+ "Got {}".format(self.patch_size, self.patch_size, patch.size())
+ )
+ self.weighting = self.weighting.to(patch.dtype).to(patch.device)
+ grads: torch.Tensor = self.gradient(patch) * self.weighting
+ # unpack the edges
+ gx: torch.Tensor = grads[:, :, 0]
+ gy: torch.Tensor = grads[:, :, 1]
+ # abc == 1st axis, mixture, 2nd axis. Ellipse_shape is a 2nd moment matrix.
+ ellipse_shape = torch.cat(
+ [
+ gx.pow(2).mean(dim=2).mean(dim=2, keepdim=True),
+ (gx * gy).mean(dim=2).mean(dim=2, keepdim=True),
+ gy.pow(2).mean(dim=2).mean(dim=2, keepdim=True),
+ ],
+ dim=2,
+ )
+
+ # Now lets detect degenerate cases: when 2 or 3 elements are close to zero (e.g. if patch is completely black
+ bad_mask = ((ellipse_shape < self.eps).float().sum(dim=2, keepdim=True) >= 2).to(ellipse_shape.dtype)
+ # We will replace degenerate shape with circular shapes.
+ circular_shape = torch.tensor([1.0, 0.0, 1.0]).to(ellipse_shape.device).to(ellipse_shape.dtype).view(1, 1, 3)
+ ellipse_shape = ellipse_shape * (1.0 - bad_mask) + circular_shape * bad_mask
+ # normalization
+ ellipse_shape = ellipse_shape / ellipse_shape.max(dim=2, keepdim=True)[0]
+ return ellipse_shape
+
+
+class LAFAffineShapeEstimator(nn.Module):
+ """Module, which extracts patches using input images and local affine frames (LAFs).
+
+ Then runs :class:`~kornia.feature.PatchAffineShapeEstimator` on patches to estimate LAFs shape.
+
+ Then original LAF shape is replaced with estimated one. The original LAF orientation is not preserved,
+ so it is recommended to first run LAFAffineShapeEstimator and then LAFOrienter.
+
+ Args:
+ patch_size: the input image patch size.
+ affine_shape_detector: Patch affine shape estimator, :class:`~kornia.feature.PatchAffineShapeEstimator`.
+ """ # pylint: disable
+
+ def __init__(self, patch_size: int = 32, affine_shape_detector: Optional[nn.Module] = None) -> None:
+ super().__init__()
+ self.patch_size = patch_size
+ self.affine_shape_detector = affine_shape_detector or PatchAffineShapeEstimator(self.patch_size)
+
+ def __repr__(self):
+ return (
+ self.__class__.__name__ + '('
+ 'patch_size='
+ + str(self.patch_size)
+ + ', '
+ + 'affine_shape_detector='
+ + str(self.affine_shape_detector)
+ + ')'
+ )
+
+ def forward(self, laf: torch.Tensor, img: torch.Tensor) -> torch.Tensor:
+ """
+ Args:
+ laf: (torch.Tensor) shape [BxNx2x3]
+ img: (torch.Tensor) shape [Bx1xHxW]
+
+ Returns:
+ torch.Tensor: laf_out shape [BxNx2x3]"""
+ raise_error_if_laf_is_not_valid(laf)
+ img_message: str = f"Invalid img shape, we expect BxCxHxW. Got: {img.shape}"
+ if not isinstance(img, torch.Tensor):
+ raise TypeError(f"img type is not a torch.Tensor. Got {type(img)}")
+ if len(img.shape) != 4:
+ raise ValueError(img_message)
+ if laf.size(0) != img.size(0):
+ raise ValueError(f"Batch size of laf and img should be the same. Got {img.size(0)}, {laf.size(0)}")
+ B, N = laf.shape[:2]
+ PS: int = self.patch_size
+ patches: torch.Tensor = extract_patches_from_pyramid(img, make_upright(laf), PS, True).view(-1, 1, PS, PS)
+ ellipse_shape: torch.Tensor = self.affine_shape_detector(patches)
+ ellipses = torch.cat([laf.view(-1, 2, 3)[..., 2].unsqueeze(1), ellipse_shape], dim=2).view(B, N, 5)
+ scale_orig = get_laf_scale(laf)
+ laf_out = ellipse_to_laf(ellipses)
+ ellipse_scale = get_laf_scale(laf_out)
+ laf_out = scale_laf(laf_out, scale_orig / ellipse_scale)
+ return laf_out
+
+
+class LAFAffNetShapeEstimator(nn.Module):
+ """Module, which extracts patches using input images and local affine frames (LAFs).
+
+ Then runs AffNet on patches to estimate LAFs shape. This is based on the original code from paper
+ "Repeatability Is Not Enough: Learning Discriminative Affine Regions via Discriminability"".
+ See :cite:`AffNet2018` for more details.
+
+ Then original LAF shape is replaced with estimated one. The original LAF orientation is not preserved,
+ so it is recommended to first run LAFAffineShapeEstimator and then LAFOrienter.
+
+ Args:
+ pretrained: Download and set pretrained weights to the model.
+ """
+
+ def __init__(self, pretrained: bool = False):
+ super().__init__()
+ self.features = nn.Sequential(
+ nn.Conv2d(1, 16, kernel_size=3, padding=1, bias=False),
+ nn.BatchNorm2d(16, affine=False),
+ nn.ReLU(),
+ nn.Conv2d(16, 16, kernel_size=3, stride=1, padding=1, bias=False),
+ nn.BatchNorm2d(16, affine=False),
+ nn.ReLU(),
+ nn.Conv2d(16, 32, kernel_size=3, stride=2, padding=1, bias=False),
+ nn.BatchNorm2d(32, affine=False),
+ nn.ReLU(),
+ nn.Conv2d(32, 32, kernel_size=3, stride=1, padding=1, bias=False),
+ nn.BatchNorm2d(32, affine=False),
+ nn.ReLU(),
+ nn.Conv2d(32, 64, kernel_size=3, stride=2, padding=1, bias=False),
+ nn.BatchNorm2d(64, affine=False),
+ nn.ReLU(),
+ nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1, bias=False),
+ nn.BatchNorm2d(64, affine=False),
+ nn.ReLU(),
+ nn.Dropout(0.25),
+ nn.Conv2d(64, 3, kernel_size=8, stride=1, padding=0, bias=True),
+ nn.Tanh(),
+ nn.AdaptiveAvgPool2d(1),
+ )
+ self.patch_size = 32
+ # use torch.hub to load pretrained model
+ if pretrained:
+ pretrained_dict = torch.hub.load_state_dict_from_url(
+ urls['affnet'], map_location=lambda storage, loc: storage
+ )
+ self.load_state_dict(pretrained_dict['state_dict'], strict=False)
+ self.eval()
+
+ @staticmethod
+ def _normalize_input(x: torch.Tensor, eps: float = 1e-6) -> torch.Tensor:
+ """Utility function that normalizes the input by batch."""
+ sp, mp = torch.std_mean(x, dim=(-3, -2, -1), keepdim=True)
+ # WARNING: we need to .detach() input, otherwise the gradients produced by
+ # the patches extractor with F.grid_sample are very noisy, making the detector
+ # training totally unstable.
+ return (x - mp.detach()) / (sp.detach() + eps)
+
+ def forward(self, laf: torch.Tensor, img: torch.Tensor) -> torch.Tensor:
+ """
+ Args:
+ laf: shape [BxNx2x3]
+ img: shape [Bx1xHxW]
+
+ Returns:
+ laf_out shape [BxNx2x3]
+ """
+ raise_error_if_laf_is_not_valid(laf)
+ img_message: str = f"Invalid img shape, we expect BxCxHxW. Got: {img.shape}"
+ if not torch.is_tensor(img):
+ raise TypeError(f"img type is not a torch.Tensor. Got {type(img)}")
+ if len(img.shape) != 4:
+ raise ValueError(img_message)
+ if laf.size(0) != img.size(0):
+ raise ValueError(f"Batch size of laf and img should be the same. Got {img.size(0)}, {laf.size(0)}")
+ B, N = laf.shape[:2]
+ PS: int = self.patch_size
+ patches: torch.Tensor = extract_patches_from_pyramid(img, make_upright(laf), PS, True).view(-1, 1, PS, PS)
+ xy = self.features(self._normalize_input(patches)).view(-1, 3)
+ a1 = torch.cat([1.0 + xy[:, 0].reshape(-1, 1, 1), 0 * xy[:, 0].reshape(-1, 1, 1)], dim=2)
+ a2 = torch.cat([xy[:, 1].reshape(-1, 1, 1), 1.0 + xy[:, 2].reshape(-1, 1, 1)], dim=2)
+ new_laf_no_center = torch.cat([a1, a2], dim=1).reshape(B, N, 2, 2)
+ new_laf = torch.cat([new_laf_no_center, laf[:, :, :, 2:3]], dim=3)
+ scale_orig = get_laf_scale(laf)
+ ellipse_scale = get_laf_scale(new_laf)
+ laf_out = scale_laf(make_upright(new_laf), scale_orig / ellipse_scale)
+ return laf_out
diff --git a/kornia/feature/defmo.py b/kornia/feature/defmo.py
new file mode 100644
index 0000000000000000000000000000000000000000..d24125937bf253524e7cfa22b7c2184a8fa5b44d
--- /dev/null
+++ b/kornia/feature/defmo.py
@@ -0,0 +1,303 @@
+from typing import Callable, Dict, List, Optional, Type
+
+import torch
+import torch.nn as nn
+
+urls: Dict[str, str] = {}
+urls["defmo_encoder"] = "http://ptak.felk.cvut.cz/personal/rozumden/defmo_saved_models/encoder_best.pt"
+urls["defmo_rendering"] = "http://ptak.felk.cvut.cz/personal/rozumden/defmo_saved_models/rendering_best.pt"
+
+
+# conv1x1, conv3x3, Bottleneck, ResNet are taken from:
+# https://github.com/pytorch/vision/blob/master/torchvision/models/resnet.py
+
+
+def conv1x1(in_planes: int, out_planes: int, stride: int = 1) -> nn.Conv2d:
+ """1x1 convolution."""
+ return nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False)
+
+
+def conv3x3(in_planes: int, out_planes: int, stride: int = 1, groups: int = 1, dilation: int = 1) -> nn.Conv2d:
+ """3x3 convolution with padding."""
+ return nn.Conv2d(
+ in_planes,
+ out_planes,
+ kernel_size=3,
+ stride=stride,
+ padding=dilation,
+ groups=groups,
+ bias=False,
+ dilation=dilation,
+ )
+
+
+class Bottleneck(nn.Module):
+ # Bottleneck in torchvision places the stride for downsampling at 3x3 convolution(self.conv2)
+ # while original implementation places the stride at the first 1x1 convolution(self.conv1)
+ # according to "Deep residual learning for image recognition"https://arxiv.org/abs/1512.03385.
+ # This variant is also known as ResNet V1.5 and improves accuracy according to
+ # https://ngc.nvidia.com/catalog/model-scripts/nvidia:resnet_50_v1_5_for_pytorch.
+
+ expansion: int = 4
+
+ def __init__(
+ self,
+ inplanes: int,
+ planes: int,
+ stride: int = 1,
+ downsample: Optional[nn.Module] = None,
+ groups: int = 1,
+ base_width: int = 64,
+ dilation: int = 1,
+ norm_layer: Optional[Callable[..., nn.Module]] = None,
+ ) -> None:
+ super().__init__()
+ if norm_layer is None:
+ norm_layer = nn.BatchNorm2d
+ width = int(planes * (base_width / 64.0)) * groups
+ # Both self.conv2 and self.downsample layers downsample the input when stride != 1
+ self.conv1 = conv1x1(inplanes, width)
+ self.bn1 = norm_layer(width)
+ self.conv2 = conv3x3(width, width, stride, groups, dilation)
+ self.bn2 = norm_layer(width)
+ self.conv3 = conv1x1(width, planes * self.expansion)
+ self.bn3 = norm_layer(planes * self.expansion)
+ self.relu = nn.ReLU(inplace=True)
+ self.downsample = downsample
+ self.stride = stride
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ identity = x
+
+ out = self.conv1(x)
+ out = self.bn1(out)
+ out = self.relu(out)
+
+ out = self.conv2(out)
+ out = self.bn2(out)
+ out = self.relu(out)
+
+ out = self.conv3(out)
+ out = self.bn3(out)
+
+ if self.downsample is not None:
+ identity = self.downsample(x)
+
+ out += identity
+ out = self.relu(out)
+
+ return out
+
+
+class ResNet(nn.Module):
+ def __init__(
+ self,
+ block: Type[Bottleneck],
+ layers: List[int],
+ num_classes: int = 1000,
+ zero_init_residual: bool = False,
+ groups: int = 1,
+ width_per_group: int = 64,
+ replace_stride_with_dilation: Optional[List[bool]] = None,
+ norm_layer: Optional[Callable[..., nn.Module]] = None,
+ ) -> None:
+ super().__init__()
+ if norm_layer is None:
+ norm_layer = nn.BatchNorm2d
+ self._norm_layer = norm_layer
+
+ self.inplanes = 64
+ self.dilation = 1
+ if replace_stride_with_dilation is None:
+ # each element in the tuple indicates if we should replace
+ # the 2x2 stride with a dilated convolution instead
+ replace_stride_with_dilation = [False, False, False]
+ if len(replace_stride_with_dilation) != 3:
+ raise ValueError(
+ "replace_stride_with_dilation should be None "
+ "or a 3-element tuple, got {}".format(replace_stride_with_dilation)
+ )
+ self.groups = groups
+ self.base_width = width_per_group
+ self.conv1 = nn.Conv2d(3, self.inplanes, kernel_size=7, stride=2, padding=3, bias=False)
+ self.bn1 = norm_layer(self.inplanes)
+ self.relu = nn.ReLU(inplace=True)
+ self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
+ self.layer1 = self._make_layer(block, 64, layers[0])
+ self.layer2 = self._make_layer(block, 128, layers[1], stride=2, dilate=replace_stride_with_dilation[0])
+ self.layer3 = self._make_layer(block, 256, layers[2], stride=2, dilate=replace_stride_with_dilation[1])
+ self.layer4 = self._make_layer(block, 512, layers[3], stride=2, dilate=replace_stride_with_dilation[2])
+ self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
+ self.fc = nn.Linear(512 * block.expansion, num_classes)
+
+ for m in self.modules():
+ if isinstance(m, nn.Conv2d):
+ nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+ elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):
+ nn.init.constant_(m.weight, 1)
+ nn.init.constant_(m.bias, 0)
+
+ # Zero-initialize the last BN in each residual branch,
+ # so that the residual branch starts with zeros, and each residual block behaves like an identity.
+ # This improves the model by 0.2~0.3% according to https://arxiv.org/abs/1706.02677
+ if zero_init_residual:
+ for m in self.modules():
+ if isinstance(m, Bottleneck):
+ nn.init.constant_(m.bn3.weight, 0) # type: ignore[arg-type]
+
+ def _make_layer(
+ self, block: Type[Bottleneck], planes: int, blocks: int, stride: int = 1, dilate: bool = False
+ ) -> nn.Sequential:
+ norm_layer = self._norm_layer
+ downsample = None
+ previous_dilation = self.dilation
+ if dilate:
+ self.dilation *= stride
+ stride = 1
+ if stride != 1 or self.inplanes != planes * block.expansion:
+ downsample = nn.Sequential(
+ conv1x1(self.inplanes, planes * block.expansion, stride), norm_layer(planes * block.expansion)
+ )
+
+ layers = []
+ layers.append(
+ block(
+ self.inplanes, planes, stride, downsample, self.groups, self.base_width, previous_dilation, norm_layer
+ )
+ )
+ self.inplanes = planes * block.expansion
+ for _ in range(1, blocks):
+ layers.append(
+ block(
+ self.inplanes,
+ planes,
+ groups=self.groups,
+ base_width=self.base_width,
+ dilation=self.dilation,
+ norm_layer=norm_layer,
+ )
+ )
+
+ return nn.Sequential(*layers)
+
+ def _forward_impl(self, x: torch.Tensor) -> torch.Tensor:
+ # See note [TorchScript super()]
+ x = self.conv1(x)
+ x = self.bn1(x)
+ x = self.relu(x)
+ x = self.maxpool(x)
+
+ x = self.layer1(x)
+ x = self.layer2(x)
+ x = self.layer3(x)
+ x = self.layer4(x)
+
+ x = self.avgpool(x)
+ x = torch.flatten(x, 1)
+ x = self.fc(x)
+
+ return x
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ return self._forward_impl(x)
+
+
+class EncoderDeFMO(nn.Module):
+ def __init__(self):
+ super().__init__()
+ model = ResNet(Bottleneck, [3, 4, 6, 3]) # ResNet50
+ modelc1 = nn.Sequential(*list(model.children())[:3])
+ modelc2 = nn.Sequential(*list(model.children())[4:8])
+ modelc1[0] = nn.Conv2d(6, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
+ self.net = nn.Sequential(modelc1, modelc2)
+
+ def forward(self, input_data: torch.Tensor) -> torch.Tensor:
+ return self.net(input_data)
+
+
+class RenderingDeFMO(nn.Module):
+ def __init__(self):
+ super().__init__()
+ self.tsr_steps: int = 24
+ model = nn.Sequential(
+ nn.Conv2d(2049, 1024, kernel_size=3, stride=1, padding=1, bias=False),
+ nn.BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True),
+ nn.ReLU(inplace=True),
+ Bottleneck(1024, 256),
+ nn.PixelShuffle(2),
+ Bottleneck(256, 64),
+ nn.PixelShuffle(2),
+ Bottleneck(64, 16),
+ nn.PixelShuffle(2),
+ nn.Conv2d(16, 16, kernel_size=3, stride=1, padding=1, bias=False),
+ nn.PixelShuffle(2),
+ nn.Conv2d(4, 4, kernel_size=3, stride=1, padding=1, bias=True),
+ nn.ReLU(inplace=True),
+ nn.Conv2d(4, 4, kernel_size=3, stride=1, padding=1, bias=True),
+ )
+ self.net = model
+ self.times = torch.linspace(0, 1, self.tsr_steps)
+
+ def forward(self, latent: torch.Tensor) -> torch.Tensor:
+ times = self.times.to(latent.device).unsqueeze(0).repeat(latent.shape[0], 1)
+ renders = []
+ for ki in range(times.shape[1]):
+ t_tensor = (
+ # TODO: replace by after deprecate pytorch 1.6
+ # times[list(range(times.shape[0])), ki]
+ times[[x for x in range(times.shape[0])], ki] # skipcq: PYL-R1721
+ .unsqueeze(-1)
+ .unsqueeze(-1)
+ .unsqueeze(-1)
+ .repeat(1, 1, latent.shape[2], latent.shape[3])
+ )
+ latenti = torch.cat((t_tensor, latent), 1)
+ result = self.net(latenti)
+ renders.append(result)
+ renders_stacked = torch.stack(renders, 1).contiguous()
+ renders_stacked[:, :, :4] = torch.sigmoid(renders_stacked[:, :, :4])
+ return renders_stacked
+
+
+class DeFMO(nn.Module):
+ """Module that disentangle a fast-moving object from the background and performs deblurring.
+
+ This is based on the original code from paper "DeFMO: Deblurring and Shape Recovery
+ of Fast Moving Objects". See :cite:`DeFMO2021` for more details.
+
+ Args:
+ pretrained: Download and set pretrained weights to the model. Default: false.
+ Returns:
+ Temporal super-resolution without background.
+ Shape:
+ - Input: (B, 6, H, W)
+ - Output: (B, S, 4, H, W)
+
+ Examples:
+ >>> import kornia
+ >>> input = torch.rand(2, 6, 240, 320)
+ >>> defmo = kornia.feature.DeFMO()
+ >>> tsr_nobgr = defmo(input) # 2x24x4x240x320
+ """
+
+ def __init__(self, pretrained: bool = False) -> None:
+ super().__init__()
+ self.encoder = EncoderDeFMO()
+ self.rendering = RenderingDeFMO()
+
+ # use torch.hub to load pretrained model
+ if pretrained:
+ pretrained_dict = torch.hub.load_state_dict_from_url(
+ urls['defmo_encoder'], map_location=lambda storage, loc: storage
+ )
+ self.encoder.load_state_dict(pretrained_dict, strict=True)
+ pretrained_dict_ren = torch.hub.load_state_dict_from_url(
+ urls['defmo_rendering'], map_location=lambda storage, loc: storage
+ )
+ self.rendering.load_state_dict(pretrained_dict_ren, strict=True)
+ self.eval()
+
+ def forward(self, input_data: torch.Tensor) -> torch.Tensor:
+ latent = self.encoder(input_data)
+ x_out = self.rendering(latent)
+ return x_out
diff --git a/kornia/feature/hardnet.py b/kornia/feature/hardnet.py
new file mode 100644
index 0000000000000000000000000000000000000000..0eff69fcbd07658f98ba33414711a006271ccc9f
--- /dev/null
+++ b/kornia/feature/hardnet.py
@@ -0,0 +1,174 @@
+from typing import Dict
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+urls: Dict[str, str] = {}
+urls["hardnet++"] = "https://github.com/DagnyT/hardnet/raw/master/pretrained/pretrained_all_datasets/HardNet++.pth"
+urls[
+ "liberty_aug"
+] = "https://github.com/DagnyT/hardnet/raw/master/pretrained/train_liberty_with_aug/checkpoint_liberty_with_aug.pth" # noqa pylint: disable
+urls["hardnet8v2"] = "http://cmp.felk.cvut.cz/~mishkdmy/hardnet8v2.pt" # pylint: disable
+
+
+class HardNet(nn.Module):
+ r"""Module, which computes HardNet descriptors of given grayscale patches of 32x32.
+
+ This is based on the original code from paper "Working hard to know your neighbor's
+ margins: Local descriptor learning loss". See :cite:`HardNet2017` for more details.
+
+ Args:
+ pretrained: Download and set pretrained weights to the model.
+
+ Returns:
+ torch.Tensor: HardNet descriptor of the patches.
+
+ Shape:
+ - Input: :math:`(B, 1, 32, 32)`
+ - Output: :math:`(B, 128)`
+
+ Examples:
+ >>> input = torch.rand(16, 1, 32, 32)
+ >>> hardnet = HardNet()
+ >>> descs = hardnet(input) # 16x128
+ """
+ patch_size = 32
+
+ def __init__(self, pretrained: bool = False) -> None:
+ super().__init__()
+ self.features = nn.Sequential(
+ nn.Conv2d(1, 32, kernel_size=3, padding=1, bias=False),
+ nn.BatchNorm2d(32, affine=False),
+ nn.ReLU(),
+ nn.Conv2d(32, 32, kernel_size=3, padding=1, bias=False),
+ nn.BatchNorm2d(32, affine=False),
+ nn.ReLU(),
+ nn.Conv2d(32, 64, kernel_size=3, stride=2, padding=1, bias=False),
+ nn.BatchNorm2d(64, affine=False),
+ nn.ReLU(),
+ nn.Conv2d(64, 64, kernel_size=3, padding=1, bias=False),
+ nn.BatchNorm2d(64, affine=False),
+ nn.ReLU(),
+ nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1, bias=False),
+ nn.BatchNorm2d(128, affine=False),
+ nn.ReLU(),
+ nn.Conv2d(128, 128, kernel_size=3, padding=1, bias=False),
+ nn.BatchNorm2d(128, affine=False),
+ nn.ReLU(),
+ nn.Dropout(0.3),
+ nn.Conv2d(128, 128, kernel_size=8, bias=False),
+ nn.BatchNorm2d(128, affine=False),
+ )
+
+ # use torch.hub to load pretrained model
+ if pretrained:
+ pretrained_dict = torch.hub.load_state_dict_from_url(
+ urls['liberty_aug'], map_location=lambda storage, loc: storage
+ )
+ self.load_state_dict(pretrained_dict['state_dict'], strict=True)
+ self.eval()
+
+ @staticmethod
+ def _normalize_input(x: torch.Tensor, eps: float = 1e-6) -> torch.Tensor:
+ """Utility function that normalizes the input by batch."""
+ sp, mp = torch.std_mean(x, dim=(-3, -2, -1), keepdim=True)
+ # WARNING: we need to .detach() input, otherwise the gradients produced by
+ # the patches extractor with F.grid_sample are very noisy, making the detector
+ # training totally unstable.
+ return (x - mp.detach()) / (sp.detach() + eps)
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor:
+ x_norm: torch.Tensor = self._normalize_input(input)
+ x_features: torch.Tensor = self.features(x_norm)
+ x_out = x_features.view(x_features.size(0), -1)
+ return F.normalize(x_out, dim=1)
+
+
+class HardNet8(nn.Module):
+ r"""Module, which computes HardNet8 descriptors of given grayscale patches of 32x32.
+
+ This is based on the original code from paper "Improving the HardNet Descriptor".
+ See :cite:`HardNet2020` for more details.
+
+ Args:
+ pretrained: Download and set pretrained weights to the model.
+
+ Returns:
+ torch.Tensor: HardNet8 descriptor of the patches.
+
+ Shape:
+ - Input: :math:`(B, 1, 32, 32)`
+ - Output: :math:`(B, 128)`
+
+ Examples:
+ >>> input = torch.rand(16, 1, 32, 32)
+ >>> hardnet = HardNet8()
+ >>> descs = hardnet(input) # 16x128
+ """
+ patch_size = 32
+
+ def __init__(self, pretrained: bool = False):
+ super().__init__()
+ self.features = nn.Sequential(
+ nn.Conv2d(1, 32, kernel_size=3, padding=1, bias=False),
+ nn.BatchNorm2d(32, affine=False),
+ nn.ReLU(),
+ nn.Conv2d(32, 32, kernel_size=3, padding=1, bias=False),
+ nn.BatchNorm2d(32, affine=False),
+ nn.ReLU(),
+ nn.Conv2d(32, 64, kernel_size=3, stride=2, padding=1, bias=False),
+ nn.BatchNorm2d(64, affine=False),
+ nn.ReLU(),
+ nn.Conv2d(64, 64, kernel_size=3, padding=1, bias=False),
+ nn.BatchNorm2d(64, affine=False),
+ nn.ReLU(),
+ nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1, bias=False),
+ nn.BatchNorm2d(128, affine=False),
+ nn.ReLU(),
+ nn.Conv2d(128, 128, kernel_size=3, padding=1, bias=False),
+ nn.BatchNorm2d(128, affine=False),
+ nn.ReLU(),
+ nn.Conv2d(128, 256, kernel_size=3, padding=1, bias=False),
+ nn.BatchNorm2d(256, affine=False),
+ nn.ReLU(),
+ nn.Dropout(0.3),
+ nn.Conv2d(256, 512, kernel_size=8, bias=False),
+ nn.BatchNorm2d(512, affine=False),
+ )
+ self.features.apply(self.weights_init)
+ self.register_buffer('components', torch.ones(512, 128, dtype=torch.float))
+ self.register_buffer('mean', torch.zeros(512, dtype=torch.float))
+
+ # use torch.hub to load pretrained model
+ if pretrained:
+ pretrained_dict = torch.hub.load_state_dict_from_url(
+ urls['hardnet8v2'], map_location=lambda storage, loc: storage
+ )
+ self.load_state_dict(pretrained_dict, strict=True)
+ self.eval()
+
+ @staticmethod
+ def weights_init(m):
+ if isinstance(m, nn.Conv2d):
+ nn.init.orthogonal_(m.weight.data, gain=0.6)
+ if m.bias is not None:
+ nn.init.constant_(m.bias.data, 0.01)
+
+ @staticmethod
+ def _normalize_input(x: torch.Tensor, eps: float = 1e-7) -> torch.Tensor:
+ """Utility function that normalizes the input by batch."""
+ sp, mp = torch.std_mean(x, dim=(-3, -2, -1), keepdim=True)
+ # WARNING: we need to .detach() input, otherwise the gradients produced by
+ # the patches extractor with F.grid_sample are very noisy, making the detector
+ # training totally unstable.
+ return (x - mp.detach()) / (sp.detach() + eps)
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor:
+ x_norm: torch.Tensor = self._normalize_input(input)
+ x_features: torch.Tensor = self.features(x_norm)
+ mean: torch.Tensor = torch.jit.annotate(torch.Tensor, self.mean)
+ components: torch.Tensor = torch.jit.annotate(torch.Tensor, self.components)
+ x_prePCA = F.normalize(x_features.view(x_features.size(0), -1))
+ pca = torch.mm(x_prePCA - mean, components)
+ return F.normalize(pca, dim=1)
diff --git a/kornia/feature/integrated.py b/kornia/feature/integrated.py
new file mode 100644
index 0000000000000000000000000000000000000000..d71352b4ae8c30ed5e34f7561836325321ffe68b
--- /dev/null
+++ b/kornia/feature/integrated.py
@@ -0,0 +1,292 @@
+from typing import Dict, List, Optional, Tuple
+
+import torch
+import torch.nn as nn
+
+from kornia.color import rgb_to_grayscale
+from kornia.geometry.subpix import ConvQuadInterp3d
+from kornia.geometry.transform import ScalePyramid
+
+from .affine_shape import LAFAffNetShapeEstimator
+from .hardnet import HardNet
+from .laf import extract_patches_from_pyramid, get_laf_center, raise_error_if_laf_is_not_valid
+from .orientation import LAFOrienter, PassLAF
+from .responses import BlobDoG, CornerGFTT
+from .scale_space_detector import ScaleSpaceDetector
+from .siftdesc import SIFTDescriptor
+
+
+def get_laf_descriptors(img: torch.Tensor,
+ lafs: torch.Tensor,
+ patch_descriptor: nn.Module,
+ patch_size: int = 32,
+ grayscale_descriptor: bool = True) -> torch.Tensor:
+ r"""Function to get local descriptors, corresponding to LAFs (keypoints).
+
+ Args:
+ img: image features with shape :math:`(B,C,H,W)`.
+ lafs: local affine frames :math:`(B,N,2,3)`.
+ patch_descriptor: patch descriptor module, e.g. :class:`~kornia.feature.SIFTDescriptor`
+ or :class:`~kornia.feature.HardNet`.
+ patch_size: patch size in pixels, which descriptor expects.
+ grayscale_descriptor: True if ``patch_descriptor`` expects single-channel image.
+
+ Returns:
+ Local descriptors of shape :math:`(B,N,D)` where :math:`D` is descriptor size.
+ """
+ raise_error_if_laf_is_not_valid(lafs)
+ patch_descriptor = patch_descriptor.to(img)
+ patch_descriptor.eval()
+
+ timg: torch.Tensor = img
+ if grayscale_descriptor and img.size(1) == 3:
+ timg = rgb_to_grayscale(img)
+
+ patches: torch.Tensor = extract_patches_from_pyramid(timg, lafs, patch_size)
+ # Descriptor accepts standard tensor [B, CH, H, W], while patches are [B, N, CH, H, W] shape
+ # So we need to reshape a bit :)
+ B, N, CH, H, W = patches.size()
+ return patch_descriptor(patches.view(B * N, CH, H, W)).view(B, N, -1)
+
+
+class LAFDescriptor(nn.Module):
+ r"""Module to get local descriptors, corresponding to LAFs (keypoints).
+
+ Internally uses :func:`~kornia.feature.get_laf_descriptors`.
+
+ Args:
+ patch_descriptor_module: patch descriptor module, e.g. :class:`~kornia.feature.SIFTDescriptor`
+ or :class:`~kornia.feature.HardNet`. Default: :class:`~kornia.feature.HardNet`.
+ patch_size: patch size in pixels, which descriptor expects.
+ grayscale_descriptor: ``True`` if patch_descriptor expects single-channel image.
+ """
+
+ def __init__(self,
+ patch_descriptor_module: nn.Module = HardNet(True),
+ patch_size: int = 32,
+ grayscale_descriptor: bool = True) -> None:
+ super().__init__()
+ self.descriptor = patch_descriptor_module
+ self.patch_size = patch_size
+ self.grayscale_descriptor = grayscale_descriptor
+
+ def __repr__(self) -> str:
+ return self.__class__.__name__ + '(' + \
+ 'descriptor=' + self.descriptor.__repr__() + ', ' + \
+ 'patch_size=' + str(self.patch_size) + ', ' + \
+ 'grayscale_descriptor=' + str(self.grayscale_descriptor) + ')'
+
+ def forward(self, img: torch.Tensor, lafs: torch.Tensor) -> torch.Tensor:
+ r"""Three stage local feature detection.
+
+ First the location and scale of interest points are determined by
+ detect function. Then affine shape and orientation.
+
+ Args:
+ img: image features with shape :math:`(B,C,H,W)`.
+ lafs: local affine frames :math:`(B,N,2,3)`.
+
+ Returns:
+ Local descriptors of shape :math:`(B,N,D)` where :math:`D` is descriptor size.
+ """
+ return get_laf_descriptors(img, lafs, self.descriptor, self.patch_size, self.grayscale_descriptor)
+
+
+class LocalFeature(nn.Module):
+ """Module, which combines local feature detector and descriptor.
+
+ Args:
+ detector: the detection module.
+ descriptor: the descriptor module.
+ """
+ def __init__(self,
+ detector: ScaleSpaceDetector,
+ descriptor: LAFDescriptor) -> None:
+ super().__init__()
+ self.detector = detector
+ self.descriptor = descriptor
+
+ def forward(self,
+ img: torch.Tensor,
+ mask: Optional[torch.Tensor] = None) -> Tuple[torch.Tensor,
+ torch.Tensor,
+ torch.Tensor]: # type: ignore
+ """
+ Args:
+ img: image to extract features with shape :math:`(B,C,H,W)`.
+ mask: a mask with weights where to apply the response function.
+ The shape must be the same as the input image.
+
+ Returns:
+ - Detected local affine frames with shape :math:`(B,N,2,3)`.
+ - Response function values for corresponding lafs with shape :math:`(B,N,1)`.
+ - Local descriptors of shape :math:`(B,N,D)` where :math:`D` is descriptor size.
+ """
+ lafs, responses = self.detector(img, mask)
+ descs = self.descriptor(img, lafs)
+ return (lafs, responses, descs)
+
+
+class SIFTFeature(LocalFeature):
+ """Convenience module, which implements DoG detector + (Root)SIFT descriptor.
+
+ Still not as good as OpenCV/VLFeat because of https://github.com/kornia/kornia/pull/884, but we are working on it
+ """
+ def __init__(self,
+ num_features: int = 8000,
+ upright: bool = False,
+ rootsift: bool = True,
+ device: torch.device = torch.device('cpu')):
+ patch_size: int = 41
+ detector = ScaleSpaceDetector(num_features,
+ resp_module=BlobDoG(),
+ nms_module=ConvQuadInterp3d(10),
+ scale_pyr_module=ScalePyramid(3, 1.6, 32, double_image=True),
+ ori_module=PassLAF() if upright else LAFOrienter(19),
+ scale_space_response=True,
+ minima_are_also_good=True,
+ mr_size=6.0).to(device)
+ descriptor = LAFDescriptor(SIFTDescriptor(patch_size=patch_size, rootsift=rootsift),
+ patch_size=patch_size,
+ grayscale_descriptor=True).to(device)
+ super().__init__(detector, descriptor)
+
+
+class GFTTAffNetHardNet(LocalFeature):
+ """Convenience module, which implements GFTT detector + AffNet-HardNet descriptor."""
+ def __init__(self,
+ num_features: int = 8000,
+ upright: bool = False,
+ device: torch.device = torch.device('cpu')):
+ detector = ScaleSpaceDetector(num_features,
+ resp_module=CornerGFTT(),
+ nms_module=ConvQuadInterp3d(10, 1e-5),
+ scale_pyr_module=ScalePyramid(3, 1.6, 32, double_image=False),
+ ori_module=PassLAF() if upright else LAFOrienter(19),
+ aff_module=LAFAffNetShapeEstimator(True).eval(),
+ mr_size=6.0).to(device)
+ descriptor = LAFDescriptor(HardNet(True).eval(),
+ patch_size=32,
+ grayscale_descriptor=True).to(device)
+ super().__init__(detector, descriptor)
+
+
+class LocalFeatureMatcher(nn.Module):
+ r"""Module, which finds correspondences between two images based on local features.
+
+ Args:
+ local_feature: Local feature detector. See :class:`~kornia.feature.GFTTAffNetHardNet`.
+ matcher: Descriptor matcher, see :class:`~kornia.feature.DescriptorMatcher`.
+
+ Returns:
+ Dict[str, torch.Tensor]: Dictionary with image correspondences and confidence scores.
+
+ Example:
+ >>> img1 = torch.rand(1, 1, 320, 200)
+ >>> img2 = torch.rand(1, 1, 128, 128)
+ >>> input = {"image0": img1, "image1": img2}
+ >>> gftt_hardnet_matcher = LocalFeatureMatcher(
+ ... GFTTAffNetHardNet(10), kornia.feature.DescriptorMatcher('snn', 0.8)
+ ... )
+ >>> out = gftt_hardnet_matcher(input)
+ """
+
+ def __init__(self, local_feature: nn.Module, matcher: nn.Module) -> None:
+ super().__init__()
+ self.local_feature = local_feature
+ self.matcher = matcher
+ self.eval()
+
+ def extract_features(self,
+ image: torch.Tensor,
+ mask: Optional[torch.Tensor] = None) -> Dict[str, torch.Tensor]:
+ """Function for feature extraction from simple image."""
+ lafs0, resps0, descs0 = self.local_feature(image, mask)
+ return {"lafs": lafs0, "responses": resps0, "descriptors": descs0}
+
+ def no_match_output(self, device: torch.device, dtype: torch.dtype) -> dict:
+ return {
+ 'keypoints0': torch.empty(0, 2, device=device, dtype=dtype),
+ 'keypoints1': torch.empty(0, 2, device=device, dtype=dtype),
+ 'lafs0': torch.empty(0, 0, 2, 3, device=device, dtype=dtype),
+ 'lafs1': torch.empty(0, 0, 2, 3, device=device, dtype=dtype),
+ 'confidence': torch.empty(0, device=device, dtype=dtype),
+ 'batch_indexes': torch.empty(0, device=device, dtype=torch.long)
+ }
+
+ def forward(self, data: Dict[str, torch.Tensor]) -> Dict[str, torch.Tensor]:
+ """
+ Args:
+ data: dictionary containing the input data in the following format:
+
+ Keyword Args:
+ image0: left image with shape :math:`(N, 1, H1, W1)`.
+ image1: right image with shape :math:`(N, 1, H2, W2)`.
+ mask0 (optional): left image mask. '0' indicates a padded position :math:`(N, H1, W1)`.
+ mask1 (optional): right image mask. '0' indicates a padded position :math:`(N, H2, W2)`.
+
+ Returns:
+ - ``keypoints0``, matching keypoints from image0 :math:`(NC, 2)`.
+ - ``keypoints1``, matching keypoints from image1 :math:`(NC, 2)`.
+ - ``confidence``, confidence score [0, 1] :math:`(NC)`.
+ - ``lafs0``, matching LAFs from image0 :math:`(1, NC, 2, 3)`.
+ - ``lafs1``, matching LAFs from image1 :math:`(1, NC, 2, 3)`.
+ - ``batch_indexes``, batch indexes for the keypoints and lafs :math:`(NC)`.
+ """
+ num_image_pairs: int = data['image0'].shape[0]
+
+ if ('lafs0' not in data.keys()) or ('descriptors0' not in data.keys()):
+ # One can supply pre-extracted local features
+ feats_dict0: Dict[str, torch.Tensor] = self.extract_features(data['image0'])
+ lafs0, descs0 = feats_dict0['lafs'], feats_dict0['descriptors']
+ else:
+ lafs0, descs0 = data['lafs0'], data['descriptors0']
+
+ if ('lafs1' not in data.keys()) or ('descriptors1' not in data.keys()):
+ feats_dict1: Dict[str, torch.Tensor] = self.extract_features(data['image1'])
+ lafs1, descs1 = feats_dict1['lafs'], feats_dict1['descriptors']
+ else:
+ lafs1, descs1 = data['lafs1'], data['descriptors1']
+
+ keypoints0: torch.Tensor = get_laf_center(lafs0)
+ keypoints1: torch.Tensor = get_laf_center(lafs1)
+
+ out_keypoints0: List[torch.Tensor] = []
+ out_keypoints1: List[torch.Tensor] = []
+ out_confidence: List[torch.Tensor] = []
+ out_batch_indexes: List[torch.Tensor] = []
+ out_lafs0: List[torch.Tensor] = []
+ out_lafs1: List[torch.Tensor] = []
+
+ for batch_idx in range(num_image_pairs):
+ dists, idxs = self.matcher(descs0[batch_idx], descs1[batch_idx])
+ if len(idxs) == 0:
+ continue
+
+ current_keypoints_0 = keypoints0[batch_idx, idxs[:, 0]]
+ current_keypoints_1 = keypoints1[batch_idx, idxs[:, 1]]
+ current_lafs_0 = lafs0[batch_idx, idxs[:, 0]]
+ current_lafs_1 = lafs1[batch_idx, idxs[:, 1]]
+
+ out_confidence.append(1.0 - dists)
+ batch_idxs = batch_idx * torch.ones(len(dists),
+ device=keypoints0.device,
+ dtype=torch.long)
+ out_keypoints0.append(current_keypoints_0)
+ out_keypoints1.append(current_keypoints_1)
+ out_lafs0.append(current_lafs_0)
+ out_lafs1.append(current_lafs_1)
+ out_batch_indexes.append(batch_idxs)
+
+ if len(out_batch_indexes) == 0:
+ return self.no_match_output(data['image0'].device,
+ data['image0'].dtype)
+
+ return {
+ 'keypoints0': torch.cat(out_keypoints0, dim=0).view(-1, 2),
+ 'keypoints1': torch.cat(out_keypoints1, dim=0).view(-1, 2),
+ 'lafs0': torch.cat(out_lafs0, dim=0).view(1, -1, 2, 3),
+ 'lafs1': torch.cat(out_lafs1, dim=0).view(1, -1, 2, 3),
+ 'confidence': torch.cat(out_confidence, dim=0).view(-1),
+ 'batch_indexes': torch.cat(out_batch_indexes, dim=0).view(-1)
+ }
diff --git a/kornia/feature/laf.py b/kornia/feature/laf.py
new file mode 100644
index 0000000000000000000000000000000000000000..8ce63b7c3692ae33d139bce0043edd65206ae854
--- /dev/null
+++ b/kornia/feature/laf.py
@@ -0,0 +1,623 @@
+import math
+from typing import Union
+
+import torch
+import torch.nn.functional as F
+
+from kornia.geometry.conversions import angle_to_rotation_matrix, convert_points_from_homogeneous, rad2deg
+from kornia.geometry.linalg import transform_points
+from kornia.geometry.transform import pyrdown
+
+
+def raise_error_if_laf_is_not_valid(laf: torch.Tensor) -> None:
+ """Auxiliary function, which verifies that input.
+
+ Args:
+ laf: [BxNx2x3] shape.
+ """
+ laf_message: str = f"Invalid laf shape, we expect BxNx2x3. Got: {laf.shape}"
+ if not isinstance(laf, torch.Tensor):
+ raise TypeError(f"Laf type is not a torch.Tensor. Got {type(laf)}")
+ if len(laf.shape) != 4:
+ raise ValueError(laf_message)
+ if laf.size(2) != 2 or laf.size(3) != 3:
+ raise ValueError(laf_message)
+ return
+
+
+def get_laf_scale(LAF: torch.Tensor) -> torch.Tensor:
+ """Return a scale of the LAFs.
+
+ Args:
+ LAF: tensor [BxNx2x3] or [BxNx2x2].
+
+ Returns:
+ tensor BxNx1x1.
+
+ Shape:
+ - Input: :math: `(B, N, 2, 3)`
+ - Output: :math: `(B, N, 1, 1)`
+
+ Example:
+ >>> input = torch.ones(1, 5, 2, 3) # BxNx2x3
+ >>> output = get_laf_scale(input) # BxNx1x1
+ """
+ raise_error_if_laf_is_not_valid(LAF)
+ eps = 1e-10
+ out = LAF[..., 0:1, 0:1] * LAF[..., 1:2, 1:2] - LAF[..., 1:2, 0:1] * LAF[..., 0:1, 1:2] + eps
+ return out.abs().sqrt()
+
+
+def get_laf_center(LAF: torch.Tensor) -> torch.Tensor:
+ """Return a center (keypoint) of the LAFs.
+
+ Args:
+ LAF: tensor [BxNx2x3].
+
+ Returns:
+ tensor BxNx2.
+
+ Shape:
+ - Input: :math: `(B, N, 2, 3)`
+ - Output: :math: `(B, N, 2)`
+
+ Example:
+ >>> input = torch.ones(1, 5, 2, 3) # BxNx2x3
+ >>> output = get_laf_center(input) # BxNx2
+ """
+ raise_error_if_laf_is_not_valid(LAF)
+ out: torch.Tensor = LAF[..., 2]
+ return out
+
+
+def get_laf_orientation(LAF: torch.Tensor) -> torch.Tensor:
+ """Return orientation of the LAFs, in degrees.
+
+ Args:
+ LAF: (torch.Tensor): tensor [BxNx2x3].
+
+ Returns:
+ torch.Tensor: tensor BxNx1 .
+
+ Shape:
+ - Input: :math: `(B, N, 2, 3)`
+ - Output: :math: `(B, N, 1)`
+
+ Example:
+ >>> input = torch.ones(1, 5, 2, 3) # BxNx2x3
+ >>> output = get_laf_orientation(input) # BxNx1
+ """
+ raise_error_if_laf_is_not_valid(LAF)
+ angle_rad: torch.Tensor = torch.atan2(LAF[..., 0, 1], LAF[..., 0, 0])
+ return rad2deg(angle_rad).unsqueeze(-1)
+
+
+def set_laf_orientation(LAF: torch.Tensor, angles_degrees: torch.Tensor) -> torch.Tensor:
+ """Change the orientation of the LAFs.
+
+ Args:
+ LAF: tensor [BxNx2x3].
+ angles: tensor BxNx1, in degrees.
+
+ Returns:
+ tensor [BxNx2x3].
+
+ Shape:
+ - Input: :math: `(B, N, 2, 3)`, `(B, N, 1)`
+ - Output: :math: `(B, N, 2, 3)`
+ """
+ raise_error_if_laf_is_not_valid(LAF)
+ B, N = LAF.shape[:2]
+ rotmat: torch.Tensor = angle_to_rotation_matrix(angles_degrees).view(B * N, 2, 2)
+ laf_out: torch.Tensor = torch.cat(
+ [torch.bmm(make_upright(LAF).view(B * N, 2, 3)[:, :2, :2], rotmat), LAF.view(B * N, 2, 3)[:, :2, 2:]], dim=2
+ ).view(B, N, 2, 3)
+ return laf_out
+
+
+def laf_from_center_scale_ori(xy: torch.Tensor, scale: torch.Tensor, ori: torch.Tensor) -> torch.Tensor:
+ """Return orientation of the LAFs, in radians. Useful to create kornia LAFs from OpenCV keypoints.
+
+ Args:
+ xy: tensor [BxNx2].
+ scale: tensor [BxNx1x1].
+ ori: tensor [BxNx1].
+
+ Returns:
+ tensor BxNx2x3.
+ """
+ names = ['xy', 'scale', 'ori']
+ for var_name, var, req_shape in zip(names, [xy, scale, ori], [("B", "N", 2), ("B", "N", 1, 1), ("B", "N", 1)]):
+ if not isinstance(var, torch.Tensor):
+ raise TypeError(f"{var_name} type is not a torch.Tensor. Got {type(var)}")
+ if len(var.shape) != len(req_shape): # type: ignore # because it does not like len(tensor.shape)
+ raise TypeError("{} shape should be must be [{}]. " "Got {}".format(var_name, str(req_shape), var.size()))
+ for i, dim in enumerate(req_shape): # type: ignore # because it wants typing for dim
+ if dim is not int:
+ continue
+ if var.size(i) != dim:
+ raise TypeError(
+ "{} shape should be must be [{}]. " "Got {}".format(var_name, str(req_shape), var.size())
+ )
+ unscaled_laf: torch.Tensor = torch.cat([angle_to_rotation_matrix(ori.squeeze(-1)), xy.unsqueeze(-1)], dim=-1)
+ laf: torch.Tensor = scale_laf(unscaled_laf, scale)
+ return laf
+
+
+def scale_laf(laf: torch.Tensor, scale_coef: Union[float, torch.Tensor]) -> torch.Tensor:
+ """Multiplies region part of LAF ([:, :, :2, :2]) by a scale_coefficient.
+
+ So the center, shape and orientation of the local feature stays the same, but the region area changes.
+
+ Args:
+ laf: tensor [BxNx2x3] or [BxNx2x2].
+ scale_coef: broadcastable tensor or float.
+
+ Returns:
+ tensor BxNx2x3.
+
+ Shape:
+ - Input: :math:`(B, N, 2, 3)`
+ - Input: :math:`(B, N,)` or ()
+ - Output: :math:`(B, N, 1, 1)`
+
+ Example:
+ >>> input = torch.ones(1, 5, 2, 3) # BxNx2x3
+ >>> scale = 0.5
+ >>> output = scale_laf(input, scale) # BxNx2x3
+ """
+ if (type(scale_coef) is not float) and (type(scale_coef) is not torch.Tensor):
+ raise TypeError("scale_coef should be float or torch.Tensor " "Got {}".format(type(scale_coef)))
+ raise_error_if_laf_is_not_valid(laf)
+ centerless_laf: torch.Tensor = laf[:, :, :2, :2]
+ return torch.cat([scale_coef * centerless_laf, laf[:, :, :, 2:]], dim=3)
+
+
+def make_upright(laf: torch.Tensor, eps: float = 1e-9) -> torch.Tensor:
+ """Rectify the affine matrix, so that it becomes upright.
+
+ Args:
+ laf: tensor of LAFs.
+ eps : for safe division.
+
+ Returns:
+ tensor of same shape.
+
+ Shape:
+ - Input: :math:`(B, N, 2, 3)`
+ - Output: :math:`(B, N, 2, 3)`
+
+ Example:
+ >>> input = torch.ones(1, 5, 2, 3) # BxNx2x3
+ >>> output = make_upright(input) # BxNx2x3
+ """
+ raise_error_if_laf_is_not_valid(laf)
+ det = get_laf_scale(laf)
+ scale = det
+ # The function is equivalent to doing 2x2 SVD and resetting rotation
+ # matrix to an identity: U, S, V = svd(LAF); LAF_upright = U * S.
+ b2a2 = torch.sqrt(laf[..., 0:1, 1:2] ** 2 + laf[..., 0:1, 0:1] ** 2) + eps
+ laf1_ell = torch.cat([(b2a2 / det).contiguous(), torch.zeros_like(det)], dim=3)
+ laf2_ell = torch.cat( # type: ignore
+ [
+ ((laf[..., 1:2, 1:2] * laf[..., 0:1, 1:2] + laf[..., 1:2, 0:1] * laf[..., 0:1, 0:1]) / (b2a2 * det)),
+ (det / b2a2).contiguous(),
+ ],
+ dim=3,
+ )
+ laf_unit_scale = torch.cat([torch.cat([laf1_ell, laf2_ell], dim=2), laf[..., :, 2:3]], dim=3)
+ return scale_laf(laf_unit_scale, scale)
+
+
+def ellipse_to_laf(ells: torch.Tensor) -> torch.Tensor:
+ """Convert ellipse regions to LAF format.
+
+ Ellipse (a, b, c) and upright covariance matrix [a11 a12; 0 a22] are connected
+ by inverse matrix square root: A = invsqrt([a b; b c]).
+
+ See also https://github.com/vlfeat/vlfeat/blob/master/toolbox/sift/vl_frame2oell.m
+
+ Args:
+ ells: tensor of ellipses in Oxford format [x y a b c].
+
+ Returns:
+ tensor of ellipses in LAF format.
+
+ Shape:
+ - Input: :math:`(B, N, 5)`
+ - Output: :math:`(B, N, 2, 3)`
+
+ Example:
+ >>> input = torch.ones(1, 10, 5) # BxNx5
+ >>> output = ellipse_to_laf(input) # BxNx2x3
+ """
+ n_dims = len(ells.size())
+ if n_dims != 3:
+ raise TypeError("ellipse shape should be must be [BxNx5]. " "Got {}".format(ells.size()))
+ B, N, dim = ells.size()
+ if dim != 5:
+ raise TypeError("ellipse shape should be must be [BxNx5]. " "Got {}".format(ells.size()))
+ # Previous implementation was incorrectly using Cholesky decomp as matrix sqrt
+ # ell_shape = torch.cat([torch.cat([ells[..., 2:3], ells[..., 3:4]], dim=2).unsqueeze(2),
+ # torch.cat([ells[..., 3:4], ells[..., 4:5]], dim=2).unsqueeze(2)], dim=2).view(-1, 2, 2)
+ # out = torch.matrix_power(torch.cholesky(ell_shape, False), -1).view(B, N, 2, 2)
+
+ # We will calculate 2x2 matrix square root via special case formula
+ # https://en.wikipedia.org/wiki/Square_root_of_a_matrix
+ # "The Cholesky factorization provides another particular example of square root
+ # which should not be confused with the unique non-negative square root."
+ # https://en.wikipedia.org/wiki/Square_root_of_a_2_by_2_matrix
+ # M = (A 0; C D)
+ # R = (sqrt(A) 0; C / (sqrt(A)+sqrt(D)) sqrt(D))
+ a11 = ells[..., 2:3].abs().sqrt()
+ a12 = torch.zeros_like(a11)
+ a22 = ells[..., 4:5].abs().sqrt()
+ a21 = ells[..., 3:4] / (a11 + a22).clamp(1e-9)
+ A = torch.stack([a11, a12, a21, a22], dim=-1).view(B, N, 2, 2).inverse()
+ out = torch.cat([A, ells[..., :2].view(B, N, 2, 1)], dim=3)
+ return out
+
+
+def laf_to_boundary_points(LAF: torch.Tensor, n_pts: int = 50) -> torch.Tensor:
+ """Convert LAFs to boundary points of the regions + center.
+
+ Used for local features visualization, see visualize_laf function.
+
+ Args:
+ LAF:
+ n_pts: number of points to output.
+
+ Returns:
+ tensor of boundary points.
+
+ Shape:
+ - Input: :math:`(B, N, 2, 3)`
+ - Output: :math:`(B, N, n_pts, 2)`
+ """
+ raise_error_if_laf_is_not_valid(LAF)
+ B, N, _, _ = LAF.size()
+ pts = torch.cat(
+ [
+ torch.sin(torch.linspace(0, 2 * math.pi, n_pts - 1)).unsqueeze(-1),
+ torch.cos(torch.linspace(0, 2 * math.pi, n_pts - 1)).unsqueeze(-1),
+ torch.ones(n_pts - 1, 1),
+ ],
+ dim=1,
+ )
+ # Add origin to draw also the orientation
+ pts = torch.cat([torch.tensor([0.0, 0.0, 1.0]).view(1, 3), pts], dim=0).unsqueeze(0).expand(B * N, n_pts, 3)
+ pts = pts.to(LAF.device).to(LAF.dtype)
+ aux = torch.tensor([0.0, 0.0, 1.0]).view(1, 1, 3).expand(B * N, 1, 3)
+ HLAF = torch.cat([LAF.view(-1, 2, 3), aux.to(LAF.device).to(LAF.dtype)], dim=1)
+ pts_h = torch.bmm(HLAF, pts.permute(0, 2, 1)).permute(0, 2, 1)
+ return convert_points_from_homogeneous(pts_h.view(B, N, n_pts, 3))
+
+
+def get_laf_pts_to_draw(LAF: torch.Tensor, img_idx: int = 0):
+ """Return numpy array for drawing LAFs (local features).
+
+ Args:
+ LAF:
+ n_pts: number of boundary points to output.
+
+ Returns:
+ tensor of boundary points.
+
+ Shape:
+ - Input: :math:`(B, N, 2, 3)`
+ - Output: :math:`(B, N, n_pts, 2)`
+
+ Examples:
+ x, y = get_laf_pts_to_draw(LAF, img_idx)
+ plt.figure()
+ plt.imshow(kornia.utils.tensor_to_image(img[img_idx]))
+ plt.plot(x, y, 'r')
+ plt.show()
+ """
+ # TODO: Refactor doctest
+ raise_error_if_laf_is_not_valid(LAF)
+ pts = laf_to_boundary_points(LAF[img_idx: img_idx + 1])[0]
+ pts_np = pts.detach().permute(1, 0, 2).cpu().numpy()
+ return (pts_np[..., 0], pts_np[..., 1])
+
+
+def denormalize_laf(LAF: torch.Tensor, images: torch.Tensor) -> torch.Tensor:
+ """De-normalize LAFs from scale to image scale.
+
+ B,N,H,W = images.size()
+ MIN_SIZE = min(H,W)
+ [a11 a21 x]
+ [a21 a22 y]
+ becomes
+ [a11*MIN_SIZE a21*MIN_SIZE x*W]
+ [a21*MIN_SIZE a22*MIN_SIZE y*H]
+
+ Args:
+ LAF:
+ images: images, LAFs are detected in.
+
+ Returns:
+ the denormalized lafs.
+
+ Shape:
+ - Input: :math:`(B, N, 2, 3)`
+ - Output: :math:`(B, N, 2, 3)`
+ """
+ raise_error_if_laf_is_not_valid(LAF)
+ _, _, h, w = images.size()
+ wf = float(w)
+ hf = float(h)
+ min_size = min(hf, wf)
+ coef = torch.ones(1, 1, 2, 3).to(LAF.dtype).to(LAF.device) * min_size
+ coef[0, 0, 0, 2] = wf
+ coef[0, 0, 1, 2] = hf
+ return coef.expand_as(LAF) * LAF
+
+
+def normalize_laf(LAF: torch.Tensor, images: torch.Tensor) -> torch.Tensor:
+ """Normalize LAFs to [0,1] scale from pixel scale. See below:
+ B,N,H,W = images.size()
+ MIN_SIZE = min(H,W)
+ [a11 a21 x]
+ [a21 a22 y]
+ becomes:
+ [a11/MIN_SIZE a21/MIN_SIZE x/W]
+ [a21/MIN_SIZE a22/MIN_SIZE y/H]
+
+ Args:
+ LAF: (torch.Tensor).
+ images: (torch.Tensor) images, LAFs are detected in
+
+ Returns:
+ LAF: (torch.Tensor).
+
+ Shape:
+ - Input: :math:`(B, N, 2, 3)`
+ - Output: :math:`(B, N, 2, 3)`
+ """
+ raise_error_if_laf_is_not_valid(LAF)
+ _, _, h, w = images.size()
+ wf: float = float(w)
+ hf: float = float(h)
+ min_size = min(hf, wf)
+ coef = torch.ones(1, 1, 2, 3).to(LAF.dtype).to(LAF.device) / min_size
+ coef[0, 0, 0, 2] = 1.0 / wf
+ coef[0, 0, 1, 2] = 1.0 / hf
+ return coef.expand_as(LAF) * LAF
+
+
+def generate_patch_grid_from_normalized_LAF(img: torch.Tensor, LAF: torch.Tensor, PS: int = 32) -> torch.Tensor:
+ """Helper function for affine grid generation.
+
+ Args:
+ img: image tensor of shape :math:`(B, CH, H, W)`.
+ LAF: laf with shape :math:`(B, N, 2, 3)`.
+ PS: patch size to be extracted.
+
+ Returns:
+ grid
+ """
+ raise_error_if_laf_is_not_valid(LAF)
+ B, N, _, _ = LAF.size()
+ _, ch, h, w = img.size()
+
+ # norm, then renorm is needed for allowing detection on one resolution
+ # and extraction at arbitrary other
+ LAF_renorm = denormalize_laf(LAF, img)
+
+ grid = F.affine_grid(LAF_renorm.view(B * N, 2, 3), [B * N, ch, PS, PS], align_corners=False) # type: ignore
+ grid[..., :, 0] = 2.0 * grid[..., :, 0].clone() / float(w) - 1.0
+ grid[..., :, 1] = 2.0 * grid[..., :, 1].clone() / float(h) - 1.0
+ return grid
+
+
+def extract_patches_simple(
+ img: torch.Tensor, laf: torch.Tensor, PS: int = 32, normalize_lafs_before_extraction: bool = True
+) -> torch.Tensor:
+ """Extract patches defined by LAFs from image tensor.
+
+ No smoothing applied, huge aliasing (better use extract_patches_from_pyramid).
+
+ Args:
+ img: images, LAFs are detected in.
+ laf:
+ PS: patch size.
+ normalize_lafs_before_extraction: if True, lafs are normalized to image size.
+
+ Returns:
+ patches with shape :math:`(B, N, CH, PS,PS)`.
+ """
+ raise_error_if_laf_is_not_valid(laf)
+ if normalize_lafs_before_extraction:
+ nlaf: torch.Tensor = normalize_laf(laf, img)
+ else:
+ nlaf = laf
+ _, ch, h, w = img.size()
+ B, N, _, _ = laf.size()
+ out = []
+ # for loop temporarily, to be refactored
+ for i in range(B):
+ grid = generate_patch_grid_from_normalized_LAF(img[i: i + 1], nlaf[i: i + 1], PS).to(img.device)
+ out.append(
+ F.grid_sample(
+ img[i: i + 1].expand(grid.size(0), ch, h, w),
+ grid, # type: ignore
+ padding_mode="border",
+ align_corners=False,
+ )
+ )
+ return torch.cat(out, dim=0).view(B, N, ch, PS, PS)
+
+
+def extract_patches_from_pyramid(
+ img: torch.Tensor, laf: torch.Tensor, PS: int = 32, normalize_lafs_before_extraction: bool = True
+) -> torch.Tensor:
+ """Extract patches defined by LAFs from image tensor.
+
+ Patches are extracted from appropriate pyramid level.
+
+ Args:
+ laf:
+ images: images, LAFs are detected in.
+ PS: patch size.
+ normalize_lafs_before_extraction: if True, lafs are normalized to image size.
+
+ Returns:
+ patches with shape :math:`(B, N, CH, PS,PS)`.
+ """
+ raise_error_if_laf_is_not_valid(laf)
+ if normalize_lafs_before_extraction:
+ nlaf: torch.Tensor = normalize_laf(laf, img)
+ else:
+ nlaf = laf
+ B, N, _, _ = laf.size()
+ _, ch, h, w = img.size()
+ scale = 2.0 * get_laf_scale(denormalize_laf(nlaf, img)) / float(PS)
+ half: float = 0.5
+ pyr_idx = (scale.log2() + half).relu().long()
+ cur_img = img
+ cur_pyr_level = 0
+ out = torch.zeros(B, N, ch, PS, PS).to(nlaf.dtype).to(nlaf.device)
+ while min(cur_img.size(2), cur_img.size(3)) >= PS:
+ _, ch, h, w = cur_img.size()
+ # for loop temporarily, to be refactored
+ for i in range(B):
+ scale_mask = (pyr_idx[i] == cur_pyr_level).squeeze()
+ if (scale_mask.float().sum()) == 0:
+ continue
+ scale_mask = (scale_mask > 0).view(-1)
+ grid = generate_patch_grid_from_normalized_LAF(cur_img[i: i + 1], nlaf[i: i + 1, scale_mask, :, :], PS)
+ patches = F.grid_sample(
+ cur_img[i: i + 1].expand(grid.size(0), ch, h, w),
+ grid, # type: ignore
+ padding_mode="border",
+ align_corners=False,
+ )
+ out[i].masked_scatter_(scale_mask.view(-1, 1, 1, 1), patches)
+ cur_img = pyrdown(cur_img)
+ cur_pyr_level += 1
+ return out
+
+
+def laf_is_inside_image(laf: torch.Tensor, images: torch.Tensor, border: int = 0) -> torch.Tensor:
+ """Check if the LAF is touching or partly outside the image boundary.
+
+ Returns the mask of LAFs, which are fully inside the image, i.e. valid.
+
+ Args:
+ laf: :math:`(B, N, 2, 3)`.
+ images: images, lafs are detected in :math:`(B, CH, H, W)`.
+ border: additional border.
+
+ Returns:
+ mask with shape :math:`(B, N)`.
+ """
+ raise_error_if_laf_is_not_valid(laf)
+ _, _, h, w = images.size()
+ pts: torch.Tensor = laf_to_boundary_points(laf, 12)
+ good_lafs_mask: torch.Tensor = (
+ (pts[..., 0] >= border) * (pts[..., 0] <= w - border) * (pts[..., 1] >= border) * (pts[..., 1] <= h - border)
+ )
+ good_lafs_mask = good_lafs_mask.min(dim=2)[0]
+ return good_lafs_mask
+
+
+def laf_to_three_points(laf: torch.Tensor):
+ """Convert local affine frame(LAF) to alternative representation: coordinates of LAF center, LAF-x unit vector,
+ LAF-y unit vector.
+
+ Args:
+ laf: :math:`(B, N, 2, 3)`.
+
+ Returns:
+ threepts :math:`(B, N, 2, 3)`.
+ """
+ raise_error_if_laf_is_not_valid(laf)
+ three_pts: torch.Tensor = torch.stack([laf[..., 2] + laf[..., 0], laf[..., 2] + laf[..., 1], laf[..., 2]], dim=-1)
+ return three_pts
+
+
+def laf_from_three_points(threepts: torch.Tensor):
+ """Convert three points to local affine frame.
+
+ Order is (0,0), (0, 1), (1, 0).
+
+ Args:
+ threepts: :math:`(B, N, 2, 3)`.
+
+ Returns:
+ laf :math:`(B, N, 2, 3)`.
+ """
+ laf: torch.Tensor = torch.stack(
+ [threepts[..., 0] - threepts[..., 2], threepts[..., 1] - threepts[..., 2], threepts[..., 2]], dim=-1
+ )
+ return laf
+
+
+def perspective_transform_lafs(trans_01: torch.Tensor, lafs_1: torch.Tensor) -> torch.Tensor:
+ r"""Function that applies perspective transformations to a set of local affine frames (LAFs).
+
+ Args:
+ trans_01: tensor for perspective transformations of shape :math:`(B, 3, 3)`.
+ lafs_1: tensor of lafs of shape :math:`(B, N, 2, 3)`.
+
+ Returns:
+ tensor of N-dimensional points of shape :math:`(B, N, 2, 3)`.
+
+ Examples:
+ >>> rng = torch.manual_seed(0)
+ >>> lafs_1 = torch.rand(2, 4, 2, 3) # BxNx2x3
+ >>> lafs_1
+ tensor([[[[0.4963, 0.7682, 0.0885],
+ [0.1320, 0.3074, 0.6341]],
+
+ [[0.4901, 0.8964, 0.4556],
+ [0.6323, 0.3489, 0.4017]],
+
+ [[0.0223, 0.1689, 0.2939],
+ [0.5185, 0.6977, 0.8000]],
+
+ [[0.1610, 0.2823, 0.6816],
+ [0.9152, 0.3971, 0.8742]]],
+
+
+ [[[0.4194, 0.5529, 0.9527],
+ [0.0362, 0.1852, 0.3734]],
+
+ [[0.3051, 0.9320, 0.1759],
+ [0.2698, 0.1507, 0.0317]],
+
+ [[0.2081, 0.9298, 0.7231],
+ [0.7423, 0.5263, 0.2437]],
+
+ [[0.5846, 0.0332, 0.1387],
+ [0.2422, 0.8155, 0.7932]]]])
+ >>> trans_01 = torch.eye(3).repeat(2, 1, 1) # Bx3x3
+ >>> trans_01.shape
+ torch.Size([2, 3, 3])
+ >>> lafs_0 = perspective_transform_lafs(trans_01, lafs_1) # BxNx2x3
+ """
+ raise_error_if_laf_is_not_valid(lafs_1)
+ if not torch.is_tensor(trans_01):
+ raise TypeError("Input type is not a torch.Tensor")
+
+ if not trans_01.device == lafs_1.device:
+ raise TypeError("Tensor must be in the same device")
+
+ if not trans_01.shape[0] == lafs_1.shape[0]:
+ raise ValueError("Input batch size must be the same for both tensors")
+
+ if (not (trans_01.shape[-1] == 3)) or (not (trans_01.shape[-2] == 3)):
+ raise ValueError("Transformation should be homography")
+
+ bs, n, _, _ = lafs_1.size()
+ # First, we convert LAF to points
+ threepts_1 = laf_to_three_points(lafs_1)
+ points_1 = threepts_1.permute(0, 1, 3, 2).reshape(bs, n * 3, 2)
+
+ # First, transform the points
+ points_0 = transform_points(trans_01, points_1)
+
+ # Back to LAF format
+ threepts_0 = points_0.view(bs, n, 3, 2).permute(0, 1, 3, 2)
+ return laf_from_three_points(threepts_0)
diff --git a/kornia/feature/loftr/__init__.py b/kornia/feature/loftr/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..59a4f95e7a178b58a2252cdaee90862aecee8fd6
--- /dev/null
+++ b/kornia/feature/loftr/__init__.py
@@ -0,0 +1 @@
+from .loftr import LoFTR
diff --git a/kornia/feature/loftr/backbone/__init__.py b/kornia/feature/loftr/backbone/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b6e731b3f53ab367c89ef0ea8e1cbffb0d990775
--- /dev/null
+++ b/kornia/feature/loftr/backbone/__init__.py
@@ -0,0 +1,11 @@
+from .resnet_fpn import ResNetFPN_8_2, ResNetFPN_16_4
+
+
+def build_backbone(config):
+ if config['backbone_type'] == 'ResNetFPN':
+ if config['resolution'] == (8, 2):
+ return ResNetFPN_8_2(config['resnetfpn'])
+ elif config['resolution'] == (16, 4):
+ return ResNetFPN_16_4(config['resnetfpn'])
+ else:
+ raise ValueError(f"LOFTR.BACKBONE_TYPE {config['backbone_type']} not supported.")
diff --git a/kornia/feature/loftr/backbone/resnet_fpn.py b/kornia/feature/loftr/backbone/resnet_fpn.py
new file mode 100644
index 0000000000000000000000000000000000000000..4ecded3d871b000c66898658ff8b564602cca736
--- /dev/null
+++ b/kornia/feature/loftr/backbone/resnet_fpn.py
@@ -0,0 +1,199 @@
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+def conv1x1(in_planes, out_planes, stride=1):
+ """1x1 convolution without padding."""
+ return nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, padding=0, bias=False)
+
+
+def conv3x3(in_planes, out_planes, stride=1):
+ """3x3 convolution with padding."""
+ return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride, padding=1, bias=False)
+
+
+class BasicBlock(nn.Module):
+ def __init__(self, in_planes, planes, stride=1):
+ super().__init__()
+ self.conv1 = conv3x3(in_planes, planes, stride)
+ self.conv2 = conv3x3(planes, planes)
+ self.bn1 = nn.BatchNorm2d(planes)
+ self.bn2 = nn.BatchNorm2d(planes)
+ self.relu = nn.ReLU(inplace=True)
+
+ if stride == 1:
+ self.downsample = None
+ else:
+ self.downsample = nn.Sequential(
+ conv1x1(in_planes, planes, stride=stride),
+ nn.BatchNorm2d(planes)
+ )
+
+ def forward(self, x):
+ y = x
+ y = self.relu(self.bn1(self.conv1(y)))
+ y = self.bn2(self.conv2(y))
+
+ if self.downsample is not None:
+ x = self.downsample(x)
+
+ return self.relu(x + y)
+
+
+class ResNetFPN_8_2(nn.Module):
+ """ResNet+FPN, output resolution are 1/8 and 1/2.
+
+ Each block has 2 layers.
+ """
+
+ def __init__(self, config):
+ super().__init__()
+ # Config
+ block = BasicBlock
+ initial_dim = config['initial_dim']
+ block_dims = config['block_dims']
+
+ # Class Variable
+ self.in_planes = initial_dim
+
+ # Networks
+ self.conv1 = nn.Conv2d(1, initial_dim, kernel_size=7, stride=2, padding=3, bias=False)
+ self.bn1 = nn.BatchNorm2d(initial_dim)
+ self.relu = nn.ReLU(inplace=True)
+
+ self.layer1 = self._make_layer(block, block_dims[0], stride=1) # 1/2
+ self.layer2 = self._make_layer(block, block_dims[1], stride=2) # 1/4
+ self.layer3 = self._make_layer(block, block_dims[2], stride=2) # 1/8
+
+ # 3. FPN upsample
+ self.layer3_outconv = conv1x1(block_dims[2], block_dims[2])
+ self.layer2_outconv = conv1x1(block_dims[1], block_dims[2])
+ self.layer2_outconv2 = nn.Sequential(
+ conv3x3(block_dims[2], block_dims[2]),
+ nn.BatchNorm2d(block_dims[2]),
+ nn.LeakyReLU(),
+ conv3x3(block_dims[2], block_dims[1]),
+ )
+ self.layer1_outconv = conv1x1(block_dims[0], block_dims[1])
+ self.layer1_outconv2 = nn.Sequential(
+ conv3x3(block_dims[1], block_dims[1]),
+ nn.BatchNorm2d(block_dims[1]),
+ nn.LeakyReLU(),
+ conv3x3(block_dims[1], block_dims[0]),
+ )
+
+ for m in self.modules():
+ if isinstance(m, nn.Conv2d):
+ nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+ elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):
+ nn.init.constant_(m.weight, 1)
+ nn.init.constant_(m.bias, 0)
+
+ def _make_layer(self, block, dim, stride=1):
+ layer1 = block(self.in_planes, dim, stride=stride)
+ layer2 = block(dim, dim, stride=1)
+ layers = (layer1, layer2)
+
+ self.in_planes = dim
+ return nn.Sequential(*layers)
+
+ def forward(self, x):
+ # ResNet Backbone
+ x0 = self.relu(self.bn1(self.conv1(x)))
+ x1 = self.layer1(x0) # 1/2
+ x2 = self.layer2(x1) # 1/4
+ x3 = self.layer3(x2) # 1/8
+
+ # FPN
+ x3_out = self.layer3_outconv(x3)
+
+ x2_out = self.layer2_outconv(x2)
+ x3_out_2x = F.interpolate(x3_out, size=(x2_out.shape[2:]), mode='bilinear', align_corners=True)
+ x2_out = self.layer2_outconv2(x2_out + x3_out_2x)
+
+ x1_out = self.layer1_outconv(x1)
+ x2_out_2x = F.interpolate(x2_out, size=(x1_out.shape[2:]), mode='bilinear', align_corners=True)
+ x1_out = self.layer1_outconv2(x1_out + x2_out_2x)
+
+ return [x3_out, x1_out]
+
+
+class ResNetFPN_16_4(nn.Module):
+ """ResNet+FPN, output resolution are 1/16 and 1/4.
+
+ Each block has 2 layers.
+ """
+
+ def __init__(self, config):
+ super().__init__()
+ # Config
+ block = BasicBlock
+ initial_dim = config['initial_dim']
+ block_dims = config['block_dims']
+
+ # Class Variable
+ self.in_planes = initial_dim
+
+ # Networks
+ self.conv1 = nn.Conv2d(1, initial_dim, kernel_size=7, stride=2, padding=3, bias=False)
+ self.bn1 = nn.BatchNorm2d(initial_dim)
+ self.relu = nn.ReLU(inplace=True)
+
+ self.layer1 = self._make_layer(block, block_dims[0], stride=1) # 1/2
+ self.layer2 = self._make_layer(block, block_dims[1], stride=2) # 1/4
+ self.layer3 = self._make_layer(block, block_dims[2], stride=2) # 1/8
+ self.layer4 = self._make_layer(block, block_dims[3], stride=2) # 1/16
+
+ # 3. FPN upsample
+ self.layer4_outconv = conv1x1(block_dims[3], block_dims[3])
+ self.layer3_outconv = conv1x1(block_dims[2], block_dims[3])
+ self.layer3_outconv2 = nn.Sequential(
+ conv3x3(block_dims[3], block_dims[3]),
+ nn.BatchNorm2d(block_dims[3]),
+ nn.LeakyReLU(),
+ conv3x3(block_dims[3], block_dims[2]),
+ )
+
+ self.layer2_outconv = conv1x1(block_dims[1], block_dims[2])
+ self.layer2_outconv2 = nn.Sequential(
+ conv3x3(block_dims[2], block_dims[2]),
+ nn.BatchNorm2d(block_dims[2]),
+ nn.LeakyReLU(),
+ conv3x3(block_dims[2], block_dims[1]),
+ )
+
+ for m in self.modules():
+ if isinstance(m, nn.Conv2d):
+ nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+ elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):
+ nn.init.constant_(m.weight, 1)
+ nn.init.constant_(m.bias, 0)
+
+ def _make_layer(self, block, dim, stride=1):
+ layer1 = block(self.in_planes, dim, stride=stride)
+ layer2 = block(dim, dim, stride=1)
+ layers = (layer1, layer2)
+
+ self.in_planes = dim
+ return nn.Sequential(*layers)
+
+ def forward(self, x):
+ # ResNet Backbone
+ x0 = self.relu(self.bn1(self.conv1(x)))
+ x1 = self.layer1(x0) # 1/2
+ x2 = self.layer2(x1) # 1/4
+ x3 = self.layer3(x2) # 1/8
+ x4 = self.layer4(x3) # 1/16
+
+ # FPN
+ x4_out = self.layer4_outconv(x4)
+
+ x4_out_2x = F.interpolate(x4_out, scale_factor=2., mode='bilinear', align_corners=True)
+ x3_out = self.layer3_outconv(x3)
+ x3_out = self.layer3_outconv2(x3_out + x4_out_2x)
+
+ x3_out_2x = F.interpolate(x3_out, scale_factor=2., mode='bilinear', align_corners=True)
+ x2_out = self.layer2_outconv(x2)
+ x2_out = self.layer2_outconv2(x2_out + x3_out_2x)
+
+ return [x4_out, x2_out]
diff --git a/kornia/feature/loftr/loftr.py b/kornia/feature/loftr/loftr.py
new file mode 100644
index 0000000000000000000000000000000000000000..4617c389dc3de4dc881a352a7f52c8e09b7f21b6
--- /dev/null
+++ b/kornia/feature/loftr/loftr.py
@@ -0,0 +1,178 @@
+from typing import Dict, Optional
+
+import torch
+import torch.nn as nn
+
+from .backbone import build_backbone
+from .loftr_module import FinePreprocess, LocalFeatureTransformer
+from .utils.coarse_matching import CoarseMatching
+from .utils.fine_matching import FineMatching
+from .utils.position_encoding import PositionEncodingSine
+
+urls: Dict[str, str] = {}
+urls["outdoor"] = "http://cmp.felk.cvut.cz/~mishkdmy/models/loftr_outdoor.ckpt"
+urls["indoor"] = "http://cmp.felk.cvut.cz/~mishkdmy/models/loftr_indoor.ckpt"
+
+# Comments: the config below is the one corresponding to the pretrained models
+# Some do not change there anything, unless you want to retrain it.
+
+default_cfg = {'backbone_type': 'ResNetFPN',
+ 'resolution': (8, 2),
+ 'fine_window_size': 5,
+ 'fine_concat_coarse_feat': True,
+ 'resnetfpn': {'initial_dim': 128, 'block_dims': [128, 196, 256]},
+ 'coarse': {'d_model': 256,
+ 'd_ffn': 256,
+ 'nhead': 8,
+ 'layer_names': ['self',
+ 'cross',
+ 'self',
+ 'cross',
+ 'self',
+ 'cross',
+ 'self',
+ 'cross'],
+ 'attention': 'linear',
+ 'temp_bug_fix': False},
+ 'match_coarse': {'thr': 0.2,
+ 'border_rm': 2,
+ 'match_type': 'dual_softmax',
+ 'dsmax_temperature': 0.1,
+ 'skh_iters': 3,
+ 'skh_init_bin_score': 1.0,
+ 'skh_prefilter': True,
+ 'train_coarse_percent': 0.4,
+ 'train_pad_num_gt_min': 200},
+ 'fine': {'d_model': 128,
+ 'd_ffn': 128,
+ 'nhead': 8,
+ 'layer_names': ['self', 'cross'],
+ 'attention': 'linear'}}
+
+
+class LoFTR(nn.Module):
+ r"""Module, which finds correspondences between two images.
+
+ This is based on the original code from paper "LoFTR: Detector-Free Local
+ Feature Matching with Transformers". See :cite:`LoFTR2021` for more details.
+
+ If the distance matrix dm is not provided, :py:func:`torch.cdist` is used.
+
+ Args:
+ config: Dict with initiliazation parameters. Do not pass it, unless you know what you are doing`.
+ pretrained: Download and set pretrained weights to the model. Options: 'outdoor', 'indoor'.
+ 'outdoor' is trained on the MegaDepth dataset and 'indoor'
+ on the ScanNet.
+
+ Returns:
+ Dictionary with image correspondences and confidence scores.
+
+ Example:
+ >>> img1 = torch.rand(1, 1, 320, 200)
+ >>> img2 = torch.rand(1, 1, 128, 128)
+ >>> input = {"image0": img1, "image1": img2}
+ >>> loftr = LoFTR('outdoor')
+ >>> out = loftr(input)
+ """
+
+ def __init__(self, pretrained: Optional[str] = 'outdoor', config: Dict = default_cfg):
+ super().__init__()
+ # Misc
+ self.config = config
+ # Modules
+ self.backbone = build_backbone(config)
+ self.pos_encoding = PositionEncodingSine(
+ config['coarse']['d_model'],
+ temp_bug_fix=config['coarse']['temp_bug_fix'])
+ self.loftr_coarse = LocalFeatureTransformer(config['coarse'])
+ self.coarse_matching = CoarseMatching(config['match_coarse'])
+ self.fine_preprocess = FinePreprocess(config)
+ self.loftr_fine = LocalFeatureTransformer(config["fine"])
+ self.fine_matching = FineMatching()
+ self.pretrained = pretrained
+ if pretrained is not None:
+ if pretrained not in urls.keys():
+ raise ValueError(f"pretrained should be None or one of {urls.keys()}")
+ pretrained_dict = torch.hub.load_state_dict_from_url(
+ urls[pretrained], map_location=lambda storage, loc: storage)
+ self.load_state_dict(pretrained_dict['state_dict'])
+ self.eval()
+
+ def forward(self, data: dict) -> Dict[str, torch.Tensor]:
+ """
+ Args:
+ data: dictionary containing the input data in the following format:
+
+ Keyword Args:
+ image0: left image with shape :math:`(N, 1, H1, W1)`.
+ image1: right image with shape :math:`(N, 1, H2, W2)`.
+ mask0 (optional): left image mask. '0' indicates a padded position :math:`(N, H1, W1)`.
+ mask1 (optional): right image mask. '0' indicates a padded position :math:`(N, H2, W2)`.
+
+ Returns:
+ - ``keypoints0``, matching keypoints from image0 :math:`(NC, 2)`.
+ - ``keypoints1``, matching keypoints from image1 :math:`(NC, 2)`.
+ - ``confidence``, confidence score [0, 1] :math:`(NC)`.
+ - ``batch_indexes``, batch indexes for the keypoints and lafs :math:`(NC)`.
+ """
+
+ # 1. Local Feature CNN
+ data.update({
+ 'bs': data['image0'].size(0),
+ 'hw0_i': data['image0'].shape[2:], 'hw1_i': data['image1'].shape[2:]
+ })
+
+ if data['hw0_i'] == data['hw1_i']: # faster & better BN convergence
+ feats_c, feats_f = self.backbone(torch.cat([data['image0'], data['image1']], dim=0))
+ (feat_c0, feat_c1), (feat_f0, feat_f1) = feats_c.split(data['bs']), feats_f.split(data['bs'])
+ else: # handle different input shapes
+ (feat_c0, feat_f0), (feat_c1, feat_f1) = self.backbone(data['image0']), self.backbone(data['image1'])
+
+ data.update({
+ 'hw0_c': feat_c0.shape[2:], 'hw1_c': feat_c1.shape[2:],
+ 'hw0_f': feat_f0.shape[2:], 'hw1_f': feat_f1.shape[2:]
+ })
+
+ # 2. coarse-level loftr module
+ # add featmap with positional encoding, then flatten it to sequence [N, HW, C]
+
+ # feat_c0 = rearrange(self.pos_encoding(feat_c0), 'n c h w -> n (h w) c')
+ # feat_c1 = rearrange(self.pos_encoding(feat_c1), 'n c h w -> n (h w) c')
+ feat_c0 = self.pos_encoding(feat_c0).permute(0, 2, 3, 1)
+ n, h, w, c = feat_c0.shape
+ feat_c0 = feat_c0.reshape(n, -1, c)
+
+ feat_c1 = self.pos_encoding(feat_c1).permute(0, 2, 3, 1)
+ n1, h1, w1, c1 = feat_c1.shape
+ feat_c1 = feat_c1.reshape(n1, -1, c1)
+
+ mask_c0 = mask_c1 = None # mask is useful in training
+ if 'mask0' in data:
+ mask_c0, mask_c1 = data['mask0'].flatten(-2), data['mask1'].flatten(-2)
+ feat_c0, feat_c1 = self.loftr_coarse(feat_c0, feat_c1, mask_c0, mask_c1)
+
+ # 3. match coarse-level
+ self.coarse_matching(feat_c0, feat_c1, data, mask_c0=mask_c0, mask_c1=mask_c1)
+
+ # 4. fine-level refinement
+ feat_f0_unfold, feat_f1_unfold = self.fine_preprocess(feat_f0, feat_f1, feat_c0, feat_c1, data)
+ if feat_f0_unfold.size(0) != 0: # at least one coarse level predicted
+ feat_f0_unfold, feat_f1_unfold = self.loftr_fine(feat_f0_unfold, feat_f1_unfold)
+
+ # 5. match fine-level
+ self.fine_matching(feat_f0_unfold, feat_f1_unfold, data)
+
+ rename_keys: Dict[str, str] = {"mkpts0_f": 'keypoints0',
+ "mkpts1_f": 'keypoints1',
+ "mconf": 'confidence',
+ "b_ids": 'batch_indexes'}
+ out = {}
+ for k, v in rename_keys.items():
+ out[v] = data[k]
+ return out
+
+ def load_state_dict(self, state_dict, *args, **kwargs):
+ for k in list(state_dict.keys()):
+ if k.startswith('matcher.'):
+ state_dict[k.replace('matcher.', '', 1)] = state_dict.pop(k)
+ return super().load_state_dict(state_dict, *args, **kwargs)
diff --git a/kornia/feature/loftr/loftr_module/__init__.py b/kornia/feature/loftr/loftr_module/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8d83af7e987bec6f6c941f6d871701a451354cd7
--- /dev/null
+++ b/kornia/feature/loftr/loftr_module/__init__.py
@@ -0,0 +1,2 @@
+from .fine_preprocess import FinePreprocess
+from .transformer import LocalFeatureTransformer
diff --git a/kornia/feature/loftr/loftr_module/fine_preprocess.py b/kornia/feature/loftr/loftr_module/fine_preprocess.py
new file mode 100644
index 0000000000000000000000000000000000000000..9e57a4cb85bad622ae3b1900316d8b617d43c267
--- /dev/null
+++ b/kornia/feature/loftr/loftr_module/fine_preprocess.py
@@ -0,0 +1,66 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class FinePreprocess(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+
+ self.config = config
+ self.cat_c_feat = config['fine_concat_coarse_feat']
+ self.W = self.config['fine_window_size']
+
+ d_model_c = self.config['coarse']['d_model']
+ d_model_f = self.config['fine']['d_model']
+ self.d_model_f = d_model_f
+ if self.cat_c_feat:
+ self.down_proj = nn.Linear(d_model_c, d_model_f, bias=True)
+ self.merge_feat = nn.Linear(2 * d_model_f, d_model_f, bias=True)
+
+ self._reset_parameters()
+
+ def _reset_parameters(self):
+ for p in self.parameters():
+ if p.dim() > 1:
+ nn.init.kaiming_normal_(p, mode="fan_out", nonlinearity="relu")
+
+ def forward(self, feat_f0, feat_f1, feat_c0, feat_c1, data):
+ W = self.W
+ stride = data['hw0_f'][0] // data['hw0_c'][0]
+
+ data.update({'W': W})
+ if data['b_ids'].shape[0] == 0:
+ feat0 = torch.empty(0, self.W**2, self.d_model_f, device=feat_f0.device)
+ feat1 = torch.empty(0, self.W**2, self.d_model_f, device=feat_f0.device)
+ return feat0, feat1
+
+ # 1. unfold(crop) all local windows
+ feat_f0_unfold = F.unfold(feat_f0, kernel_size=(W, W), stride=stride, padding=W // 2)
+
+ # feat_f0_unfold = rearrange(feat_f0_unfold, 'n (c ww) l -> n l ww c', ww=W**2)
+ n0, cww0, l0 = feat_f0_unfold.shape
+ c0 = cww0 // (W * W)
+ feat_f0_unfold = feat_f0_unfold.reshape(n0, c0, -1, l0).permute(0, 3, 2, 1)
+
+ feat_f1_unfold = F.unfold(feat_f1, kernel_size=(W, W), stride=stride, padding=W // 2)
+ # feat_f1_unfold = rearrange(feat_f1_unfold, 'n (c ww) l -> n l ww c', ww=W**2)
+ n1, cww1, l1 = feat_f1_unfold.shape
+ c1 = cww1 // (W * W)
+ feat_f1_unfold = feat_f1_unfold.reshape(n1, c1, -1, l1).permute(0, 3, 2, 1)
+
+ # 2. select only the predicted matches
+ feat_f0_unfold = feat_f0_unfold[data['b_ids'], data['i_ids']] # [n, ww, cf]
+ feat_f1_unfold = feat_f1_unfold[data['b_ids'], data['j_ids']]
+
+ # option: use coarse-level loftr feature as context: concat and linear
+ if self.cat_c_feat:
+ feat_c_win = self.down_proj(torch.cat([feat_c0[data['b_ids'], data['i_ids']],
+ feat_c1[data['b_ids'], data['j_ids']]], 0)) # [2n, c]
+ feat_cf_win = self.merge_feat(torch.cat([
+ torch.cat([feat_f0_unfold, feat_f1_unfold], 0), # [2n, ww, cf]
+ feat_c_win.unsqueeze(1).repeat(1, W**2, 1), # [2n, ww, cf]
+ ], -1))
+ feat_f0_unfold, feat_f1_unfold = torch.chunk(feat_cf_win, 2, dim=0)
+
+ return feat_f0_unfold, feat_f1_unfold
diff --git a/kornia/feature/loftr/loftr_module/linear_attention.py b/kornia/feature/loftr/loftr_module/linear_attention.py
new file mode 100644
index 0000000000000000000000000000000000000000..aa6064d2758232c044f873e1f9d6bb6160d35f1e
--- /dev/null
+++ b/kornia/feature/loftr/loftr_module/linear_attention.py
@@ -0,0 +1,88 @@
+"""Linear Transformer proposed in "Transformers are RNNs: Fast Autoregressive Transformers with Linear Attention"
+Modified from: https://github.com/idiap/fast-
+transformers/blob/master/fast_transformers/attention/linear_attention.py."""
+
+from typing import Optional
+
+import torch
+from torch.nn import Dropout, Module
+
+
+def elu_feature_map(x):
+ return torch.nn.functional.elu(x) + 1
+
+
+class LinearAttention(Module):
+ def __init__(self, eps=1e-6):
+ super().__init__()
+ self.feature_map = elu_feature_map
+ self.eps = eps
+
+ def forward(self,
+ queries: torch.Tensor,
+ keys: torch.Tensor,
+ values: torch.Tensor,
+ q_mask: Optional[torch.Tensor] = None,
+ kv_mask: Optional[torch.Tensor] = None) -> torch.Tensor:
+ """ Multi-Head linear attention proposed in "Transformers are RNNs"
+ Args:
+ queries: [N, L, H, D]
+ keys: [N, S, H, D]
+ values: [N, S, H, D]
+ q_mask: [N, L]
+ kv_mask: [N, S]
+ Returns:
+ queried_values: (N, L, H, D)
+ """
+ Q = self.feature_map(queries)
+ K = self.feature_map(keys)
+
+ # set padded position to zero
+ if q_mask is not None:
+ Q = Q * q_mask[:, :, None, None]
+ if kv_mask is not None:
+ K = K * kv_mask[:, :, None, None]
+ values = values * kv_mask[:, :, None, None]
+
+ v_length = values.size(1)
+ values = values / v_length # prevent fp16 overflow
+ KV = torch.einsum("nshd,nshv->nhdv", K, values) # (S,D)' @ S,V
+ Z = 1 / (torch.einsum("nlhd,nhd->nlh", Q, K.sum(dim=1)) + self.eps)
+ queried_values = torch.einsum("nlhd,nhdv,nlh->nlhv", Q, KV, Z) * v_length
+
+ return queried_values.contiguous()
+
+
+class FullAttention(Module):
+ def __init__(self, use_dropout=False, attention_dropout=0.1):
+ super().__init__()
+ self.use_dropout = use_dropout
+ self.dropout = Dropout(attention_dropout)
+
+ def forward(self, queries, keys, values, q_mask=None, kv_mask=None):
+ """Multi-head scaled dot-product attention, a.k.a full attention.
+
+ Args:
+ queries: [N, L, H, D]
+ keys: [N, S, H, D]
+ values: [N, S, H, D]
+ q_mask: [N, L]
+ kv_mask: [N, S]
+ Returns:
+ queried_values: (N, L, H, D)
+ """
+
+ # Compute the unnormalized attention and apply the masks
+ QK = torch.einsum("nlhd,nshd->nlsh", queries, keys)
+ if kv_mask is not None:
+ QK.masked_fill_(~(q_mask[:, :, None, None] * kv_mask[:, None, :, None]), float('-inf'))
+
+ # Compute the attention and the weighted average
+ softmax_temp = 1. / queries.size(3)**.5 # sqrt(D)
+ A = torch.softmax(softmax_temp * QK, dim=2)
+ if self.use_dropout:
+ A = self.dropout(A)
+
+ queried_values = torch.einsum("nlsh,nshd->nlhd", A, values)
+
+ return queried_values.contiguous()
diff --git a/kornia/feature/loftr/loftr_module/transformer.py b/kornia/feature/loftr/loftr_module/transformer.py
new file mode 100644
index 0000000000000000000000000000000000000000..bc39ff09ceac9a46d8da44653e410b48d4e5546b
--- /dev/null
+++ b/kornia/feature/loftr/loftr_module/transformer.py
@@ -0,0 +1,110 @@
+import copy
+from typing import Optional
+
+import torch
+import torch.nn as nn
+
+from .linear_attention import FullAttention, LinearAttention
+
+
+class LoFTREncoderLayer(nn.Module):
+ def __init__(self,
+ d_model,
+ nhead,
+ attention='linear'):
+ super().__init__()
+
+ self.dim = d_model // nhead
+ self.nhead = nhead
+
+ # multi-head attention
+ self.q_proj = nn.Linear(d_model, d_model, bias=False)
+ self.k_proj = nn.Linear(d_model, d_model, bias=False)
+ self.v_proj = nn.Linear(d_model, d_model, bias=False)
+ self.attention = LinearAttention() if attention == 'linear' else FullAttention()
+ self.merge = nn.Linear(d_model, d_model, bias=False)
+
+ # feed-forward network
+ self.mlp = nn.Sequential(
+ nn.Linear(d_model * 2, d_model * 2, bias=False),
+ nn.ReLU(True),
+ nn.Linear(d_model * 2, d_model, bias=False),
+ )
+
+ # norm and dropout
+ self.norm1 = nn.LayerNorm(d_model)
+ self.norm2 = nn.LayerNorm(d_model)
+
+ def forward(self,
+ x: torch.Tensor,
+ source: torch.Tensor,
+ x_mask: Optional[torch.Tensor] = None,
+ source_mask: Optional[torch.Tensor] = None) -> torch.Tensor:
+ """
+ Args:
+ x (torch.Tensor): [N, L, C]
+ source (torch.Tensor): [N, S, C]
+ x_mask (torch.Tensor): [N, L] (optional)
+ source_mask (torch.Tensor): [N, S] (optional)
+ """
+ bs = x.size(0)
+ query, key, value = x, source, source
+
+ # multi-head attention
+ query = self.q_proj(query).view(bs, -1, self.nhead, self.dim) # [N, L, (H, D)]
+ key = self.k_proj(key).view(bs, -1, self.nhead, self.dim) # [N, S, (H, D)]
+ value = self.v_proj(value).view(bs, -1, self.nhead, self.dim)
+ message = self.attention(query, key, value, q_mask=x_mask, kv_mask=source_mask) # [N, L, (H, D)]
+ message = self.merge(message.view(bs, -1, self.nhead * self.dim)) # [N, L, C]
+ message = self.norm1(message)
+
+ # feed-forward network
+ message = self.mlp(torch.cat([x, message], dim=2))
+ message = self.norm2(message)
+
+ return x + message
+
+
+class LocalFeatureTransformer(nn.Module):
+ """A Local Feature Transformer (LoFTR) module."""
+
+ def __init__(self, config):
+ super().__init__()
+
+ self.config = config
+ self.d_model = config['d_model']
+ self.nhead = config['nhead']
+ self.layer_names = config['layer_names']
+ encoder_layer = LoFTREncoderLayer(config['d_model'], config['nhead'], config['attention'])
+ self.layers = nn.ModuleList([copy.deepcopy(encoder_layer) for _ in range(len(self.layer_names))])
+ self._reset_parameters()
+
+ def _reset_parameters(self):
+ for p in self.parameters():
+ if p.dim() > 1:
+ nn.init.xavier_uniform_(p)
+
+ def forward(self, feat0, feat1, mask0=None, mask1=None):
+ """
+ Args:
+ feat0 (torch.Tensor): [N, L, C]
+ feat1 (torch.Tensor): [N, S, C]
+ mask0 (torch.Tensor): [N, L] (optional)
+ mask1 (torch.Tensor): [N, S] (optional)
+ """
+
+ if self.d_model != feat0.size(2):
+ msg = "the feature number of src and transformer must be equal"
+ raise ValueError(msg)
+
+ for layer, name in zip(self.layers, self.layer_names):
+ if name == 'self':
+ feat0 = layer(feat0, feat0, mask0, mask0)
+ feat1 = layer(feat1, feat1, mask1, mask1)
+ elif name == 'cross':
+ feat0 = layer(feat0, feat1, mask0, mask1)
+ feat1 = layer(feat1, feat0, mask1, mask0)
+ else:
+ raise KeyError
+
+ return feat0, feat1
diff --git a/kornia/feature/loftr/utils/__init__.py b/kornia/feature/loftr/utils/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/kornia/feature/loftr/utils/coarse_matching.py b/kornia/feature/loftr/utils/coarse_matching.py
new file mode 100644
index 0000000000000000000000000000000000000000..622cebcd1e0052a4e6a9ac35108810d15d55fe10
--- /dev/null
+++ b/kornia/feature/loftr/utils/coarse_matching.py
@@ -0,0 +1,270 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+INF = 1e9
+
+
+def mask_border(m, b: int, v):
+ """ Mask borders with value
+ Args:
+ m (torch.Tensor): [N, H0, W0, H1, W1]
+ b (int)
+ v (m.dtype)
+ """
+ if b <= 0:
+ return
+
+ m[:, :b] = v
+ m[:, :, :b] = v
+ m[:, :, :, :b] = v
+ m[:, :, :, :, :b] = v
+ m[:, -b:] = v
+ m[:, :, -b:] = v
+ m[:, :, :, -b:] = v
+ m[:, :, :, :, -b:] = v
+
+
+def mask_border_with_padding(m, bd, v, p_m0, p_m1):
+ if bd <= 0:
+ return
+
+ m[:, :bd] = v
+ m[:, :, :bd] = v
+ m[:, :, :, :bd] = v
+ m[:, :, :, :, :bd] = v
+
+ h0s, w0s = p_m0.sum(1).max(-1)[0].int(), p_m0.sum(-1).max(-1)[0].int()
+ h1s, w1s = p_m1.sum(1).max(-1)[0].int(), p_m1.sum(-1).max(-1)[0].int()
+ for b_idx, (h0, w0, h1, w1) in enumerate(zip(h0s, w0s, h1s, w1s)):
+ m[b_idx, h0 - bd:] = v
+ m[b_idx, :, w0 - bd:] = v
+ m[b_idx, :, :, h1 - bd:] = v
+ m[b_idx, :, :, :, w1 - bd:] = v
+
+
+def compute_max_candidates(p_m0, p_m1):
+ """Compute the max candidates of all pairs within a batch.
+
+ Args:
+ p_m0, p_m1 (torch.Tensor): padded masks
+ """
+ h0s, w0s = p_m0.sum(1).max(-1)[0], p_m0.sum(-1).max(-1)[0]
+ h1s, w1s = p_m1.sum(1).max(-1)[0], p_m1.sum(-1).max(-1)[0]
+ max_cand = torch.sum(
+ torch.min(torch.stack([h0s * w0s, h1s * w1s], -1), -1)[0])
+ return max_cand
+
+
+class CoarseMatching(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.config = config
+ # general config
+ self.thr = config['thr']
+ self.border_rm = config['border_rm']
+ # -- # for trainig fine-level LoFTR
+ self.train_coarse_percent = config['train_coarse_percent']
+ self.train_pad_num_gt_min = config['train_pad_num_gt_min']
+
+ # we provide 2 options for differentiable matching
+ self.match_type = config['match_type']
+ if self.match_type == 'dual_softmax':
+ self.temperature = config['dsmax_temperature']
+ elif self.match_type == 'sinkhorn':
+ try:
+ from .superglue import log_optimal_transport
+ except ImportError:
+ raise ImportError("download superglue.py first!")
+ self.log_optimal_transport = log_optimal_transport
+ self.bin_score = nn.Parameter(
+ torch.tensor(config['skh_init_bin_score'], requires_grad=True))
+ self.skh_iters = config['skh_iters']
+ self.skh_prefilter = config['skh_prefilter']
+ else:
+ raise NotImplementedError()
+
+ def forward(self, feat_c0, feat_c1, data, mask_c0=None, mask_c1=None):
+ """
+ Args:
+ feat0 (torch.Tensor): [N, L, C]
+ feat1 (torch.Tensor): [N, S, C]
+ data (dict)
+ mask_c0 (torch.Tensor): [N, L] (optional)
+ mask_c1 (torch.Tensor): [N, S] (optional)
+ Update:
+ data (dict): {
+ 'b_ids' (torch.Tensor): [M'],
+ 'i_ids' (torch.Tensor): [M'],
+ 'j_ids' (torch.Tensor): [M'],
+ 'gt_mask' (torch.Tensor): [M'],
+ 'mkpts0_c' (torch.Tensor): [M, 2],
+ 'mkpts1_c' (torch.Tensor): [M, 2],
+ 'mconf' (torch.Tensor): [M]}
+ NOTE: M' != M during training.
+ """
+ _, L, S, _ = feat_c0.size(0), feat_c0.size(1), feat_c1.size(1), feat_c0.size(2)
+
+ # normalize
+ feat_c0, feat_c1 = map(lambda feat: feat / feat.shape[-1]**.5,
+ [feat_c0, feat_c1])
+
+ if self.match_type == 'dual_softmax':
+ sim_matrix = torch.einsum("nlc,nsc->nls", feat_c0,
+ feat_c1) / self.temperature
+ if mask_c0 is not None:
+ sim_matrix.masked_fill_(
+ ~(mask_c0[..., None] * mask_c1[:, None]).bool(),
+ -INF)
+ conf_matrix = F.softmax(sim_matrix, 1) * F.softmax(sim_matrix, 2)
+
+ elif self.match_type == 'sinkhorn':
+ # sinkhorn, dustbin included
+ sim_matrix = torch.einsum("nlc,nsc->nls", feat_c0, feat_c1)
+ if mask_c0 is not None:
+ sim_matrix[:, :L, :S].masked_fill_(
+ ~(mask_c0[..., None] * mask_c1[:, None]).bool(),
+ -INF)
+
+ # build uniform prior & use sinkhorn
+ log_assign_matrix = self.log_optimal_transport(
+ sim_matrix, self.bin_score, self.skh_iters)
+ assign_matrix = log_assign_matrix.exp()
+ conf_matrix = assign_matrix[:, :-1, :-1]
+
+ # filter prediction with dustbin score (only in evaluation mode)
+ if not self.training and self.skh_prefilter:
+ filter0 = (assign_matrix.max(dim=2)[1] == S)[:, :-1] # [N, L]
+ filter1 = (assign_matrix.max(dim=1)[1] == L)[:, :-1] # [N, S]
+ conf_matrix[filter0[..., None].repeat(1, 1, S)] = 0
+ conf_matrix[filter1[:, None].repeat(1, L, 1)] = 0
+
+ if self.config['sparse_spvs']:
+ data.update({'conf_matrix_with_bin': assign_matrix.clone()})
+
+ data.update({'conf_matrix': conf_matrix})
+
+ # predict coarse matches from conf_matrix
+ data.update(**self.get_coarse_match(conf_matrix, data))
+
+ @torch.no_grad()
+ def get_coarse_match(self, conf_matrix, data):
+ """
+ Args:
+ conf_matrix (torch.Tensor): [N, L, S]
+ data (dict): with keys ['hw0_i', 'hw1_i', 'hw0_c', 'hw1_c']
+ Returns:
+ coarse_matches (dict): {
+ 'b_ids' (torch.Tensor): [M'],
+ 'i_ids' (torch.Tensor): [M'],
+ 'j_ids' (torch.Tensor): [M'],
+ 'gt_mask' (torch.Tensor): [M'],
+ 'm_bids' (torch.Tensor): [M],
+ 'mkpts0_c' (torch.Tensor): [M, 2],
+ 'mkpts1_c' (torch.Tensor): [M, 2],
+ 'mconf' (torch.Tensor): [M]}
+ """
+ axes_lengths = {
+ 'h0c': data['hw0_c'][0],
+ 'w0c': data['hw0_c'][1],
+ 'h1c': data['hw1_c'][0],
+ 'w1c': data['hw1_c'][1]
+ }
+ _device = conf_matrix.device
+ # 1. confidence thresholding
+ mask = conf_matrix > self.thr
+ N = conf_matrix.shape[0]
+ mask = mask.reshape(N,
+ axes_lengths['h0c'], axes_lengths['w0c'],
+ axes_lengths['h1c'], axes_lengths['w1c'])
+ # mask = rearrange(mask, 'b (h0c w0c) (h1c w1c) -> b h0c w0c h1c w1c',
+ # **axes_lengths)
+ if 'mask0' not in data:
+ mask_border(mask, self.border_rm, False)
+ else:
+ mask_border_with_padding(mask, self.border_rm, False,
+ data['mask0'], data['mask1'])
+ mask = mask.reshape(N,
+ axes_lengths['h0c'] * axes_lengths['w0c'],
+ axes_lengths['h1c'] * axes_lengths['w1c'])
+ # rearrange(mask, 'b h0c w0c h1c w1c -> b (h0c w0c) (h1c w1c)',
+ # **axes_lengths)
+
+ # 2. mutual nearest
+ mask = mask \
+ * (conf_matrix == conf_matrix.max(dim=2, keepdim=True)[0]) \
+ * (conf_matrix == conf_matrix.max(dim=1, keepdim=True)[0])
+
+ # 3. find all valid coarse matches
+ # this only works when at most one `True` in each row
+ mask_v, all_j_ids = mask.max(dim=2)
+ b_ids, i_ids = torch.where(mask_v)
+ j_ids = all_j_ids[b_ids, i_ids]
+ mconf = conf_matrix[b_ids, i_ids, j_ids]
+
+ # 4. Random sampling of training samples for fine-level LoFTR
+ # (optional) pad samples with gt coarse-level matches
+ if self.training:
+ # NOTE:
+ # The sampling is performed across all pairs in a batch without manually balancing
+ # #samples for fine-level increases w.r.t. batch_size
+ if 'mask0' not in data:
+ num_candidates_max = mask.size(0) * max(
+ mask.size(1), mask.size(2))
+ else:
+ num_candidates_max = compute_max_candidates(
+ data['mask0'], data['mask1'])
+ num_matches_train = num_candidates_max * self.train_coarse_percent
+ num_matches_train = int(num_matches_train)
+ num_matches_pred = len(b_ids)
+ if self.train_pad_num_gt_min < num_matches_train:
+ msg = "min-num-gt-pad should be less than num-train-matches"
+ raise ValueError(msg)
+
+ # pred_indices is to select from prediction
+ if num_matches_pred <= num_matches_train - self.train_pad_num_gt_min:
+ pred_indices = torch.arange(num_matches_pred, device=_device)
+ else:
+ pred_indices = torch.randint(
+ num_matches_pred,
+ (num_matches_train - self.train_pad_num_gt_min, ),
+ device=_device)
+
+ # gt_pad_indices is to select from gt padding. e.g. max(3787-4800, 200)
+ gt_pad_indices = torch.randint(
+ len(data['spv_b_ids']),
+ (max(num_matches_train - num_matches_pred,
+ self.train_pad_num_gt_min), ),
+ device=_device)
+ mconf_gt = torch.zeros(len(data['spv_b_ids']), device=_device) # set conf of gt paddings to all zero
+
+ b_ids, i_ids, j_ids, mconf = map(
+ lambda x, y: torch.cat([x[pred_indices], y[gt_pad_indices]],
+ dim=0),
+ *zip([b_ids, data['spv_b_ids']], [i_ids, data['spv_i_ids']],
+ [j_ids, data['spv_j_ids']], [mconf, mconf_gt]))
+
+ # These matches select patches that feed into fine-level network
+ coarse_matches = {'b_ids': b_ids, 'i_ids': i_ids, 'j_ids': j_ids}
+
+ # 4. Update with matches in original image resolution
+ scale = data['hw0_i'][0] / data['hw0_c'][0]
+ scale0 = scale * data['scale0'][b_ids] if 'scale0' in data else scale
+ scale1 = scale * data['scale1'][b_ids] if 'scale1' in data else scale
+ mkpts0_c = torch.stack(
+ [i_ids % data['hw0_c'][1], i_ids // data['hw0_c'][1]],
+ dim=1) * scale0
+ mkpts1_c = torch.stack(
+ [j_ids % data['hw1_c'][1], j_ids // data['hw1_c'][1]],
+ dim=1) * scale1
+
+ # These matches is the current prediction (for visualization)
+ coarse_matches.update({
+ 'gt_mask': mconf == 0,
+ 'm_bids': b_ids[mconf != 0], # mconf == 0 => gt matches
+ 'mkpts0_c': mkpts0_c[mconf != 0].to(dtype=conf_matrix.dtype),
+ 'mkpts1_c': mkpts1_c[mconf != 0].to(dtype=conf_matrix.dtype),
+ 'mconf': mconf[mconf != 0]
+ })
+
+ return coarse_matches
diff --git a/kornia/feature/loftr/utils/fine_matching.py b/kornia/feature/loftr/utils/fine_matching.py
new file mode 100644
index 0000000000000000000000000000000000000000..9b97bd6b751c509fa5782812c7249725691f9a52
--- /dev/null
+++ b/kornia/feature/loftr/utils/fine_matching.py
@@ -0,0 +1,78 @@
+import math
+
+import torch
+import torch.nn as nn
+
+from kornia.geometry.subpix import dsnt
+from kornia.utils.grid import create_meshgrid
+
+
+class FineMatching(nn.Module):
+ """FineMatching with s2d paradigm."""
+
+ def __init__(self):
+ super().__init__()
+
+ def forward(self, feat_f0, feat_f1, data):
+ """
+ Args:
+ feat0 (torch.Tensor): [M, WW, C]
+ feat1 (torch.Tensor): [M, WW, C]
+ data (dict)
+ Update:
+ data (dict):{
+ 'expec_f' (torch.Tensor): [M, 3],
+ 'mkpts0_f' (torch.Tensor): [M, 2],
+ 'mkpts1_f' (torch.Tensor): [M, 2]}
+ """
+ M, WW, C = feat_f0.shape
+ W = int(math.sqrt(WW))
+ scale = data['hw0_i'][0] / data['hw0_f'][0]
+ self.M, self.W, self.WW, self.C, self.scale = M, W, WW, C, scale
+
+ # corner case: if no coarse matches found
+ if M == 0:
+ if self.training:
+ raise ValueError("M >0, when training, see coarse_matching.py")
+ # logger.warning('No matches found in coarse-level.')
+ data.update({
+ 'expec_f': torch.empty(0, 3, device=feat_f0.device, dtype=feat_f0.dtype),
+ 'mkpts0_f': data['mkpts0_c'],
+ 'mkpts1_f': data['mkpts1_c'],
+ })
+ return
+
+ feat_f0_picked = feat_f0_picked = feat_f0[:, WW // 2, :]
+ sim_matrix = torch.einsum('mc,mrc->mr', feat_f0_picked, feat_f1)
+ softmax_temp = 1. / C**.5
+ heatmap = torch.softmax(softmax_temp * sim_matrix, dim=1).view(-1, W, W)
+
+ # compute coordinates from heatmap
+ coords_normalized = dsnt.spatial_expectation2d(heatmap[None], True)[0] # [M, 2]
+ grid_normalized = create_meshgrid(
+ W, W, normalized_coordinates=True, device=heatmap.device, dtype=heatmap.dtype
+ ).reshape(1, -1, 2) # [1, WW, 2]
+
+ # compute std over
+ var = torch.sum(grid_normalized**2 * heatmap.view(-1, WW, 1), dim=1) - coords_normalized**2 # [M, 2]
+ std = torch.sum(torch.sqrt(torch.clamp(var, min=1e-10)), -1) # [M] clamp needed for numerical stability
+
+ # for fine-level supervision
+ data.update({'expec_f': torch.cat([coords_normalized, std.unsqueeze(1)], -1)})
+
+ # compute absolute kpt coords
+ self.get_fine_match(coords_normalized, data)
+
+ @torch.no_grad()
+ def get_fine_match(self, coords_normed, data):
+ W, _, _, scale = self.W, self.WW, self.C, self.scale
+
+ # mkpts0_f and mkpts1_f
+ mkpts0_f = data['mkpts0_c']
+ scale1 = scale * data['scale1'][data['b_ids']] if 'scale0' in data else scale
+ mkpts1_f = data['mkpts1_c'] + (coords_normed * (W // 2) * scale1)[:len(data['mconf'])]
+
+ data.update({
+ "mkpts0_f": mkpts0_f,
+ "mkpts1_f": mkpts1_f
+ })
diff --git a/kornia/feature/loftr/utils/geometry.py b/kornia/feature/loftr/utils/geometry.py
new file mode 100644
index 0000000000000000000000000000000000000000..e53a9f38dd5df4e5adc28f7f962dedd29dcd46c0
--- /dev/null
+++ b/kornia/feature/loftr/utils/geometry.py
@@ -0,0 +1,53 @@
+import torch
+
+
+@torch.no_grad()
+def warp_kpts(kpts0, depth0, depth1, T_0to1, K0, K1):
+ """Warp kpts0 from I0 to I1 with depth, K and Rt Also check covisibility and depth consistency. Depth is
+ consistent if relative error < 0.2 (hard-coded).
+
+ Args:
+ kpts0 (torch.Tensor): [N, L, 2] - ,
+ depth0 (torch.Tensor): [N, H, W],
+ depth1 (torch.Tensor): [N, H, W],
+ T_0to1 (torch.Tensor): [N, 3, 4],
+ K0 (torch.Tensor): [N, 3, 3],
+ K1 (torch.Tensor): [N, 3, 3],
+ Returns:
+ calculable_mask (torch.Tensor): [N, L]
+ warped_keypoints0 (torch.Tensor): [N, L, 2]
+ """
+ kpts0_long = kpts0.round().long()
+
+ # Sample depth, get calculable_mask on depth != 0
+ kpts0_depth = torch.stack(
+ [depth0[i, kpts0_long[i, :, 1], kpts0_long[i, :, 0]] for i in range(kpts0.shape[0])], dim=0
+ ) # (N, L)
+ nonzero_mask = kpts0_depth != 0
+
+ # Unproject
+ kpts0_h = torch.cat([kpts0, torch.ones_like(kpts0[:, :, [0]])], dim=-1) * kpts0_depth[..., None] # (N, L, 3)
+ kpts0_cam = K0.inverse() @ kpts0_h.transpose(2, 1) # (N, 3, L)
+
+ # Rigid Transform
+ w_kpts0_cam = T_0to1[:, :3, :3] @ kpts0_cam + T_0to1[:, :3, [3]] # (N, 3, L)
+ w_kpts0_depth_computed = w_kpts0_cam[:, 2, :]
+
+ # Project
+ w_kpts0_h = (K1 @ w_kpts0_cam).transpose(2, 1) # (N, L, 3)
+ w_kpts0 = w_kpts0_h[:, :, :2] / (w_kpts0_h[:, :, [2]] + 1e-4) # (N, L, 2), +1e-4 to avoid zero depth
+
+ # Covisible Check
+ h, w = depth1.shape[1:3]
+ covisible_mask = (w_kpts0[:, :, 0] > 0) * (w_kpts0[:, :, 0] < w - 1) * \
+ (w_kpts0[:, :, 1] > 0) * (w_kpts0[:, :, 1] < h - 1)
+ w_kpts0_long = w_kpts0.long()
+ w_kpts0_long[~covisible_mask, :] = 0
+
+ w_kpts0_depth = torch.stack(
+ [depth1[i, w_kpts0_long[i, :, 1], w_kpts0_long[i, :, 0]] for i in range(w_kpts0_long.shape[0])], dim=0
+ ) # (N, L)
+ consistent_mask = ((w_kpts0_depth - w_kpts0_depth_computed) / w_kpts0_depth).abs() < 0.2
+ valid_mask = nonzero_mask * covisible_mask * consistent_mask
+
+ return valid_mask, w_kpts0
diff --git a/kornia/feature/loftr/utils/position_encoding.py b/kornia/feature/loftr/utils/position_encoding.py
new file mode 100644
index 0000000000000000000000000000000000000000..f260edde1646133d900065964ab576e467086a23
--- /dev/null
+++ b/kornia/feature/loftr/utils/position_encoding.py
@@ -0,0 +1,41 @@
+import math
+
+import torch
+from torch import nn
+
+
+class PositionEncodingSine(nn.Module):
+ """This is a sinusoidal position encoding that generalized to 2-dimensional images."""
+
+ def __init__(self, d_model, max_shape=(256, 256), temp_bug_fix=True):
+ """
+ Args:
+ max_shape (tuple): for 1/8 featmap, the max length of 256 corresponds to 2048 pixels
+ temp_bug_fix (bool): As noted in this [issue](https://github.com/zju3dv/LoFTR/issues/41),
+ the original implementation of LoFTR includes a bug in the pos-enc impl, which has little impact
+ on the final performance. For now, we keep both impls for backward compatibility.
+ We will remove the buggy impl after re-training all variants of our released models.
+ """
+ super().__init__()
+
+ pe = torch.zeros((d_model, *max_shape))
+ y_position = torch.ones(max_shape).cumsum(0).float().unsqueeze(0)
+ x_position = torch.ones(max_shape).cumsum(1).float().unsqueeze(0)
+ if temp_bug_fix:
+ div_term = torch.exp(torch.arange(0, d_model // 2, 2).float() * (-math.log(10000.0) / (d_model // 2)))
+ else: # a buggy implementation (for backward compatibility only)
+ div_term = torch.exp(torch.arange(0, d_model // 2, 2).float() * (-math.log(10000.0) / d_model // 2))
+ div_term = div_term[:, None, None] # [C//4, 1, 1]
+ pe[0::4, :, :] = torch.sin(x_position * div_term)
+ pe[1::4, :, :] = torch.cos(x_position * div_term)
+ pe[2::4, :, :] = torch.sin(y_position * div_term)
+ pe[3::4, :, :] = torch.cos(y_position * div_term)
+
+ self.register_buffer('pe', pe.unsqueeze(0), persistent=False) # [1, C, H, W]
+
+ def forward(self, x):
+ """
+ Args:
+ x: [N, C, H, W]
+ """
+ return x + self.pe[:, :, :x.size(2), :x.size(3)]
diff --git a/kornia/feature/loftr/utils/supervision.py b/kornia/feature/loftr/utils/supervision.py
new file mode 100644
index 0000000000000000000000000000000000000000..30242a25261a3452e4b55b1028863e98a796f987
--- /dev/null
+++ b/kornia/feature/loftr/utils/supervision.py
@@ -0,0 +1,151 @@
+import torch
+
+from kornia.utils import create_meshgrid
+
+from .geometry import warp_kpts
+
+# Coarse-Level supervision
+
+
+@torch.no_grad()
+def mask_pts_at_padded_regions(grid_pt, mask):
+ """For megadepth dataset, zero-padding exists in images."""
+ n, h, w = mask.shape
+ mask = mask.reshape(n, h * w).unsqueeze(-1).repeat(1, 1, 2)
+ # from einops import repeat
+ # mask = repeat(mask, 'n h w -> n (h w) c', c=2)
+ grid_pt[~mask.bool()] = 0
+ return grid_pt
+
+
+@torch.no_grad()
+def spvs_coarse(data, config):
+ """
+ Update:
+ data (dict): {
+ "conf_matrix_gt": [N, hw0, hw1],
+ 'spv_b_ids': [M]
+ 'spv_i_ids': [M]
+ 'spv_j_ids': [M]
+ 'spv_w_pt0_i': [N, hw0, 2], in original image resolution
+ 'spv_pt1_i': [N, hw1, 2], in original image resolution
+ }
+
+ NOTE:
+ - for scannet dataset, there're 3 kinds of resolution {i, c, f}
+ - for megadepth dataset, there're 4 kinds of resolution {i, i_resize, c, f}
+ """
+ # 1. misc
+ device = data['image0'].device
+ N, _, H0, W0 = data['image0'].shape
+ _, _, H1, W1 = data['image1'].shape
+ scale = config['LOFTR']['RESOLUTION'][0]
+ scale0 = scale * data['scale0'][:, None] if 'scale0' in data else scale
+ scale1 = scale * data['scale1'][:, None] if 'scale0' in data else scale
+ h0, w0, h1, w1 = map(lambda x: x // scale, [H0, W0, H1, W1])
+
+ # 2. warp grids
+ # create kpts in meshgrid and resize them to image resolution
+ grid_pt0_c = create_meshgrid(h0, w0, False, device).reshape(1, h0 * w0, 2).repeat(N, 1, 1) # [N, hw, 2]
+ grid_pt0_i = scale0 * grid_pt0_c
+ grid_pt1_c = create_meshgrid(h1, w1, False, device).reshape(1, h1 * w1, 2).repeat(N, 1, 1)
+ grid_pt1_i = scale1 * grid_pt1_c
+
+ # mask padded region to (0, 0), so no need to manually mask conf_matrix_gt
+ if 'mask0' in data:
+ grid_pt0_i = mask_pts_at_padded_regions(grid_pt0_i, data['mask0'])
+ grid_pt1_i = mask_pts_at_padded_regions(grid_pt1_i, data['mask1'])
+
+ # warp kpts bi-directionally and resize them to coarse-level resolution
+ # (no depth consistency check, since it leads to worse results experimentally)
+ # (unhandled edge case: points with 0-depth will be warped to the left-up corner)
+ _, w_pt0_i = warp_kpts(grid_pt0_i, data['depth0'], data['depth1'], data['T_0to1'], data['K0'], data['K1'])
+ _, w_pt1_i = warp_kpts(grid_pt1_i, data['depth1'], data['depth0'], data['T_1to0'], data['K1'], data['K0'])
+ w_pt0_c = w_pt0_i / scale1
+ w_pt1_c = w_pt1_i / scale0
+
+ # 3. check if mutual nearest neighbor
+ w_pt0_c_round = w_pt0_c[:, :, :].round().long()
+ nearest_index1 = w_pt0_c_round[..., 0] + w_pt0_c_round[..., 1] * w1
+ w_pt1_c_round = w_pt1_c[:, :, :].round().long()
+ nearest_index0 = w_pt1_c_round[..., 0] + w_pt1_c_round[..., 1] * w0
+
+ # corner case: out of boundary
+ def out_bound_mask(pt, w, h):
+ return (pt[..., 0] < 0) + (pt[..., 0] >= w) + (pt[..., 1] < 0) + (pt[..., 1] >= h)
+ nearest_index1[out_bound_mask(w_pt0_c_round, w1, h1)] = 0
+ nearest_index0[out_bound_mask(w_pt1_c_round, w0, h0)] = 0
+
+ loop_back = torch.stack([nearest_index0[_b][_i] for _b, _i in enumerate(nearest_index1)], dim=0)
+ correct_0to1 = loop_back == torch.arange(h0 * w0, device=device)[None].repeat(N, 1)
+ correct_0to1[:, 0] = False # ignore the top-left corner
+
+ # 4. construct a gt conf_matrix
+ conf_matrix_gt = torch.zeros(N, h0 * w0, h1 * w1, device=device)
+ b_ids, i_ids = torch.where(correct_0to1 != 0)
+ j_ids = nearest_index1[b_ids, i_ids]
+
+ conf_matrix_gt[b_ids, i_ids, j_ids] = 1
+ data.update({'conf_matrix_gt': conf_matrix_gt})
+
+ # 5. save coarse matches(gt) for training fine level
+ if len(b_ids) == 0:
+ # this won't affect fine-level loss calculation
+ b_ids = torch.tensor([0], device=device)
+ i_ids = torch.tensor([0], device=device)
+ j_ids = torch.tensor([0], device=device)
+
+ data.update({
+ 'spv_b_ids': b_ids,
+ 'spv_i_ids': i_ids,
+ 'spv_j_ids': j_ids
+ })
+
+ # 6. save intermediate results (for fast fine-level computation)
+ data.update({
+ 'spv_w_pt0_i': w_pt0_i,
+ 'spv_pt1_i': grid_pt1_i
+ })
+
+
+def compute_supervision_coarse(data, config):
+ if len(set(data['dataset_name'])) != 1:
+ raise ValueError("Do not support mixed datasets training!")
+ data_source = data['dataset_name'][0]
+ if data_source.lower() in ['scannet', 'megadepth']:
+ spvs_coarse(data, config)
+ else:
+ raise ValueError(f'Unknown data source: {data_source}')
+
+
+# Fine-Level supervision
+
+@torch.no_grad()
+def spvs_fine(data, config):
+ """
+ Update:
+ data (dict):{
+ "expec_f_gt": [M, 2]}
+ """
+ # 1. misc
+ # w_pt0_i, pt1_i = data.pop('spv_w_pt0_i'), data.pop('spv_pt1_i')
+ w_pt0_i, pt1_i = data['spv_w_pt0_i'], data['spv_pt1_i']
+ scale = config['LOFTR']['RESOLUTION'][1]
+ radius = config['LOFTR']['FINE_WINDOW_SIZE'] // 2
+
+ # 2. get coarse prediction
+ b_ids, i_ids, j_ids = data['b_ids'], data['i_ids'], data['j_ids']
+
+ # 3. compute gt
+ scale = scale * data['scale1'][b_ids] if 'scale0' in data else scale
+ # `expec_f_gt` might exceed the window, i.e. abs(*) > 1, which would be filtered later
+ expec_f_gt = (w_pt0_i[b_ids, i_ids] - pt1_i[b_ids, j_ids]) / scale / radius # [M, 2]
+ data.update({"expec_f_gt": expec_f_gt})
+
+
+def compute_supervision_fine(data, config):
+ data_source = data['dataset_name'][0]
+ if data_source.lower() in ['scannet', 'megadepth']:
+ spvs_fine(data, config)
+ else:
+ raise NotImplementedError
diff --git a/kornia/feature/matching.py b/kornia/feature/matching.py
new file mode 100644
index 0000000000000000000000000000000000000000..750ec327ab9bb6e0f15b779bb1a93a5bd655fe4c
--- /dev/null
+++ b/kornia/feature/matching.py
@@ -0,0 +1,229 @@
+from typing import Optional, Tuple
+
+import torch
+import torch.nn as nn
+
+
+def match_nn(
+ desc1: torch.Tensor, desc2: torch.Tensor, dm: Optional[torch.Tensor] = None
+) -> Tuple[torch.Tensor, torch.Tensor]:
+ r"""Function, which finds nearest neighbors in desc2 for each vector in desc1.
+
+ If the distance matrix dm is not provided, :py:func:`torch.cdist` is used.
+
+ Args:
+ desc1: Batch of descriptors of a shape :math:`(B1, D)`.
+ desc2: Batch of descriptors of a shape :math:`(B2, D)`.
+ dm: Tensor containing the distances from each descriptor in desc1
+ to each descriptor in desc2, shape of :math:`(B1, B2)`.
+
+ Returns:
+ - Descriptor distance of matching descriptors, shape of :math:`(B1, 1)`.
+ - Long tensor indexes of matching descriptors in desc1 and desc2, shape of :math:`(B1, 2)`.
+ """
+ if len(desc1.shape) != 2:
+ raise AssertionError
+ if len(desc2.shape) != 2:
+ raise AssertionError
+
+ if dm is None:
+ dm = torch.cdist(desc1, desc2)
+ else:
+ if not ((dm.size(0) == desc1.size(0)) and (dm.size(1) == desc2.size(0))):
+ raise AssertionError
+
+ match_dists, idxs_in_2 = torch.min(dm, dim=1)
+ idxs_in1: torch.Tensor = torch.arange(0, idxs_in_2.size(0), device=idxs_in_2.device)
+ matches_idxs: torch.Tensor = torch.cat([idxs_in1.view(-1, 1), idxs_in_2.view(-1, 1)], dim=1)
+ return match_dists.view(-1, 1), matches_idxs.view(-1, 2)
+
+
+def match_mnn(
+ desc1: torch.Tensor, desc2: torch.Tensor, dm: Optional[torch.Tensor] = None
+) -> Tuple[torch.Tensor, torch.Tensor]:
+ """Function, which finds mutual nearest neighbors in desc2 for each vector in desc1.
+
+ If the distance matrix dm is not provided, :py:func:`torch.cdist` is used.
+
+ Args:
+ desc1: Batch of descriptors of a shape :math:`(B1, D)`.
+ desc2: Batch of descriptors of a shape :math:`(B2, D)`.
+ dm: Tensor containing the distances from each descriptor in desc1
+ to each descriptor in desc2, shape of :math:`(B1, B2)`.
+
+ Return:
+ - Descriptor distance of matching descriptors, shape of. :math:`(B3, 1)`.
+ - Long tensor indexes of matching descriptors in desc1 and desc2, shape of :math:`(B3, 2)`,
+ where 0 <= B3 <= min(B1, B2)
+ """
+ if len(desc1.shape) != 2:
+ raise AssertionError
+ if len(desc2.shape) != 2:
+ raise AssertionError
+
+ if dm is None:
+ dm = torch.cdist(desc1, desc2)
+ else:
+ if not ((dm.size(0) == desc1.size(0)) and (dm.size(1) == desc2.size(0))):
+ raise AssertionError
+
+ ms = min(dm.size(0), dm.size(1))
+ match_dists, idxs_in_2 = torch.min(dm, dim=1)
+ match_dists2, idxs_in_1 = torch.min(dm, dim=0)
+ minsize_idxs = torch.arange(ms, device=dm.device)
+
+ if dm.size(0) <= dm.size(1):
+ mutual_nns = minsize_idxs == idxs_in_1[idxs_in_2][:ms]
+ matches_idxs = torch.cat([minsize_idxs.view(-1, 1), idxs_in_2.view(-1, 1)], dim=1)[mutual_nns]
+ match_dists = match_dists[mutual_nns]
+ else:
+ mutual_nns = minsize_idxs == idxs_in_2[idxs_in_1][:ms]
+ matches_idxs = torch.cat([idxs_in_1.view(-1, 1), minsize_idxs.view(-1, 1)], dim=1)[mutual_nns]
+ match_dists = match_dists2[mutual_nns]
+ return match_dists.view(-1, 1), matches_idxs.view(-1, 2)
+
+
+def match_snn(
+ desc1: torch.Tensor, desc2: torch.Tensor, th: float = 0.8, dm: Optional[torch.Tensor] = None
+) -> Tuple[torch.Tensor, torch.Tensor]:
+ """Function, which finds nearest neighbors in desc2 for each vector in desc1.
+
+ The method satisfies first to second nearest neighbor distance <= th.
+
+ If the distance matrix dm is not provided, :py:func:`torch.cdist` is used.
+
+ Args:
+ desc1: Batch of descriptors of a shape :math:`(B1, D)`.
+ desc2: Batch of descriptors of a shape :math:`(B2, D)`.
+ th: distance ratio threshold.
+ dm: Tensor containing the distances from each descriptor in desc1
+ to each descriptor in desc2, shape of :math:`(B1, B2)`.
+
+ Return:
+ - Descriptor distance of matching descriptors, shape of :math:`(B3, 1)`.
+ - Long tensor indexes of matching descriptors in desc1 and desc2. Shape: :math:`(B3, 2)`,
+ where 0 <= B3 <= B1.
+ """
+ if len(desc1.shape) != 2:
+ raise AssertionError
+ if len(desc2.shape) != 2:
+ raise AssertionError
+ if desc2.shape[0] < 2:
+ raise AssertionError
+
+ if dm is None:
+ dm = torch.cdist(desc1, desc2)
+ else:
+ if not ((dm.size(0) == desc1.size(0)) and (dm.size(1) == desc2.size(0))):
+ raise AssertionError
+
+ vals, idxs_in_2 = torch.topk(dm, 2, dim=1, largest=False)
+ ratio = vals[:, 0] / vals[:, 1]
+ mask = ratio <= th
+ match_dists = ratio[mask]
+ idxs_in1 = torch.arange(0, idxs_in_2.size(0), device=dm.device)[mask]
+ idxs_in_2 = idxs_in_2[:, 0][mask]
+ matches_idxs = torch.cat([idxs_in1.view(-1, 1), idxs_in_2.view(-1, 1)], dim=1)
+ return match_dists.view(-1, 1), matches_idxs.view(-1, 2)
+
+
+def match_smnn(
+ desc1: torch.Tensor, desc2: torch.Tensor, th: float = 0.8, dm: Optional[torch.Tensor] = None
+) -> Tuple[torch.Tensor, torch.Tensor]:
+ """Function, which finds mutual nearest neighbors in desc2 for each vector in desc1.
+
+ the method satisfies first to second nearest neighbor distance <= th.
+
+ If the distance matrix dm is not provided, :py:func:`torch.cdist` is used.
+
+ Args:
+ desc1: Batch of descriptors of a shape :math:`(B1, D)`.
+ desc2: Batch of descriptors of a shape :math:`(B2, D)`.
+ th: distance ratio threshold.
+ dm: Tensor containing the distances from each descriptor in desc1
+ to each descriptor in desc2, shape of :math:`(B1, B2)`.
+
+ Return:
+ - Descriptor distance of matching descriptors, shape of. :math:`(B3, 1)`.
+ - Long tensor indexes of matching descriptors in desc1 and desc2,
+ shape of :math:`(B3, 2)` where 0 <= B3 <= B1.
+ """
+ if len(desc1.shape) != 2:
+ raise AssertionError
+ if len(desc2.shape) != 2:
+ raise AssertionError
+ if desc1.shape[0] < 2:
+ raise AssertionError
+ if desc2.shape[0] < 2:
+ raise AssertionError
+
+ if dm is None:
+ dm = torch.cdist(desc1, desc2)
+ else:
+ if not ((dm.size(0) == desc1.size(0)) and (dm.size(1) == desc2.size(0))):
+ raise AssertionError
+
+ dists1, idx1 = match_snn(desc1, desc2, th, dm)
+ dists2, idx2 = match_snn(desc2, desc1, th, dm.t())
+
+ if len(dists2) > 0 and len(dists1) > 0:
+ idx2 = idx2.flip(1)
+ idxs_dm = torch.cdist(idx1.float(), idx2.float(), p=1.0)
+ mutual_idxs1 = idxs_dm.min(dim=1)[0] < 1e-8
+ mutual_idxs2 = idxs_dm.min(dim=0)[0] < 1e-8
+ good_idxs1 = idx1[mutual_idxs1.view(-1)]
+ good_idxs2 = idx2[mutual_idxs2.view(-1)]
+ dists1_good = dists1[mutual_idxs1.view(-1)]
+ dists2_good = dists2[mutual_idxs2.view(-1)]
+ _, idx_upl1 = torch.sort(good_idxs1[:, 0])
+ _, idx_upl2 = torch.sort(good_idxs2[:, 0])
+ good_idxs1 = good_idxs1[idx_upl1]
+ match_dists = torch.max(dists1_good[idx_upl1], dists2_good[idx_upl2])
+ matches_idxs = good_idxs1
+ else:
+ matches_idxs, match_dists = torch.empty(0, 2, device=dm.device), torch.empty(0, 1, device=dm.device)
+ return match_dists.view(-1, 1), matches_idxs.view(-1, 2)
+
+
+class DescriptorMatcher(nn.Module):
+ """Module version of matching functions.
+
+ See :func:`~kornia.feature.match_nn`, :func:`~kornia.feature.match_snn`,
+ :func:`~kornia.feature.match_mnn` or :func:`~kornia.feature.match_smnn` for more details.
+
+ Args:
+ match_mode: type of matching, can be `nn`, `snn`, `mnn`, `smnn`.
+ th: threshold on distance ratio, or other quality measure.
+ """
+ known_modes = ['nn', 'mnn', 'snn', 'smnn']
+
+ def __init__(self, match_mode: str = 'snn', th: float = 0.8) -> None:
+ super().__init__()
+ _match_mode: str = match_mode.lower()
+ if _match_mode not in self.known_modes:
+ raise NotImplementedError(f"{match_mode} is not supported. Try one of {self.known_modes}")
+ self.match_mode = _match_mode
+ self.th = th
+
+ def forward(self, desc1: torch.Tensor, desc2: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+ """
+ Args:
+ desc1: Batch of descriptors of a shape :math:`(B1, D)`.
+ desc2: Batch of descriptors of a shape :math:`(B2, D)`.
+
+ Return:
+ - Descriptor distance of matching descriptors, shape of :math:`(B3, 1)`.
+ - Long tensor indexes of matching descriptors in desc1 and desc2,
+ shape of :math:`(B3, 2)` where :math:`0 <= B3 <= B1`.
+ """
+ if self.match_mode == 'nn':
+ out = match_nn(desc1, desc2)
+ elif self.match_mode == 'mnn':
+ out = match_mnn(desc1, desc2)
+ elif self.match_mode == 'snn':
+ out = match_snn(desc1, desc2, self.th)
+ elif self.match_mode == 'smnn':
+ out = match_smnn(desc1, desc2, self.th)
+ else:
+ raise NotImplementedError
+ return out
diff --git a/kornia/feature/mkd.py b/kornia/feature/mkd.py
new file mode 100644
index 0000000000000000000000000000000000000000..a921b5bd3d41b2d90dabf4647fc66ab16e5592bb
--- /dev/null
+++ b/kornia/feature/mkd.py
@@ -0,0 +1,675 @@
+from typing import Dict, List, Tuple, Union
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from kornia.constants import pi
+from kornia.filters import GaussianBlur2d, SpatialGradient
+from kornia.geometry.conversions import cart2pol
+from kornia.utils import create_meshgrid
+
+# Precomputed coefficients for Von Mises kernel, given N and K(appa).
+sqrt2: float = 1.4142135623730951
+COEFFS_N1_K1: List[float] = [0.38214156, 0.48090413]
+COEFFS_N2_K8: List[float] = [0.14343168, 0.268285, 0.21979234]
+COEFFS_N3_K8: List[float] = [0.14343168, 0.268285, 0.21979234, 0.15838885]
+COEFFS: Dict[str, List[float]] = {'xy': COEFFS_N1_K1, 'rhophi': COEFFS_N2_K8, 'theta': COEFFS_N3_K8}
+
+urls: Dict[str, str] = {
+ k: f'https://github.com/manyids2/mkd_pytorch/raw/master/mkd_pytorch/mkd-{k}-64.pth'
+ for k in ['cart', 'polar', 'concat']
+}
+
+
+def get_grid_dict(patch_size: int = 32) -> Dict[str, torch.Tensor]:
+ r"""Get cartesian and polar parametrizations of grid."""
+ kgrid = create_meshgrid(height=patch_size, width=patch_size, normalized_coordinates=True)
+ x = kgrid[0, :, :, 0]
+ y = kgrid[0, :, :, 1]
+ rho, phi = cart2pol(x, y)
+ grid_dict = {'x': x, 'y': y, 'rho': rho, 'phi': phi}
+ return grid_dict
+
+
+def get_kron_order(d1: int, d2: int) -> torch.Tensor:
+ r"""Get order for doing kronecker product."""
+ kron_order = torch.zeros([d1 * d2, 2], dtype=torch.int64)
+ for i in range(d1):
+ for j in range(d2):
+ kron_order[i * d2 + j, 0] = i
+ kron_order[i * d2 + j, 1] = j
+ return kron_order
+
+
+class MKDGradients(nn.Module):
+ r"""Module, which computes gradients of given patches, stacked as [magnitudes, orientations].
+
+ Given gradients $g_x$, $g_y$ with respect to $x$, $y$ respectively,
+ - $\mathbox{mags} = $\sqrt{g_x^2 + g_y^2 + eps}$
+ - $\mathbox{oris} = $\mbox{tan}^{-1}(\nicefrac{g_y}{g_x})$.
+
+ Args:
+ patch_size: Input patch size in pixels.
+
+ Returns:
+ gradients of given patches.
+
+ Shape:
+ - Input: (B, 1, patch_size, patch_size)
+ - Output: (B, 2, patch_size, patch_size)
+
+ Example:
+ >>> patches = torch.rand(23, 1, 32, 32)
+ >>> gradient = MKDGradients()
+ >>> g = gradient(patches) # 23x2x32x32
+ """
+
+ def __init__(self) -> None:
+ super().__init__()
+ self.eps = 1e-8
+
+ self.grad = SpatialGradient(mode='diff', order=1, normalized=False)
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ if not isinstance(x, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(x)}")
+ if not len(x.shape) == 4:
+ raise ValueError(f"Invalid input shape, we expect Bx1xHxW. Got: {x.shape}")
+ # Modify 'diff' gradient. Before we had lambda function, but it is not jittable
+ grads_xy = -self.grad(x)
+ gx = grads_xy[:, :, 0, :, :]
+ gy = grads_xy[:, :, 1, :, :]
+ y = torch.cat(cart2pol(gx, gy, self.eps), dim=1)
+ return y
+
+ def __repr__(self) -> str:
+ return self.__class__.__name__
+
+
+class VonMisesKernel(nn.Module):
+ r"""Module, which computes parameters of Von Mises kernel given coefficients, and embeds given patches.
+
+ Args:
+ patch_size: Input patch size in pixels.
+ coeffs: List of coefficients. Some examples are hardcoded in COEFFS,
+
+ Returns:
+ Von Mises embedding of given parametrization.
+
+ Shape:
+ - Input: (B, 1, patch_size, patch_size)
+ - Output: (B, d, patch_size, patch_size)
+
+ Examples:
+ >>> oris = torch.rand(23, 1, 32, 32)
+ >>> vm = VonMisesKernel(patch_size=32,
+ ... coeffs=[0.14343168,
+ ... 0.268285,
+ ... 0.21979234])
+ >>> emb = vm(oris) # 23x7x32x32
+ """
+
+ def __init__(self, patch_size: int, coeffs: Union[list, tuple]) -> None:
+ super().__init__()
+
+ self.patch_size = patch_size
+ b_coeffs: torch.Tensor = torch.tensor(coeffs)
+ self.register_buffer('coeffs', b_coeffs)
+
+ # Compute parameters.
+ n: int = len(coeffs) - 1
+ self.n: int = n
+ self.d: int = 2 * n + 1
+
+ # Precompute helper variables.
+ emb0 = torch.ones([1, 1, patch_size, patch_size])
+ frange = torch.arange(n) + 1
+ frange = frange.reshape(-1, 1, 1)
+ weights = torch.zeros([2 * n + 1])
+ weights[: n + 1] = torch.sqrt(b_coeffs)
+ weights[n + 1:] = torch.sqrt(b_coeffs[1:])
+ weights = weights.reshape(-1, 1, 1)
+ self.register_buffer('emb0', emb0)
+ self.register_buffer('frange', frange)
+ self.register_buffer('weights', weights)
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ if not isinstance(x, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(x)}")
+
+ if not len(x.shape) == 4 or x.shape[1] != 1:
+ raise ValueError(f"Invalid input shape, we expect Bx1xHxW. Got: {x.shape}")
+
+ # TODO: unify the two lines below when pytorch 1.6 support is dropped
+ emb0: torch.Tensor = torch.jit.annotate(torch.Tensor, self.emb0)
+ emb0 = emb0.to(x).repeat(x.size(0), 1, 1, 1)
+ frange = self.frange.to(x) * x
+ emb1 = torch.cos(frange)
+ emb2 = torch.sin(frange)
+ embedding = torch.cat([emb0, emb1, emb2], dim=1)
+ embedding = self.weights * embedding
+ return embedding
+
+ def __repr__(self) -> str:
+ return (
+ self.__class__.__name__
+ + '('
+ + 'patch_size='
+ + str(self.patch_size)
+ + ', '
+ + 'n='
+ + str(self.n)
+ + ', '
+ + 'd='
+ + str(self.d)
+ + ', '
+ + 'coeffs='
+ + str(self.coeffs)
+ + ')'
+ )
+
+
+class EmbedGradients(nn.Module):
+ r"""Module that computes gradient embedding, weighted by sqrt of magnitudes of given patches.
+
+ Args:
+ patch_size: Input patch size in pixels.
+ relative: absolute or relative gradients.
+
+ Returns:
+ Gradient embedding.
+
+ Shape:
+ - Input: (B, 2, patch_size, patch_size)
+ - Output: (B, 7, patch_size, patch_size)
+
+ Examples:
+ >>> grads = torch.rand(23, 2, 32, 32)
+ >>> emb_grads = EmbedGradients(patch_size=32,
+ ... relative=False)
+ >>> emb = emb_grads(grads) # 23x7x32x32
+ """
+
+ def __init__(self, patch_size: int = 32, relative: bool = False) -> None:
+ super().__init__()
+ self.patch_size = patch_size
+ self.relative = relative
+ self.eps = 1e-8
+
+ # Theta kernel for gradients.
+ self.kernel = VonMisesKernel(patch_size=patch_size, coeffs=COEFFS['theta'])
+
+ # Relative gradients.
+ kgrid = create_meshgrid(height=patch_size, width=patch_size, normalized_coordinates=True)
+ _, phi = cart2pol(kgrid[:, :, :, 0], kgrid[:, :, :, 1])
+ self.register_buffer('phi', phi)
+
+ def emb_mags(self, mags: torch.Tensor) -> torch.Tensor:
+ """Embed square roots of magnitudes with eps for numerical reasons."""
+ mags = torch.sqrt(mags + self.eps)
+ return mags
+
+ def forward(self, grads: torch.Tensor) -> torch.Tensor:
+ if not isinstance(grads, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(grads)}")
+ if not len(grads.shape) == 4:
+ raise ValueError(f"Invalid input shape, we expect Bx2xHxW. Got: {grads.shape}")
+ mags = grads[:, :1, :, :]
+ oris = grads[:, 1:, :, :]
+ if self.relative:
+ oris = oris - self.phi.to(oris)
+ y = self.kernel(oris) * self.emb_mags(mags)
+ return y
+
+ def __repr__(self) -> str:
+ return (
+ self.__class__.__name__
+ + '('
+ + 'patch_size='
+ + str(self.patch_size)
+ + ', '
+ + 'relative='
+ + str(self.relative)
+ + ')'
+ )
+
+
+def spatial_kernel_embedding(kernel_type, grids: dict) -> torch.Tensor:
+ r"""Compute embeddings for cartesian and polar parametrizations."""
+ factors = {"phi": 1.0, "rho": pi / sqrt2, "x": pi / 2, "y": pi / 2}
+ if kernel_type == 'cart':
+ coeffs_ = 'xy'
+ params_ = ['x', 'y']
+ elif kernel_type == 'polar':
+ coeffs_ = 'rhophi'
+ params_ = ['phi', 'rho']
+
+ # Infer patch_size.
+ keys = list(grids.keys())
+ patch_size = grids[keys[0]].shape[-1]
+
+ # Scale appropriately.
+ grids_normed = {k: v * factors[k] for k, v in grids.items()}
+ grids_normed = {k: v.unsqueeze(0).unsqueeze(0).float() for k, v in grids_normed.items()}
+
+ # x,y/rho,phi kernels.
+ vm_a = VonMisesKernel(patch_size=patch_size, coeffs=COEFFS[coeffs_])
+ vm_b = VonMisesKernel(patch_size=patch_size, coeffs=COEFFS[coeffs_])
+
+ emb_a = vm_a(grids_normed[params_[0]]).squeeze()
+ emb_b = vm_b(grids_normed[params_[1]]).squeeze()
+
+ # Final precomputed position embedding.
+ kron_order = get_kron_order(vm_a.d, vm_b.d)
+ spatial_kernel = emb_a.index_select(0, kron_order[:, 0]) * emb_b.index_select(0, kron_order[:, 1])
+ return spatial_kernel
+
+
+class ExplicitSpacialEncoding(nn.Module):
+ r"""Module that computes explicit cartesian or polar embedding.
+
+ Args:
+ kernel_type: Parametrization of kernel ``'polar'`` or ``'cart'``.
+ fmap_size: Input feature map size in pixels.
+ in_dims: Dimensionality of input feature map.
+ do_gmask: Apply gaussian mask.
+ do_l2: Apply l2-normalization.
+
+ Returns:
+ Explicit cartesian or polar embedding.
+
+ Shape:
+ - Input: (B, in_dims, fmap_size, fmap_size)
+ - Output: (B, out_dims, fmap_size, fmap_size)
+
+ Example:
+ >>> emb_ori = torch.rand(23, 7, 32, 32)
+ >>> ese = ExplicitSpacialEncoding(kernel_type='polar',
+ ... fmap_size=32,
+ ... in_dims=7,
+ ... do_gmask=True,
+ ... do_l2=True)
+ >>> desc = ese(emb_ori) # 23x175x32x32
+ """
+
+ def __init__(
+ self,
+ kernel_type: str = 'polar',
+ fmap_size: int = 32,
+ in_dims: int = 7,
+ do_gmask: bool = True,
+ do_l2: bool = True,
+ ) -> None:
+ super().__init__()
+
+ if kernel_type not in ['polar', 'cart']:
+ raise NotImplementedError(f'{kernel_type} is not valid, use polar or cart).')
+
+ self.kernel_type = kernel_type
+ self.fmap_size = fmap_size
+ self.in_dims = in_dims
+ self.do_gmask = do_gmask
+ self.do_l2 = do_l2
+ self.grid = get_grid_dict(fmap_size)
+ self.gmask = None
+
+ # Precompute embedding.
+ emb = spatial_kernel_embedding(self.kernel_type, self.grid)
+
+ # Gaussian mask.
+ if self.do_gmask:
+ self.gmask = self.get_gmask(sigma=1.0)
+ emb = emb * self.gmask
+
+ # Store precomputed embedding.
+ self.register_buffer('emb', emb.unsqueeze(0))
+ self.d_emb: int = emb.shape[0]
+ self.out_dims: int = self.in_dims * self.d_emb
+ self.odims: int = self.out_dims
+
+ # Store kronecker form.
+ emb2, idx1 = self.init_kron()
+ self.register_buffer('emb2', emb2)
+ self.register_buffer('idx1', idx1)
+
+ def get_gmask(self, sigma: float) -> torch.Tensor:
+ """Compute Gaussian mask."""
+ norm_rho = self.grid['rho'] / self.grid['rho'].max()
+ gmask = torch.exp(-1 * norm_rho ** 2 / sigma ** 2)
+ return gmask
+
+ def init_kron(self) -> Tuple[torch.Tensor, torch.Tensor]:
+ """Initialize helper variables to calculate kronecker."""
+ kron = get_kron_order(self.in_dims, self.d_emb)
+ _emb = torch.jit.annotate(torch.Tensor, self.emb)
+ emb2 = torch.index_select(_emb, 1, kron[:, 1])
+ return emb2, kron[:, 0]
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ if not isinstance(x, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(x)}")
+ if not ((len(x.shape) == 4) | (x.shape[1] == self.in_dims)):
+ raise ValueError(f"Invalid input shape, we expect Bx{self.in_dims}xHxW. Got: {x.shape}")
+ idx1 = torch.jit.annotate(torch.Tensor, self.idx1)
+ emb1 = torch.index_select(x, 1, idx1)
+ output = emb1 * self.emb2
+ output = output.sum(dim=(2, 3))
+ if self.do_l2:
+ output = F.normalize(output, dim=1)
+ return output
+
+ def __repr__(self) -> str:
+ return (
+ self.__class__.__name__
+ + '('
+ + 'kernel_type='
+ + str(self.kernel_type)
+ + ', '
+ + 'fmap_size='
+ + str(self.fmap_size)
+ + ', '
+ + 'in_dims='
+ + str(self.in_dims)
+ + ', '
+ + 'out_dims='
+ + str(self.out_dims)
+ + ', '
+ + 'do_gmask='
+ + str(self.do_gmask)
+ + ', '
+ + 'do_l2='
+ + str(self.do_l2)
+ + ')'
+ )
+
+
+class Whitening(nn.Module):
+ r"""Module, performs supervised or unsupervised whitening.
+
+ This is based on the paper "Understanding and Improving Kernel Local Descriptors".
+ See :cite:`mukundan2019understanding` for more details.
+
+ Args:
+ xform: Variant of whitening to use. None, 'lw', 'pca', 'pcaws', 'pcawt'.
+ whitening_model: Dictionary with keys 'mean', 'eigvecs', 'eigvals' holding torch.Tensors.
+ in_dims: Dimensionality of input descriptors.
+ output_dims: (int) Dimensionality reduction.
+ keval: Shrinkage parameter.
+ t: Attenuation parameter.
+
+ Returns:
+ l2-normalized, whitened descriptors.
+
+ Shape:
+ - Input: (B, in_dims, fmap_size, fmap_size)
+ - Output: (B, out_dims, fmap_size, fmap_size)
+
+ Examples:
+ >>> descs = torch.rand(23, 238)
+ >>> whitening_model = {'pca': {'mean': torch.zeros(238),
+ ... 'eigvecs': torch.eye(238),
+ ... 'eigvals': torch.ones(238)}}
+ >>> whitening = Whitening(xform='pcawt',
+ ... whitening_model=whitening_model,
+ ... in_dims=238,
+ ... output_dims=128,
+ ... keval=40,
+ ... t=0.7)
+ >>> wdescs = whitening(descs) # 23x128
+ """
+
+ def __init__(
+ self,
+ xform: str,
+ whitening_model: Union[Dict[str, Dict[str, torch.Tensor]], None],
+ in_dims: int,
+ output_dims: int = 128,
+ keval: int = 40,
+ t: float = 0.7,
+ ) -> None:
+ super().__init__()
+
+ self.xform = xform
+ self.in_dims = in_dims
+ self.keval = keval
+ self.t = t
+ self.pval = 1.0
+
+ # Compute true output_dims.
+ output_dims = min(output_dims, in_dims)
+ self.output_dims = output_dims
+
+ # Initialize identity transform.
+ self.mean = nn.Parameter(torch.zeros(in_dims), requires_grad=True)
+ self.evecs = nn.Parameter(torch.eye(in_dims)[:, :output_dims], requires_grad=True)
+ self.evals = nn.Parameter(torch.ones(in_dims)[:output_dims], requires_grad=True)
+
+ if whitening_model is not None:
+ self.load_whitening_parameters(whitening_model)
+
+ def load_whitening_parameters(self, whitening_model: Dict[str, Dict[str, torch.Tensor]]) -> None:
+ algo = 'lw' if self.xform == 'lw' else 'pca'
+ wh_model = whitening_model[algo]
+ self.mean.data = wh_model['mean']
+ self.evecs.data = wh_model['eigvecs'][:, : self.output_dims]
+ self.evals.data = wh_model['eigvals'][: self.output_dims]
+
+ modifications = {
+ 'pca': self._modify_pca,
+ 'lw': self._modify_lw,
+ 'pcaws': self._modify_pcaws,
+ 'pcawt': self._modify_pcawt,
+ }
+
+ # Call modification.
+ modifications[self.xform]()
+
+ def _modify_pca(self) -> None:
+ """Modify powerlaw parameter."""
+ self.pval = 0.5
+
+ def _modify_lw(self) -> None:
+ """No modification required."""
+
+ def _modify_pcaws(self) -> None:
+ """Shrinkage for eigenvalues."""
+ alpha = self.evals[self.keval]
+ evals = ((1 - alpha) * self.evals) + alpha
+ self.evecs.data = self.evecs @ torch.diag(torch.pow(evals, -0.5))
+
+ def _modify_pcawt(self) -> None:
+ """Attenuation for eigenvalues."""
+ m = -0.5 * self.t
+ self.evecs.data = self.evecs @ torch.diag(torch.pow(self.evals, m))
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ if not isinstance(x, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(x)}")
+ if not len(x.shape) == 2:
+ raise ValueError(f"Invalid input shape, we expect NxD. Got: {x.shape}")
+ x = x - self.mean # Center the data.
+ x = x @ self.evecs # Apply rotation and/or scaling.
+ x = torch.sign(x) * torch.pow(torch.abs(x), self.pval) # Powerlaw.
+ return F.normalize(x, dim=1)
+
+ def __repr__(self) -> str:
+ return (
+ self.__class__.__name__
+ + '('
+ + 'xform='
+ + str(self.xform)
+ + ', '
+ + 'in_dims='
+ + str(self.in_dims)
+ + ', '
+ + 'output_dims='
+ + str(self.output_dims)
+ + ')'
+ )
+
+
+class MKDDescriptor(nn.Module):
+ r"""Module that computes Multiple Kernel local descriptors.
+
+ This is based on the paper "Understanding and Improving Kernel Local Descriptors".
+ See :cite:`mukundan2019understanding` for more details.
+
+ Args:
+ patch_size: Input patch size in pixels.
+ kernel_type: Parametrization of kernel ``'concat'``, ``'cart'``, ``'polar'``.
+ whitening: Whitening transform to apply ``None``, ``'lw'``, ``'pca'``, ``'pcawt'``, ``'pcaws'``.
+ training_set: Set that model was trained on ``'liberty'``, ``'notredame'``, ``'yosemite'``.
+ output_dims: Dimensionality reduction.
+
+ Returns:
+ Explicit cartesian or polar embedding.
+
+ Shape:
+ - Input: :math:`(B, in_{dims}, fmap_{size}, fmap_{size})`.
+ - Output: :math:`(B, out_{dims}, fmap_{size}, fmap_{size})`,
+
+ Examples:
+ >>> patches = torch.rand(23, 1, 32, 32)
+ >>> mkd = MKDDescriptor(patch_size=32,
+ ... kernel_type='concat',
+ ... whitening='pcawt',
+ ... training_set='liberty',
+ ... output_dims=128)
+ >>> desc = mkd(patches) # 23x128
+ """
+
+ def __init__(
+ self,
+ patch_size: int = 32,
+ kernel_type: str = 'concat',
+ whitening: str = 'pcawt',
+ training_set: str = 'liberty',
+ output_dims: int = 128,
+ ) -> None:
+ super().__init__()
+
+ self.patch_size: int = patch_size
+ self.kernel_type: str = kernel_type
+ self.whitening: str = whitening
+ self.training_set: str = training_set
+
+ self.sigma = 1.4 * (patch_size / 64)
+ self.smoothing = GaussianBlur2d((5, 5), (self.sigma, self.sigma), 'replicate')
+ self.gradients = MKDGradients()
+ # This stupid thing needed for jitting...
+ polar_s: str = 'polar'
+ cart_s: str = 'cart'
+ self.parametrizations = [polar_s, cart_s] if self.kernel_type == 'concat' else [self.kernel_type]
+
+ # Initialize cartesian/polar embedding with absolute/relative gradients.
+ self.odims: int = 0
+ relative_orientations = {polar_s: True, cart_s: False}
+ self.feats = {}
+ for parametrization in self.parametrizations:
+ gradient_embedding = EmbedGradients(patch_size=patch_size, relative=relative_orientations[parametrization])
+ spatial_encoding = ExplicitSpacialEncoding(
+ kernel_type=parametrization, fmap_size=patch_size, in_dims=gradient_embedding.kernel.d
+ )
+
+ self.feats[parametrization] = nn.Sequential(gradient_embedding, spatial_encoding)
+ self.odims += spatial_encoding.odims
+ # Compute true output_dims.
+ self.output_dims: int = min(output_dims, self.odims)
+
+ # Load supervised(lw)/unsupervised(pca) model trained on training_set.
+ if self.whitening is not None:
+ whitening_models = torch.hub.load_state_dict_from_url(
+ urls[self.kernel_type], map_location=lambda storage, loc: storage
+ )
+ whitening_model = whitening_models[training_set]
+ self.whitening_layer = Whitening(
+ whitening, whitening_model, in_dims=self.odims, output_dims=self.output_dims
+ )
+ self.odims = self.output_dims
+ self.eval()
+
+ def forward(self, patches: torch.Tensor) -> torch.Tensor:
+ if not isinstance(patches, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(patches)}")
+ if not len(patches.shape) == 4:
+ raise ValueError(f"Invalid input shape, we expect Bx1xHxW. Got: {patches.shape}")
+ # Extract gradients.
+ g = self.smoothing(patches)
+ g = self.gradients(g)
+
+ # Extract polar/cart features.
+ features = []
+ for parametrization in self.parametrizations:
+ self.feats[parametrization].to(g.device)
+ features.append(self.feats[parametrization](g))
+
+ # Concatenate.
+ y = torch.cat(features, dim=1)
+
+ # l2-normalize.
+ y = F.normalize(y, dim=1)
+
+ # Whiten descriptors.
+ if self.whitening is not None:
+ y = self.whitening_layer(y)
+
+ return y
+
+ def __repr__(self) -> str:
+ return (
+ self.__class__.__name__
+ + '('
+ + 'patch_size='
+ + str(self.patch_size)
+ + ', '
+ + 'kernel_type='
+ + str(self.kernel_type)
+ + ', '
+ + 'whitening='
+ + str(self.whitening)
+ + ', '
+ + 'training_set='
+ + str(self.training_set)
+ + ', '
+ + 'output_dims='
+ + str(self.output_dims)
+ + ')'
+ )
+
+
+def load_whitening_model(kernel_type: str, training_set: str) -> Dict:
+ whitening_models = torch.hub.load_state_dict_from_url(urls[kernel_type], map_location=lambda storage, loc: storage)
+ whitening_model = whitening_models[training_set]
+ return whitening_model
+
+
+class SimpleKD(nn.Module):
+ """Example to write custom Kernel Descriptors."""
+
+ def __init__(
+ self,
+ patch_size: int = 32,
+ kernel_type: str = 'polar', # 'cart' 'polar'
+ whitening: str = 'pcawt', # 'lw', 'pca', 'pcaws', 'pcawt
+ training_set: str = 'liberty', # 'liberty', 'notredame', 'yosemite'
+ output_dims: int = 128,
+ ) -> None:
+ super().__init__()
+
+ relative: bool = kernel_type == 'polar'
+ sigma: float = 1.4 * (patch_size / 64)
+ self.patch_size = patch_size
+ # Sequence of modules.
+ smoothing = GaussianBlur2d((5, 5), (sigma, sigma), 'replicate')
+ gradients = MKDGradients()
+ ori = EmbedGradients(patch_size=patch_size, relative=relative)
+ ese = ExplicitSpacialEncoding(kernel_type=kernel_type, fmap_size=patch_size, in_dims=ori.kernel.d)
+ wh = Whitening(
+ whitening, load_whitening_model(kernel_type, training_set), in_dims=ese.odims, output_dims=output_dims
+ )
+
+ self.features = nn.Sequential(smoothing, gradients, ori, ese, wh)
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ return self.features(x)
diff --git a/kornia/feature/orientation.py b/kornia/feature/orientation.py
new file mode 100644
index 0000000000000000000000000000000000000000..a9c767f3f1462e6ce4016312c6327969e3099e7e
--- /dev/null
+++ b/kornia/feature/orientation.py
@@ -0,0 +1,245 @@
+import math
+from typing import Dict, Optional
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from kornia.constants import pi
+from kornia.filters import get_gaussian_kernel2d, SpatialGradient
+from kornia.geometry import rad2deg
+
+from .laf import extract_patches_from_pyramid, get_laf_orientation, raise_error_if_laf_is_not_valid, set_laf_orientation
+
+urls: Dict[str, str] = {}
+urls["orinet"] = "https://github.com/ducha-aiki/affnet/raw/master/pretrained/OriNet.pth"
+
+
+class PassLAF(nn.Module):
+ """Dummy module to use instead of local feature orientation or affine shape estimator."""
+
+ def forward(self, laf: torch.Tensor, img: torch.Tensor) -> torch.Tensor:
+ """
+ Args:
+ laf: 4d tensor.
+ img: the input image tensor.
+
+ Return:
+ torch.Tensor: unchanged laf from the input."""
+ return laf
+
+
+class PatchDominantGradientOrientation(nn.Module):
+ """Module, which estimates the dominant gradient orientation of the given patches, in radians.
+
+ Zero angle points towards right.
+
+ Args:
+ patch_size: size of the (square) input patch.
+ num_angular_bins: number of histogram bins.
+ eps: for safe division, and arctan.
+ """
+
+ def __init__(self, patch_size: int = 32, num_angular_bins: int = 36, eps: float = 1e-8):
+ super().__init__()
+ self.patch_size = patch_size
+ self.num_ang_bins = num_angular_bins
+ self.gradient = SpatialGradient('sobel', 1)
+ self.eps = eps
+ self.angular_smooth = nn.Conv1d(1, 1, kernel_size=3, padding=1, bias=False, padding_mode="circular")
+ with torch.no_grad():
+ self.angular_smooth.weight[:] = torch.tensor([[[0.33, 0.34, 0.33]]])
+ sigma: float = float(self.patch_size) / math.sqrt(2.0)
+ self.weighting = get_gaussian_kernel2d((self.patch_size, self.patch_size), (sigma, sigma), True)
+
+ def __repr__(self):
+ return (
+ self.__class__.__name__ + '('
+ 'patch_size='
+ + str(self.patch_size)
+ + ', '
+ + 'num_ang_bins='
+ + str(self.num_ang_bins)
+ + ', '
+ + 'eps='
+ + str(self.eps)
+ + ')'
+ )
+
+ def forward(self, patch: torch.Tensor) -> torch.Tensor:
+ """Args:
+ patch: shape [Bx1xHxW]
+ Returns:
+ torch.Tensor: angle shape [B]"""
+ if not isinstance(patch, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(patch)}")
+ if not len(patch.shape) == 4:
+ raise ValueError(f"Invalid input shape, we expect Bx1xHxW. Got: {patch.shape}")
+ _, CH, W, H = patch.size()
+ if (W != self.patch_size) or (H != self.patch_size) or (CH != 1):
+ raise TypeError(
+ "input shape should be must be [Bx1x{}x{}]. "
+ "Got {}".format(self.patch_size, self.patch_size, patch.size())
+ )
+ self.weighting = self.weighting.to(patch.dtype).to(patch.device)
+ self.angular_smooth = self.angular_smooth.to(patch.dtype).to(patch.device)
+ grads: torch.Tensor = self.gradient(patch)
+ # unpack the edges
+ gx: torch.Tensor = grads[:, :, 0]
+ gy: torch.Tensor = grads[:, :, 1]
+
+ mag: torch.Tensor = torch.sqrt(gx * gx + gy * gy + self.eps)
+ ori: torch.Tensor = torch.atan2(gy, gx + self.eps) + 2.0 * pi
+
+ o_big = float(self.num_ang_bins) * (ori + 1.0 * pi) / (2.0 * pi)
+ bo0_big = torch.floor(o_big)
+ wo1_big = o_big - bo0_big
+ bo0_big = bo0_big % self.num_ang_bins
+ bo1_big = (bo0_big + 1) % self.num_ang_bins
+ wo0_big = (1.0 - wo1_big) * mag
+ wo1_big = wo1_big * mag
+ ang_bins_list = []
+ for i in range(0, self.num_ang_bins):
+ ang_bins_i = F.adaptive_avg_pool2d(
+ (bo0_big == i).to(patch.dtype) * wo0_big + (bo1_big == i).to(patch.dtype) * wo1_big, (1, 1)
+ )
+ ang_bins_list.append(ang_bins_i)
+ ang_bins = torch.cat(ang_bins_list, 1).view(-1, 1, self.num_ang_bins)
+ ang_bins = self.angular_smooth(ang_bins)
+ values, indices = ang_bins.view(-1, self.num_ang_bins).max(1)
+ angle = -((2.0 * pi * indices.to(patch.dtype) / float(self.num_ang_bins)) - pi)
+ return angle
+
+
+class OriNet(nn.Module):
+ """Network, which estimates the canonical orientation of the given 32x32 patches, in radians.
+
+ Zero angle points towards right. This is based on the original code from paper
+ "Repeatability Is Not Enough: Learning Discriminative Affine Regions via Discriminability"".
+ See :cite:`AffNet2018` for more details.
+
+ Args:
+ pretrained: Download and set pretrained weights to the model.
+ eps: to avoid division by zero in atan2.
+
+ Returns:
+ Angle in radians.
+
+ Shape:
+ - Input: (B, 1, 32, 32)
+ - Output: (B)
+
+ Examples:
+ >>> input = torch.rand(16, 1, 32, 32)
+ >>> orinet = OriNet()
+ >>> angle = orinet(input) # 16
+ """
+
+ def __init__(self, pretrained: bool = False, eps: float = 1e-8):
+ super().__init__()
+ self.features = nn.Sequential(
+ nn.Conv2d(1, 16, kernel_size=3, padding=1, bias=False),
+ nn.BatchNorm2d(16, affine=False),
+ nn.ReLU(),
+ nn.Conv2d(16, 16, kernel_size=3, stride=1, padding=1, bias=False),
+ nn.BatchNorm2d(16, affine=False),
+ nn.ReLU(),
+ nn.Conv2d(16, 32, kernel_size=3, stride=2, padding=1, bias=False),
+ nn.BatchNorm2d(32, affine=False),
+ nn.ReLU(),
+ nn.Conv2d(32, 32, kernel_size=3, stride=1, padding=1, bias=False),
+ nn.BatchNorm2d(32, affine=False),
+ nn.ReLU(),
+ nn.Conv2d(32, 64, kernel_size=3, stride=2, padding=1, bias=False),
+ nn.BatchNorm2d(64, affine=False),
+ nn.ReLU(),
+ nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1, bias=False),
+ nn.BatchNorm2d(64, affine=False),
+ nn.ReLU(),
+ nn.Dropout(0.25),
+ nn.Conv2d(64, 2, kernel_size=8, stride=1, padding=1, bias=True),
+ nn.Tanh(),
+ nn.AdaptiveAvgPool2d(1),
+ )
+ self.eps = eps
+ # use torch.hub to load pretrained model
+ if pretrained:
+ pretrained_dict = torch.hub.load_state_dict_from_url(
+ urls['orinet'], map_location=lambda storage, loc: storage
+ )
+ self.load_state_dict(pretrained_dict['state_dict'], strict=False)
+ self.eval()
+
+ @staticmethod
+ def _normalize_input(x: torch.Tensor, eps: float = 1e-6) -> torch.Tensor:
+ """Utility function that normalizes the input by batch.""" ""
+ sp, mp = torch.std_mean(x, dim=(-3, -2, -1), keepdim=True)
+ # WARNING: we need to .detach() input, otherwise the gradients produced by
+ # the patches extractor with F.grid_sample are very noisy, making the detector
+ # training totally unstable.
+ return (x - mp.detach()) / (sp.detach() + eps)
+
+ def forward(self, patch: torch.Tensor) -> torch.Tensor:
+ """Args:
+ patch: (torch.Tensor) shape [Bx1xHxW]
+ Returns:
+ patch: (torch.Tensor) shape [B]"""
+ xy = self.features(self._normalize_input(patch)).view(-1, 2)
+ angle = torch.atan2(xy[:, 0] + 1e-8, xy[:, 1] + self.eps)
+ return angle
+
+
+class LAFOrienter(nn.Module):
+ """Module, which extracts patches using input images and local affine frames (LAFs).
+
+ Then runs :class:`~kornia.feature.PatchDominantGradientOrientation` or
+ :class:`~kornia.feature.OriNet` on patches and then rotates the LAFs by the estimated angles
+
+ Args:
+ patch_size:
+ num_angular_bins:
+ angle_detector: Patch orientation estimator, e.g. :class:`~kornia.feature.PatchDominantGradientOrientation`
+ or OriNet.
+ """ # pylint: disable
+
+ def __init__(self, patch_size: int = 32, num_angular_bins: int = 36, angle_detector: Optional[nn.Module] = None):
+ super().__init__()
+ self.patch_size = patch_size
+ self.num_ang_bins = num_angular_bins
+ self.angle_detector: nn.Module
+ if angle_detector is None:
+ self.angle_detector = PatchDominantGradientOrientation(self.patch_size, self.num_ang_bins)
+ else:
+ self.angle_detector = angle_detector
+
+ def __repr__(self):
+ return (
+ self.__class__.__name__ + '('
+ 'patch_size=' + str(self.patch_size) + ', ' + 'angle_detector=' + str(self.angle_detector) + ')'
+ )
+
+ def forward(self, laf: torch.Tensor, img: torch.Tensor) -> torch.Tensor:
+ """
+ Args:
+ laf: shape [BxNx2x3]
+ img: shape [Bx1xHxW]
+
+ Returns:
+ laf_out, shape [BxNx2x3]
+ """
+ raise_error_if_laf_is_not_valid(laf)
+ img_message: str = f"Invalid img shape, we expect BxCxHxW. Got: {img.shape}"
+ if not isinstance(img, torch.Tensor):
+ raise TypeError(f"img type is not a torch.Tensor. Got {type(img)}")
+ if len(img.shape) != 4:
+ raise ValueError(img_message)
+ if laf.size(0) != img.size(0):
+ raise ValueError(f"Batch size of laf and img should be the same. Got {img.size(0)}, {laf.size(0)}")
+ B, N = laf.shape[:2]
+ patches: torch.Tensor = extract_patches_from_pyramid(img, laf, self.patch_size).view(
+ -1, 1, self.patch_size, self.patch_size
+ )
+ angles_radians: torch.Tensor = self.angle_detector(patches).view(B, N)
+ prev_angle = get_laf_orientation(laf).view_as(angles_radians)
+ laf_out: torch.Tensor = set_laf_orientation(laf, rad2deg(angles_radians) + prev_angle)
+ return laf_out
diff --git a/kornia/feature/responses.py b/kornia/feature/responses.py
new file mode 100644
index 0000000000000000000000000000000000000000..eea96da150feafc18e00fed79bd3941ebf10179f
--- /dev/null
+++ b/kornia/feature/responses.py
@@ -0,0 +1,349 @@
+from typing import Optional, Union
+
+import torch
+import torch.nn as nn
+
+from kornia.filters import gaussian_blur2d, spatial_gradient
+
+
+def harris_response(
+ input: torch.Tensor,
+ k: Union[torch.Tensor, float] = 0.04,
+ grads_mode: str = 'sobel',
+ sigmas: Optional[torch.Tensor] = None,
+) -> torch.Tensor:
+ r"""Compute the Harris cornerness function.
+
+ Function does not do any normalization or nms. The response map is computed according the following formulation:
+
+ .. math::
+ R = max(0, det(M) - k \cdot trace(M)^2)
+
+ where:
+
+ .. math::
+ M = \sum_{(x,y) \in W}
+ \begin{bmatrix}
+ I^{2}_x & I_x I_y \\
+ I_x I_y & I^{2}_y \\
+ \end{bmatrix}
+
+ and :math:`k` is an empirically determined constant
+ :math:`k โ [ 0.04 , 0.06 ]`
+
+ Args:
+ input: input image with shape :math:`(B, C, H, W)`.
+ k: the Harris detector free parameter.
+ grads_mode: can be ``'sobel'`` for standalone use or ``'diff'`` for use on Gaussian pyramid.
+ sigmas: coefficients to be multiplied by multichannel response. Should be shape of :math:`(B)`
+ It is necessary for performing non-maxima-suppression across different scale pyramid levels.
+ See `vlfeat `_.
+
+ Return:
+ the response map per channel with shape :math:`(B, C, H, W)`.
+
+ Example:
+ >>> input = torch.tensor([[[
+ ... [0., 0., 0., 0., 0., 0., 0.],
+ ... [0., 1., 1., 1., 1., 1., 0.],
+ ... [0., 1., 1., 1., 1., 1., 0.],
+ ... [0., 1., 1., 1., 1., 1., 0.],
+ ... [0., 1., 1., 1., 1., 1., 0.],
+ ... [0., 1., 1., 1., 1., 1., 0.],
+ ... [0., 0., 0., 0., 0., 0., 0.],
+ ... ]]]) # 1x1x7x7
+ >>> # compute the response map
+ harris_response(input, 0.04)
+ tensor([[[[0.0012, 0.0039, 0.0020, 0.0000, 0.0020, 0.0039, 0.0012],
+ [0.0039, 0.0065, 0.0040, 0.0000, 0.0040, 0.0065, 0.0039],
+ [0.0020, 0.0040, 0.0029, 0.0000, 0.0029, 0.0040, 0.0020],
+ [0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000],
+ [0.0020, 0.0040, 0.0029, 0.0000, 0.0029, 0.0040, 0.0020],
+ [0.0039, 0.0065, 0.0040, 0.0000, 0.0040, 0.0065, 0.0039],
+ [0.0012, 0.0039, 0.0020, 0.0000, 0.0020, 0.0039, 0.0012]]]])
+ """
+ # TODO: Recompute doctest
+ if not isinstance(input, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(input)}")
+
+ if not len(input.shape) == 4:
+ raise ValueError(f"Invalid input shape, we expect BxCxHxW. Got: {input.shape}")
+
+ if sigmas is not None:
+ if not isinstance(sigmas, torch.Tensor):
+ raise TypeError(f"sigmas type is not a torch.Tensor. Got {type(sigmas)}")
+ if (not len(sigmas.shape) == 1) or (sigmas.size(0) != input.size(0)):
+ raise ValueError(f"Invalid sigmas shape, we expect B == input.size(0). Got: {sigmas.shape}")
+
+ gradients: torch.Tensor = spatial_gradient(input, grads_mode)
+ dx: torch.Tensor = gradients[:, :, 0]
+ dy: torch.Tensor = gradients[:, :, 1]
+
+ # compute the structure tensor M elements
+
+ dx2: torch.Tensor = gaussian_blur2d(dx ** 2, (7, 7), (1.0, 1.0))
+ dy2: torch.Tensor = gaussian_blur2d(dy ** 2, (7, 7), (1.0, 1.0))
+ dxy: torch.Tensor = gaussian_blur2d(dx * dy, (7, 7), (1.0, 1.0))
+
+ det_m: torch.Tensor = dx2 * dy2 - dxy * dxy
+ trace_m: torch.Tensor = dx2 + dy2
+
+ # compute the response map
+ scores: torch.Tensor = det_m - k * (trace_m ** 2)
+
+ if sigmas is not None:
+ scores = scores * sigmas.pow(4).view(-1, 1, 1, 1)
+
+ return scores
+
+
+def gftt_response(
+ input: torch.Tensor, grads_mode: str = 'sobel', sigmas: Optional[torch.Tensor] = None
+) -> torch.Tensor:
+ r"""Compute the Shi-Tomasi cornerness function.
+
+ Function does not do any normalization or nms. The response map is computed according the following formulation:
+
+ .. math::
+ R = min(eig(M))
+
+ where:
+
+ .. math::
+ M = \sum_{(x,y) \in W}
+ \begin{bmatrix}
+ I^{2}_x & I_x I_y \\
+ I_x I_y & I^{2}_y \\
+ \end{bmatrix}
+
+ Args:
+ input: input image with shape :math:`(B, C, H, W)`.
+ grads_mode: can be ``'sobel'`` for standalone use or ``'diff'`` for use on Gaussian pyramid.
+ sigmas: coefficients to be multiplied by multichannel response. Should be shape of :math:`(B)`
+ It is necessary for performing non-maxima-suppression across different scale pyramid levels.
+ See `vlfeat `_.
+
+ Return:
+ the response map per channel with shape :math:`(B, C, H, W)`.
+
+ Example:
+ >>> input = torch.tensor([[[
+ ... [0., 0., 0., 0., 0., 0., 0.],
+ ... [0., 1., 1., 1., 1., 1., 0.],
+ ... [0., 1., 1., 1., 1., 1., 0.],
+ ... [0., 1., 1., 1., 1., 1., 0.],
+ ... [0., 1., 1., 1., 1., 1., 0.],
+ ... [0., 1., 1., 1., 1., 1., 0.],
+ ... [0., 0., 0., 0., 0., 0., 0.],
+ ... ]]]) # 1x1x7x7
+ >>> # compute the response map
+ gftt_response(input)
+ tensor([[[[0.0155, 0.0334, 0.0194, 0.0000, 0.0194, 0.0334, 0.0155],
+ [0.0334, 0.0575, 0.0339, 0.0000, 0.0339, 0.0575, 0.0334],
+ [0.0194, 0.0339, 0.0497, 0.0000, 0.0497, 0.0339, 0.0194],
+ [0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000],
+ [0.0194, 0.0339, 0.0497, 0.0000, 0.0497, 0.0339, 0.0194],
+ [0.0334, 0.0575, 0.0339, 0.0000, 0.0339, 0.0575, 0.0334],
+ [0.0155, 0.0334, 0.0194, 0.0000, 0.0194, 0.0334, 0.0155]]]])
+ """
+ # TODO: Recompute doctest
+ if not isinstance(input, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(input)}")
+
+ if not len(input.shape) == 4:
+ raise ValueError(f"Invalid input shape, we expect BxCxHxW. Got: {input.shape}")
+
+ gradients: torch.Tensor = spatial_gradient(input, grads_mode)
+ dx: torch.Tensor = gradients[:, :, 0]
+ dy: torch.Tensor = gradients[:, :, 1]
+
+ dx2: torch.Tensor = gaussian_blur2d(dx ** 2, (7, 7), (1.0, 1.0))
+ dy2: torch.Tensor = gaussian_blur2d(dy ** 2, (7, 7), (1.0, 1.0))
+ dxy: torch.Tensor = gaussian_blur2d(dx * dy, (7, 7), (1.0, 1.0))
+
+ det_m: torch.Tensor = dx2 * dy2 - dxy * dxy
+ trace_m: torch.Tensor = dx2 + dy2
+
+ e1: torch.Tensor = 0.5 * (trace_m + torch.sqrt((trace_m ** 2 - 4 * det_m).abs()))
+ e2: torch.Tensor = 0.5 * (trace_m - torch.sqrt((trace_m ** 2 - 4 * det_m).abs()))
+
+ scores: torch.Tensor = torch.min(e1, e2)
+
+ if sigmas is not None:
+ scores = scores * sigmas.pow(4).view(-1, 1, 1, 1)
+
+ return scores
+
+
+def hessian_response(
+ input: torch.Tensor, grads_mode: str = 'sobel', sigmas: Optional[torch.Tensor] = None
+) -> torch.Tensor:
+ r"""Compute the absolute of determinant of the Hessian matrix.
+
+ Function does not do any normalization or nms. The response map is computed according the following formulation:
+
+ .. math::
+ R = det(H)
+
+ where:
+
+ .. math::
+ M = \sum_{(x,y) \in W}
+ \begin{bmatrix}
+ I_{xx} & I_{xy} \\
+ I_{xy} & I_{yy} \\
+ \end{bmatrix}
+
+ Args:
+ input: input image with shape :math:`(B, C, H, W)`.
+ grads_mode: can be ``'sobel'`` for standalone use or ``'diff'`` for use on Gaussian pyramid.
+ sigmas: coefficients to be multiplied by multichannel response. Should be shape of :math:`(B)`
+ It is necessary for performing non-maxima-suppression across different scale pyramid levels.
+ See `vlfeat `_.
+
+ Return:
+ the response map per channel with shape :math:`(B, C, H, W)`.
+
+ Shape:
+ - Input: :math:`(B, C, H, W)`
+ - Output: :math:`(B, C, H, W)`
+
+ Examples:
+ >>> input = torch.tensor([[[
+ ... [0., 0., 0., 0., 0., 0., 0.],
+ ... [0., 1., 1., 1., 1., 1., 0.],
+ ... [0., 1., 1., 1., 1., 1., 0.],
+ ... [0., 1., 1., 1., 1., 1., 0.],
+ ... [0., 1., 1., 1., 1., 1., 0.],
+ ... [0., 1., 1., 1., 1., 1., 0.],
+ ... [0., 0., 0., 0., 0., 0., 0.],
+ ... ]]]) # 1x1x7x7
+ >>> # compute the response map
+ hessian_response(input)
+ tensor([[[[0.0155, 0.0334, 0.0194, 0.0000, 0.0194, 0.0334, 0.0155],
+ [0.0334, 0.0575, 0.0339, 0.0000, 0.0339, 0.0575, 0.0334],
+ [0.0194, 0.0339, 0.0497, 0.0000, 0.0497, 0.0339, 0.0194],
+ [0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000],
+ [0.0194, 0.0339, 0.0497, 0.0000, 0.0497, 0.0339, 0.0194],
+ [0.0334, 0.0575, 0.0339, 0.0000, 0.0339, 0.0575, 0.0334],
+ [0.0155, 0.0334, 0.0194, 0.0000, 0.0194, 0.0334, 0.0155]]]])
+ """
+ # TODO: Recompute doctest
+ if not isinstance(input, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(input)}")
+
+ if not len(input.shape) == 4:
+ raise ValueError(f"Invalid input shape, we expect BxCxHxW. Got: {input.shape}")
+
+ if sigmas is not None:
+ if not isinstance(sigmas, torch.Tensor):
+ raise TypeError(f"sigmas type is not a torch.Tensor. Got {type(sigmas)}")
+
+ if (not len(sigmas.shape) == 1) or (sigmas.size(0) != input.size(0)):
+ raise ValueError(f"Invalid sigmas shape, we expect B == input.size(0). Got: {sigmas.shape}")
+
+ gradients: torch.Tensor = spatial_gradient(input, grads_mode, 2)
+ dxx: torch.Tensor = gradients[:, :, 0]
+ dxy: torch.Tensor = gradients[:, :, 1]
+ dyy: torch.Tensor = gradients[:, :, 2]
+
+ scores: torch.Tensor = dxx * dyy - dxy ** 2
+
+ if sigmas is not None:
+ scores = scores * sigmas.pow(4).view(-1, 1, 1, 1)
+
+ return scores
+
+
+def dog_response(input: torch.Tensor) -> torch.Tensor:
+ r"""Compute the Difference-of-Gaussian response.
+
+ Args:
+ input: a given the gaussian 5d tensor :math:`(B, C, D, H, W)`.
+
+ Return:
+ the response map per channel with shape :math:`(B, C, D-1, H, W)`.
+
+ """
+ if not isinstance(input, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(input)}")
+
+ if not len(input.shape) == 5:
+ raise ValueError(f"Invalid input shape, we expect BxCxDxHxW. Got: {input.shape}")
+
+ return input[:, :, 1:] - input[:, :, :-1]
+
+
+class BlobDoG(nn.Module):
+ r"""Module that calculates Difference-of-Gaussians blobs.
+
+ See :func:`~kornia.feature.dog_response` for details.
+ """
+
+ def __init__(self) -> None:
+ super().__init__()
+ return
+
+ def __repr__(self) -> str:
+ return self.__class__.__name__
+
+ def forward(self, input: torch.Tensor, sigmas: Optional[torch.Tensor] = None) -> torch.Tensor: # type: ignore
+ return dog_response(input) # type: ignore
+
+
+class CornerHarris(nn.Module):
+ r"""Module that calculates Harris corners.
+
+ See :func:`~kornia.feature.harris_response` for details.
+ """
+
+ def __init__(self, k: Union[float, torch.Tensor], grads_mode='sobel') -> None:
+ super().__init__()
+ if type(k) is float:
+ self.register_buffer('k', torch.tensor(k))
+ else:
+ self.register_buffer('k', k) # type: ignore
+ self.grads_mode: str = grads_mode
+ return
+
+ def __repr__(self) -> str:
+ return self.__class__.__name__ + '(k=' + str(self.k) + ', ' + 'grads_mode=' + self.grads_mode + ')'
+
+ def forward(self, input: torch.Tensor, sigmas: Optional[torch.Tensor] = None) -> torch.Tensor: # type: ignore
+ return harris_response(input, self.k, self.grads_mode, sigmas) # type: ignore
+
+
+class CornerGFTT(nn.Module):
+ r"""Module that calculates Shi-Tomasi corners.
+
+ See :func:`~kornia.feature.gfft_response` for details.
+ """
+
+ def __init__(self, grads_mode='sobel') -> None:
+ super().__init__()
+ self.grads_mode: str = grads_mode
+ return
+
+ def __repr__(self) -> str:
+ return self.__class__.__name__ + 'grads_mode=' + self.grads_mode + ')'
+
+ def forward(self, input: torch.Tensor, sigmas: Optional[torch.Tensor] = None) -> torch.Tensor: # type: ignore
+ return gftt_response(input, self.grads_mode, sigmas)
+
+
+class BlobHessian(nn.Module):
+ r"""Module that calculates Hessian blobs.
+
+ See :func:`~kornia.feature.hessian_response` for details.
+ """
+
+ def __init__(self, grads_mode='sobel') -> None:
+ super().__init__()
+ self.grads_mode: str = grads_mode
+ return
+
+ def __repr__(self) -> str:
+ return self.__class__.__name__ + 'grads_mode=' + self.grads_mode + ')'
+
+ def forward(self, input: torch.Tensor, sigmas: Optional[torch.Tensor] = None) -> torch.Tensor: # type: ignore
+ return hessian_response(input, self.grads_mode, sigmas)
diff --git a/kornia/feature/scale_space_detector.py b/kornia/feature/scale_space_detector.py
new file mode 100644
index 0000000000000000000000000000000000000000..0441a3a5c4c64bc0ad1145e7fb0678f309603980
--- /dev/null
+++ b/kornia/feature/scale_space_detector.py
@@ -0,0 +1,226 @@
+from typing import List, Optional, Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from kornia.geometry.subpix import ConvSoftArgmax3d
+from kornia.geometry.transform import ScalePyramid
+
+from .laf import denormalize_laf, laf_is_inside_image, normalize_laf
+from .orientation import PassLAF
+from .responses import BlobHessian
+
+
+def _scale_index_to_scale(max_coords: torch.Tensor, sigmas: torch.Tensor, num_levels: int) -> torch.Tensor:
+ r"""Auxiliary function for ScaleSpaceDetector. Converts scale level index from ConvSoftArgmax3d
+ to the actual scale, using the sigmas from the ScalePyramid output.
+
+ Args:
+ max_coords: tensor [BxNx3].
+ sigmas: tensor [BxNxD], D >= 1
+
+ Returns:
+ tensor [BxNx3].
+ """
+ # depth (scale) in coord_max is represented as (float) index, not the scale yet.
+ # we will interpolate the scale using pytorch.grid_sample function
+ # Because grid_sample is for 4d input only, we will create fake 2nd dimension
+ # ToDo: replace with 3d input, when grid_sample will start to support it
+
+ # Reshape for grid shape
+ B, N, _ = max_coords.shape
+ scale_coords = max_coords[:, :, 0].contiguous().view(-1, 1, 1, 1)
+ # Replace the scale_x_y
+ out = torch.cat(
+ [sigmas[0, 0] * torch.pow(2.0, scale_coords / float(num_levels)).view(B, N, 1), max_coords[:, :, 1:]], dim=2
+ )
+ return out
+
+
+def _create_octave_mask(mask: torch.Tensor, octave_shape: List[int]) -> torch.Tensor:
+ r"""Downsample a mask based on the given octave shape."""
+ mask_shape = octave_shape[-2:]
+ mask_octave = F.interpolate(mask, mask_shape, mode='bilinear', align_corners=False) # type: ignore
+ return mask_octave.unsqueeze(1)
+
+
+class ScaleSpaceDetector(nn.Module):
+ r"""Module for differentiable local feature detection, as close as possible to classical
+ local feature detectors like Harris, Hessian-Affine or SIFT (DoG).
+
+ It has 5 modules inside: scale pyramid generator, response ("cornerness") function,
+ soft nms function, affine shape estimator and patch orientation estimator.
+ Each of those modules could be replaced with learned custom one, as long, as
+ they respect output shape.
+
+ Args:
+ num_features: Number of features to detect. In order to keep everything batchable,
+ output would always have num_features output, even for completely homogeneous images.
+ mr_size: multiplier for local feature scale compared to the detection scale.
+ 6.0 is matching OpenCV 12.0 convention for SIFT.
+ scale_pyr_module: generates scale pyramid. See :class:`~kornia.geometry.ScalePyramid` for details.
+ Default: ScalePyramid(3, 1.6, 10).
+ resp_module: calculates ``'cornerness'`` of the pixel.
+ nms_module: outputs per-patch coordinates of the response maxima.
+ See :class:`~kornia.geometry.ConvSoftArgmax3d` for details.
+ ori_module: for local feature orientation estimation. Default:class:`~kornia.feature.PassLAF`,
+ which does nothing. See :class:`~kornia.feature.LAFOrienter` for details.
+ aff_module: for local feature affine shape estimation. Default: :class:`~kornia.feature.PassLAF`,
+ which does nothing. See :class:`~kornia.feature.LAFAffineShapeEstimator` for details.
+ minima_are_also_good: if True, then both response function minima and maxima are detected
+ Useful for symmetric response functions like DoG or Hessian. Default is False
+ """
+
+ def __init__(
+ self,
+ num_features: int = 500,
+ mr_size: float = 6.0,
+ scale_pyr_module: nn.Module = ScalePyramid(3, 1.6, 15),
+ resp_module: nn.Module = BlobHessian(),
+ nms_module: nn.Module = ConvSoftArgmax3d(
+ (3, 3, 3), (1, 1, 1), (1, 1, 1), normalized_coordinates=False, output_value=True
+ ),
+ ori_module: nn.Module = PassLAF(),
+ aff_module: nn.Module = PassLAF(),
+ minima_are_also_good: bool = False,
+ scale_space_response=False,
+ ):
+ super().__init__()
+ self.mr_size = mr_size
+ self.num_features = num_features
+ self.scale_pyr = scale_pyr_module
+ self.resp = resp_module
+ self.nms = nms_module
+ self.ori = ori_module
+ self.aff = aff_module
+ self.minima_are_also_good = minima_are_also_good
+ # scale_space_response should be True if the response function works on scale space
+ # like Difference-of-Gaussians
+ self.scale_space_response = scale_space_response
+
+ def __repr__(self):
+ return (
+ self.__class__.__name__ + '('
+ 'num_features='
+ + str(self.num_features)
+ + ', '
+ + 'mr_size='
+ + str(self.mr_size)
+ + ', '
+ + 'scale_pyr='
+ + self.scale_pyr.__repr__()
+ + ', '
+ + 'resp='
+ + self.resp.__repr__()
+ + ', '
+ + 'nms='
+ + self.nms.__repr__()
+ + ', '
+ + 'ori='
+ + self.ori.__repr__()
+ + ', '
+ + 'aff='
+ + self.aff.__repr__()
+ + ')'
+ )
+
+ def detect(
+ self, img: torch.Tensor, num_feats: int, mask: Optional[torch.Tensor] = None
+ ) -> Tuple[torch.Tensor, torch.Tensor]:
+ dev: torch.device = img.device
+ dtype: torch.dtype = img.dtype
+ sp, sigmas, _ = self.scale_pyr(img)
+ all_responses: List[torch.Tensor] = []
+ all_lafs: List[torch.Tensor] = []
+ for oct_idx, octave in enumerate(sp):
+ sigmas_oct = sigmas[oct_idx]
+ B, CH, L, H, W = octave.size()
+ # Run response function
+ if self.scale_space_response:
+ oct_resp = self.resp(octave, sigmas_oct.view(-1))
+ else:
+ oct_resp = self.resp(octave.permute(0, 2, 1, 3, 4).reshape(B * L, CH, H, W), sigmas_oct.view(-1)).view(
+ B, L, CH, H, W
+ )
+ # We want nms for scale responses, so reorder to (B, CH, L, H, W)
+ oct_resp = oct_resp.permute(0, 2, 1, 3, 4)
+ # 3rd extra level is required for DoG only
+ if self.scale_pyr.extra_levels % 2 != 0: # type: ignore
+ oct_resp = oct_resp[:, :, :-1]
+
+ if mask is not None:
+ oct_mask: torch.Tensor = _create_octave_mask(mask, oct_resp.shape)
+ oct_resp = oct_mask * oct_resp
+
+ # Differentiable nms
+ coord_max, response_max = self.nms(oct_resp)
+ if self.minima_are_also_good:
+ coord_min, response_min = self.nms(-oct_resp)
+ take_min_mask = (response_min > response_max).to(response_max.dtype)
+ response_max = response_min * take_min_mask + (1 - take_min_mask) * response_max
+ coord_max = coord_min * take_min_mask.unsqueeze(2) + (1 - take_min_mask.unsqueeze(2)) * coord_max
+
+ # Now, lets crop out some small responses
+ responses_flatten = response_max.view(response_max.size(0), -1) # [B, N]
+ max_coords_flatten = coord_max.view(response_max.size(0), 3, -1).permute(0, 2, 1) # [B, N, 3]
+
+ if responses_flatten.size(1) > num_feats:
+ resp_flat_best, idxs = torch.topk(responses_flatten, k=num_feats, dim=1)
+ max_coords_best = torch.gather(max_coords_flatten, 1, idxs.unsqueeze(-1).repeat(1, 1, 3))
+ else:
+ resp_flat_best = responses_flatten
+ max_coords_best = max_coords_flatten
+ B, N = resp_flat_best.size()
+
+ # Converts scale level index from ConvSoftArgmax3d to the actual scale, using the sigmas
+ max_coords_best = _scale_index_to_scale(
+ max_coords_best, sigmas_oct, self.scale_pyr.n_levels # type: ignore
+ )
+
+ # Create local affine frames (LAFs)
+ rotmat = torch.eye(2, dtype=dtype, device=dev).view(1, 1, 2, 2)
+ current_lafs = torch.cat(
+ [
+ self.mr_size * max_coords_best[:, :, 0].view(B, N, 1, 1) * rotmat,
+ max_coords_best[:, :, 1:3].view(B, N, 2, 1),
+ ],
+ dim=3,
+ )
+
+ # Zero response lafs, which touch the boundary
+ good_mask = laf_is_inside_image(current_lafs, octave[:, 0])
+ resp_flat_best = resp_flat_best * good_mask.to(dev, dtype)
+
+ # Normalize LAFs
+ current_lafs = normalize_laf(current_lafs, octave[:, 0]) # We don`t need # of scale levels, only shape
+
+ all_responses.append(resp_flat_best)
+ all_lafs.append(current_lafs)
+
+ # Sort and keep best n
+ responses: torch.Tensor = torch.cat(all_responses, dim=1)
+ lafs: torch.Tensor = torch.cat(all_lafs, dim=1)
+ responses, idxs = torch.topk(responses, k=num_feats, dim=1)
+ lafs = torch.gather(lafs, 1, idxs.unsqueeze(-1).unsqueeze(-1).repeat(1, 1, 2, 3))
+ return responses, denormalize_laf(lafs, img)
+
+ def forward( # type: ignore
+ self, img: torch.Tensor, mask: Optional[torch.Tensor] = None # type: ignore
+ ) -> Tuple[torch.Tensor, torch.Tensor]:
+ """Three stage local feature detection. First the location and scale of interest points are determined by
+ detect function. Then affine shape and orientation.
+
+ Args:
+ img: image to extract features with shape [BxCxHxW]
+ mask: a mask with weights where to apply the response function. The shape must be the same as
+ the input image.
+
+ Returns:
+ lafs: shape [BxNx2x3]. Detected local affine frames.
+ responses: shape [BxNx1]. Response function values for corresponding lafs
+ """
+ responses, lafs = self.detect(img, self.num_features, mask)
+ lafs = self.aff(lafs, img)
+ lafs = self.ori(lafs, img)
+ return lafs, responses
diff --git a/kornia/feature/siftdesc.py b/kornia/feature/siftdesc.py
new file mode 100644
index 0000000000000000000000000000000000000000..d69a2eac0ee385035b53964d8f26b86745d6d277
--- /dev/null
+++ b/kornia/feature/siftdesc.py
@@ -0,0 +1,191 @@
+import math
+from typing import Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from kornia.filters import get_gaussian_kernel2d, spatial_gradient
+from kornia.geometry.conversions import pi
+
+
+def get_sift_pooling_kernel(ksize: int = 25) -> torch.Tensor:
+ r"""Return a weighted pooling kernel for SIFT descriptor.
+
+ Args:
+ ksize: kernel_size.
+
+ Returns:
+ the pooling kernel with shape :math:`(ksize, ksize)`.
+ """
+ ks_2: float = float(ksize) / 2.0
+ xc2: torch.Tensor = ks_2 - (torch.arange(ksize).float() + 0.5 - ks_2).abs() # type: ignore
+ kernel: torch.Tensor = torch.ger(xc2, xc2) / (ks_2 ** 2)
+ return kernel
+
+
+def get_sift_bin_ksize_stride_pad(patch_size: int, num_spatial_bins: int) -> Tuple:
+ r"""Return a tuple with SIFT parameters.
+
+ Args:
+ patch_size: the given patch size.
+ num_spatial_bins: the ggiven number of spatial bins.
+
+ Returns:
+ ksize, stride, pad.
+ """
+ ksize: int = 2 * int(patch_size / (num_spatial_bins + 1))
+ stride: int = patch_size // num_spatial_bins
+ pad: int = ksize // 4
+ out_size: int = (patch_size + 2 * pad - (ksize - 1) - 1) // stride + 1
+ if out_size != num_spatial_bins:
+ raise ValueError(
+ f"Patch size {patch_size} is incompatible with \
+ requested number of spatial bins {num_spatial_bins} \
+ for SIFT descriptor. Usually it happens when patch size is too small\
+ for num_spatial_bins specified"
+ )
+ return ksize, stride, pad
+
+
+class SIFTDescriptor(nn.Module):
+ r"""Module which computes SIFT descriptors of given patches.
+
+ Args:
+ patch_size: Input patch size in pixels.
+ num_ang_bins: Number of angular bins.
+ num_spatial_bins: Number of spatial bins.
+ clipval:
+ rootsift: if ``True``, RootSIFT (Arandjeloviฤ et. al, 2012) is computed.
+
+ Returns:
+ SIFT descriptor of the patches with shape.
+
+ Shape:
+ - Input: :math:`(B, 1, \text{num_spatial_bins}, \text{num_spatial_bins})`
+ - Output: :math:`(B, \text{num_ang_bins * num_spatial_bins ** 2})`
+
+ Example:
+ >>> input = torch.rand(23, 1, 32, 32)
+ >>> SIFT = SIFTDescriptor(32, 8, 4)
+ >>> descs = SIFT(input) # 23x128
+ """
+
+ def __repr__(self) -> str:
+ return (
+ self.__class__.__name__
+ + '('
+ + 'num_ang_bins='
+ + str(self.num_ang_bins)
+ + ', '
+ + 'num_spatial_bins='
+ + str(self.num_spatial_bins)
+ + ', '
+ + 'patch_size='
+ + str(self.patch_size)
+ + ', '
+ + 'rootsift='
+ + str(self.rootsift)
+ + ', '
+ + 'clipval='
+ + str(self.clipval)
+ + ')'
+ )
+
+ def __init__(
+ self,
+ patch_size: int = 41,
+ num_ang_bins: int = 8,
+ num_spatial_bins: int = 4,
+ rootsift: bool = True,
+ clipval: float = 0.2,
+ ) -> None:
+ super().__init__()
+ self.eps = 1e-10
+ self.num_ang_bins = num_ang_bins
+ self.num_spatial_bins = num_spatial_bins
+ self.clipval = clipval
+ self.rootsift = rootsift
+ self.patch_size = patch_size
+
+ ks: int = self.patch_size
+ sigma: float = float(ks) / math.sqrt(2.0)
+ self.gk = get_gaussian_kernel2d((ks, ks), (sigma, sigma), True)
+
+ (self.bin_ksize, self.bin_stride, self.pad) = get_sift_bin_ksize_stride_pad(patch_size, num_spatial_bins)
+
+ nw = get_sift_pooling_kernel(ksize=self.bin_ksize).float()
+ self.pk = nn.Conv2d(
+ 1,
+ 1,
+ kernel_size=(nw.size(0), nw.size(1)),
+ stride=(self.bin_stride, self.bin_stride),
+ padding=(self.pad, self.pad),
+ bias=False,
+ )
+ self.pk.weight.data.copy_(nw.reshape(1, 1, nw.size(0), nw.size(1))) # type: ignore
+ return
+
+ def get_pooling_kernel(self) -> torch.Tensor:
+ return self.pk.weight.detach()
+
+ def get_weighting_kernel(self) -> torch.Tensor:
+ return self.gk.detach()
+
+ def forward(self, input):
+ if not isinstance(input, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(input)}")
+ if not len(input.shape) == 4:
+ raise ValueError(f"Invalid input shape, we expect Bx1xHxW. Got: {input.shape}")
+ B, CH, W, H = input.size()
+ if (W != self.patch_size) or (H != self.patch_size) or (CH != 1):
+ raise TypeError(
+ "input shape should be must be [Bx1x{}x{}]. "
+ "Got {}".format(self.patch_size, self.patch_size, input.size())
+ )
+ self.pk = self.pk.to(input.dtype).to(input.device)
+
+ grads: torch.Tensor = spatial_gradient(input, 'diff')
+ # unpack the edges
+ gx: torch.Tensor = grads[:, :, 0]
+ gy: torch.Tensor = grads[:, :, 1]
+
+ mag: torch.Tensor = torch.sqrt(gx * gx + gy * gy + self.eps)
+ ori: torch.Tensor = torch.atan2(gy, gx + self.eps) + 2.0 * pi
+ mag = mag * self.gk.expand_as(mag).type_as(mag).to(mag.device)
+ o_big: torch.Tensor = float(self.num_ang_bins) * ori / (2.0 * pi)
+
+ bo0_big_: torch.Tensor = torch.floor(o_big)
+ wo1_big_: torch.Tensor = o_big - bo0_big_
+ bo0_big: torch.Tensor = bo0_big_ % self.num_ang_bins
+ bo1_big: torch.Tensor = (bo0_big + 1) % self.num_ang_bins
+ wo0_big: torch.Tensor = (1.0 - wo1_big_) * mag # type: ignore
+ wo1_big: torch.Tensor = wo1_big_ * mag
+
+ ang_bins = []
+ for i in range(0, self.num_ang_bins):
+ out = self.pk((bo0_big == i).to(input.dtype) * wo0_big + (bo1_big == i).to(input.dtype) * wo1_big)
+ ang_bins.append(out)
+ ang_bins = torch.cat(ang_bins, dim=1)
+ ang_bins = ang_bins.view(B, -1)
+ ang_bins = F.normalize(ang_bins, p=2)
+ ang_bins = torch.clamp(ang_bins, 0.0, float(self.clipval))
+ ang_bins = F.normalize(ang_bins, p=2)
+ if self.rootsift:
+ ang_bins = torch.sqrt(F.normalize(ang_bins, p=1) + self.eps)
+ return ang_bins
+
+
+def sift_describe(
+ input: torch.Tensor,
+ patch_size: int = 41,
+ num_ang_bins: int = 8,
+ num_spatial_bins: int = 4,
+ rootsift: bool = True,
+ clipval: float = 0.2,
+) -> torch.Tensor:
+ r"""Compute the sift descriptor.
+
+ See :class:`~kornia.feature.SIFTDescriptor` for details.
+ """
+ return SIFTDescriptor(patch_size, num_ang_bins, num_spatial_bins, rootsift, clipval)(input)
diff --git a/kornia/feature/sosnet.py b/kornia/feature/sosnet.py
new file mode 100644
index 0000000000000000000000000000000000000000..e4acabb28d519aa73ca2c707785b2d9e18ef1d91
--- /dev/null
+++ b/kornia/feature/sosnet.py
@@ -0,0 +1,68 @@
+from typing import Dict
+
+import torch
+import torch.nn as nn
+
+urls: Dict[str, str] = {}
+urls["lib"] = "https://github.com/yuruntian/SOSNet/raw/master/sosnet-weights/sosnet_32x32_liberty.pth"
+urls["hp_a"] = "https://github.com/yuruntian/SOSNet/raw/master/sosnet-weights/sosnet_32x32_hpatches_a.pth"
+
+
+class SOSNet(nn.Module):
+ r"""128-dimensional SOSNet model definition for 32x32 patches.
+
+ This is based on the original code from paper
+ "SOSNet:Second Order Similarity Regularization for Local Descriptor Learning".
+
+ Args:
+ pretrained: Download and set pretrained weights to the model.
+
+ Shape:
+ - Input: :math:`(B, 1, 32, 32)`
+ - Output: :math:`(B, 128)`
+
+ Examples:
+ >>> input = torch.rand(8, 1, 32, 32)
+ >>> sosnet = SOSNet()
+ >>> descs = sosnet(input) # 8x128
+ """
+ patch_size = 32
+
+ def __init__(self, pretrained: bool = False) -> None:
+ super().__init__()
+ self.layers = nn.Sequential(
+ nn.InstanceNorm2d(1, affine=False),
+ nn.Conv2d(1, 32, kernel_size=3, padding=1, bias=False),
+ nn.BatchNorm2d(32, affine=False),
+ nn.ReLU(),
+ nn.Conv2d(32, 32, kernel_size=3, padding=1, bias=False),
+ nn.BatchNorm2d(32, affine=False),
+ nn.ReLU(),
+ nn.Conv2d(32, 64, kernel_size=3, stride=2, padding=1, bias=False),
+ nn.BatchNorm2d(64, affine=False),
+ nn.ReLU(),
+ nn.Conv2d(64, 64, kernel_size=3, padding=1, bias=False),
+ nn.BatchNorm2d(64, affine=False),
+ nn.ReLU(),
+ nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1, bias=False),
+ nn.BatchNorm2d(128, affine=False),
+ nn.ReLU(),
+ nn.Conv2d(128, 128, kernel_size=3, padding=1, bias=False),
+ nn.BatchNorm2d(128, affine=False),
+ nn.ReLU(),
+ nn.Dropout(0.1),
+ nn.Conv2d(128, 128, kernel_size=8, bias=False),
+ nn.BatchNorm2d(128, affine=False),
+ )
+ self.desc_norm = nn.Sequential(nn.LocalResponseNorm(256, alpha=256.0, beta=0.5, k=0.0))
+ # load pretrained model
+ if pretrained:
+ pretrained_dict = torch.hub.load_state_dict_from_url(urls['lib'], map_location=lambda storage, loc: storage)
+ self.load_state_dict(pretrained_dict, strict=True)
+ self.eval()
+ return
+
+ def forward(self, input: torch.Tensor, eps: float = 1e-10) -> torch.Tensor:
+ descr = self.desc_norm(self.layers(input) + eps)
+ descr = descr.view(descr.size(0), -1)
+ return descr
diff --git a/kornia/feature/tfeat.py b/kornia/feature/tfeat.py
new file mode 100644
index 0000000000000000000000000000000000000000..2ca4b4e09674c89e030970280121e46f1dac2424
--- /dev/null
+++ b/kornia/feature/tfeat.py
@@ -0,0 +1,65 @@
+from typing import Dict
+
+import torch
+import torch.nn as nn
+
+urls: Dict[str, str] = {}
+urls[
+ "liberty"
+] = "https://github.com/vbalnt/tfeat/raw/master/pretrained-models/tfeat-liberty.params" # pylint: disable
+urls[
+ "notredame"
+] = "https://github.com/vbalnt/tfeat/raw/master/pretrained-models/tfeat-notredame.params" # pylint: disable
+urls[
+ "yosemite"
+] = "https://github.com/vbalnt/tfeat/raw/master/pretrained-models/tfeat-yosemite.params" # pylint: disable
+
+
+class TFeat(nn.Module):
+ r"""Module, which computes TFeat descriptors of given grayscale patches of 32x32.
+
+ This is based on the original code from paper "Learning local feature descriptors
+ with triplets and shallow convolutional neural networks".
+ See :cite:`TFeat2016` for more details
+
+ Args:
+ pretrained: Download and set pretrained weights to the model.
+
+ Returns:
+ torch.Tensor: TFeat descriptor of the patches.
+
+ Shape:
+ - Input: :math:`(B, 1, 32, 32)`
+ - Output: :math:`(B, 128)`
+
+ Examples:
+ >>> input = torch.rand(16, 1, 32, 32)
+ >>> tfeat = TFeat()
+ >>> descs = tfeat(input) # 16x128
+ """
+ patch_size = 32
+
+ def __init__(self, pretrained: bool = False) -> None:
+ super().__init__()
+ self.features = nn.Sequential(
+ nn.InstanceNorm2d(1, affine=False),
+ nn.Conv2d(1, 32, kernel_size=7),
+ nn.Tanh(),
+ nn.MaxPool2d(kernel_size=2, stride=2),
+ nn.Conv2d(32, 64, kernel_size=6),
+ nn.Tanh(),
+ )
+ self.descr = nn.Sequential(nn.Linear(64 * 8 * 8, 128), nn.Tanh())
+ # use torch.hub to load pretrained model
+ if pretrained:
+ pretrained_dict = torch.hub.load_state_dict_from_url(
+ urls['liberty'], map_location=lambda storage, loc: storage
+ )
+ self.load_state_dict(pretrained_dict, strict=True)
+ self.eval()
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor:
+ x = self.features(input)
+ x = x.view(x.size(0), -1)
+ x = self.descr(x)
+ return x
diff --git a/kornia/filters/__init__.py b/kornia/filters/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..2e7fcb87096fe74bcff357cf5268c759fb025aa0
--- /dev/null
+++ b/kornia/filters/__init__.py
@@ -0,0 +1,77 @@
+from .blur import box_blur, BoxBlur
+from .blur_pool import blur_pool2d, BlurPool2D, max_blur_pool2d, MaxBlurPool2D
+from .canny import Canny, canny
+from .filter import filter2d, filter2D, filter2d_separable, filter3d, filter3D
+from .gaussian import gaussian_blur2d, GaussianBlur2d
+from .kernels import (
+ gaussian,
+ get_binary_kernel2d,
+ get_box_kernel2d,
+ get_diff_kernel2d,
+ get_gaussian_discrete_kernel1d,
+ get_gaussian_erf_kernel1d,
+ get_gaussian_kernel1d,
+ get_gaussian_kernel2d,
+ get_laplacian_kernel1d,
+ get_laplacian_kernel2d,
+ get_sobel_kernel2d,
+ get_spatial_gradient_kernel2d,
+ get_spatial_gradient_kernel3d,
+ laplacian_1d,
+)
+from .kernels_geometry import get_motion_kernel2d, get_motion_kernel3d
+from .laplacian import Laplacian, laplacian
+from .median import median_blur, MedianBlur
+from .motion import motion_blur, motion_blur3d, MotionBlur, MotionBlur3D
+from .sobel import Sobel, sobel, spatial_gradient, spatial_gradient3d, SpatialGradient, SpatialGradient3d
+from .unsharp import unsharp_mask, UnsharpMask
+
+__all__ = [
+ "gaussian",
+ "get_binary_kernel2d",
+ "get_box_kernel2d",
+ "get_gaussian_kernel1d",
+ "get_gaussian_discrete_kernel1d",
+ "get_gaussian_erf_kernel1d",
+ "get_gaussian_kernel2d",
+ "get_laplacian_kernel1d",
+ "get_laplacian_kernel2d",
+ "get_motion_kernel2d",
+ "get_motion_kernel3d",
+ "get_spatial_gradient_kernel2d",
+ "get_spatial_gradient_kernel3d",
+ "get_sobel_kernel2d",
+ "get_diff_kernel2d",
+ "gaussian_blur2d",
+ "laplacian",
+ "laplacian_1d",
+ "unsharp_mask",
+ "sobel",
+ "spatial_gradient",
+ "canny",
+ "box_blur",
+ "blur_pool2d",
+ "max_blur_pool2d",
+ "median_blur",
+ "motion_blur",
+ "motion_blur3d",
+ "filter2d",
+ "filter2d_separable",
+ "filter3d",
+ "filter2D",
+ "filter3D",
+ "GaussianBlur2d",
+ "Laplacian",
+ "SpatialGradient",
+ "Sobel",
+ "Canny",
+ "BoxBlur",
+ "BlurPool2D",
+ "MaxBlurPool2D",
+ "MedianBlur",
+ "MotionBlur",
+ "MotionBlur3D",
+ "SpatialGradient3d",
+ "spatial_gradient3d",
+ "UnsharpMask",
+]
diff --git a/kornia/filters/__tmp__.py b/kornia/filters/__tmp__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6b8b094028a4066f0b892bc0f1cd590cc3bb7d52
--- /dev/null
+++ b/kornia/filters/__tmp__.py
@@ -0,0 +1,21 @@
+import warnings
+from functools import wraps
+from typing import Callable
+
+warnings.simplefilter('always', DeprecationWarning)
+
+
+def __deprecation_warning(name: str, replacement: str):
+ warnings.warn(
+ f"`{name}` will be renamed to `{replacement}` in the future versions. " f"Please use `{replacement}` instead.",
+ category=DeprecationWarning,
+ )
+
+
+def _deprecation_wrapper(new_func: Callable, old_func: str) -> Callable:
+ @wraps(new_func)
+ def wrapper(*args, **kwargs):
+ __deprecation_warning(old_func, new_func.__name__)
+ return new_func(*args, **kwargs)
+
+ return wrapper
diff --git a/kornia/filters/blur.py b/kornia/filters/blur.py
new file mode 100644
index 0000000000000000000000000000000000000000..1e397090e469d4987e01a26a8658362dcc473c6a
--- /dev/null
+++ b/kornia/filters/blur.py
@@ -0,0 +1,111 @@
+from typing import Tuple
+
+import torch
+import torch.nn as nn
+
+from .filter import filter2d
+from .kernels import get_box_kernel2d, normalize_kernel2d
+
+
+def box_blur(
+ input: torch.Tensor, kernel_size: Tuple[int, int], border_type: str = 'reflect', normalized: bool = True
+) -> torch.Tensor:
+ r"""Blur an image using the box filter.
+
+ .. image:: _static/img/box_blur.png
+
+ The function smooths an image using the kernel:
+
+ .. math::
+ K = \frac{1}{\text{kernel_size}_x * \text{kernel_size}_y}
+ \begin{bmatrix}
+ 1 & 1 & 1 & \cdots & 1 & 1 \\
+ 1 & 1 & 1 & \cdots & 1 & 1 \\
+ \vdots & \vdots & \vdots & \ddots & \vdots & \vdots \\
+ 1 & 1 & 1 & \cdots & 1 & 1 \\
+ \end{bmatrix}
+
+ Args:
+ image: the image to blur with shape :math:`(B,C,H,W)`.
+ kernel_size: the blurring kernel size.
+ border_type: the padding mode to be applied before convolving.
+ The expected modes are: ``'constant'``, ``'reflect'``, ``'replicate'`` or ``'circular'``.
+ normalized: if True, L1 norm of the kernel is set to 1.
+
+ Returns:
+ the blurred tensor with shape :math:`(B,C,H,W)`.
+
+ .. note::
+ See a working example `here `__.
+
+ Example:
+ >>> input = torch.rand(2, 4, 5, 7)
+ >>> output = box_blur(input, (3, 3)) # 2x4x5x7
+ >>> output.shape
+ torch.Size([2, 4, 5, 7])
+ """
+ kernel: torch.Tensor = get_box_kernel2d(kernel_size)
+ if normalized:
+ kernel = normalize_kernel2d(kernel)
+ return filter2d(input, kernel, border_type)
+
+
+class BoxBlur(nn.Module):
+ r"""Blur an image using the box filter.
+
+ The function smooths an image using the kernel:
+
+ .. math::
+ K = \frac{1}{\text{kernel_size}_x * \text{kernel_size}_y}
+ \begin{bmatrix}
+ 1 & 1 & 1 & \cdots & 1 & 1 \\
+ 1 & 1 & 1 & \cdots & 1 & 1 \\
+ \vdots & \vdots & \vdots & \ddots & \vdots & \vdots \\
+ 1 & 1 & 1 & \cdots & 1 & 1 \\
+ \end{bmatrix}
+
+ Args:
+ kernel_size: the blurring kernel size.
+ border_type: the padding mode to be applied before convolving.
+ The expected modes are: ``'constant'``, ``'reflect'``,
+ ``'replicate'`` or ``'circular'``. Default: ``'reflect'``.
+ normalized: if True, L1 norm of the kernel is set to 1.
+
+ Returns:
+ the blurred input tensor.
+
+ Shape:
+ - Input: :math:`(B, C, H, W)`
+ - Output: :math:`(B, C, H, W)`
+
+ Example:
+ >>> input = torch.rand(2, 4, 5, 7)
+ >>> blur = BoxBlur((3, 3))
+ >>> output = blur(input) # 2x4x5x7
+ >>> output.shape
+ torch.Size([2, 4, 5, 7])
+ """
+
+ def __init__(self, kernel_size: Tuple[int, int], border_type: str = 'reflect', normalized: bool = True) -> None:
+ super().__init__()
+ self.kernel_size: Tuple[int, int] = kernel_size
+ self.border_type: str = border_type
+ self.normalized: bool = normalized
+
+ def __repr__(self) -> str:
+ return (
+ self.__class__.__name__
+ + '(kernel_size='
+ + str(self.kernel_size)
+ + ', '
+ + 'normalized='
+ + str(self.normalized)
+ + ', '
+ + 'border_type='
+ + self.border_type
+ + ')'
+ )
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor:
+ return box_blur(input, self.kernel_size, self.border_type, self.normalized)
diff --git a/kornia/filters/blur_pool.py b/kornia/filters/blur_pool.py
new file mode 100644
index 0000000000000000000000000000000000000000..ca95a13506eab5659c3aba16bbba59946f927187
--- /dev/null
+++ b/kornia/filters/blur_pool.py
@@ -0,0 +1,204 @@
+from typing import Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from .kernels import get_pascal_kernel_2d
+from .median import _compute_zero_padding # TODO: Move to proper place
+
+__all__ = ["BlurPool2D", "MaxBlurPool2D", "blur_pool2d", "max_blur_pool2d"]
+
+
+class BlurPool2D(nn.Module):
+ r"""Compute blur (anti-aliasing) and downsample a given feature map.
+
+ See :cite:`zhang2019shiftinvar` for more details.
+
+ Args:
+ kernel_size: the kernel size for max pooling.
+ stride: stride for pooling.
+
+ Shape:
+ - Input: :math:`(B, C, H, W)`
+ - Output: :math:`(N, C, H_{out}, W_{out})`, where
+
+ .. math::
+ H_{out} = \left\lfloor\frac{H_{in} + 2 \times \text{kernel\_size//2}[0] -
+ \text{kernel\_size}[0]}{\text{stride}[0]} + 1\right\rfloor
+
+ .. math::
+ W_{out} = \left\lfloor\frac{W_{in} + 2 \times \text{kernel\_size//2}[1] -
+ \text{kernel\_size}[1]}{\text{stride}[1]} + 1\right\rfloor
+
+ Examples:
+ >>> from kornia.filters.blur_pool import BlurPool2D
+ >>> input = torch.eye(5)[None, None]
+ >>> bp = BlurPool2D(kernel_size=3, stride=2)
+ >>> bp(input)
+ tensor([[[[0.3125, 0.0625, 0.0000],
+ [0.0625, 0.3750, 0.0625],
+ [0.0000, 0.0625, 0.3125]]]])
+ """
+
+ def __init__(self, kernel_size: int, stride: int = 2):
+ super().__init__()
+ self.kernel_size = kernel_size
+ self.stride = stride
+ self.register_buffer('kernel', get_pascal_kernel_2d(kernel_size, norm=True))
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor:
+ # To align the logic with the whole lib
+ kernel = torch.as_tensor(self.kernel, device=input.device, dtype=input.dtype)
+ return _blur_pool_by_kernel2d(input, kernel.repeat((input.size(1), 1, 1, 1)), self.stride)
+
+
+class MaxBlurPool2D(nn.Module):
+ r"""Compute pools and blurs and downsample a given feature map.
+
+ Equivalent to ```nn.Sequential(nn.MaxPool2d(...), BlurPool2D(...))```
+
+ See :cite:`zhang2019shiftinvar` for more details.
+
+ Args:
+ kernel_size: the kernel size for max pooling.
+ stride: stride for pooling.
+ max_pool_size: the kernel size for max pooling.
+ ceil_mode: should be true to match output size of conv2d with same kernel size.
+
+ Shape:
+ - Input: :math:`(B, C, H, W)`
+ - Output: :math:`(B, C, H / stride, W / stride)`
+
+ Returns:
+ torch.Tensor: the transformed tensor.
+
+ Examples:
+ >>> import torch.nn as nn
+ >>> from kornia.filters.blur_pool import BlurPool2D
+ >>> input = torch.eye(5)[None, None]
+ >>> mbp = MaxBlurPool2D(kernel_size=3, stride=2, max_pool_size=2, ceil_mode=False)
+ >>> mbp(input)
+ tensor([[[[0.5625, 0.3125],
+ [0.3125, 0.8750]]]])
+ >>> seq = nn.Sequential(nn.MaxPool2d(kernel_size=2, stride=1), BlurPool2D(kernel_size=3, stride=2))
+ >>> seq(input)
+ tensor([[[[0.5625, 0.3125],
+ [0.3125, 0.8750]]]])
+ """
+
+ def __init__(self, kernel_size: int, stride: int = 2, max_pool_size: int = 2, ceil_mode: bool = False):
+ super().__init__()
+ self.kernel_size = kernel_size
+ self.stride = stride
+ self.max_pool_size = max_pool_size
+ self.ceil_mode = ceil_mode
+ self.register_buffer('kernel', get_pascal_kernel_2d(kernel_size, norm=True))
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor:
+ # To align the logic with the whole lib
+ kernel = torch.as_tensor(self.kernel, device=input.device, dtype=input.dtype)
+ return _max_blur_pool_by_kernel2d(
+ input, kernel.repeat((input.size(1), 1, 1, 1)), self.stride, self.max_pool_size, self.ceil_mode
+ )
+
+
+def blur_pool2d(input: torch.Tensor, kernel_size: int, stride: int = 2):
+ r"""Compute blurs and downsample a given feature map.
+
+ .. image:: _static/img/blur_pool2d.png
+
+ See :class:`~kornia.filters.BlurPool2D` for details.
+
+ See :cite:`zhang2019shiftinvar` for more details.
+
+ Args:
+ kernel_size: the kernel size for max pooling..
+ ceil_mode: should be true to match output size of conv2d with same kernel size.
+
+ Shape:
+ - Input: :math:`(B, C, H, W)`
+ - Output: :math:`(N, C, H_{out}, W_{out})`, where
+
+ .. math::
+ H_{out} = \left\lfloor\frac{H_{in} + 2 \times \text{kernel\_size//2}[0] -
+ \text{kernel\_size}[0]}{\text{stride}[0]} + 1\right\rfloor
+
+ .. math::
+ W_{out} = \left\lfloor\frac{W_{in} + 2 \times \text{kernel\_size//2}[1] -
+ \text{kernel\_size}[1]}{\text{stride}[1]} + 1\right\rfloor
+
+ Returns:
+ the transformed tensor.
+
+ .. note::
+ This function is tested against https://github.com/adobe/antialiased-cnns.
+
+ .. note::
+ See a working example `here `__.
+
+ Examples:
+ >>> input = torch.eye(5)[None, None]
+ >>> blur_pool2d(input, 3)
+ tensor([[[[0.3125, 0.0625, 0.0000],
+ [0.0625, 0.3750, 0.0625],
+ [0.0000, 0.0625, 0.3125]]]])
+ """
+ kernel = get_pascal_kernel_2d(kernel_size, norm=True).repeat((input.size(1), 1, 1, 1)).to(input)
+ return _blur_pool_by_kernel2d(input, kernel, stride)
+
+
+def max_blur_pool2d(
+ input: torch.Tensor, kernel_size: int, stride: int = 2, max_pool_size: int = 2, ceil_mode: bool = False
+) -> torch.Tensor:
+ r"""Compute pools and blurs and downsample a given feature map.
+
+ .. image:: _static/img/max_blur_pool2d.png
+
+ See :class:`~kornia.filters.MaxBlurPool2D` for details.
+
+ Args:
+ kernel_size: the kernel size for max pooling.
+ stride: stride for pooling.
+ max_pool_size: the kernel size for max pooling.
+ ceil_mode: should be true to match output size of conv2d with same kernel size.
+
+ .. note::
+ This function is tested against https://github.com/adobe/antialiased-cnns.
+
+ .. note::
+ See a working example `here `__.
+
+ Examples:
+ >>> input = torch.eye(5)[None, None]
+ >>> max_blur_pool2d(input, 3)
+ tensor([[[[0.5625, 0.3125],
+ [0.3125, 0.8750]]]])
+ """
+ if not len(input.shape) == 4:
+ raise ValueError(f"Invalid input shape, we expect BxCxHxW. Got: {input.shape}")
+ kernel = get_pascal_kernel_2d(kernel_size, norm=True).repeat((input.size(1), 1, 1, 1)).to(input)
+ return _max_blur_pool_by_kernel2d(input, kernel, stride, max_pool_size, ceil_mode)
+
+
+def _blur_pool_by_kernel2d(input: torch.Tensor, kernel: torch.Tensor, stride: int):
+ """Compute blur_pool by a given :math:`CxC_{out}xNxN` kernel."""
+ if not (len(kernel.shape) == 4 and kernel.size(-1) == kernel.size(-2)):
+ raise AssertionError(f"Invalid kernel shape. Expect CxC_outxNxN, Got {kernel.shape}")
+ padding: Tuple[int, int] = _compute_zero_padding((kernel.shape[-2], kernel.shape[-1]))
+ return F.conv2d(input, kernel, padding=padding, stride=stride, groups=input.size(1))
+
+
+def _max_blur_pool_by_kernel2d(
+ input: torch.Tensor, kernel: torch.Tensor, stride: int, max_pool_size: int, ceil_mode: bool
+):
+ """Compute max_blur_pool by a given :math:`CxC_{out}xNxN` kernel."""
+ if not (len(kernel.shape) == 4 and kernel.size(-1) == kernel.size(-2)):
+ raise AssertionError(f"Invalid kernel shape. Expect CxC_outxNxN, Got {kernel.shape}")
+ # compute local maxima
+ input = F.max_pool2d(input, kernel_size=max_pool_size, padding=0, stride=1, ceil_mode=ceil_mode)
+ # blur and downsample
+ padding: Tuple[int, int] = _compute_zero_padding((kernel.shape[-2], kernel.shape[-1]))
+ return F.conv2d(input, kernel, padding=padding, stride=stride, groups=input.size(1))
diff --git a/kornia/filters/canny.py b/kornia/filters/canny.py
new file mode 100644
index 0000000000000000000000000000000000000000..2f11f4b737d393c8a510bfc37fc77f3a400f9bc2
--- /dev/null
+++ b/kornia/filters/canny.py
@@ -0,0 +1,233 @@
+import math
+from typing import Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from kornia.color import rgb_to_grayscale
+
+from .gaussian import gaussian_blur2d
+from .kernels import get_canny_nms_kernel, get_hysteresis_kernel
+from .sobel import spatial_gradient
+
+
+def canny(
+ input: torch.Tensor,
+ low_threshold: float = 0.1,
+ high_threshold: float = 0.2,
+ kernel_size: Tuple[int, int] = (5, 5),
+ sigma: Tuple[float, float] = (1, 1),
+ hysteresis: bool = True,
+ eps: float = 1e-6,
+) -> Tuple[torch.Tensor, torch.Tensor]:
+ r"""Find edges of the input image and filters them using the Canny algorithm.
+
+ .. image:: _static/img/canny.png
+
+ Args:
+ input: input image tensor with shape :math:`(B,C,H,W)`.
+ low_threshold: lower threshold for the hysteresis procedure.
+ high_threshold: upper threshold for the hysteresis procedure.
+ kernel_size: the size of the kernel for the gaussian blur.
+ sigma: the standard deviation of the kernel for the gaussian blur.
+ hysteresis: if True, applies the hysteresis edge tracking.
+ Otherwise, the edges are divided between weak (0.5) and strong (1) edges.
+ eps: regularization number to avoid NaN during backprop.
+
+ Returns:
+ - the canny edge magnitudes map, shape of :math:`(B,1,H,W)`.
+ - the canny edge detection filtered by thresholds and hysteresis, shape of :math:`(B,1,H,W)`.
+
+ .. note::
+ See a working example `here `__.
+
+ Example:
+ >>> input = torch.rand(5, 3, 4, 4)
+ >>> magnitude, edges = canny(input) # 5x3x4x4
+ >>> magnitude.shape
+ torch.Size([5, 1, 4, 4])
+ >>> edges.shape
+ torch.Size([5, 1, 4, 4])
+ """
+ if not isinstance(input, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(input)}")
+
+ if not len(input.shape) == 4:
+ raise ValueError(f"Invalid input shape, we expect BxCxHxW. Got: {input.shape}")
+
+ if low_threshold > high_threshold:
+ raise ValueError(
+ "Invalid input thresholds. low_threshold should be smaller than the high_threshold. Got: {}>{}".format(
+ low_threshold, high_threshold
+ )
+ )
+
+ if low_threshold < 0 and low_threshold > 1:
+ raise ValueError(f"Invalid input threshold. low_threshold should be in range (0,1). Got: {low_threshold}")
+
+ if high_threshold < 0 and high_threshold > 1:
+ raise ValueError(f"Invalid input threshold. high_threshold should be in range (0,1). Got: {high_threshold}")
+
+ device: torch.device = input.device
+ dtype: torch.dtype = input.dtype
+
+ # To Grayscale
+ if input.shape[1] == 3:
+ input = rgb_to_grayscale(input)
+
+ # Gaussian filter
+ blurred: torch.Tensor = gaussian_blur2d(input, kernel_size, sigma)
+
+ # Compute the gradients
+ gradients: torch.Tensor = spatial_gradient(blurred, normalized=False)
+
+ # Unpack the edges
+ gx: torch.Tensor = gradients[:, :, 0]
+ gy: torch.Tensor = gradients[:, :, 1]
+
+ # Compute gradient magnitude and angle
+ magnitude: torch.Tensor = torch.sqrt(gx * gx + gy * gy + eps)
+ angle: torch.Tensor = torch.atan2(gy, gx)
+
+ # Radians to Degrees
+ angle = 180. * angle / math.pi
+
+ # Round angle to the nearest 45 degree
+ angle = torch.round(angle / 45) * 45
+
+ # Non-maximal suppression
+ nms_kernels: torch.Tensor = get_canny_nms_kernel(device, dtype)
+ nms_magnitude: torch.Tensor = F.conv2d(magnitude, nms_kernels, padding=nms_kernels.shape[-1] // 2)
+
+ # Get the indices for both directions
+ positive_idx: torch.Tensor = (angle / 45) % 8
+ positive_idx = positive_idx.long()
+
+ negative_idx: torch.Tensor = ((angle / 45) + 4) % 8
+ negative_idx = negative_idx.long()
+
+ # Apply the non-maximum suppresion to the different directions
+ channel_select_filtered_positive: torch.Tensor = torch.gather(nms_magnitude, 1, positive_idx)
+ channel_select_filtered_negative: torch.Tensor = torch.gather(nms_magnitude, 1, negative_idx)
+
+ channel_select_filtered: torch.Tensor = torch.stack(
+ [channel_select_filtered_positive, channel_select_filtered_negative], 1
+ )
+
+ is_max: torch.Tensor = channel_select_filtered.min(dim=1)[0] > 0.0
+
+ magnitude = magnitude * is_max
+
+ # Threshold
+ edges: torch.Tensor = F.threshold(magnitude, low_threshold, 0.0)
+
+ low: torch.Tensor = magnitude > low_threshold
+ high: torch.Tensor = magnitude > high_threshold
+
+ edges = low * 0.5 + high * 0.5
+ edges = edges.to(dtype)
+
+ # Hysteresis
+ if hysteresis:
+ edges_old: torch.Tensor = -torch.ones(edges.shape, device=edges.device, dtype=dtype)
+ hysteresis_kernels: torch.Tensor = get_hysteresis_kernel(device, dtype)
+
+ while ((edges_old - edges).abs() != 0).any():
+ weak: torch.Tensor = (edges == 0.5).float()
+ strong: torch.Tensor = (edges == 1).float()
+
+ hysteresis_magnitude: torch.Tensor = F.conv2d(
+ edges, hysteresis_kernels, padding=hysteresis_kernels.shape[-1] // 2
+ )
+ hysteresis_magnitude = (hysteresis_magnitude == 1).any(1, keepdim=True).to(dtype)
+ hysteresis_magnitude = hysteresis_magnitude * weak + strong
+
+ edges_old = edges.clone()
+ edges = hysteresis_magnitude + (hysteresis_magnitude == 0) * weak * 0.5
+
+ edges = hysteresis_magnitude
+
+ return magnitude, edges
+
+
+class Canny(nn.Module):
+ r"""Module that finds edges of the input image and filters them using the Canny algorithm.
+
+ Args:
+ input: input image tensor with shape :math:`(B,C,H,W)`.
+ low_threshold: lower threshold for the hysteresis procedure.
+ high_threshold: upper threshold for the hysteresis procedure.
+ kernel_size: the size of the kernel for the gaussian blur.
+ sigma: the standard deviation of the kernel for the gaussian blur.
+ hysteresis: if True, applies the hysteresis edge tracking.
+ Otherwise, the edges are divided between weak (0.5) and strong (1) edges.
+ eps: regularization number to avoid NaN during backprop.
+
+ Returns:
+ - the canny edge magnitudes map, shape of :math:`(B,1,H,W)`.
+ - the canny edge detection filtered by thresholds and hysteresis, shape of :math:`(B,1,H,W)`.
+
+ Example:
+ >>> input = torch.rand(5, 3, 4, 4)
+ >>> magnitude, edges = Canny()(input) # 5x3x4x4
+ >>> magnitude.shape
+ torch.Size([5, 1, 4, 4])
+ >>> edges.shape
+ torch.Size([5, 1, 4, 4])
+ """
+
+ def __init__(
+ self,
+ low_threshold: float = 0.1,
+ high_threshold: float = 0.2,
+ kernel_size: Tuple[int, int] = (5, 5),
+ sigma: Tuple[float, float] = (1, 1),
+ hysteresis: bool = True,
+ eps: float = 1e-6,
+ ) -> None:
+ super().__init__()
+
+ if low_threshold > high_threshold:
+ raise ValueError(
+ "Invalid input thresholds. low_threshold should be\
+ smaller than the high_threshold. Got: {}>{}".format(
+ low_threshold, high_threshold
+ )
+ )
+
+ if low_threshold < 0 or low_threshold > 1:
+ raise ValueError(f"Invalid input threshold. low_threshold should be in range (0,1). Got: {low_threshold}")
+
+ if high_threshold < 0 or high_threshold > 1:
+ raise ValueError(f"Invalid input threshold. high_threshold should be in range (0,1). Got: {high_threshold}")
+
+ # Gaussian blur parameters
+ self.kernel_size = kernel_size
+ self.sigma = sigma
+
+ # Double threshold
+ self.low_threshold = low_threshold
+ self.high_threshold = high_threshold
+
+ # Hysteresis
+ self.hysteresis = hysteresis
+
+ self.eps: float = eps
+
+ def __repr__(self) -> str:
+ return ''.join(
+ (
+ f'{type(self).__name__}(',
+ ', '.join(
+ f'{name}={getattr(self, name)}' for name in sorted(self.__dict__) if not name.startswith('_')
+ ),
+ ')',
+ )
+ )
+
+ def forward(self, input: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+ return canny(
+ input, self.low_threshold, self.high_threshold, self.kernel_size, self.sigma, self.hysteresis, self.eps
+ )
diff --git a/kornia/filters/filter.py b/kornia/filters/filter.py
new file mode 100644
index 0000000000000000000000000000000000000000..67194297bf8c31a70cef5a3960e44a768920dd21
--- /dev/null
+++ b/kornia/filters/filter.py
@@ -0,0 +1,287 @@
+from typing import List
+
+import torch
+import torch.nn.functional as F
+
+from .__tmp__ import _deprecation_wrapper
+from .kernels import normalize_kernel2d
+
+
+def _compute_padding(kernel_size: List[int]) -> List[int]:
+ """Compute padding tuple."""
+ # 4 or 6 ints: (padding_left, padding_right,padding_top,padding_bottom)
+ # https://pytorch.org/docs/stable/nn.html#torch.nn.functional.pad
+ if len(kernel_size) < 2:
+ raise AssertionError(kernel_size)
+ computed = [k // 2 for k in kernel_size]
+
+ # for even kernels we need to do asymmetric padding :(
+
+ out_padding = 2 * len(kernel_size) * [0]
+
+ for i in range(len(kernel_size)):
+ computed_tmp = computed[-(i + 1)]
+ if kernel_size[i] % 2 == 0:
+ padding = computed_tmp - 1
+ else:
+ padding = computed_tmp
+ out_padding[2 * i + 0] = padding
+ out_padding[2 * i + 1] = computed_tmp
+ return out_padding
+
+
+def filter2d(
+ input: torch.Tensor, kernel: torch.Tensor, border_type: str = 'reflect', normalized: bool = False,
+ padding: str = 'same'
+) -> torch.Tensor:
+ r"""Convolve a tensor with a 2d kernel.
+
+ The function applies a given kernel to a tensor. The kernel is applied
+ independently at each depth channel of the tensor. Before applying the
+ kernel, the function applies padding according to the specified mode so
+ that the output remains in the same shape.
+
+ Args:
+ input: the input tensor with shape of
+ :math:`(B, C, H, W)`.
+ kernel: the kernel to be convolved with the input
+ tensor. The kernel shape must be :math:`(1, kH, kW)` or :math:`(B, kH, kW)`.
+ border_type: the padding mode to be applied before convolving.
+ The expected modes are: ``'constant'``, ``'reflect'``,
+ ``'replicate'`` or ``'circular'``.
+ normalized: If True, kernel will be L1 normalized.
+ padding: This defines the type of padding.
+ 2 modes available ``'same'`` or ``'valid'``.
+
+ Return:
+ torch.Tensor: the convolved tensor of same size and numbers of channels
+ as the input with shape :math:`(B, C, H, W)`.
+
+ Example:
+ >>> input = torch.tensor([[[
+ ... [0., 0., 0., 0., 0.],
+ ... [0., 0., 0., 0., 0.],
+ ... [0., 0., 5., 0., 0.],
+ ... [0., 0., 0., 0., 0.],
+ ... [0., 0., 0., 0., 0.],]]])
+ >>> kernel = torch.ones(1, 3, 3)
+ >>> filter2d(input, kernel, padding='same')
+ tensor([[[[0., 0., 0., 0., 0.],
+ [0., 5., 5., 5., 0.],
+ [0., 5., 5., 5., 0.],
+ [0., 5., 5., 5., 0.],
+ [0., 0., 0., 0., 0.]]]])
+ """
+ if not isinstance(input, torch.Tensor):
+ raise TypeError(f"Input input is not torch.Tensor. Got {type(input)}")
+
+ if not isinstance(kernel, torch.Tensor):
+ raise TypeError(f"Input kernel is not torch.Tensor. Got {type(kernel)}")
+
+ if not isinstance(border_type, str):
+ raise TypeError(f"Input border_type is not string. Got {type(border_type)}")
+
+ if border_type not in ['constant', 'reflect', 'replicate', 'circular']:
+ raise ValueError(f"Invalid border type, we expect 'constant', \
+ 'reflect', 'replicate', 'circular'. Got:{border_type}")
+
+ if not isinstance(padding, str):
+ raise TypeError(f"Input padding is not string. Got {type(padding)}")
+
+ if padding not in ['valid', 'same']:
+ raise ValueError(f"Invalid padding mode, we expect 'valid' or 'same'. Got: {padding}")
+
+ if not len(input.shape) == 4:
+ raise ValueError(f"Invalid input shape, we expect BxCxHxW. Got: {input.shape}")
+
+ if (not len(kernel.shape) == 3) and not ((kernel.shape[0] == 0) or (kernel.shape[0] == input.shape[0])):
+ raise ValueError(f"Invalid kernel shape, we expect 1xHxW or BxHxW. Got: {kernel.shape}")
+
+ # prepare kernel
+ b, c, h, w = input.shape
+ tmp_kernel: torch.Tensor = kernel.unsqueeze(1).to(input)
+
+ if normalized:
+ tmp_kernel = normalize_kernel2d(tmp_kernel)
+
+ tmp_kernel = tmp_kernel.expand(-1, c, -1, -1)
+
+ height, width = tmp_kernel.shape[-2:]
+
+ # pad the input tensor
+ if padding == 'same':
+ padding_shape: List[int] = _compute_padding([height, width])
+ input = F.pad(input, padding_shape, mode=border_type)
+
+ # kernel and input tensor reshape to align element-wise or batch-wise params
+ tmp_kernel = tmp_kernel.reshape(-1, 1, height, width)
+ input = input.view(-1, tmp_kernel.size(0), input.size(-2), input.size(-1))
+
+ # convolve the tensor with the kernel.
+ output = F.conv2d(input, tmp_kernel, groups=tmp_kernel.size(0), padding=0, stride=1)
+
+ if padding == 'same':
+ out = output.view(b, c, h, w)
+ else:
+ out = output.view(b, c, h - height + 1, w - width + 1)
+
+ return out
+
+
+def filter2d_separable(input: torch.Tensor,
+ kernel_x: torch.Tensor,
+ kernel_y: torch.Tensor,
+ border_type: str = 'reflect',
+ normalized: bool = False,
+ padding: str = 'same') -> torch.Tensor:
+ r"""Convolve a tensor with two 1d kernels, in x and y directions.
+
+ The function applies a given kernel to a tensor. The kernel is applied
+ independently at each depth channel of the tensor. Before applying the
+ kernel, the function applies padding according to the specified mode so
+ that the output remains in the same shape.
+
+ Args:
+ input: the input tensor with shape of
+ :math:`(B, C, H, W)`.
+ kernel_x: the kernel to be convolved with the input
+ tensor. The kernel shape must be :math:`(1, kW)` or :math:`(B, kW)`.
+ kernel_y: the kernel to be convolved with the input
+ tensor. The kernel shape must be :math:`(1, kH)` or :math:`(B, kH)`.
+ border_type: the padding mode to be applied before convolving.
+ The expected modes are: ``'constant'``, ``'reflect'``,
+ ``'replicate'`` or ``'circular'``.
+ normalized: If True, kernel will be L1 normalized.
+ padding: This defines the type of padding.
+ 2 modes available ``'same'`` or ``'valid'``.
+
+ Return:
+ torch.Tensor: the convolved tensor of same size and numbers of channels
+ as the input with shape :math:`(B, C, H, W)`.
+
+ Example:
+ >>> input = torch.tensor([[[
+ ... [0., 0., 0., 0., 0.],
+ ... [0., 0., 0., 0., 0.],
+ ... [0., 0., 5., 0., 0.],
+ ... [0., 0., 0., 0., 0.],
+ ... [0., 0., 0., 0., 0.],]]])
+ >>> kernel = torch.ones(1, 3)
+
+ >>> filter2d_separable(input, kernel, kernel, padding='same')
+ tensor([[[[0., 0., 0., 0., 0.],
+ [0., 5., 5., 5., 0.],
+ [0., 5., 5., 5., 0.],
+ [0., 5., 5., 5., 0.],
+ [0., 0., 0., 0., 0.]]]])
+ """
+ out_x = filter2d(input, kernel_x.unsqueeze(0), border_type, normalized, padding)
+ out = filter2d(out_x, kernel_y.unsqueeze(-1), border_type, normalized, padding)
+ return out
+
+
+def filter3d(
+ input: torch.Tensor, kernel: torch.Tensor, border_type: str = 'replicate', normalized: bool = False
+) -> torch.Tensor:
+ r"""Convolve a tensor with a 3d kernel.
+
+ The function applies a given kernel to a tensor. The kernel is applied
+ independently at each depth channel of the tensor. Before applying the
+ kernel, the function applies padding according to the specified mode so
+ that the output remains in the same shape.
+
+ Args:
+ input: the input tensor with shape of
+ :math:`(B, C, D, H, W)`.
+ kernel: the kernel to be convolved with the input
+ tensor. The kernel shape must be :math:`(1, kD, kH, kW)` or :math:`(B, kD, kH, kW)`.
+ border_type: the padding mode to be applied before convolving.
+ The expected modes are: ``'constant'``,
+ ``'replicate'`` or ``'circular'``.
+ normalized: If True, kernel will be L1 normalized.
+
+ Return:
+ the convolved tensor of same size and numbers of channels
+ as the input with shape :math:`(B, C, D, H, W)`.
+
+ Example:
+ >>> input = torch.tensor([[[
+ ... [[0., 0., 0., 0., 0.],
+ ... [0., 0., 0., 0., 0.],
+ ... [0., 0., 0., 0., 0.],
+ ... [0., 0., 0., 0., 0.],
+ ... [0., 0., 0., 0., 0.]],
+ ... [[0., 0., 0., 0., 0.],
+ ... [0., 0., 0., 0., 0.],
+ ... [0., 0., 5., 0., 0.],
+ ... [0., 0., 0., 0., 0.],
+ ... [0., 0., 0., 0., 0.]],
+ ... [[0., 0., 0., 0., 0.],
+ ... [0., 0., 0., 0., 0.],
+ ... [0., 0., 0., 0., 0.],
+ ... [0., 0., 0., 0., 0.],
+ ... [0., 0., 0., 0., 0.]]
+ ... ]]])
+ >>> kernel = torch.ones(1, 3, 3, 3)
+ >>> filter3d(input, kernel)
+ tensor([[[[[0., 0., 0., 0., 0.],
+ [0., 5., 5., 5., 0.],
+ [0., 5., 5., 5., 0.],
+ [0., 5., 5., 5., 0.],
+ [0., 0., 0., 0., 0.]],
+
+ [[0., 0., 0., 0., 0.],
+ [0., 5., 5., 5., 0.],
+ [0., 5., 5., 5., 0.],
+ [0., 5., 5., 5., 0.],
+ [0., 0., 0., 0., 0.]],
+
+ [[0., 0., 0., 0., 0.],
+ [0., 5., 5., 5., 0.],
+ [0., 5., 5., 5., 0.],
+ [0., 5., 5., 5., 0.],
+ [0., 0., 0., 0., 0.]]]]])
+ """
+ if not isinstance(input, torch.Tensor):
+ raise TypeError(f"Input border_type is not torch.Tensor. Got {type(input)}")
+
+ if not isinstance(kernel, torch.Tensor):
+ raise TypeError(f"Input border_type is not torch.Tensor. Got {type(kernel)}")
+
+ if not isinstance(border_type, str):
+ raise TypeError(f"Input border_type is not string. Got {type(kernel)}")
+
+ if not len(input.shape) == 5:
+ raise ValueError(f"Invalid input shape, we expect BxCxDxHxW. Got: {input.shape}")
+
+ if not len(kernel.shape) == 4 and kernel.shape[0] != 1:
+ raise ValueError(f"Invalid kernel shape, we expect 1xDxHxW. Got: {kernel.shape}")
+
+ # prepare kernel
+ b, c, d, h, w = input.shape
+ tmp_kernel: torch.Tensor = kernel.unsqueeze(1).to(input)
+
+ if normalized:
+ bk, dk, hk, wk = kernel.shape
+ tmp_kernel = normalize_kernel2d(tmp_kernel.view(bk, dk, hk * wk)).view_as(tmp_kernel)
+
+ tmp_kernel = tmp_kernel.expand(-1, c, -1, -1, -1)
+
+ # pad the input tensor
+ depth, height, width = tmp_kernel.shape[-3:]
+ padding_shape: List[int] = _compute_padding([depth, height, width])
+ input_pad: torch.Tensor = F.pad(input, padding_shape, mode=border_type)
+
+ # kernel and input tensor reshape to align element-wise or batch-wise params
+ tmp_kernel = tmp_kernel.reshape(-1, 1, depth, height, width)
+ input_pad = input_pad.view(-1, tmp_kernel.size(0), input_pad.size(-3), input_pad.size(-2), input_pad.size(-1))
+
+ # convolve the tensor with the kernel.
+ output = F.conv3d(input_pad, tmp_kernel, groups=tmp_kernel.size(0), padding=0, stride=1)
+
+ return output.view(b, c, d, h, w)
+
+
+# for backward compatibility.
+filter2D = _deprecation_wrapper(filter2d, 'filter2D')
+filter3D = _deprecation_wrapper(filter3d, 'filter3D')
diff --git a/kornia/filters/gaussian.py b/kornia/filters/gaussian.py
new file mode 100644
index 0000000000000000000000000000000000000000..6fe2b1d6a58390959cc3ff9f8219b40c08168dc2
--- /dev/null
+++ b/kornia/filters/gaussian.py
@@ -0,0 +1,116 @@
+from typing import Tuple
+
+import torch
+import torch.nn as nn
+
+from .filter import filter2d, filter2d_separable
+from .kernels import get_gaussian_kernel1d, get_gaussian_kernel2d
+
+
+def gaussian_blur2d(input: torch.Tensor,
+ kernel_size: Tuple[int, int],
+ sigma: Tuple[float, float],
+ border_type: str = 'reflect',
+ separable: bool = True) -> torch.Tensor:
+ r"""Create an operator that blurs a tensor using a Gaussian filter.
+
+ .. image:: _static/img/gaussian_blur2d.png
+
+ The operator smooths the given tensor with a gaussian kernel by convolving
+ it to each channel. It supports batched operation.
+
+ Arguments:
+ input: the input tensor with shape :math:`(B,C,H,W)`.
+ kernel_size: the size of the kernel.
+ sigma: the standard deviation of the kernel.
+ border_type: the padding mode to be applied before convolving.
+ The expected modes are: ``'constant'``, ``'reflect'``,
+ ``'replicate'`` or ``'circular'``. Default: ``'reflect'``.
+ separable: run as composition of two 1d-convolutions.
+
+ Returns:
+ the blurred tensor with shape :math:`(B, C, H, W)`.
+
+ .. note::
+ See a working example `here `__.
+
+ Examples:
+ >>> input = torch.rand(2, 4, 5, 5)
+ >>> output = gaussian_blur2d(input, (3, 3), (1.5, 1.5))
+ >>> output.shape
+ torch.Size([2, 4, 5, 5])
+ """
+ if separable:
+ kernel_x: torch.Tensor = get_gaussian_kernel1d(kernel_size[1], sigma[1])
+ kernel_y: torch.Tensor = get_gaussian_kernel1d(kernel_size[0], sigma[0])
+ out = filter2d_separable(input, kernel_x[None], kernel_y[None], border_type)
+ else:
+ kernel: torch.Tensor = get_gaussian_kernel2d(kernel_size, sigma)
+ out = filter2d(input, kernel[None], border_type)
+ return out
+
+
+class GaussianBlur2d(nn.Module):
+ r"""Create an operator that blurs a tensor using a Gaussian filter.
+
+ The operator smooths the given tensor with a gaussian kernel by convolving
+ it to each channel. It supports batched operation.
+
+ Arguments:
+ kernel_size: the size of the kernel.
+ sigma: the standard deviation of the kernel.
+ border_type: the padding mode to be applied before convolving.
+ The expected modes are: ``'constant'``, ``'reflect'``,
+ ``'replicate'`` or ``'circular'``. Default: ``'reflect'``.
+ separable: run as composition of two 1d-convolutions.
+
+ Returns:
+ the blurred tensor.
+
+ Shape:
+ - Input: :math:`(B, C, H, W)`
+ - Output: :math:`(B, C, H, W)`
+
+ Examples::
+
+ >>> input = torch.rand(2, 4, 5, 5)
+ >>> gauss = GaussianBlur2d((3, 3), (1.5, 1.5))
+ >>> output = gauss(input) # 2x4x5x5
+ >>> output.shape
+ torch.Size([2, 4, 5, 5])
+ """
+
+ def __init__(self,
+ kernel_size: Tuple[int, int],
+ sigma: Tuple[float, float],
+ border_type: str = 'reflect',
+ separable: bool = True) -> None:
+ super().__init__()
+ self.kernel_size: Tuple[int, int] = kernel_size
+ self.sigma: Tuple[float, float] = sigma
+ self.border_type = border_type
+ self.separable = separable
+
+ def __repr__(self) -> str:
+ return (
+ self.__class__.__name__
+ + '(kernel_size='
+ + str(self.kernel_size)
+ + ', '
+ + 'sigma='
+ + str(self.sigma)
+ + ', '
+ + 'border_type='
+ + self.border_type
+ + 'separable='
+ + str(self.separable)
+ + ')'
+ )
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor:
+ return gaussian_blur2d(input,
+ self.kernel_size,
+ self.sigma,
+ self.border_type,
+ self.separable)
diff --git a/kornia/filters/kernels.py b/kornia/filters/kernels.py
new file mode 100644
index 0000000000000000000000000000000000000000..3b9eb1029d43cab8858c6f02b7a77bdc82741266
--- /dev/null
+++ b/kornia/filters/kernels.py
@@ -0,0 +1,632 @@
+from math import sqrt
+from typing import List, Optional, Tuple
+
+import torch
+
+
+def normalize_kernel2d(input: torch.Tensor) -> torch.Tensor:
+ r"""Normalize both derivative and smoothing kernel."""
+ if len(input.size()) < 2:
+ raise TypeError(f"input should be at least 2D tensor. Got {input.size()}")
+ norm: torch.Tensor = input.abs().sum(dim=-1).sum(dim=-1)
+ return input / (norm.unsqueeze(-1).unsqueeze(-1))
+
+
+def gaussian(window_size: int, sigma: float) -> torch.Tensor:
+ device, dtype = None, None
+ if isinstance(sigma, torch.Tensor):
+ device, dtype = sigma.device, sigma.dtype
+ x = torch.arange(window_size, device=device, dtype=dtype) - window_size // 2
+ if window_size % 2 == 0:
+ x = x + 0.5
+ gauss = torch.exp(-x.pow(2.0) / (2 * sigma ** 2))
+ return gauss / gauss.sum()
+
+
+def gaussian_discrete_erf(window_size: int, sigma) -> torch.Tensor:
+ r"""Discrete Gaussian by interpolating the error function. Adapted from:
+ https://github.com/Project-MONAI/MONAI/blob/master/monai/networks/layers/convutils.py
+ """
+ device = sigma.device if isinstance(sigma, torch.Tensor) else None
+ sigma = torch.as_tensor(sigma, dtype=torch.float, device=device)
+ x = torch.arange(window_size).float() - window_size // 2
+ t = 0.70710678 / torch.abs(sigma)
+ gauss = 0.5 * ((t * (x + 0.5)).erf() - (t * (x - 0.5)).erf())
+ gauss = gauss.clamp(min=0)
+ return gauss / gauss.sum()
+
+
+def _modified_bessel_0(x: torch.Tensor) -> torch.Tensor:
+ r"""Adapted from:
+ https://github.com/Project-MONAI/MONAI/blob/master/monai/networks/layers/convutils.py
+ """
+ if torch.abs(x) < 3.75:
+ y = (x / 3.75) * (x / 3.75)
+ return 1.0 + y * (
+ 3.5156229 + y * (3.0899424 + y * (1.2067492 + y * (0.2659732 + y * (0.360768e-1 + y * 0.45813e-2))))
+ )
+ ax = torch.abs(x)
+ y = 3.75 / ax
+ ans = 0.916281e-2 + y * (-0.2057706e-1 + y * (0.2635537e-1 + y * (-0.1647633e-1 + y * 0.392377e-2)))
+ coef = 0.39894228 + y * (0.1328592e-1 + y * (0.225319e-2 + y * (-0.157565e-2 + y * ans)))
+ return (torch.exp(ax) / torch.sqrt(ax)) * coef
+
+
+def _modified_bessel_1(x: torch.Tensor) -> torch.Tensor:
+ r"""adapted from:
+ https://github.com/Project-MONAI/MONAI/blob/master/monai/networks/layers/convutils.py
+ """
+ if torch.abs(x) < 3.75:
+ y = (x / 3.75) * (x / 3.75)
+ ans = 0.51498869 + y * (0.15084934 + y * (0.2658733e-1 + y * (0.301532e-2 + y * 0.32411e-3)))
+ return torch.abs(x) * (0.5 + y * (0.87890594 + y * ans))
+ ax = torch.abs(x)
+ y = 3.75 / ax
+ ans = 0.2282967e-1 + y * (-0.2895312e-1 + y * (0.1787654e-1 - y * 0.420059e-2))
+ ans = 0.39894228 + y * (-0.3988024e-1 + y * (-0.362018e-2 + y * (0.163801e-2 + y * (-0.1031555e-1 + y * ans))))
+ ans = ans * torch.exp(ax) / torch.sqrt(ax)
+ return -ans if x < 0.0 else ans
+
+
+def _modified_bessel_i(n: int, x: torch.Tensor) -> torch.Tensor:
+ r"""adapted from:
+ https://github.com/Project-MONAI/MONAI/blob/master/monai/networks/layers/convutils.py
+ """
+ if n < 2:
+ raise ValueError("n must be greater than 1.")
+ if x == 0.0:
+ return x
+ device = x.device
+ tox = 2.0 / torch.abs(x)
+ ans = torch.tensor(0.0, device=device)
+ bip = torch.tensor(0.0, device=device)
+ bi = torch.tensor(1.0, device=device)
+ m = int(2 * (n + int(sqrt(40.0 * n))))
+ for j in range(m, 0, -1):
+ bim = bip + float(j) * tox * bi
+ bip = bi
+ bi = bim
+ if abs(bi) > 1.0e10:
+ ans = ans * 1.0e-10
+ bi = bi * 1.0e-10
+ bip = bip * 1.0e-10
+ if j == n:
+ ans = bip
+ ans = ans * _modified_bessel_0(x) / bi
+ return -ans if x < 0.0 and (n % 2) == 1 else ans
+
+
+def gaussian_discrete(window_size, sigma) -> torch.Tensor:
+ r"""Discrete Gaussian kernel based on the modified Bessel functions. Adapted from:
+ https://github.com/Project-MONAI/MONAI/blob/master/monai/networks/layers/convutils.py
+ """
+ device = sigma.device if isinstance(sigma, torch.Tensor) else None
+ sigma = torch.as_tensor(sigma, dtype=torch.float, device=device)
+ sigma2 = sigma * sigma
+ tail = int(window_size // 2)
+ out_pos: List[Optional[torch.Tensor]] = [None] * (tail + 1)
+ out_pos[0] = _modified_bessel_0(sigma2)
+ out_pos[1] = _modified_bessel_1(sigma2)
+ for k in range(2, len(out_pos)):
+ out_pos[k] = _modified_bessel_i(k, sigma2)
+ out = out_pos[:0:-1]
+ out.extend(out_pos)
+ out = torch.stack(out) * torch.exp(sigma2) # type: ignore
+ return out / out.sum() # type: ignore
+
+
+def laplacian_1d(window_size) -> torch.Tensor:
+ r"""One could also use the Laplacian of Gaussian formula
+ to design the filter.
+ """
+
+ filter_1d = torch.ones(window_size)
+ filter_1d[window_size // 2] = 1 - window_size
+ laplacian_1d: torch.Tensor = filter_1d
+ return laplacian_1d
+
+
+def get_box_kernel2d(kernel_size: Tuple[int, int]) -> torch.Tensor:
+ r"""Utility function that returns a box filter."""
+ kx: float = float(kernel_size[0])
+ ky: float = float(kernel_size[1])
+ scale: torch.Tensor = torch.tensor(1.0) / torch.tensor([kx * ky])
+ tmp_kernel: torch.Tensor = torch.ones(1, kernel_size[0], kernel_size[1])
+ return scale.to(tmp_kernel.dtype) * tmp_kernel
+
+
+def get_binary_kernel2d(window_size: Tuple[int, int]) -> torch.Tensor:
+ r"""Create a binary kernel to extract the patches. If the window size
+ is HxW will create a (H*W)xHxW kernel.
+ """
+ window_range: int = window_size[0] * window_size[1]
+ kernel: torch.Tensor = torch.zeros(window_range, window_range)
+ for i in range(window_range):
+ kernel[i, i] += 1.0
+ return kernel.view(window_range, 1, window_size[0], window_size[1])
+
+
+def get_sobel_kernel_3x3() -> torch.Tensor:
+ """Utility function that returns a sobel kernel of 3x3."""
+ return torch.tensor([[-1.0, 0.0, 1.0], [-2.0, 0.0, 2.0], [-1.0, 0.0, 1.0]])
+
+
+def get_sobel_kernel_5x5_2nd_order() -> torch.Tensor:
+ """Utility function that returns a 2nd order sobel kernel of 5x5."""
+ return torch.tensor(
+ [
+ [-1.0, 0.0, 2.0, 0.0, -1.0],
+ [-4.0, 0.0, 8.0, 0.0, -4.0],
+ [-6.0, 0.0, 12.0, 0.0, -6.0],
+ [-4.0, 0.0, 8.0, 0.0, -4.0],
+ [-1.0, 0.0, 2.0, 0.0, -1.0],
+ ]
+ )
+
+
+def _get_sobel_kernel_5x5_2nd_order_xy() -> torch.Tensor:
+ """Utility function that returns a 2nd order sobel kernel of 5x5."""
+ return torch.tensor(
+ [
+ [-1.0, -2.0, 0.0, 2.0, 1.0],
+ [-2.0, -4.0, 0.0, 4.0, 2.0],
+ [0.0, 0.0, 0.0, 0.0, 0.0],
+ [2.0, 4.0, 0.0, -4.0, -2.0],
+ [1.0, 2.0, 0.0, -2.0, -1.0],
+ ]
+ )
+
+
+def get_diff_kernel_3x3() -> torch.Tensor:
+ """Utility function that returns a first order derivative kernel of 3x3."""
+ return torch.tensor([[-0.0, 0.0, 0.0], [-1.0, 0.0, 1.0], [-0.0, 0.0, 0.0]])
+
+
+def get_diff_kernel3d(device=torch.device('cpu'), dtype=torch.float) -> torch.Tensor:
+ """Utility function that returns a first order derivative kernel of 3x3x3."""
+ kernel: torch.Tensor = torch.tensor(
+ [
+ [
+ [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],
+ [[0.0, 0.0, 0.0], [-0.5, 0.0, 0.5], [0.0, 0.0, 0.0]],
+ [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],
+ ],
+ [
+ [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],
+ [[0.0, -0.5, 0.0], [0.0, 0.0, 0.0], [0.0, 0.5, 0.0]],
+ [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],
+ ],
+ [
+ [[0.0, 0.0, 0.0], [0.0, -0.5, 0.0], [0.0, 0.0, 0.0]],
+ [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],
+ [[0.0, 0.0, 0.0], [0.0, 0.5, 0.0], [0.0, 0.0, 0.0]],
+ ],
+ ],
+ device=device,
+ dtype=dtype,
+ )
+ return kernel.unsqueeze(1)
+
+
+def get_diff_kernel3d_2nd_order(device=torch.device('cpu'), dtype=torch.float) -> torch.Tensor:
+ """Utility function that returns a first order derivative kernel of 3x3x3."""
+ kernel: torch.Tensor = torch.tensor(
+ [
+ [
+ [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],
+ [[0.0, 0.0, 0.0], [1.0, -2.0, 1.0], [0.0, 0.0, 0.0]],
+ [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],
+ ],
+ [
+ [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],
+ [[0.0, 1.0, 0.0], [0.0, -2.0, 0.0], [0.0, 1.0, 0.0]],
+ [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],
+ ],
+ [
+ [[0.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 0.0]],
+ [[0.0, 0.0, 0.0], [0.0, -2.0, 0.0], [0.0, 0.0, 0.0]],
+ [[0.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 0.0]],
+ ],
+ [
+ [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],
+ [[1.0, 0.0, -1.0], [0.0, 0.0, 0.0], [-1.0, 0.0, 1.0]],
+ [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],
+ ],
+ [
+ [[0.0, 1.0, 0.0], [0.0, 0.0, 0.0], [0.0, -1.0, 0.0]],
+ [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],
+ [[0.0, -1.0, 0.0], [0.0, 0.0, 0.0], [0.0, 1.0, 0.0]],
+ ],
+ [
+ [[0.0, 0.0, 0.0], [1.0, 0.0, -1.0], [0.0, 0.0, 0.0]],
+ [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],
+ [[0.0, 0.0, 0.0], [-1.0, 0.0, 1.0], [0.0, 0.0, 0.0]],
+ ],
+ ],
+ device=device,
+ dtype=dtype,
+ )
+ return kernel.unsqueeze(1)
+
+
+def get_sobel_kernel2d() -> torch.Tensor:
+ kernel_x: torch.Tensor = get_sobel_kernel_3x3()
+ kernel_y: torch.Tensor = kernel_x.transpose(0, 1)
+ return torch.stack([kernel_x, kernel_y])
+
+
+def get_diff_kernel2d() -> torch.Tensor:
+ kernel_x: torch.Tensor = get_diff_kernel_3x3()
+ kernel_y: torch.Tensor = kernel_x.transpose(0, 1)
+ return torch.stack([kernel_x, kernel_y])
+
+
+def get_sobel_kernel2d_2nd_order() -> torch.Tensor:
+ gxx: torch.Tensor = get_sobel_kernel_5x5_2nd_order()
+ gyy: torch.Tensor = gxx.transpose(0, 1)
+ gxy: torch.Tensor = _get_sobel_kernel_5x5_2nd_order_xy()
+ return torch.stack([gxx, gxy, gyy])
+
+
+def get_diff_kernel2d_2nd_order() -> torch.Tensor:
+ gxx: torch.Tensor = torch.tensor([[0.0, 0.0, 0.0], [1.0, -2.0, 1.0], [0.0, 0.0, 0.0]])
+ gyy: torch.Tensor = gxx.transpose(0, 1)
+ gxy: torch.Tensor = torch.tensor([[-1.0, 0.0, 1.0], [0.0, 0.0, 0.0], [1.0, 0.0, -1.0]])
+ return torch.stack([gxx, gxy, gyy])
+
+
+def get_spatial_gradient_kernel2d(mode: str, order: int) -> torch.Tensor:
+ r"""Function that returns kernel for 1st or 2nd order image gradients,
+ using one of the following operators: sobel, diff"""
+ if mode not in ['sobel', 'diff']:
+ raise TypeError(
+ "mode should be either sobel\
+ or diff. Got {}".format(
+ mode
+ )
+ )
+ if order not in [1, 2]:
+ raise TypeError(
+ "order should be either 1 or 2\
+ Got {}".format(
+ order
+ )
+ )
+ if mode == 'sobel' and order == 1:
+ kernel: torch.Tensor = get_sobel_kernel2d()
+ elif mode == 'sobel' and order == 2:
+ kernel = get_sobel_kernel2d_2nd_order()
+ elif mode == 'diff' and order == 1:
+ kernel = get_diff_kernel2d()
+ elif mode == 'diff' and order == 2:
+ kernel = get_diff_kernel2d_2nd_order()
+ else:
+ raise NotImplementedError("")
+ return kernel
+
+
+def get_spatial_gradient_kernel3d(mode: str, order: int, device=torch.device('cpu'), dtype=torch.float) -> torch.Tensor:
+ r"""Function that returns kernel for 1st or 2nd order scale pyramid gradients,
+ using one of the following operators: sobel, diff"""
+ if mode not in ['sobel', 'diff']:
+ raise TypeError(
+ "mode should be either sobel\
+ or diff. Got {}".format(
+ mode
+ )
+ )
+ if order not in [1, 2]:
+ raise TypeError(
+ "order should be either 1 or 2\
+ Got {}".format(
+ order
+ )
+ )
+ if mode == 'sobel':
+ raise NotImplementedError("Sobel kernel for 3d gradient is not implemented yet")
+ if mode == 'diff' and order == 1:
+ kernel = get_diff_kernel3d(device, dtype)
+ elif mode == 'diff' and order == 2:
+ kernel = get_diff_kernel3d_2nd_order(device, dtype)
+ else:
+ raise NotImplementedError("")
+ return kernel
+
+
+def get_gaussian_kernel1d(kernel_size: int, sigma: float, force_even: bool = False) -> torch.Tensor:
+ r"""Function that returns Gaussian filter coefficients.
+
+ Args:
+ kernel_size: filter size. It should be odd and positive.
+ sigma: gaussian standard deviation.
+ force_even: overrides requirement for odd kernel size.
+
+ Returns:
+ 1D tensor with gaussian filter coefficients.
+
+ Shape:
+ - Output: :math:`(\text{kernel_size})`
+
+ Examples:
+
+ >>> get_gaussian_kernel1d(3, 2.5)
+ tensor([0.3243, 0.3513, 0.3243])
+
+ >>> get_gaussian_kernel1d(5, 1.5)
+ tensor([0.1201, 0.2339, 0.2921, 0.2339, 0.1201])
+ """
+ if not isinstance(kernel_size, int) or ((kernel_size % 2 == 0) and not force_even) or (kernel_size <= 0):
+ raise TypeError("kernel_size must be an odd positive integer. " "Got {}".format(kernel_size))
+ window_1d: torch.Tensor = gaussian(kernel_size, sigma)
+ return window_1d
+
+
+def get_gaussian_discrete_kernel1d(kernel_size: int, sigma: float, force_even: bool = False) -> torch.Tensor:
+ r"""Function that returns Gaussian filter coefficients
+ based on the modified Bessel functions. Adapted from:
+ https://github.com/Project-MONAI/MONAI/blob/master/monai/networks/layers/convutils.py
+
+ Args:
+ kernel_size: filter size. It should be odd and positive.
+ sigma: gaussian standard deviation.
+ force_even: overrides requirement for odd kernel size.
+
+ Returns:
+ 1D tensor with gaussian filter coefficients.
+
+ Shape:
+ - Output: :math:`(\text{kernel_size})`
+
+ Examples:
+
+ >>> get_gaussian_discrete_kernel1d(3, 2.5)
+ tensor([0.3235, 0.3531, 0.3235])
+
+ >>> get_gaussian_discrete_kernel1d(5, 1.5)
+ tensor([0.1096, 0.2323, 0.3161, 0.2323, 0.1096])
+ """
+ if not isinstance(kernel_size, int) or ((kernel_size % 2 == 0) and not force_even) or (kernel_size <= 0):
+ raise TypeError("kernel_size must be an odd positive integer. " "Got {}".format(kernel_size))
+ window_1d = gaussian_discrete(kernel_size, sigma)
+ return window_1d
+
+
+def get_gaussian_erf_kernel1d(kernel_size: int, sigma: float, force_even: bool = False) -> torch.Tensor:
+ r"""Function that returns Gaussian filter coefficients by interpolating the error function,
+ adapted from:
+ https://github.com/Project-MONAI/MONAI/blob/master/monai/networks/layers/convutils.py
+
+ Args:
+ kernel_size: filter size. It should be odd and positive.
+ sigma: gaussian standard deviation.
+ force_even: overrides requirement for odd kernel size.
+
+ Returns:
+ 1D tensor with gaussian filter coefficients.
+
+ Shape:
+ - Output: :math:`(\text{kernel_size})`
+
+ Examples:
+
+ >>> get_gaussian_erf_kernel1d(3, 2.5)
+ tensor([0.3245, 0.3511, 0.3245])
+
+ >>> get_gaussian_erf_kernel1d(5, 1.5)
+ tensor([0.1226, 0.2331, 0.2887, 0.2331, 0.1226])
+ """
+ if not isinstance(kernel_size, int) or ((kernel_size % 2 == 0) and not force_even) or (kernel_size <= 0):
+ raise TypeError("kernel_size must be an odd positive integer. " "Got {}".format(kernel_size))
+ window_1d = gaussian_discrete_erf(kernel_size, sigma)
+ return window_1d
+
+
+def get_gaussian_kernel2d(
+ kernel_size: Tuple[int, int], sigma: Tuple[float, float], force_even: bool = False
+) -> torch.Tensor:
+ r"""Function that returns Gaussian filter matrix coefficients.
+
+ Args:
+ kernel_size: filter sizes in the x and y direction.
+ Sizes should be odd and positive.
+ sigma: gaussian standard deviation in the x and y
+ direction.
+ force_even: overrides requirement for odd kernel size.
+
+ Returns:
+ 2D tensor with gaussian filter matrix coefficients.
+
+ Shape:
+ - Output: :math:`(\text{kernel_size}_x, \text{kernel_size}_y)`
+
+ Examples:
+ >>> get_gaussian_kernel2d((3, 3), (1.5, 1.5))
+ tensor([[0.0947, 0.1183, 0.0947],
+ [0.1183, 0.1478, 0.1183],
+ [0.0947, 0.1183, 0.0947]])
+ >>> get_gaussian_kernel2d((3, 5), (1.5, 1.5))
+ tensor([[0.0370, 0.0720, 0.0899, 0.0720, 0.0370],
+ [0.0462, 0.0899, 0.1123, 0.0899, 0.0462],
+ [0.0370, 0.0720, 0.0899, 0.0720, 0.0370]])
+ """
+ if not isinstance(kernel_size, tuple) or len(kernel_size) != 2:
+ raise TypeError(f"kernel_size must be a tuple of length two. Got {kernel_size}")
+ if not isinstance(sigma, tuple) or len(sigma) != 2:
+ raise TypeError(f"sigma must be a tuple of length two. Got {sigma}")
+ ksize_x, ksize_y = kernel_size
+ sigma_x, sigma_y = sigma
+ kernel_x: torch.Tensor = get_gaussian_kernel1d(ksize_x, sigma_x, force_even)
+ kernel_y: torch.Tensor = get_gaussian_kernel1d(ksize_y, sigma_y, force_even)
+ kernel_2d: torch.Tensor = torch.matmul(kernel_x.unsqueeze(-1), kernel_y.unsqueeze(-1).t())
+ return kernel_2d
+
+
+def get_laplacian_kernel1d(kernel_size: int) -> torch.Tensor:
+ r"""Function that returns the coefficients of a 1D Laplacian filter.
+
+ Args:
+ kernel_size: filter size. It should be odd and positive.
+
+ Returns:
+ 1D tensor with laplacian filter coefficients.
+
+ Shape:
+ - Output: math:`(\text{kernel_size})`
+
+ Examples:
+ >>> get_laplacian_kernel1d(3)
+ tensor([ 1., -2., 1.])
+ >>> get_laplacian_kernel1d(5)
+ tensor([ 1., 1., -4., 1., 1.])
+
+ """
+ if not isinstance(kernel_size, int) or kernel_size % 2 == 0 or kernel_size <= 0:
+ raise TypeError(f"ksize must be an odd positive integer. Got {kernel_size}")
+ window_1d: torch.Tensor = laplacian_1d(kernel_size)
+ return window_1d
+
+
+def get_laplacian_kernel2d(kernel_size: int) -> torch.Tensor:
+ r"""Function that returns Gaussian filter matrix coefficients.
+
+ Args:
+ kernel_size: filter size should be odd.
+
+ Returns:
+ 2D tensor with laplacian filter matrix coefficients.
+
+ Shape:
+ - Output: :math:`(\text{kernel_size}_x, \text{kernel_size}_y)`
+
+ Examples:
+ >>> get_laplacian_kernel2d(3)
+ tensor([[ 1., 1., 1.],
+ [ 1., -8., 1.],
+ [ 1., 1., 1.]])
+ >>> get_laplacian_kernel2d(5)
+ tensor([[ 1., 1., 1., 1., 1.],
+ [ 1., 1., 1., 1., 1.],
+ [ 1., 1., -24., 1., 1.],
+ [ 1., 1., 1., 1., 1.],
+ [ 1., 1., 1., 1., 1.]])
+ """
+ if not isinstance(kernel_size, int) or kernel_size % 2 == 0 or kernel_size <= 0:
+ raise TypeError(f"ksize must be an odd positive integer. Got {kernel_size}")
+
+ kernel = torch.ones((kernel_size, kernel_size))
+ mid = kernel_size // 2
+ kernel[mid, mid] = 1 - kernel_size ** 2
+ kernel_2d: torch.Tensor = kernel
+ return kernel_2d
+
+
+def get_pascal_kernel_2d(kernel_size: int, norm: bool = True) -> torch.Tensor:
+ """Generate pascal filter kernel by kernel size.
+
+ Args:
+ kernel_size: height and width of the kernel.
+ norm: if to normalize the kernel or not. Default: True.
+
+ Returns:
+ kernel shaped as :math:`(kernel_size, kernel_size)`
+
+ Examples:
+ >>> get_pascal_kernel_2d(1)
+ tensor([[1.]])
+ >>> get_pascal_kernel_2d(4)
+ tensor([[0.0156, 0.0469, 0.0469, 0.0156],
+ [0.0469, 0.1406, 0.1406, 0.0469],
+ [0.0469, 0.1406, 0.1406, 0.0469],
+ [0.0156, 0.0469, 0.0469, 0.0156]])
+ >>> get_pascal_kernel_2d(4, norm=False)
+ tensor([[1., 3., 3., 1.],
+ [3., 9., 9., 3.],
+ [3., 9., 9., 3.],
+ [1., 3., 3., 1.]])
+ """
+ a = get_pascal_kernel_1d(kernel_size)
+
+ filt = a[:, None] * a[None, :]
+ if norm:
+ filt = filt / torch.sum(filt)
+ return filt
+
+
+def get_pascal_kernel_1d(kernel_size: int, norm: bool = False) -> torch.Tensor:
+ """Generate Yang Hui triangle (Pascal's triangle) by a given number.
+
+ Args:
+ kernel_size: height and width of the kernel.
+ norm: if to normalize the kernel or not. Default: False.
+
+ Returns:
+ kernel shaped as :math:`(kernel_size,)`
+
+ Examples:
+ >>> get_pascal_kernel_1d(1)
+ tensor([1.])
+ >>> get_pascal_kernel_1d(2)
+ tensor([1., 1.])
+ >>> get_pascal_kernel_1d(3)
+ tensor([1., 2., 1.])
+ >>> get_pascal_kernel_1d(4)
+ tensor([1., 3., 3., 1.])
+ >>> get_pascal_kernel_1d(5)
+ tensor([1., 4., 6., 4., 1.])
+ >>> get_pascal_kernel_1d(6)
+ tensor([ 1., 5., 10., 10., 5., 1.])
+ """
+ pre: List[float] = []
+ cur: List[float] = []
+ for i in range(kernel_size):
+ cur = [1.0] * (i + 1)
+
+ for j in range(1, i // 2 + 1):
+ value = pre[j - 1] + pre[j]
+ cur[j] = value
+ if i != 2 * j:
+ cur[-j - 1] = value
+ pre = cur
+
+ out = torch.as_tensor(cur)
+ if norm:
+ out = out / torch.sum(out)
+ return out
+
+
+def get_canny_nms_kernel(device=torch.device('cpu'), dtype=torch.float) -> torch.Tensor:
+ """Utility function that returns 3x3 kernels for the Canny Non-maximal suppression."""
+ kernel: torch.Tensor = torch.tensor(
+ [
+ [[0.0, 0.0, 0.0], [0.0, 1.0, -1.0], [0.0, 0.0, 0.0]],
+ [[0.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, -1.0]],
+ [[0.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, -1.0, 0.0]],
+ [[0.0, 0.0, 0.0], [0.0, 1.0, 0.0], [-1.0, 0.0, 0.0]],
+ [[0.0, 0.0, 0.0], [-1.0, 1.0, 0.0], [0.0, 0.0, 0.0]],
+ [[-1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 0.0]],
+ [[0.0, -1.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 0.0]],
+ [[0.0, 0.0, -1.0], [0.0, 1.0, 0.0], [0.0, 0.0, 0.0]],
+ ],
+ device=device,
+ dtype=dtype,
+ )
+ return kernel.unsqueeze(1)
+
+
+def get_hysteresis_kernel(device=torch.device('cpu'), dtype=torch.float) -> torch.Tensor:
+ """Utility function that returns the 3x3 kernels for the Canny hysteresis."""
+ kernel: torch.Tensor = torch.tensor(
+ [
+ [[0.0, 0.0, 0.0], [0.0, 0.0, 1.0], [0.0, 0.0, 0.0]],
+ [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 1.0]],
+ [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 1.0, 0.0]],
+ [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [1.0, 0.0, 0.0]],
+ [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 0.0, 0.0]],
+ [[1.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],
+ [[0.0, 1.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],
+ [[0.0, 0.0, 1.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],
+ ],
+ device=device,
+ dtype=dtype,
+ )
+ return kernel.unsqueeze(1)
diff --git a/kornia/filters/kernels_geometry.py b/kornia/filters/kernels_geometry.py
new file mode 100644
index 0000000000000000000000000000000000000000..6bca901d93063f5354f78cb84a2e084c368f5e66
--- /dev/null
+++ b/kornia/filters/kernels_geometry.py
@@ -0,0 +1,204 @@
+from typing import cast, Tuple, Union
+
+import torch
+
+from kornia.geometry.transform import rotate, rotate3d
+from kornia.utils import _extract_device_dtype
+
+
+def get_motion_kernel2d(
+ kernel_size: int,
+ angle: Union[torch.Tensor, float],
+ direction: Union[torch.Tensor, float] = 0.0,
+ mode: str = 'nearest',
+) -> torch.Tensor:
+ r"""Return 2D motion blur filter.
+
+ Args:
+ kernel_size: motion kernel width and height. It should be odd and positive.
+ angle: angle of the motion blur in degrees (anti-clockwise rotation).
+ direction: forward/backward direction of the motion blur.
+ Lower values towards -1.0 will point the motion blur towards the back (with angle provided via angle),
+ while higher values towards 1.0 will point the motion blur forward. A value of 0.0 leads to a
+ uniformly (but still angled) motion blur.
+ mode: interpolation mode for rotating the kernel. ``'bilinear'`` or ``'nearest'``.
+
+ Returns:
+ The motion blur kernel of shape :math:`(B, k_\text{size}, k_\text{size})`.
+
+ Examples:
+ >>> get_motion_kernel2d(5, 0., 0.)
+ tensor([[[0.0000, 0.0000, 0.0000, 0.0000, 0.0000],
+ [0.0000, 0.0000, 0.0000, 0.0000, 0.0000],
+ [0.2000, 0.2000, 0.2000, 0.2000, 0.2000],
+ [0.0000, 0.0000, 0.0000, 0.0000, 0.0000],
+ [0.0000, 0.0000, 0.0000, 0.0000, 0.0000]]])
+
+ >>> get_motion_kernel2d(3, 215., -0.5)
+ tensor([[[0.0000, 0.0000, 0.1667],
+ [0.0000, 0.3333, 0.0000],
+ [0.5000, 0.0000, 0.0000]]])
+ """
+ device, dtype = _extract_device_dtype(
+ [angle if isinstance(angle, torch.Tensor) else None, direction if isinstance(direction, torch.Tensor) else None]
+ )
+
+ if not isinstance(kernel_size, int) or kernel_size % 2 == 0 or kernel_size < 3:
+ raise TypeError("ksize must be an odd integer >= than 3")
+
+ if not isinstance(angle, torch.Tensor):
+ angle = torch.tensor([angle], device=device, dtype=dtype)
+
+ angle = cast(torch.Tensor, angle)
+
+ if angle.dim() == 0:
+ angle = angle.unsqueeze(0)
+
+ if angle.dim() != 1:
+ raise AssertionError(f"angle must be a 1-dim tensor. Got {angle}.")
+
+ if not isinstance(direction, torch.Tensor):
+ direction = torch.tensor([direction], device=device, dtype=dtype)
+
+ direction = cast(torch.Tensor, direction)
+
+ if direction.dim() == 0:
+ direction = direction.unsqueeze(0)
+
+ if direction.dim() != 1:
+ raise AssertionError(f"direction must be a 1-dim tensor. Got {direction}.")
+
+ if direction.size(0) != angle.size(0):
+ raise AssertionError(f"direction and angle must have the same length. Got {direction} and {angle}.")
+
+ kernel_tuple: Tuple[int, int] = (kernel_size, kernel_size)
+
+ # direction from [-1, 1] to [0, 1] range
+ direction = (torch.clamp(direction, -1.0, 1.0) + 1.0) / 2.0
+ # kernel = torch.zeros((direction.size(0), *kernel_tuple), device=device, dtype=dtype)
+
+ # Element-wise linspace
+ # kernel[:, kernel_size // 2, :] = torch.stack(
+ # [(direction + ((1 - 2 * direction) / (kernel_size - 1)) * i) for i in range(kernel_size)], dim=-1)
+ # Alternatively
+ # m = ((1 - 2 * direction)[:, None].repeat(1, kernel_size) / (kernel_size - 1))
+ # kernel[:, kernel_size // 2, :] = direction[:, None].repeat(1, kernel_size) + m * torch.arange(0, kernel_size)
+ k = torch.stack([(direction + ((1 - 2 * direction) / (kernel_size - 1)) * i) for i in range(kernel_size)], dim=-1)
+ kernel = torch.nn.functional.pad(k[:, None], [0, 0, kernel_size // 2, kernel_size // 2, 0, 0])
+
+ if kernel.shape != torch.Size([direction.size(0), *kernel_tuple]):
+ raise AssertionError
+ kernel = kernel.unsqueeze(1)
+
+ # rotate (counterclockwise) kernel by given angle
+ kernel = rotate(kernel, angle, mode=mode, align_corners=True)
+ kernel = kernel[:, 0]
+ kernel = kernel / kernel.sum(dim=(1, 2), keepdim=True)
+ return kernel
+
+
+def get_motion_kernel3d(
+ kernel_size: int,
+ angle: Union[torch.Tensor, Tuple[float, float, float]],
+ direction: Union[torch.Tensor, float] = 0.0,
+ mode: str = 'nearest',
+) -> torch.Tensor:
+ r"""Return 3D motion blur filter.
+
+ Args:
+ kernel_size: motion kernel width, height and depth. It should be odd and positive.
+ angle: Range of yaw (x-axis), pitch (y-axis), roll (z-axis) to select from.
+ If tensor, it must be :math:`(B, 3)`.
+ If tuple, it must be (yaw, pitch, raw).
+ direction: forward/backward direction of the motion blur.
+ Lower values towards -1.0 will point the motion blur towards the back (with angle provided via angle),
+ while higher values towards 1.0 will point the motion blur forward. A value of 0.0 leads to a
+ uniformly (but still angled) motion blur.
+ mode: interpolation mode for rotating the kernel. ``'bilinear'`` or ``'nearest'``.
+
+ Returns:
+ The motion blur kernel with shape :math:`(B, k_\text{size}, k_\text{size}, k_\text{size})`.
+
+ Examples:
+ >>> get_motion_kernel3d(3, (0., 0., 0.), 0.)
+ tensor([[[[0.0000, 0.0000, 0.0000],
+ [0.0000, 0.0000, 0.0000],
+ [0.0000, 0.0000, 0.0000]],
+
+ [[0.0000, 0.0000, 0.0000],
+ [0.3333, 0.3333, 0.3333],
+ [0.0000, 0.0000, 0.0000]],
+
+ [[0.0000, 0.0000, 0.0000],
+ [0.0000, 0.0000, 0.0000],
+ [0.0000, 0.0000, 0.0000]]]])
+
+ >>> get_motion_kernel3d(3, (90., 90., 0.), -0.5)
+ tensor([[[[0.0000, 0.0000, 0.0000],
+ [0.0000, 0.0000, 0.0000],
+ [0.0000, 0.5000, 0.0000]],
+
+ [[0.0000, 0.0000, 0.0000],
+ [0.0000, 0.3333, 0.0000],
+ [0.0000, 0.0000, 0.0000]],
+
+ [[0.0000, 0.1667, 0.0000],
+ [0.0000, 0.0000, 0.0000],
+ [0.0000, 0.0000, 0.0000]]]])
+ """
+ if not isinstance(kernel_size, int) or kernel_size % 2 == 0 or kernel_size < 3:
+ raise TypeError(f"ksize must be an odd integer >= than 3. Got {kernel_size}.")
+
+ device, dtype = _extract_device_dtype(
+ [angle if isinstance(angle, torch.Tensor) else None, direction if isinstance(direction, torch.Tensor) else None]
+ )
+
+ if not isinstance(angle, torch.Tensor):
+ angle = torch.tensor([angle], device=device, dtype=dtype)
+
+ angle = cast(torch.Tensor, angle)
+
+ if angle.dim() == 1:
+ angle = angle.unsqueeze(0)
+
+ if not (len(angle.shape) == 2 and angle.size(1) == 3):
+ raise AssertionError(f"angle must be (B, 3). Got {angle}.")
+
+ if not isinstance(direction, torch.Tensor):
+ direction = torch.tensor([direction], device=device, dtype=dtype)
+
+ direction = cast(torch.Tensor, direction)
+
+ if direction.dim() == 0:
+ direction = direction.unsqueeze(0)
+
+ if direction.dim() != 1:
+ raise AssertionError(f"direction must be a 1-dim tensor. Got {direction}.")
+
+ if direction.size(0) != angle.size(0):
+ raise AssertionError(f"direction and angle must have the same length. Got {direction} and {angle}.")
+
+ kernel_tuple: Tuple[int, int, int] = (kernel_size, kernel_size, kernel_size)
+
+ # direction from [-1, 1] to [0, 1] range
+ direction = (torch.clamp(direction, -1.0, 1.0) + 1.0) / 2.0
+ kernel = torch.zeros((direction.size(0), *kernel_tuple), device=device, dtype=dtype)
+
+ # Element-wise linspace
+ # kernel[:, kernel_size // 2, kernel_size // 2, :] = torch.stack(
+ # [(direction + ((1 - 2 * direction) / (kernel_size - 1)) * i) for i in range(kernel_size)], dim=-1)
+ k = torch.stack([(direction + ((1 - 2 * direction) / (kernel_size - 1)) * i) for i in range(kernel_size)], dim=-1)
+ kernel = torch.nn.functional.pad(
+ k[:, None, None], [0, 0, kernel_size // 2, kernel_size // 2, kernel_size // 2, kernel_size // 2, 0, 0]
+ )
+
+ if kernel.shape != torch.Size([direction.size(0), *kernel_tuple]):
+ raise AssertionError
+ kernel = kernel.unsqueeze(1)
+
+ # rotate (counterclockwise) kernel by given angle
+ kernel = rotate3d(kernel, angle[:, 0], angle[:, 1], angle[:, 2], mode=mode, align_corners=True)
+ kernel = kernel[:, 0]
+ kernel = kernel / kernel.sum(dim=(1, 2, 3), keepdim=True)
+
+ return kernel
diff --git a/kornia/filters/laplacian.py b/kornia/filters/laplacian.py
new file mode 100644
index 0000000000000000000000000000000000000000..6b62292a53c60435dedc7367bc8f26531855be32
--- /dev/null
+++ b/kornia/filters/laplacian.py
@@ -0,0 +1,93 @@
+import torch
+import torch.nn as nn
+
+from .filter import filter2d
+from .kernels import get_laplacian_kernel2d, normalize_kernel2d
+
+
+def laplacian(
+ input: torch.Tensor, kernel_size: int, border_type: str = 'reflect', normalized: bool = True
+) -> torch.Tensor:
+ r"""Create an operator that returns a tensor using a Laplacian filter.
+
+ .. image:: _static/img/laplacian.png
+
+ The operator smooths the given tensor with a laplacian kernel by convolving
+ it to each channel. It supports batched operation.
+
+ Args:
+ input: the input image tensor with shape :math:`(B, C, H, W)`.
+ kernel_size: the size of the kernel.
+ border_type: the padding mode to be applied before convolving.
+ The expected modes are: ``'constant'``, ``'reflect'``,
+ ``'replicate'`` or ``'circular'``.
+ normalized: if True, L1 norm of the kernel is set to 1.
+
+ Return:
+ the blurred image with shape :math:`(B, C, H, W)`.
+
+ .. note::
+ See a working example `here `__.
+
+ Examples:
+ >>> input = torch.rand(2, 4, 5, 5)
+ >>> output = laplacian(input, 3)
+ >>> output.shape
+ torch.Size([2, 4, 5, 5])
+ """
+ kernel: torch.Tensor = torch.unsqueeze(get_laplacian_kernel2d(kernel_size), dim=0)
+
+ if normalized:
+ kernel = normalize_kernel2d(kernel)
+
+ return filter2d(input, kernel, border_type)
+
+
+class Laplacian(nn.Module):
+ r"""Create an operator that returns a tensor using a Laplacian filter.
+
+ The operator smooths the given tensor with a laplacian kernel by convolving
+ it to each channel. It supports batched operation.
+
+ Args:
+ kernel_size: the size of the kernel.
+ border_type: the padding mode to be applied before convolving.
+ The expected modes are: ``'constant'``, ``'reflect'``,
+ ``'replicate'`` or ``'circular'``.
+ normalized: if True, L1 norm of the kernel is set to 1.
+
+ Shape:
+ - Input: :math:`(B, C, H, W)`
+ - Output: :math:`(B, C, H, W)`
+
+ Examples:
+ >>> input = torch.rand(2, 4, 5, 5)
+ >>> laplace = Laplacian(5)
+ >>> output = laplace(input)
+ >>> output.shape
+ torch.Size([2, 4, 5, 5])
+ """
+
+ def __init__(self, kernel_size: int, border_type: str = 'reflect', normalized: bool = True) -> None:
+ super().__init__()
+ self.kernel_size: int = kernel_size
+ self.border_type: str = border_type
+ self.normalized: bool = normalized
+
+ def __repr__(self) -> str:
+ return (
+ self.__class__.__name__
+ + '(kernel_size='
+ + str(self.kernel_size)
+ + ', '
+ + 'normalized='
+ + str(self.normalized)
+ + ', '
+ + 'border_type='
+ + self.border_type
+ + ')'
+ )
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor:
+ return laplacian(input, self.kernel_size, self.border_type, self.normalized)
diff --git a/kornia/filters/median.py b/kornia/filters/median.py
new file mode 100644
index 0000000000000000000000000000000000000000..3d9e26910568e95a48e6d0426ad9ca22e167c091
--- /dev/null
+++ b/kornia/filters/median.py
@@ -0,0 +1,86 @@
+from typing import List, Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from .kernels import get_binary_kernel2d
+
+
+def _compute_zero_padding(kernel_size: Tuple[int, int]) -> Tuple[int, int]:
+ r"""Utility function that computes zero padding tuple."""
+ computed: List[int] = [(k - 1) // 2 for k in kernel_size]
+ return computed[0], computed[1]
+
+
+def median_blur(input: torch.Tensor, kernel_size: Tuple[int, int]) -> torch.Tensor:
+ r"""Blur an image using the median filter.
+
+ .. image:: _static/img/median_blur.png
+
+ Args:
+ input: the input image with shape :math:`(B,C,H,W)`.
+ kernel_size: the blurring kernel size.
+
+ Returns:
+ the blurred input tensor with shape :math:`(B,C,H,W)`.
+
+ .. note::
+ See a working example `here `__.
+
+ Example:
+ >>> input = torch.rand(2, 4, 5, 7)
+ >>> output = median_blur(input, (3, 3))
+ >>> output.shape
+ torch.Size([2, 4, 5, 7])
+ """
+ if not isinstance(input, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(input)}")
+
+ if not len(input.shape) == 4:
+ raise ValueError(f"Invalid input shape, we expect BxCxHxW. Got: {input.shape}")
+
+ padding: Tuple[int, int] = _compute_zero_padding(kernel_size)
+
+ # prepare kernel
+ kernel: torch.Tensor = get_binary_kernel2d(kernel_size).to(input)
+ b, c, h, w = input.shape
+
+ # map the local window to single vector
+ features: torch.Tensor = F.conv2d(input.reshape(b * c, 1, h, w), kernel, padding=padding, stride=1)
+ features = features.view(b, c, -1, h, w) # BxCx(K_h * K_w)xHxW
+
+ # compute the median along the feature axis
+ median: torch.Tensor = torch.median(features, dim=2)[0]
+
+ return median
+
+
+class MedianBlur(nn.Module):
+ r"""Blur an image using the median filter.
+
+ Args:
+ kernel_size: the blurring kernel size.
+
+ Returns:
+ the blurred input tensor.
+
+ Shape:
+ - Input: :math:`(B, C, H, W)`
+ - Output: :math:`(B, C, H, W)`
+
+ Example:
+ >>> input = torch.rand(2, 4, 5, 7)
+ >>> blur = MedianBlur((3, 3))
+ >>> output = blur(input)
+ >>> output.shape
+ torch.Size([2, 4, 5, 7])
+ """
+
+ def __init__(self, kernel_size: Tuple[int, int]) -> None:
+ super().__init__()
+ self.kernel_size: Tuple[int, int] = kernel_size
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor:
+ return median_blur(input, self.kernel_size)
diff --git a/kornia/filters/motion.py b/kornia/filters/motion.py
new file mode 100644
index 0000000000000000000000000000000000000000..3a0ac7414570bcfef4b73172b09fc8ee0790568c
--- /dev/null
+++ b/kornia/filters/motion.py
@@ -0,0 +1,195 @@
+from typing import Tuple, Union
+
+import torch
+import torch.nn as nn
+
+from .filter import filter2d, filter3d
+from .kernels_geometry import get_motion_kernel2d, get_motion_kernel3d
+
+
+class MotionBlur(nn.Module):
+ r"""Blur 2D images (4D tensor) using the motion filter.
+
+ Args:
+ kernel_size: motion kernel width and height. It should be odd and positive.
+ angle: angle of the motion blur in degrees (anti-clockwise rotation).
+ direction: forward/backward direction of the motion blur.
+ Lower values towards -1.0 will point the motion blur towards the back (with angle provided via angle),
+ while higher values towards 1.0 will point the motion blur forward. A value of 0.0 leads to a
+ uniformly (but still angled) motion blur.
+ border_type: the padding mode to be applied before convolving. The expected modes are:
+ ``'constant'``, ``'reflect'``, ``'replicate'`` or ``'circular'``.
+
+ Returns:
+ the blurred input tensor.
+
+ Shape:
+ - Input: :math:`(B, C, H, W)`
+ - Output: :math:`(B, C, H, W)`
+
+ Examples:
+ >>> input = torch.rand(2, 4, 5, 7)
+ >>> motion_blur = MotionBlur(3, 35., 0.5)
+ >>> output = motion_blur(input) # 2x4x5x7
+ """
+
+ def __init__(self, kernel_size: int, angle: float, direction: float, border_type: str = 'constant') -> None:
+ super().__init__()
+ self.kernel_size = kernel_size
+ self.angle: float = angle
+ self.direction: float = direction
+ self.border_type: str = border_type
+
+ def __repr__(self) -> str:
+ return (
+ f'{self.__class__.__name__} (kernel_size={self.kernel_size}, '
+ f'angle={self.angle}, direction={self.direction}, border_type={self.border_type})'
+ )
+
+ def forward(self, x: torch.Tensor):
+ return motion_blur(x, self.kernel_size, self.angle, self.direction, self.border_type)
+
+
+class MotionBlur3D(nn.Module):
+ r"""Blur 3D volumes (5D tensor) using the motion filter.
+
+ Args:
+ kernel_size: motion kernel width and height. It should be odd and positive.
+ angle: Range of yaw (x-axis), pitch (y-axis), roll (z-axis) to select from.
+ direction: forward/backward direction of the motion blur.
+ Lower values towards -1.0 will point the motion blur towards the back (with angle provided via angle),
+ while higher values towards 1.0 will point the motion blur forward. A value of 0.0 leads to a
+ uniformly (but still angled) motion blur.
+ border_type: the padding mode to be applied before convolving. The expected modes are:
+ ``'constant'``, ``'reflect'``, ``'replicate'`` or ``'circular'``.
+
+ Returns:
+ the blurred input tensor.
+
+ Shape:
+ - Input: :math:`(B, C, D, H, W)`
+ - Output: :math:`(B, C, D, H, W)`
+
+ Examples:
+ >>> input = torch.rand(2, 4, 5, 7, 9)
+ >>> motion_blur = MotionBlur3D(3, 35., 0.5)
+ >>> output = motion_blur(input) # 2x4x5x7x9
+ """
+
+ def __init__(
+ self,
+ kernel_size: int,
+ angle: Union[float, Tuple[float, float, float]],
+ direction: float,
+ border_type: str = 'constant',
+ ) -> None:
+ super().__init__()
+ self.kernel_size = kernel_size
+ self.angle: Tuple[float, float, float]
+ if isinstance(angle, float):
+ self.angle = (angle, angle, angle)
+ elif isinstance(angle, (tuple, list)) and len(angle) == 3:
+ self.angle = angle
+ else:
+ raise ValueError(f"Expect angle to be either a float or a tuple of floats. Got {angle}.")
+ self.direction: float = direction
+ self.border_type: str = border_type
+
+ def __repr__(self) -> str:
+ return (
+ f'{self.__class__.__name__} (kernel_size={self.kernel_size}, '
+ f'angle={self.angle}, direction={self.direction}, border_type={self.border_type})'
+ )
+
+ def forward(self, x: torch.Tensor):
+ return motion_blur3d(x, self.kernel_size, self.angle, self.direction, self.border_type)
+
+
+def motion_blur(
+ input: torch.Tensor,
+ kernel_size: int,
+ angle: Union[float, torch.Tensor],
+ direction: Union[float, torch.Tensor],
+ border_type: str = 'constant',
+ mode: str = 'nearest',
+) -> torch.Tensor:
+ r"""Perform motion blur on tensor images.
+
+ .. image:: _static/img/motion_blur.png
+
+ Args:
+ input: the input tensor with shape :math:`(B, C, H, W)`.
+ kernel_size: motion kernel width and height. It should be odd and positive.
+ angle (Union[torch.Tensor, float]): angle of the motion blur in degrees (anti-clockwise rotation).
+ If tensor, it must be :math:`(B,)`.
+ direction : forward/backward direction of the motion blur.
+ Lower values towards -1.0 will point the motion blur towards the back (with angle provided via angle),
+ while higher values towards 1.0 will point the motion blur forward. A value of 0.0 leads to a
+ uniformly (but still angled) motion blur.
+ If tensor, it must be :math:`(B,)`.
+ border_type: the padding mode to be applied before convolving. The expected modes are:
+ ``'constant'``, ``'reflect'``, ``'replicate'`` or ``'circular'``. Default: ``'constant'``.
+ mode: interpolation mode for rotating the kernel. ``'bilinear'`` or ``'nearest'``.
+
+ Return:
+ the blurred image with shape :math:`(B, C, H, W)`.
+
+ Example:
+ >>> input = torch.randn(1, 3, 80, 90).repeat(2, 1, 1, 1)
+ >>> # perform exact motion blur across the batch
+ >>> out_1 = motion_blur(input, 5, 90., 1)
+ >>> torch.allclose(out_1[0], out_1[1])
+ True
+ >>> # perform element-wise motion blur across the batch
+ >>> out_1 = motion_blur(input, 5, torch.tensor([90., 180,]), torch.tensor([1., -1.]))
+ >>> torch.allclose(out_1[0], out_1[1])
+ False
+ """
+ if border_type not in ["constant", "reflect", "replicate", "circular"]:
+ raise AssertionError
+ kernel: torch.Tensor = get_motion_kernel2d(kernel_size, angle, direction, mode)
+ return filter2d(input, kernel, border_type)
+
+
+def motion_blur3d(
+ input: torch.Tensor,
+ kernel_size: int,
+ angle: Union[Tuple[float, float, float], torch.Tensor],
+ direction: Union[float, torch.Tensor],
+ border_type: str = 'constant',
+ mode: str = 'nearest',
+) -> torch.Tensor:
+ r"""Perform motion blur on 3D volumes (5D tensor).
+
+ Args:
+ input: the input tensor with shape :math:`(B, C, D, H, W)`.
+ kernel_size: motion kernel width, height and depth. It should be odd and positive.
+ angle: Range of yaw (x-axis), pitch (y-axis), roll (z-axis) to select from.
+ If tensor, it must be :math:`(B, 3)`.
+ direction: forward/backward direction of the motion blur.
+ Lower values towards -1.0 will point the motion blur towards the back (with angle provided via angle),
+ while higher values towards 1.0 will point the motion blur forward. A value of 0.0 leads to a
+ uniformly (but still angled) motion blur.
+ If tensor, it must be :math:`(B,)`.
+ border_type: the padding mode to be applied before convolving. The expected modes are:
+ ``'constant'``, ``'reflect'``, ``'replicate'`` or ``'circular'``. Default: ``'constant'``.
+ mode: interpolation mode for rotating the kernel. ``'bilinear'`` or ``'nearest'``.
+
+ Return:
+ the blurred image with shape :math:`(B, C, D, H, W)`.
+
+ Example:
+ >>> input = torch.randn(1, 3, 120, 80, 90).repeat(2, 1, 1, 1, 1)
+ >>> # perform exact motion blur across the batch
+ >>> out_1 = motion_blur3d(input, 5, (0., 90., 90.), 1)
+ >>> torch.allclose(out_1[0], out_1[1])
+ True
+ >>> # perform element-wise motion blur across the batch
+ >>> out_1 = motion_blur3d(input, 5, torch.tensor([[0., 90., 90.], [90., 180., 0.]]), torch.tensor([1., -1.]))
+ >>> torch.allclose(out_1[0], out_1[1])
+ False
+ """
+ if border_type not in ["constant", "reflect", "replicate", "circular"]:
+ raise AssertionError
+ kernel: torch.Tensor = get_motion_kernel3d(kernel_size, angle, direction, mode)
+ return filter3d(input, kernel, border_type)
diff --git a/kornia/filters/sobel.py b/kornia/filters/sobel.py
new file mode 100644
index 0000000000000000000000000000000000000000..8c9edc2a9774556911c5b964c13e5dd8c4dc8244
--- /dev/null
+++ b/kornia/filters/sobel.py
@@ -0,0 +1,269 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from .kernels import get_spatial_gradient_kernel2d, get_spatial_gradient_kernel3d, normalize_kernel2d
+
+
+def spatial_gradient(input: torch.Tensor, mode: str = 'sobel', order: int = 1, normalized: bool = True) -> torch.Tensor:
+ r"""Compute the first order image derivative in both x and y using a Sobel
+ operator.
+
+ .. image:: _static/img/spatial_gradient.png
+
+ Args:
+ input: input image tensor with shape :math:`(B, C, H, W)`.
+ mode: derivatives modality, can be: `sobel` or `diff`.
+ order: the order of the derivatives.
+ normalized: whether the output is normalized.
+
+ Return:
+ the derivatives of the input feature map. with shape :math:`(B, C, 2, H, W)`.
+
+ .. note::
+ See a working example `here `__.
+
+ Examples:
+ >>> input = torch.rand(1, 3, 4, 4)
+ >>> output = spatial_gradient(input) # 1x3x2x4x4
+ >>> output.shape
+ torch.Size([1, 3, 2, 4, 4])
+ """
+ if not isinstance(input, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(input)}")
+
+ if not len(input.shape) == 4:
+ raise ValueError(f"Invalid input shape, we expect BxCxHxW. Got: {input.shape}")
+ # allocate kernel
+ kernel: torch.Tensor = get_spatial_gradient_kernel2d(mode, order)
+ if normalized:
+ kernel = normalize_kernel2d(kernel)
+
+ # prepare kernel
+ b, c, h, w = input.shape
+ tmp_kernel: torch.Tensor = kernel.to(input).detach()
+ tmp_kernel = tmp_kernel.unsqueeze(1).unsqueeze(1)
+
+ # convolve input tensor with sobel kernel
+ kernel_flip: torch.Tensor = tmp_kernel.flip(-3)
+
+ # Pad with "replicate for spatial dims, but with zeros for channel
+ spatial_pad = [kernel.size(1) // 2, kernel.size(1) // 2, kernel.size(2) // 2, kernel.size(2) // 2]
+ out_channels: int = 3 if order == 2 else 2
+ padded_inp: torch.Tensor = F.pad(input.reshape(b * c, 1, h, w), spatial_pad, 'replicate')[:, :, None]
+
+ return F.conv3d(padded_inp, kernel_flip, padding=0).view(b, c, out_channels, h, w)
+
+
+def spatial_gradient3d(input: torch.Tensor, mode: str = 'diff', order: int = 1) -> torch.Tensor:
+ r"""Compute the first and second order volume derivative in x, y and d using a diff
+ operator.
+
+ Args:
+ input: input features tensor with shape :math:`(B, C, D, H, W)`.
+ mode: derivatives modality, can be: `sobel` or `diff`.
+ order: the order of the derivatives.
+
+ Return:
+ the spatial gradients of the input feature map.
+
+ Shape:
+ - Input: :math:`(B, C, D, H, W)`. D, H, W are spatial dimensions, gradient is calculated w.r.t to them.
+ - Output: :math:`(B, C, 3, D, H, W)` or :math:`(B, C, 6, D, H, W)`
+
+ Examples:
+ >>> input = torch.rand(1, 4, 2, 4, 4)
+ >>> output = spatial_gradient3d(input)
+ >>> output.shape
+ torch.Size([1, 4, 3, 2, 4, 4])
+ """
+ if not isinstance(input, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(input)}")
+
+ if not len(input.shape) == 5:
+ raise ValueError(f"Invalid input shape, we expect BxCxDxHxW. Got: {input.shape}")
+ b, c, d, h, w = input.shape
+ dev = input.device
+ dtype = input.dtype
+ if (mode == 'diff') and (order == 1):
+ # we go for the special case implementation due to conv3d bad speed
+ x: torch.Tensor = F.pad(input, 6 * [1], 'replicate')
+ center = slice(1, -1)
+ left = slice(0, -2)
+ right = slice(2, None)
+ out = torch.empty(b, c, 3, d, h, w, device=dev, dtype=dtype)
+ out[..., 0, :, :, :] = (x[..., center, center, right] - x[..., center, center, left])
+ out[..., 1, :, :, :] = (x[..., center, right, center] - x[..., center, left, center])
+ out[..., 2, :, :, :] = (x[..., right, center, center] - x[..., left, center, center])
+ out = 0.5 * out
+ else:
+ # prepare kernel
+ # allocate kernel
+ kernel: torch.Tensor = get_spatial_gradient_kernel3d(mode, order)
+
+ tmp_kernel: torch.Tensor = kernel.to(input).detach()
+ tmp_kernel = tmp_kernel.repeat(c, 1, 1, 1, 1)
+
+ # convolve input tensor with grad kernel
+ kernel_flip: torch.Tensor = tmp_kernel.flip(-3)
+
+ # Pad with "replicate for spatial dims, but with zeros for channel
+ spatial_pad = [kernel.size(2) // 2,
+ kernel.size(2) // 2,
+ kernel.size(3) // 2,
+ kernel.size(3) // 2,
+ kernel.size(4) // 2,
+ kernel.size(4) // 2]
+ out_ch: int = 6 if order == 2 else 3
+ out = F.conv3d(F.pad(input, spatial_pad, 'replicate'),
+ kernel_flip,
+ padding=0,
+ groups=c).view(b, c, out_ch, d, h, w)
+ return out
+
+
+def sobel(input: torch.Tensor, normalized: bool = True, eps: float = 1e-6) -> torch.Tensor:
+ r"""Compute the Sobel operator and returns the magnitude per channel.
+
+ .. image:: _static/img/sobel.png
+
+ Args:
+ input: the input image with shape :math:`(B,C,H,W)`.
+ normalized: if True, L1 norm of the kernel is set to 1.
+ eps: regularization number to avoid NaN during backprop.
+
+ Return:
+ the sobel edge gradient magnitudes map with shape :math:`(B,C,H,W)`.
+
+ .. note::
+ See a working example `here `__.
+
+ Example:
+ >>> input = torch.rand(1, 3, 4, 4)
+ >>> output = sobel(input) # 1x3x4x4
+ >>> output.shape
+ torch.Size([1, 3, 4, 4])
+ """
+ if not isinstance(input, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(input)}")
+
+ if not len(input.shape) == 4:
+ raise ValueError(f"Invalid input shape, we expect BxCxHxW. Got: {input.shape}")
+
+ # comput the x/y gradients
+ edges: torch.Tensor = spatial_gradient(input, normalized=normalized)
+
+ # unpack the edges
+ gx: torch.Tensor = edges[:, :, 0]
+ gy: torch.Tensor = edges[:, :, 1]
+
+ # compute gradient maginitude
+ magnitude: torch.Tensor = torch.sqrt(gx * gx + gy * gy + eps)
+
+ return magnitude
+
+
+class SpatialGradient(nn.Module):
+ r"""Compute the first order image derivative in both x and y using a Sobel
+ operator.
+
+ Args:
+ mode: derivatives modality, can be: `sobel` or `diff`.
+ order: the order of the derivatives.
+ normalized: whether the output is normalized.
+
+ Return:
+ the sobel edges of the input feature map.
+
+ Shape:
+ - Input: :math:`(B, C, H, W)`
+ - Output: :math:`(B, C, 2, H, W)`
+
+ Examples:
+ >>> input = torch.rand(1, 3, 4, 4)
+ >>> output = SpatialGradient()(input) # 1x3x2x4x4
+ """
+
+ def __init__(self, mode: str = 'sobel', order: int = 1, normalized: bool = True) -> None:
+ super().__init__()
+ self.normalized: bool = normalized
+ self.order: int = order
+ self.mode: str = mode
+
+ def __repr__(self) -> str:
+ return (
+ self.__class__.__name__ + '('
+ 'order=' + str(self.order) + ', ' + 'normalized=' + str(self.normalized) + ', ' + 'mode=' + self.mode + ')'
+ )
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor:
+ return spatial_gradient(input, self.mode, self.order, self.normalized)
+
+
+class SpatialGradient3d(nn.Module):
+ r"""Compute the first and second order volume derivative in x, y and d using a diff
+ operator.
+
+ Args:
+ mode: derivatives modality, can be: `sobel` or `diff`.
+ order: the order of the derivatives.
+
+ Return:
+ the spatial gradients of the input feature map.
+
+ Shape:
+ - Input: :math:`(B, C, D, H, W)`. D, H, W are spatial dimensions, gradient is calculated w.r.t to them.
+ - Output: :math:`(B, C, 3, D, H, W)` or :math:`(B, C, 6, D, H, W)`
+
+ Examples:
+ >>> input = torch.rand(1, 4, 2, 4, 4)
+ >>> output = SpatialGradient3d()(input)
+ >>> output.shape
+ torch.Size([1, 4, 3, 2, 4, 4])
+ """
+
+ def __init__(self, mode: str = 'diff', order: int = 1) -> None:
+ super().__init__()
+ self.order: int = order
+ self.mode: str = mode
+ self.kernel = get_spatial_gradient_kernel3d(mode, order)
+ return
+
+ def __repr__(self) -> str:
+ return self.__class__.__name__ + '(' 'order=' + str(self.order) + ', ' + 'mode=' + self.mode + ')'
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor: # type: ignore
+ return spatial_gradient3d(input, self.mode, self.order)
+
+
+class Sobel(nn.Module):
+ r"""Compute the Sobel operator and returns the magnitude per channel.
+
+ Args:
+ normalized: if True, L1 norm of the kernel is set to 1.
+ eps: regularization number to avoid NaN during backprop.
+
+ Return:
+ the sobel edge gradient magnitudes map.
+
+ Shape:
+ - Input: :math:`(B, C, H, W)`
+ - Output: :math:`(B, C, H, W)`
+
+ Examples:
+ >>> input = torch.rand(1, 3, 4, 4)
+ >>> output = Sobel()(input) # 1x3x4x4
+ """
+
+ def __init__(self, normalized: bool = True, eps: float = 1e-6) -> None:
+ super().__init__()
+ self.normalized: bool = normalized
+ self.eps: float = eps
+
+ def __repr__(self) -> str:
+ return self.__class__.__name__ + '(' 'normalized=' + str(self.normalized) + ')'
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor:
+ return sobel(input, self.normalized, self.eps)
diff --git a/kornia/filters/unsharp.py b/kornia/filters/unsharp.py
new file mode 100644
index 0000000000000000000000000000000000000000..809101bcefcdcf055d50e55df6602e6e6fff7d71
--- /dev/null
+++ b/kornia/filters/unsharp.py
@@ -0,0 +1,74 @@
+from typing import Tuple
+
+import torch
+import torch.nn as nn
+
+from .gaussian import gaussian_blur2d
+
+
+def unsharp_mask(
+ input: torch.Tensor, kernel_size: Tuple[int, int], sigma: Tuple[float, float], border_type: str = 'reflect'
+) -> torch.Tensor:
+ r"""Create an operator that sharpens a tensor by applying operation out = 2 * image - gaussian_blur2d(image).
+
+ .. image:: _static/img/unsharp_mask.png
+
+ Args:
+ input: the input tensor with shape :math:`(B,C,H,W)`.
+ kernel_size: the size of the kernel.
+ sigma: the standard deviation of the kernel.
+ border_type: the padding mode to be applied before convolving.
+ The expected modes are: ``'constant'``, ``'reflect'``,
+ ``'replicate'`` or ``'circular'``.
+
+ Returns:
+ the blurred tensor with shape :math:`(B,C,H,W)`.
+
+ Examples:
+ >>> input = torch.rand(2, 4, 5, 5)
+ >>> output = unsharp_mask(input, (3, 3), (1.5, 1.5))
+ >>> output.shape
+ torch.Size([2, 4, 5, 5])
+ """
+ data_blur: torch.Tensor = gaussian_blur2d(input, kernel_size, sigma, border_type)
+ data_sharpened: torch.Tensor = input + (input - data_blur)
+ return data_sharpened
+
+
+class UnsharpMask(nn.Module):
+ r"""Create an operator that sharpens image with: out = 2 * image - gaussian_blur2d(image).
+
+ Args:
+ kernel_size: the size of the kernel.
+ sigma: the standard deviation of the kernel.
+ border_type: the padding mode to be applied before convolving.
+ The expected modes are: ``'constant'``, ``'reflect'``,
+ ``'replicate'`` or ``'circular'``.
+
+ Returns:
+ the sharpened tensor with shape :math:`(B,C,H,W)`.
+
+ Shape:
+ - Input: :math:`(B, C, H, W)`
+ - Output: :math:`(B, C, H, W)`
+
+ .. note::
+ See a working example `here `__.
+
+ Examples:
+ >>> input = torch.rand(2, 4, 5, 5)
+ >>> sharpen = UnsharpMask((3, 3), (1.5, 1.5))
+ >>> output = sharpen(input)
+ >>> output.shape
+ torch.Size([2, 4, 5, 5])
+ """
+
+ def __init__(self, kernel_size: Tuple[int, int], sigma: Tuple[float, float], border_type: str = 'reflect') -> None:
+ super().__init__()
+ self.kernel_size: Tuple[int, int] = kernel_size
+ self.sigma: Tuple[float, float] = sigma
+ self.border_type = border_type
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor:
+ return unsharp_mask(input, self.kernel_size, self.sigma, self.border_type)
diff --git a/kornia/geometry/__init__.py b/kornia/geometry/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..47068a259294177836b042de8cbd9a0b4f6d3ab4
--- /dev/null
+++ b/kornia/geometry/__init__.py
@@ -0,0 +1,11 @@
+from .bbox import *
+from .calibration import *
+from .camera import *
+from .conversions import *
+from .depth import *
+from .epipolar import *
+from .homography import *
+from .linalg import *
+from .ransac import *
+from .subpix import *
+from .transform import *
diff --git a/kornia/geometry/bbox.py b/kornia/geometry/bbox.py
new file mode 100644
index 0000000000000000000000000000000000000000..74249bd4de9945f468bfe9d8d06ce025a6c8b8d4
--- /dev/null
+++ b/kornia/geometry/bbox.py
@@ -0,0 +1,467 @@
+from typing import Tuple
+
+import torch
+
+from .linalg import transform_points
+
+__all__ = [
+ "validate_bbox",
+ "validate_bbox3d",
+ "infer_bbox_shape",
+ "infer_bbox_shape3d",
+ "bbox_to_mask",
+ "bbox_to_mask3d",
+ "bbox_generator",
+ "bbox_generator3d",
+ "transform_bbox",
+]
+
+
+@torch.jit.ignore
+def validate_bbox(boxes: torch.Tensor) -> bool:
+ """Validate if a 2D bounding box usable or not. This function checks if the boxes are rectangular or not.
+
+ Args:
+ boxes: a tensor containing the coordinates of the bounding boxes to be extracted. The tensor must have the shape
+ of Bx4x2, where each box is defined in the following ``clockwise`` order: top-left, top-right, bottom-right,
+ bottom-left. The coordinates must be in the x, y order.
+ """
+ if not (len(boxes.shape) == 3 and boxes.shape[1:] == torch.Size([4, 2])):
+ raise AssertionError(f"Box shape must be (B, 4, 2). Got {boxes.shape}.")
+
+ if not torch.allclose((boxes[:, 1, 0] - boxes[:, 0, 0] + 1), (boxes[:, 2, 0] - boxes[:, 3, 0] + 1)):
+ raise ValueError(
+ "Boxes must have be rectangular, while get widths %s and %s"
+ % (str(boxes[:, 1, 0] - boxes[:, 0, 0] + 1), str(boxes[:, 2, 0] - boxes[:, 3, 0] + 1))
+ )
+
+ if not torch.allclose((boxes[:, 2, 1] - boxes[:, 0, 1] + 1), (boxes[:, 3, 1] - boxes[:, 1, 1] + 1)):
+ raise ValueError(
+ "Boxes must have be rectangular, while get heights %s and %s"
+ % (str(boxes[:, 2, 1] - boxes[:, 0, 1] + 1), str(boxes[:, 3, 1] - boxes[:, 1, 1] + 1))
+ )
+
+ return True
+
+
+@torch.jit.ignore
+def validate_bbox3d(boxes: torch.Tensor) -> bool:
+ """Validate if a 3D bounding box usable or not. This function checks if the boxes are cube or not.
+
+ Args:
+ boxes: a tensor containing the coordinates of the bounding boxes to be extracted. The tensor must have the shape
+ of Bx8x3, where each box is defined in the following ``clockwise`` order: front-top-left, front-top-right,
+ front-bottom-right, front-bottom-left, back-top-left, back-top-right, back-bottom-right, back-bottom-left.
+ The coordinates must be in the x, y, z order.
+ """
+ if not (len(boxes.shape) == 3 and boxes.shape[1:] == torch.Size([8, 3])):
+ raise AssertionError(f"Box shape must be (B, 8, 3). Got {boxes.shape}.")
+
+ left = torch.index_select(boxes, 1, torch.tensor([1, 2, 5, 6], device=boxes.device, dtype=torch.long))[:, :, 0]
+ right = torch.index_select(boxes, 1, torch.tensor([0, 3, 4, 7], device=boxes.device, dtype=torch.long))[:, :, 0]
+ widths = left - right + 1
+ if not torch.allclose(widths.permute(1, 0), widths[:, 0]):
+ raise AssertionError(f"Boxes must have be cube, while get different widths {widths}.")
+
+ bot = torch.index_select(boxes, 1, torch.tensor([2, 3, 6, 7], device=boxes.device, dtype=torch.long))[:, :, 1]
+ upper = torch.index_select(boxes, 1, torch.tensor([0, 1, 4, 5], device=boxes.device, dtype=torch.long))[:, :, 1]
+ heights = bot - upper + 1
+ if not torch.allclose(heights.permute(1, 0), heights[:, 0]):
+ raise AssertionError(f"Boxes must have be cube, while get different heights {heights}.")
+
+ depths = boxes[:, 4:, 2] - boxes[:, :4, 2] + 1
+ if not torch.allclose(depths.permute(1, 0), depths[:, 0]):
+ raise AssertionError(f"Boxes must have be cube, while get different depths {depths}.")
+
+ return True
+
+
+def infer_bbox_shape(boxes: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+ r"""Auto-infer the output sizes for the given 2D bounding boxes.
+
+ Args:
+ boxes: a tensor containing the coordinates of the bounding boxes to be extracted. The tensor must have the shape
+ of Bx4x2, where each box is defined in the following ``clockwise`` order: top-left, top-right, bottom-right,
+ bottom-left. The coordinates must be in the x, y order.
+
+ Returns:
+ - Bounding box heights, shape of :math:`(B,)`.
+ - Boundingbox widths, shape of :math:`(B,)`.
+
+ Example:
+ >>> boxes = torch.tensor([[
+ ... [1., 1.],
+ ... [2., 1.],
+ ... [2., 2.],
+ ... [1., 2.],
+ ... ], [
+ ... [1., 1.],
+ ... [3., 1.],
+ ... [3., 2.],
+ ... [1., 2.],
+ ... ]]) # 2x4x2
+ >>> infer_bbox_shape(boxes)
+ (tensor([2., 2.]), tensor([2., 3.]))
+ """
+ validate_bbox(boxes)
+ width: torch.Tensor = boxes[:, 1, 0] - boxes[:, 0, 0] + 1
+ height: torch.Tensor = boxes[:, 2, 1] - boxes[:, 0, 1] + 1
+ return height, width
+
+
+def infer_bbox_shape3d(boxes: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+ r"""Auto-infer the output sizes for the given 3D bounding boxes.
+
+ Args:
+ boxes: a tensor containing the coordinates of the bounding boxes to be extracted. The tensor must have the shape
+ of Bx8x3, where each box is defined in the following ``clockwise`` order: front-top-left, front-top-right,
+ front-bottom-right, front-bottom-left, back-top-left, back-top-right, back-bottom-right, back-bottom-left.
+ The coordinates must be in the x, y, z order.
+
+ Returns:
+ - Bounding box depths, shape of :math:`(B,)`.
+ - Bounding box heights, shape of :math:`(B,)`.
+ - Bounding box widths, shape of :math:`(B,)`.
+
+ Example:
+ >>> boxes = torch.tensor([[[ 0, 1, 2],
+ ... [10, 1, 2],
+ ... [10, 21, 2],
+ ... [ 0, 21, 2],
+ ... [ 0, 1, 32],
+ ... [10, 1, 32],
+ ... [10, 21, 32],
+ ... [ 0, 21, 32]],
+ ... [[ 3, 4, 5],
+ ... [43, 4, 5],
+ ... [43, 54, 5],
+ ... [ 3, 54, 5],
+ ... [ 3, 4, 65],
+ ... [43, 4, 65],
+ ... [43, 54, 65],
+ ... [ 3, 54, 65]]]) # 2x8x3
+ >>> infer_bbox_shape3d(boxes)
+ (tensor([31, 61]), tensor([21, 51]), tensor([11, 41]))
+ """
+ validate_bbox3d(boxes)
+
+ left = torch.index_select(boxes, 1, torch.tensor([1, 2, 5, 6], device=boxes.device, dtype=torch.long))[:, :, 0]
+ right = torch.index_select(boxes, 1, torch.tensor([0, 3, 4, 7], device=boxes.device, dtype=torch.long))[:, :, 0]
+ widths = (left - right + 1)[:, 0]
+
+ bot = torch.index_select(boxes, 1, torch.tensor([2, 3, 6, 7], device=boxes.device, dtype=torch.long))[:, :, 1]
+ upper = torch.index_select(boxes, 1, torch.tensor([0, 1, 4, 5], device=boxes.device, dtype=torch.long))[:, :, 1]
+ heights = (bot - upper + 1)[:, 0]
+
+ depths = (boxes[:, 4:, 2] - boxes[:, :4, 2] + 1)[:, 0]
+ return depths, heights, widths
+
+
+def bbox_to_mask(boxes: torch.Tensor, width: int, height: int) -> torch.Tensor:
+ """Convert 2D bounding boxes to masks. Covered area is 1. and the remaining is 0.
+
+ Args:
+ boxes: a tensor containing the coordinates of the bounding boxes to be extracted. The tensor must have the shape
+ of Bx4x2, where each box is defined in the following ``clockwise`` order: top-left, top-right, bottom-right
+ and bottom-left. The coordinates must be in the x, y order.
+ width: width of the masked image.
+ height: height of the masked image.
+
+ Returns:
+ the output mask tensor.
+
+ Note:
+ It is currently non-differentiable.
+
+ Examples:
+ >>> boxes = torch.tensor([[
+ ... [1., 1.],
+ ... [3., 1.],
+ ... [3., 2.],
+ ... [1., 2.],
+ ... ]]) # 1x4x2
+ >>> bbox_to_mask(boxes, 5, 5)
+ tensor([[[0., 0., 0., 0., 0.],
+ [0., 1., 1., 1., 0.],
+ [0., 1., 1., 1., 0.],
+ [0., 0., 0., 0., 0.],
+ [0., 0., 0., 0., 0.]]])
+ """
+ validate_bbox(boxes)
+ # zero padding the surroudings
+ mask = torch.zeros((len(boxes), height + 2, width + 2), dtype=torch.float, device=boxes.device)
+ # push all points one pixel off
+ # in order to zero-out the fully filled rows or columns
+ box_i = (boxes + 1).long()
+ # set all pixels within box to 1
+ for msk, bx in zip(mask, box_i):
+ msk[bx[0, 1]:bx[2, 1] + 1, bx[0, 0]:bx[1, 0] + 1] = 1.0
+ return mask[:, 1:-1, 1:-1]
+
+
+def bbox_to_mask3d(boxes: torch.Tensor, size: Tuple[int, int, int]) -> torch.Tensor:
+ """Convert 3D bounding boxes to masks. Covered area is 1. and the remaining is 0.
+
+ Args:
+ boxes: a tensor containing the coordinates of the bounding boxes to be extracted. The tensor must have the shape
+ of Bx8x3, where each box is defined in the following ``clockwise`` order: front-top-left, front-top-right,
+ front-bottom-right, front-bottom-left, back-top-left, back-top-right, back-bottom-right, back-bottom-left.
+ The coordinates must be in the x, y, z order.
+ size: depth, height and width of the masked image.
+
+ Returns:
+ the output mask tensor.
+
+ Examples:
+ >>> boxes = torch.tensor([[
+ ... [1., 1., 1.],
+ ... [2., 1., 1.],
+ ... [2., 2., 1.],
+ ... [1., 2., 1.],
+ ... [1., 1., 2.],
+ ... [2., 1., 2.],
+ ... [2., 2., 2.],
+ ... [1., 2., 2.],
+ ... ]]) # 1x8x3
+ >>> bbox_to_mask3d(boxes, (4, 5, 5))
+ tensor([[[[[0., 0., 0., 0., 0.],
+ [0., 0., 0., 0., 0.],
+ [0., 0., 0., 0., 0.],
+ [0., 0., 0., 0., 0.],
+ [0., 0., 0., 0., 0.]],
+
+ [[0., 0., 0., 0., 0.],
+ [0., 1., 1., 0., 0.],
+ [0., 1., 1., 0., 0.],
+ [0., 0., 0., 0., 0.],
+ [0., 0., 0., 0., 0.]],
+
+ [[0., 0., 0., 0., 0.],
+ [0., 1., 1., 0., 0.],
+ [0., 1., 1., 0., 0.],
+ [0., 0., 0., 0., 0.],
+ [0., 0., 0., 0., 0.]],
+
+ [[0., 0., 0., 0., 0.],
+ [0., 0., 0., 0., 0.],
+ [0., 0., 0., 0., 0.],
+ [0., 0., 0., 0., 0.],
+ [0., 0., 0., 0., 0.]]]]])
+ """
+ validate_bbox3d(boxes)
+ mask = torch.zeros((len(boxes), *size))
+
+ mask_out = []
+ # TODO: Looking for a vectorized way
+ for m, box in zip(mask, boxes):
+ m = m.index_fill(
+ 0,
+ torch.arange(box[0, 2].item(), box[4, 2].item() + 1, device=box.device, dtype=torch.long),
+ torch.tensor(1, device=box.device, dtype=box.dtype),
+ )
+ m = m.index_fill(
+ 1,
+ torch.arange(box[1, 1].item(), box[2, 1].item() + 1, device=box.device, dtype=torch.long),
+ torch.tensor(1, device=box.device, dtype=box.dtype),
+ )
+ m = m.index_fill(
+ 2,
+ torch.arange(box[0, 0].item(), box[1, 0].item() + 1, device=box.device, dtype=torch.long),
+ torch.tensor(1, device=box.device, dtype=box.dtype),
+ )
+ m = m.unsqueeze(dim=0)
+ m_out = torch.ones_like(m)
+ m_out = m_out * (m == 1).all(dim=2, keepdim=True).all(dim=1, keepdim=True)
+ m_out = m_out * (m == 1).all(dim=3, keepdim=True).all(dim=1, keepdim=True)
+ m_out = m_out * (m == 1).all(dim=2, keepdim=True).all(dim=3, keepdim=True)
+ mask_out.append(m_out)
+
+ return torch.stack(mask_out, dim=0).float()
+
+
+def bbox_generator(
+ x_start: torch.Tensor, y_start: torch.Tensor, width: torch.Tensor, height: torch.Tensor
+) -> torch.Tensor:
+ """Generate 2D bounding boxes according to the provided start coords, width and height.
+
+ Args:
+ x_start: a tensor containing the x coordinates of the bounding boxes to be extracted. Shape must be a scalar
+ tensor or :math:`(B,)`.
+ y_start: a tensor containing the y coordinates of the bounding boxes to be extracted. Shape must be a scalar
+ tensor or :math:`(B,)`.
+ width: widths of the masked image. Shape must be a scalar tensor or :math:`(B,)`.
+ height: heights of the masked image. Shape must be a scalar tensor or :math:`(B,)`.
+
+ Returns:
+ the bounding box tensor.
+
+ Examples:
+ >>> x_start = torch.tensor([0, 1])
+ >>> y_start = torch.tensor([1, 0])
+ >>> width = torch.tensor([5, 3])
+ >>> height = torch.tensor([7, 4])
+ >>> bbox_generator(x_start, y_start, width, height)
+ tensor([[[0, 1],
+ [4, 1],
+ [4, 7],
+ [0, 7]],
+
+ [[1, 0],
+ [3, 0],
+ [3, 3],
+ [1, 3]]])
+ """
+ if not (x_start.shape == y_start.shape and x_start.dim() in [0, 1]):
+ raise AssertionError(f"`x_start` and `y_start` must be a scalar or (B,). Got {x_start}, {y_start}.")
+ if not (width.shape == height.shape and width.dim() in [0, 1]):
+ raise AssertionError(f"`width` and `height` must be a scalar or (B,). Got {width}, {height}.")
+ if not x_start.dtype == y_start.dtype == width.dtype == height.dtype:
+ raise AssertionError(
+ "All tensors must be in the same dtype. Got "
+ f"`x_start`({x_start.dtype}), `y_start`({x_start.dtype}), `width`({width.dtype}), `height`({height.dtype})."
+ )
+ if not x_start.device == y_start.device == width.device == height.device:
+ raise AssertionError(
+ "All tensors must be in the same device. Got "
+ f"`x_start`({x_start.device}), `y_start`({x_start.device}), "
+ f"`width`({width.device}), `height`({height.device})."
+ )
+
+ bbox = torch.tensor([[[0, 0], [0, 0], [0, 0], [0, 0]]], device=x_start.device, dtype=x_start.dtype).repeat(
+ 1 if x_start.dim() == 0 else len(x_start), 1, 1
+ )
+
+ bbox[:, :, 0] += x_start.view(-1, 1)
+ bbox[:, :, 1] += y_start.view(-1, 1)
+ bbox[:, 1, 0] += width - 1
+ bbox[:, 2, 0] += width - 1
+ bbox[:, 2, 1] += height - 1
+ bbox[:, 3, 1] += height - 1
+
+ return bbox
+
+
+def bbox_generator3d(
+ x_start: torch.Tensor,
+ y_start: torch.Tensor,
+ z_start: torch.Tensor,
+ width: torch.Tensor,
+ height: torch.Tensor,
+ depth: torch.Tensor,
+) -> torch.Tensor:
+ """Generate 3D bounding boxes according to the provided start coords, width, height and depth.
+
+ Args:
+ x_start: a tensor containing the x coordinates of the bounding boxes to be extracted. Shape must be a scalar
+ tensor or :math:`(B,)`.
+ y_start: a tensor containing the y coordinates of the bounding boxes to be extracted. Shape must be a scalar
+ tensor or :math:`(B,)`.
+ z_start: a tensor containing the z coordinates of the bounding boxes to be extracted. Shape must be a scalar
+ tensor or :math:`(B,)`.
+ width: widths of the masked image. Shape must be a scalar tensor or :math:`(B,)`.
+ height: heights of the masked image. Shape must be a scalar tensor or :math:`(B,)`.
+ depth: depths of the masked image. Shape must be a scalar tensor or :math:`(B,)`.
+
+ Returns:
+ the 3d bounding box tensor :math:`(B, 8, 3)`.
+
+ Examples:
+ >>> x_start = torch.tensor([0, 3])
+ >>> y_start = torch.tensor([1, 4])
+ >>> z_start = torch.tensor([2, 5])
+ >>> width = torch.tensor([10, 40])
+ >>> height = torch.tensor([20, 50])
+ >>> depth = torch.tensor([30, 60])
+ >>> bbox_generator3d(x_start, y_start, z_start, width, height, depth)
+ tensor([[[ 0, 1, 2],
+ [10, 1, 2],
+ [10, 21, 2],
+ [ 0, 21, 2],
+ [ 0, 1, 32],
+ [10, 1, 32],
+ [10, 21, 32],
+ [ 0, 21, 32]],
+
+ [[ 3, 4, 5],
+ [43, 4, 5],
+ [43, 54, 5],
+ [ 3, 54, 5],
+ [ 3, 4, 65],
+ [43, 4, 65],
+ [43, 54, 65],
+ [ 3, 54, 65]]])
+ """
+ if not (x_start.shape == y_start.shape == z_start.shape and x_start.dim() in [0, 1]):
+ raise AssertionError(
+ f"`x_start`, `y_start` and `z_start` must be a scalar or (B,). Got {x_start}, {y_start}, {z_start}."
+ )
+ if not (width.shape == height.shape == depth.shape and width.dim() in [0, 1]):
+ raise AssertionError(f"`width`, `height` and `depth` must be a scalar or (B,). Got {width}, {height}, {depth}.")
+ if not x_start.dtype == y_start.dtype == z_start.dtype == width.dtype == height.dtype == depth.dtype:
+ raise AssertionError(
+ "All tensors must be in the same dtype. "
+ f"Got `x_start`({x_start.dtype}), `y_start`({x_start.dtype}), `z_start`({x_start.dtype}), "
+ f"`width`({width.dtype}), `height`({height.dtype}) and `depth`({depth.dtype})."
+ )
+ if not x_start.device == y_start.device == z_start.device == width.device == height.device == depth.device:
+ raise AssertionError(
+ "All tensors must be in the same device. "
+ f"Got `x_start`({x_start.device}), `y_start`({x_start.device}), `z_start`({x_start.device}), "
+ f"`width`({width.device}), `height`({height.device}) and `depth`({depth.device})."
+ )
+
+ # front
+ bbox = torch.tensor(
+ [[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]], device=x_start.device, dtype=x_start.dtype
+ ).repeat(len(x_start), 1, 1)
+
+ bbox[:, :, 0] += x_start.view(-1, 1)
+ bbox[:, :, 1] += y_start.view(-1, 1)
+ bbox[:, :, 2] += z_start.view(-1, 1)
+ bbox[:, 1, 0] += width
+ bbox[:, 2, 0] += width
+ bbox[:, 2, 1] += height
+ bbox[:, 3, 1] += height
+
+ # back
+ bbox_back = bbox.clone()
+ bbox_back[:, :, -1] += depth.unsqueeze(dim=1).repeat(1, 4)
+ bbox = torch.cat([bbox, bbox_back], dim=1)
+
+ return bbox
+
+
+def transform_bbox(trans_mat: torch.Tensor, boxes: torch.Tensor, mode: str = "xyxy") -> torch.Tensor:
+ r"""Function that applies a transformation matrix to a box or batch of boxes. Boxes must
+ be a tensor of the shape (N, 4) or a batch of boxes (B, N, 4) and trans_mat must be a (3, 3)
+ transformation matrix or a batch of transformation matrices (B, 3, 3)
+
+ Args:
+ trans_mat: The transformation matrix to be applied
+ boxes: The boxes to be transformed
+ mode: The format in which the boxes are provided. If set to 'xyxy' the boxes are assumed to be in the format
+ ``xmin, ymin, xmax, ymax``. If set to 'xywh' the boxes are assumed to be in the format
+ ``xmin, ymin, width, height``
+ Returns:
+ The set of transformed points in the specified mode
+ """
+
+ if not isinstance(mode, str):
+ raise TypeError(f"Mode must be a string. Got {type(mode)}")
+
+ if mode not in ("xyxy", "xywh"):
+ raise ValueError(f"Mode must be one of 'xyxy', 'xywh'. Got {mode}")
+
+ # convert boxes to format xyxy
+ if mode == "xywh":
+ boxes[..., -2] = boxes[..., 0] + boxes[..., -2] # x + w
+ boxes[..., -1] = boxes[..., 1] + boxes[..., -1] # y + h
+
+ transformed_boxes: torch.Tensor = transform_points(trans_mat, boxes.view(boxes.shape[0], -1, 2))
+ transformed_boxes = transformed_boxes.view_as(boxes)
+
+ if mode == 'xywh':
+ transformed_boxes[..., 2] = transformed_boxes[..., 2] - transformed_boxes[..., 0]
+ transformed_boxes[..., 3] = transformed_boxes[..., 3] - transformed_boxes[..., 1]
+
+ return transformed_boxes
diff --git a/kornia/geometry/calibration/__init__.py b/kornia/geometry/calibration/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..d62ef7e52f8a8f3897ceb4563a53d61b7f2db269
--- /dev/null
+++ b/kornia/geometry/calibration/__init__.py
@@ -0,0 +1,11 @@
+from .distort import distort_points, tilt_projection
+from .pnp import solve_pnp_dlt
+from .undistort import undistort_image, undistort_points
+
+__all__ = [
+ "undistort_points",
+ "undistort_image",
+ "tilt_projection",
+ "distort_points",
+ "solve_pnp_dlt",
+]
diff --git a/kornia/geometry/calibration/distort.py b/kornia/geometry/calibration/distort.py
new file mode 100644
index 0000000000000000000000000000000000000000..4b01933bc43a8a1d70b181fae56775e97f1f0d99
--- /dev/null
+++ b/kornia/geometry/calibration/distort.py
@@ -0,0 +1,137 @@
+import torch
+
+
+# Based on https://github.com/opencv/opencv/blob/master/modules/calib3d/src/distortion_model.hpp#L75
+def tilt_projection(taux: torch.Tensor, tauy: torch.Tensor, return_inverse: bool = False) -> torch.Tensor:
+ r"""Estimate the tilt projection matrix or the inverse tilt projection matrix.
+
+ Args:
+ taux: Rotation angle in radians around the :math:`x`-axis with shape :math:`(*, 1)`.
+ tauy: Rotation angle in radians around the :math:`y`-axis with shape :math:`(*, 1)`.
+ return_inverse: False to obtain the the tilt projection matrix. True for the inverse matrix.
+
+ Returns:
+ torch.Tensor: Inverse tilt projection matrix with shape :math:`(*, 3, 3)`.
+ """
+ if taux.shape != tauy.shape:
+ raise ValueError(f'Shape of taux {taux.shape} and tauy {tauy.shape} do not match.')
+
+ ndim: int = taux.dim()
+ taux = taux.reshape(-1)
+ tauy = tauy.reshape(-1)
+
+ cTx = torch.cos(taux)
+ sTx = torch.sin(taux)
+ cTy = torch.cos(tauy)
+ sTy = torch.sin(tauy)
+ zero = torch.zeros_like(cTx)
+ one = torch.ones_like(cTx)
+
+ Rx = torch.stack([one, zero, zero, zero, cTx, sTx, zero, -sTx, cTx], -1).reshape(-1, 3, 3)
+ Ry = torch.stack([cTy, zero, -sTy, zero, one, zero, sTy, zero, cTy], -1).reshape(-1, 3, 3)
+ R = Ry @ Rx
+
+ if return_inverse:
+ invR22 = 1 / R[..., 2, 2]
+ invPz = torch.stack(
+ [invR22, zero, R[..., 0, 2] * invR22, zero, invR22, R[..., 1, 2] * invR22, zero, zero, one], -1
+ ).reshape(-1, 3, 3)
+
+ inv_tilt = R.transpose(-1, -2) @ invPz
+ if ndim == 0:
+ inv_tilt = torch.squeeze(inv_tilt)
+
+ return inv_tilt
+
+ Pz = torch.stack(
+ [R[..., 2, 2], zero, -R[..., 0, 2], zero, R[..., 2, 2], -R[..., 1, 2], zero, zero, one], -1
+ ).reshape(-1, 3, 3)
+
+ tilt = Pz @ R.transpose(-1, -2)
+ if ndim == 0:
+ tilt = torch.squeeze(tilt)
+
+ return tilt
+
+
+def distort_points(points: torch.Tensor, K: torch.Tensor, dist: torch.Tensor) -> torch.Tensor:
+ r"""Distortion of a set of 2D points based on the lens distortion model.
+
+ Radial :math:`(k_1, k_2, k_3, k_4, k_4, k_6)`,
+ tangential :math:`(p_1, p_2)`, thin prism :math:`(s_1, s_2, s_3, s_4)`, and tilt :math:`(\tau_x, \tau_y)`
+ distortion models are considered in this function.
+
+ Args:
+ points: Input image points with shape :math:`(*, N, 2)`.
+ K: Intrinsic camera matrix with shape :math:`(*, 3, 3)`.
+ dist: Distortion coefficients
+ :math:`(k_1,k_2,p_1,p_2[,k_3[,k_4,k_5,k_6[,s_1,s_2,s_3,s_4[,\tau_x,\tau_y]]]])`. This is
+ a vector with 4, 5, 8, 12 or 14 elements with shape :math:`(*, n)`.
+
+ Returns:
+ Undistorted 2D points with shape :math:`(*, N, 2)`.
+
+ Example:
+ >>> points = torch.rand(1, 1, 2)
+ >>> K = torch.eye(3)[None]
+ >>> dist_coeff = torch.rand(1, 4)
+ >>> points_dist = distort_points(points, K, dist_coeff)
+
+ """
+ if points.dim() < 2 and points.shape[-1] != 2:
+ raise ValueError(f'points shape is invalid. Got {points.shape}.')
+
+ if K.shape[-2:] != (3, 3):
+ raise ValueError(f'K matrix shape is invalid. Got {K.shape}.')
+
+ if dist.shape[-1] not in [4, 5, 8, 12, 14]:
+ raise ValueError(f'Invalid number of distortion coefficients. Got {dist.shape[-1]}')
+
+ # Adding zeros to obtain vector with 14 coeffs.
+ if dist.shape[-1] < 14:
+ dist = torch.nn.functional.pad(dist, [0, 14 - dist.shape[-1]])
+
+ # Convert 2D points from pixels to normalized camera coordinates
+ cx: torch.Tensor = K[..., 0:1, 2] # princial point in x (Bx1)
+ cy: torch.Tensor = K[..., 1:2, 2] # princial point in y (Bx1)
+ fx: torch.Tensor = K[..., 0:1, 0] # focal in x (Bx1)
+ fy: torch.Tensor = K[..., 1:2, 1] # focal in y (Bx1)
+ # This is equivalent to K^-1 [u,v,1]^T
+ x: torch.Tensor = (points[..., 0] - cx) / fx # (BxN - Bx1)/Bx1 -> BxN or (N,)
+ y: torch.Tensor = (points[..., 1] - cy) / fy # (BxN - Bx1)/Bx1 -> BxN or (N,)
+
+ # Distort points
+ r2 = x * x + y * y
+
+ rad_poly = (1 + dist[..., 0:1] * r2 + dist[..., 1:2] * r2 * r2 + dist[..., 4:5] * r2 ** 3) / (
+ 1 + dist[..., 5:6] * r2 + dist[..., 6:7] * r2 * r2 + dist[..., 7:8] * r2 ** 3
+ )
+ xd = (
+ x * rad_poly
+ + 2 * dist[..., 2:3] * x * y
+ + dist[..., 3:4] * (r2 + 2 * x * x)
+ + dist[..., 8:9] * r2
+ + dist[..., 9:10] * r2 * r2
+ )
+ yd = (
+ y * rad_poly
+ + dist[..., 2:3] * (r2 + 2 * y * y)
+ + 2 * dist[..., 3:4] * x * y
+ + dist[..., 10:11] * r2
+ + dist[..., 11:12] * r2 * r2
+ )
+
+ # Compensate for tilt distortion
+ if torch.any(dist[..., 12] != 0) or torch.any(dist[..., 13] != 0):
+ tilt = tilt_projection(dist[..., 12], dist[..., 13])
+
+ # Transposed untilt points (instead of [x,y,1]^T, we obtain [x,y,1])
+ points_untilt = torch.stack([xd, yd, torch.ones_like(xd)], -1) @ tilt.transpose(-2, -1)
+ xd = points_untilt[..., 0] / points_untilt[..., 2]
+ yd = points_untilt[..., 1] / points_untilt[..., 2]
+
+ # Convert points from normalized camera coordinates to pixel coordinates
+ x = fx * xd + cx
+ y = fy * yd + cy
+
+ return torch.stack([x, y], -1)
diff --git a/kornia/geometry/calibration/pnp.py b/kornia/geometry/calibration/pnp.py
new file mode 100644
index 0000000000000000000000000000000000000000..3ff27ea6876895236e003365a1a3090d1aea4b25
--- /dev/null
+++ b/kornia/geometry/calibration/pnp.py
@@ -0,0 +1,290 @@
+from typing import Optional, Tuple
+
+import torch
+
+from kornia.geometry.conversions import convert_points_to_homogeneous
+from kornia.geometry.linalg import transform_points
+from kornia.utils import eye_like
+from kornia.utils._compat import linalg_qr
+
+
+def _mean_isotropic_scale_normalize(
+ points: torch.Tensor, eps: float = 1e-8
+) -> Tuple[torch.Tensor, torch.Tensor]:
+ r"""Normalizes points.
+
+ Args:
+ points : Tensor containing the points to be normalized with shape :math:`(B, N, D)`.
+ eps : Small value to avoid division by zero error.
+
+ Returns:
+ Tuple containing the normalized points in the shape :math:`(B, N, D)` and the transformation matrix
+ in the shape :math:`(B, D+1, D+1)`.
+
+ """
+ if not isinstance(points, torch.Tensor):
+ raise AssertionError(f"points is not an instance of torch.Tensor. Type of points is {type(points)}")
+
+ if len(points.shape) != 3:
+ raise AssertionError(f"points must be of shape (B, N, D). Got shape {points.shape}.")
+
+ x_mean = torch.mean(points, dim=1, keepdim=True) # Bx1xD
+ scale = (points - x_mean).norm(dim=-1, p=2).mean(dim=-1) # B
+
+ D_int = points.shape[-1]
+ D_float = torch.tensor(points.shape[-1], dtype=torch.float64, device=points.device)
+ scale = torch.sqrt(D_float) / (scale + eps) # B
+ transform = eye_like(D_int + 1, points) # (B, D+1, D+1)
+
+ idxs = torch.arange(D_int, dtype=torch.int64, device=points.device)
+ transform[:, idxs, idxs] = transform[:, idxs, idxs] * scale[:, None]
+ transform[:, idxs, D_int] = transform[:, idxs, D_int] + (-scale[:, None] * x_mean[:, 0, idxs])
+
+ points_norm = transform_points(transform, points) # BxNxD
+
+ return (points_norm, transform)
+
+
+def solve_pnp_dlt(
+ world_points: torch.Tensor, img_points: torch.Tensor,
+ intrinsics: torch.Tensor, weights: Optional[torch.Tensor] = None,
+ svd_eps: float = 1e-4,
+) -> torch.Tensor:
+ r"""This function attempts to solve the Perspective-n-Point (PnP)
+ problem using Direct Linear Transform (DLT).
+
+ Given a batch (where batch size is :math:`B`) of :math:`N` 3D points
+ (where :math:`N \geq 6`) in the world space, a batch of :math:`N`
+ corresponding 2D points in the image space and a batch of
+ intrinsic matrices, this function tries to estimate a batch of
+ world to camera transformation matrices.
+
+ This implementation needs at least 6 points (i.e. :math:`N \geq 6`) to
+ provide solutions.
+
+ This function cannot be used if all the 3D world points (of any element
+ of the batch) lie on a line or if all the 3D world points (of any element
+ of the batch) lie on a plane. This function attempts to check for these
+ conditions and throws an AssertionError if found. Do note that this check
+ is sensitive to the value of the svd_eps parameter.
+
+ Another bad condition occurs when the camera and the points lie on a
+ twisted cubic. However, this function does not check for this condition.
+
+ Args:
+ world_points : A tensor with shape :math:`(B, N, 3)` representing
+ the points in the world space.
+ img_points : A tensor with shape :math:`(B, N, 2)` representing
+ the points in the image space.
+ intrinsics : A tensor with shape :math:`(B, 3, 3)` representing
+ the intrinsic matrices.
+ weights : This parameter is not used currently and is just a
+ placeholder for API consistency.
+ svd_eps : A small float value to avoid numerical precision issues.
+
+ Returns:
+ A tensor with shape :math:`(B, 3, 4)` representing the estimated world to
+ camera transformation matrices (also known as the extrinsic matrices).
+
+ Example:
+ >>> world_points = torch.tensor([[
+ ... [ 5. , -5. , 0. ], [ 0. , 0. , 1.5],
+ ... [ 2.5, 3. , 6. ], [ 9. , -2. , 3. ],
+ ... [-4. , 5. , 2. ], [-5. , 5. , 1. ],
+ ... ]], dtype=torch.float64)
+ >>>
+ >>> img_points = torch.tensor([[
+ ... [1409.1504, -800.936 ], [ 407.0207, -182.1229],
+ ... [ 392.7021, 177.9428], [1016.838 , -2.9416],
+ ... [ -63.1116, 142.9204], [-219.3874, 99.666 ],
+ ... ]], dtype=torch.float64)
+ >>>
+ >>> intrinsics = torch.tensor([[
+ ... [ 500., 0., 250.],
+ ... [ 0., 500., 250.],
+ ... [ 0., 0., 1.],
+ ... ]], dtype=torch.float64)
+ >>>
+ >>> print(world_points.shape, img_points.shape, intrinsics.shape)
+ torch.Size([1, 6, 3]) torch.Size([1, 6, 2]) torch.Size([1, 3, 3])
+ >>>
+ >>> pred_world_to_cam = kornia.geometry.solve_pnp_dlt(world_points, img_points, intrinsics)
+ >>>
+ >>> print(pred_world_to_cam.shape)
+ torch.Size([1, 3, 4])
+ >>>
+ >>> pred_world_to_cam
+ tensor([[[ 0.9392, -0.3432, -0.0130, 1.6734],
+ [ 0.3390, 0.9324, -0.1254, -4.3634],
+ [ 0.0552, 0.1134, 0.9920, 3.7785]]], dtype=torch.float64)
+ """
+ # This function was implemented based on ideas inspired from multiple references.
+ # ============
+ # References:
+ # ============
+ # 1. https://team.inria.fr/lagadic/camera_localization/tutorial-pose-dlt-opencv.html
+ # 2. https://github.com/opencv/opencv/blob/68d15fc62edad980f1ffa15ee478438335f39cc3/modules/calib3d/src/calibration.cpp # noqa: E501
+ # 3. http://rpg.ifi.uzh.ch/docs/teaching/2020/03_camera_calibration.pdf
+ # 4. http://www.cs.cmu.edu/~16385/s17/Slides/11.3_Pose_Estimation.pdf
+ # 5. https://www.ece.mcmaster.ca/~shirani/vision/hartley_ch7.pdf
+
+ if not isinstance(world_points, torch.Tensor):
+ raise AssertionError(
+ f"world_points is not an instance of torch.Tensor. Type of world_points is {type(world_points)}"
+ )
+
+ if not isinstance(img_points, torch.Tensor):
+ raise AssertionError(
+ f"img_points is not an instance of torch.Tensor. Type of img_points is {type(img_points)}"
+ )
+
+ if not isinstance(intrinsics, torch.Tensor):
+ raise AssertionError(
+ f"intrinsics is not an instance of torch.Tensor. Type of intrinsics is {type(intrinsics)}"
+ )
+
+ if (weights is not None) and (not isinstance(weights, torch.Tensor)):
+ raise AssertionError(
+ f"If weights is not None, then weights should be an instance "
+ f"of torch.Tensor. Type of weights is {type(weights)}"
+ )
+
+ if type(svd_eps) is not float:
+ raise AssertionError(f"Type of svd_eps is not float. Got {type(svd_eps)}")
+
+ accepted_dtypes = (torch.float32, torch.float64)
+
+ if world_points.dtype not in accepted_dtypes:
+ raise AssertionError(
+ f"world_points must have one of the following dtypes {accepted_dtypes}. "
+ f"Currently it has {world_points.dtype}."
+ )
+
+ if img_points.dtype not in accepted_dtypes:
+ raise AssertionError(
+ f"img_points must have one of the following dtypes {accepted_dtypes}. "
+ f"Currently it has {img_points.dtype}."
+ )
+
+ if intrinsics.dtype not in accepted_dtypes:
+ raise AssertionError(
+ f"intrinsics must have one of the following dtypes {accepted_dtypes}. "
+ f"Currently it has {intrinsics.dtype}."
+ )
+
+ if (len(world_points.shape) != 3) or (world_points.shape[2] != 3):
+ raise AssertionError(
+ f"world_points must be of shape (B, N, 3). Got shape {world_points.shape}."
+ )
+
+ if (len(img_points.shape) != 3) or (img_points.shape[2] != 2):
+ raise AssertionError(
+ f"img_points must be of shape (B, N, 2). Got shape {img_points.shape}."
+ )
+
+ if (len(intrinsics.shape) != 3) or (intrinsics.shape[1:] != (3, 3)):
+ raise AssertionError(
+ f"intrinsics must be of shape (B, 3, 3). Got shape {intrinsics.shape}."
+ )
+
+ if world_points.shape[1] != img_points.shape[1]:
+ raise AssertionError("world_points and img_points must have equal number of points.")
+
+ if (world_points.shape[0] != img_points.shape[0]) or (world_points.shape[0] != intrinsics.shape[0]):
+ raise AssertionError("world_points, img_points and intrinsics must have the same batch size.")
+
+ if world_points.shape[1] < 6:
+ raise AssertionError(
+ f"At least 6 points are required to use this function. "
+ f"Got {world_points.shape[1]} points."
+ )
+
+ B, N = world_points.shape[:2]
+
+ # Getting normalized world points.
+ world_points_norm, world_transform_norm = _mean_isotropic_scale_normalize(world_points)
+
+ # Checking if world_points_norm (of any element of the batch) has rank = 3. This
+ # function cannot be used if all world points (of any element of the batch) lie
+ # on a line or if all world points (of any element of the batch) lie on a plane.
+ _, s, _ = torch.svd(world_points_norm)
+ if torch.any(s[:, -1] < svd_eps):
+ raise AssertionError(
+ f"The last singular value of one/more of the elements of the batch is smaller "
+ f"than {svd_eps}. This function cannot be used if all world_points (of any "
+ f"element of the batch) lie on a line or if all world_points (of any "
+ f"element of the batch) lie on a plane."
+ )
+
+ intrinsics_inv = torch.inverse(intrinsics)
+ world_points_norm_h = convert_points_to_homogeneous(world_points_norm)
+
+ # Transforming img_points with intrinsics_inv to get img_points_inv
+ img_points_inv = transform_points(intrinsics_inv, img_points)
+
+ # Normalizing img_points_inv
+ img_points_norm, img_transform_norm = _mean_isotropic_scale_normalize(img_points_inv)
+ inv_img_transform_norm = torch.inverse(img_transform_norm)
+
+ # Setting up the system (the matrix A in Ax=0)
+ system = torch.zeros((B, 2 * N, 12), dtype=world_points.dtype, device=world_points.device)
+ system[:, 0::2, 0:4] = world_points_norm_h
+ system[:, 1::2, 4:8] = world_points_norm_h
+ system[:, 0::2, 8:12] = world_points_norm_h * (-1) * img_points_norm[..., 0:1]
+ system[:, 1::2, 8:12] = world_points_norm_h * (-1) * img_points_norm[..., 1:2]
+
+ # Getting the solution vectors.
+ _, _, v = torch.svd(system)
+ solution = v[..., -1]
+
+ # Reshaping the solution vectors to the correct shape.
+ solution = solution.reshape(B, 3, 4)
+
+ # Creating solution_4x4
+ solution_4x4 = eye_like(4, solution)
+ solution_4x4[:, :3, :] = solution
+
+ # De-normalizing the solution
+ intermediate = torch.bmm(solution_4x4, world_transform_norm)
+ solution = torch.bmm(inv_img_transform_norm, intermediate[:, :3, :])
+
+ # We obtained one solution for each element of the batch. We may
+ # need to multiply each solution with a scalar. This is because
+ # if x is a solution to Ax=0, then cx is also a solution. We can
+ # find the required scalars by using the properties of
+ # rotation matrices. We do this in two parts:
+
+ # First, we fix the sign by making sure that the determinant of
+ # the all the rotation matrices are non negative (since determinant
+ # of a rotation matrix should be 1).
+ det = torch.det(solution[:, :3, :3])
+ ones = torch.ones_like(det)
+ sign_fix = torch.where(det < 0, ones * -1, ones)
+ solution = solution * sign_fix[:, None, None]
+
+ # Then, we make sure that norm of the 0th columns of the rotation
+ # matrices are 1. Do note that the norm of any column of a rotation
+ # matrix should be 1. Here we use the 0th column to calculate norm_col.
+ # We then multiply solution with mul_factor.
+ norm_col = torch.norm(input=solution[:, :3, 0], p=2, dim=1)
+ mul_factor = (1 / norm_col)[:, None, None]
+ temp = solution * mul_factor
+
+ # To make sure that the rotation matrix would be orthogonal, we apply
+ # QR decomposition.
+ ortho, right = linalg_qr(temp[:, :3, :3])
+
+ # We may need to fix the signs of the columns of the ortho matrix.
+ # If right[i, j, j] is negative, then we need to flip the signs of
+ # the column ortho[i, :, j]. The below code performs the necessary
+ # operations in an better way.
+ mask = eye_like(3, ortho)
+ col_sign_fix = torch.sign(mask * right)
+ rot_mat = torch.bmm(ortho, col_sign_fix)
+
+ # Preparing the final output.
+ pred_world_to_cam = torch.cat([rot_mat, temp[:, :3, 3:4]], dim=-1)
+
+ # TODO: Implement algorithm to refine the solution.
+
+ return pred_world_to_cam
diff --git a/kornia/geometry/calibration/undistort.py b/kornia/geometry/calibration/undistort.py
new file mode 100644
index 0000000000000000000000000000000000000000..88063bdddf555a3761172dbc965029eec4f02090
--- /dev/null
+++ b/kornia/geometry/calibration/undistort.py
@@ -0,0 +1,152 @@
+import torch
+
+from kornia.geometry.linalg import transform_points
+from kornia.geometry.transform import remap
+from kornia.utils import create_meshgrid
+
+from .distort import distort_points, tilt_projection
+
+
+# Based on https://github.com/opencv/opencv/blob/master/modules/calib3d/src/undistort.dispatch.cpp#L384
+def undistort_points(points: torch.Tensor, K: torch.Tensor, dist: torch.Tensor) -> torch.Tensor:
+ r"""Compensate for lens distortion a set of 2D image points.
+
+ Radial :math:`(k_1, k_2, k_3, k_4, k_4, k_6)`,
+ tangential :math:`(p_1, p_2)`, thin prism :math:`(s_1, s_2, s_3, s_4)`, and tilt :math:`(\tau_x, \tau_y)`
+ distortion models are considered in this function.
+
+ Args:
+ points: Input image points with shape :math:`(*, N, 2)`.
+ K: Intrinsic camera matrix with shape :math:`(*, 3, 3)`.
+ dist: Distortion coefficients
+ :math:`(k_1,k_2,p_1,p_2[,k_3[,k_4,k_5,k_6[,s_1,s_2,s_3,s_4[,\tau_x,\tau_y]]]])`. This is
+ a vector with 4, 5, 8, 12 or 14 elements with shape :math:`(*, n)`.
+
+ Returns:
+ Undistorted 2D points with shape :math:`(*, N, 2)`.
+
+ Example:
+ >>> _ = torch.manual_seed(0)
+ >>> x = torch.rand(1, 4, 2)
+ >>> K = torch.eye(3)[None]
+ >>> dist = torch.rand(1, 4)
+ >>> undistort_points(x, K, dist)
+ tensor([[[-0.1513, -0.1165],
+ [ 0.0711, 0.1100],
+ [-0.0697, 0.0228],
+ [-0.1843, -0.1606]]])
+ """
+ if points.dim() < 2 and points.shape[-1] != 2:
+ raise ValueError(f'points shape is invalid. Got {points.shape}.')
+
+ if K.shape[-2:] != (3, 3):
+ raise ValueError(f'K matrix shape is invalid. Got {K.shape}.')
+
+ if dist.shape[-1] not in [4, 5, 8, 12, 14]:
+ raise ValueError(f"Invalid number of distortion coefficients. Got {dist.shape[-1]}")
+
+ # Adding zeros to obtain vector with 14 coeffs.
+ if dist.shape[-1] < 14:
+ dist = torch.nn.functional.pad(dist, [0, 14 - dist.shape[-1]])
+
+ # Convert 2D points from pixels to normalized camera coordinates
+ cx: torch.Tensor = K[..., 0:1, 2] # princial point in x (Bx1)
+ cy: torch.Tensor = K[..., 1:2, 2] # princial point in y (Bx1)
+ fx: torch.Tensor = K[..., 0:1, 0] # focal in x (Bx1)
+ fy: torch.Tensor = K[..., 1:2, 1] # focal in y (Bx1)
+ # This is equivalent to K^-1 [u,v,1]^T
+ x: torch.Tensor = (points[..., 0] - cx) / fx # (BxN - Bx1)/Bx1 -> BxN
+ y: torch.Tensor = (points[..., 1] - cy) / fy # (BxN - Bx1)/Bx1 -> BxN
+
+ # Compensate for tilt distortion
+ if torch.any(dist[..., 12] != 0) or torch.any(dist[..., 13] != 0):
+ inv_tilt = tilt_projection(dist[..., 12], dist[..., 13], True)
+
+ # Transposed untilt points (instead of [x,y,1]^T, we obtain [x,y,1])
+ x, y = transform_points(inv_tilt, torch.stack([x, y], dim=-1)).unbind(-1)
+
+ # Iteratively undistort points
+ x0, y0 = x, y
+ for _ in range(5):
+ r2 = x * x + y * y
+
+ inv_rad_poly = (1 + dist[..., 5:6] * r2 + dist[..., 6:7] * r2 * r2 + dist[..., 7:8] * r2 ** 3) / (
+ 1 + dist[..., 0:1] * r2 + dist[..., 1:2] * r2 * r2 + dist[..., 4:5] * r2 ** 3
+ )
+ deltaX = (
+ 2 * dist[..., 2:3] * x * y
+ + dist[..., 3:4] * (r2 + 2 * x * x)
+ + dist[..., 8:9] * r2
+ + dist[..., 9:10] * r2 * r2
+ )
+ deltaY = (
+ dist[..., 2:3] * (r2 + 2 * y * y)
+ + 2 * dist[..., 3:4] * x * y
+ + dist[..., 10:11] * r2
+ + dist[..., 11:12] * r2 * r2
+ )
+
+ x = (x0 - deltaX) * inv_rad_poly
+ y = (y0 - deltaY) * inv_rad_poly
+
+ # Convert points from normalized camera coordinates to pixel coordinates
+ x = fx * x + cx
+ y = fy * y + cy
+
+ return torch.stack([x, y], -1)
+
+
+# Based on https://github.com/opencv/opencv/blob/master/modules/calib3d/src/undistort.dispatch.cpp#L287
+def undistort_image(image: torch.Tensor, K: torch.Tensor, dist: torch.Tensor) -> torch.Tensor:
+ r"""Compensate an image for lens distortion.
+
+ Radial :math:`(k_1, k_2, k_3, k_4, k_4, k_6)`,
+ tangential :math:`(p_1, p_2)`, thin prism :math:`(s_1, s_2, s_3, s_4)`, and tilt :math:`(\tau_x, \tau_y)`
+ distortion models are considered in this function.
+
+ Args:
+ image: Input image with shape :math:`(*, C, H, W)`.
+ K: Intrinsic camera matrix with shape :math:`(*, 3, 3)`.
+ dist: Distortion coefficients
+ :math:`(k_1,k_2,p_1,p_2[,k_3[,k_4,k_5,k_6[,s_1,s_2,s_3,s_4[,\tau_x,\tau_y]]]])`. This is
+ a vector with 4, 5, 8, 12 or 14 elements with shape :math:`(*, n)`.
+
+ Returns:
+ Undistorted image with shape :math:`(*, C, H, W)`.
+
+ Example:
+ >>> img = torch.rand(1, 3, 5, 5)
+ >>> K = torch.eye(3)[None]
+ >>> dist_coeff = torch.rand(4)
+ >>> out = undistort_image(img, K, dist_coeff)
+ >>> out.shape
+ torch.Size([1, 3, 5, 5])
+
+ """
+ if len(image.shape) < 2:
+ raise ValueError(f"Image shape is invalid. Got: {image.shape}.")
+
+ if K.shape[-2:] != (3, 3):
+ raise ValueError(f'K matrix shape is invalid. Got {K.shape}.')
+
+ if dist.shape[-1] not in [4, 5, 8, 12, 14]:
+ raise ValueError(f'Invalid number of distortion coefficients. Got {dist.shape[-1]}.')
+
+ if not image.is_floating_point():
+ raise ValueError(f'Invalid input image data type. Input should be float. Got {image.dtype}.')
+
+ B, _, rows, cols = image.shape
+
+ # Create point coordinates for each pixel of the image
+ xy_grid: torch.Tensor = create_meshgrid(rows, cols, False, image.device, image.dtype)
+ pts = xy_grid.reshape(-1, 2) # (rows*cols)x2 matrix of pixel coordinates
+
+ # Distort points and define maps
+ ptsd: torch.Tensor = distort_points(pts, K, dist) # Bx(rows*cols)x2
+ mapx: torch.Tensor = ptsd[..., 0].reshape(B, rows, cols) # B x rows x cols, float
+ mapy: torch.Tensor = ptsd[..., 1].reshape(B, rows, cols) # B x rows x cols, float
+
+ # Remap image to undistort
+ out = remap(image, mapx, mapy, align_corners=True)
+
+ return out
diff --git a/kornia/geometry/camera/__init__.py b/kornia/geometry/camera/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5bc6495d58720421ada7591af222005886c7a5f4
--- /dev/null
+++ b/kornia/geometry/camera/__init__.py
@@ -0,0 +1,12 @@
+from .perspective import project_points, unproject_points
+from .pinhole import cam2pixel, PinholeCamera, pixel2cam
+from .stereo import StereoCamera
+
+__all__ = [
+ "PinholeCamera",
+ "StereoCamera",
+ "pixel2cam",
+ "cam2pixel",
+ "unproject_points",
+ "project_points"
+]
diff --git a/kornia/geometry/camera/perspective.py b/kornia/geometry/camera/perspective.py
new file mode 100644
index 0000000000000000000000000000000000000000..6e8c5a9056d96840bfca24274514bde5056ce1c8
--- /dev/null
+++ b/kornia/geometry/camera/perspective.py
@@ -0,0 +1,137 @@
+import torch
+import torch.nn.functional as F
+
+from kornia.geometry.conversions import convert_points_from_homogeneous, convert_points_to_homogeneous
+
+
+def project_points(point_3d: torch.Tensor, camera_matrix: torch.Tensor) -> torch.Tensor:
+ r"""Project a 3d point onto the 2d camera plane.
+
+ Args:
+ point3d: tensor containing the 3d points to be projected
+ to the camera plane. The shape of the tensor can be :math:`(*, 3)`.
+ camera_matrix: tensor containing the intrinsics camera
+ matrix. The tensor shape must be :math:`(*, 3, 3)`.
+
+ Returns:
+ tensor of (u, v) cam coordinates with shape :math:`(*, 2)`.
+
+ Example:
+ >>> _ = torch.manual_seed(0)
+ >>> X = torch.rand(1, 3)
+ >>> K = torch.eye(3)[None]
+ >>> project_points(X, K)
+ tensor([[5.6088, 8.6827]])
+ """
+ if not isinstance(point_3d, torch.Tensor):
+ raise TypeError(f"Input point_3d type is not a torch.Tensor. Got {type(point_3d)}")
+
+ if not isinstance(camera_matrix, torch.Tensor):
+ raise TypeError(f"Input camera_matrix type is not a torch.Tensor. Got {type(camera_matrix)}")
+
+ if not (point_3d.device == camera_matrix.device):
+ raise ValueError("Input tensors must be all in the same device.")
+
+ if not point_3d.shape[-1] == 3:
+ raise ValueError("Input points_3d must be in the shape of (*, 3)." " Got {}".format(point_3d.shape))
+
+ if not camera_matrix.shape[-2:] == (3, 3):
+ raise ValueError("Input camera_matrix must be in the shape of (*, 3, 3).")
+
+ # projection eq. [u, v, w]' = K * [x y z 1]'
+ # u = fx * X / Z + cx
+ # v = fy * Y / Z + cy
+
+ # project back using depth dividing in a safe way
+ xy_coords: torch.Tensor = convert_points_from_homogeneous(point_3d)
+ x_coord: torch.Tensor = xy_coords[..., 0]
+ y_coord: torch.Tensor = xy_coords[..., 1]
+
+ # unpack intrinsics
+ fx: torch.Tensor = camera_matrix[..., 0, 0]
+ fy: torch.Tensor = camera_matrix[..., 1, 1]
+ cx: torch.Tensor = camera_matrix[..., 0, 2]
+ cy: torch.Tensor = camera_matrix[..., 1, 2]
+
+ # apply intrinsics ans return
+ u_coord: torch.Tensor = x_coord * fx + cx
+ v_coord: torch.Tensor = y_coord * fy + cy
+
+ return torch.stack([u_coord, v_coord], dim=-1)
+
+
+def unproject_points(
+ point_2d: torch.Tensor, depth: torch.Tensor, camera_matrix: torch.Tensor, normalize: bool = False
+) -> torch.Tensor:
+ r"""Unproject a 2d point in 3d.
+
+ Transform coordinates in the pixel frame to the camera frame.
+
+ Args:
+ point2d: tensor containing the 2d to be projected to
+ world coordinates. The shape of the tensor can be :math:`(*, 2)`.
+ depth: tensor containing the depth value of each 2d
+ points. The tensor shape must be equal to point2d :math:`(*, 1)`.
+ camera_matrix: tensor containing the intrinsics camera
+ matrix. The tensor shape must be :math:`(*, 3, 3)`.
+ normalize: whether to normalize the pointcloud. This
+ must be set to `True` when the depth is represented as the Euclidean
+ ray length from the camera position.
+
+ Returns:
+ tensor of (x, y, z) world coordinates with shape :math:`(*, 3)`.
+
+ Example:
+ >>> _ = torch.manual_seed(0)
+ >>> x = torch.rand(1, 2)
+ >>> depth = torch.ones(1, 1)
+ >>> K = torch.eye(3)[None]
+ >>> unproject_points(x, depth, K)
+ tensor([[0.4963, 0.7682, 1.0000]])
+ """
+ if not isinstance(point_2d, torch.Tensor):
+ raise TypeError(f"Input point_2d type is not a torch.Tensor. Got {type(point_2d)}")
+
+ if not isinstance(depth, torch.Tensor):
+ raise TypeError(f"Input depth type is not a torch.Tensor. Got {type(depth)}")
+
+ if not isinstance(camera_matrix, torch.Tensor):
+ raise TypeError(f"Input camera_matrix type is not a torch.Tensor. Got {type(camera_matrix)}")
+
+ if not (point_2d.device == depth.device == camera_matrix.device):
+ raise ValueError("Input tensors must be all in the same device.")
+
+ if not point_2d.shape[-1] == 2:
+ raise ValueError("Input points_2d must be in the shape of (*, 2)." " Got {}".format(point_2d.shape))
+
+ if not depth.shape[-1] == 1:
+ raise ValueError("Input depth must be in the shape of (*, 1)." " Got {}".format(depth.shape))
+
+ if not camera_matrix.shape[-2:] == (3, 3):
+ raise ValueError("Input camera_matrix must be in the shape of (*, 3, 3).")
+
+ # projection eq. K_inv * [u v 1]'
+ # x = (u - cx) * Z / fx
+ # y = (v - cy) * Z / fy
+
+ # unpack coordinates
+ u_coord: torch.Tensor = point_2d[..., 0]
+ v_coord: torch.Tensor = point_2d[..., 1]
+
+ # unpack intrinsics
+ fx: torch.Tensor = camera_matrix[..., 0, 0]
+ fy: torch.Tensor = camera_matrix[..., 1, 1]
+ cx: torch.Tensor = camera_matrix[..., 0, 2]
+ cy: torch.Tensor = camera_matrix[..., 1, 2]
+
+ # projective
+ x_coord: torch.Tensor = (u_coord - cx) / fx
+ y_coord: torch.Tensor = (v_coord - cy) / fy
+
+ xyz: torch.Tensor = torch.stack([x_coord, y_coord], dim=-1)
+ xyz = convert_points_to_homogeneous(xyz)
+
+ if normalize:
+ xyz = F.normalize(xyz, dim=-1, p=2.0)
+
+ return xyz * depth
diff --git a/kornia/geometry/camera/pinhole.py b/kornia/geometry/camera/pinhole.py
new file mode 100644
index 0000000000000000000000000000000000000000..1913cbb2ece44f608de41251eabb4695be148dbb
--- /dev/null
+++ b/kornia/geometry/camera/pinhole.py
@@ -0,0 +1,669 @@
+from typing import Iterable, Optional
+
+import torch
+
+from kornia.geometry.linalg import inverse_transformation, transform_points
+
+
+class PinholeCamera:
+ r"""Class that represents a Pinhole Camera model.
+
+ Args:
+ intrinsics: tensor with shape :math:`(B, 4, 4)`
+ containing the full 4x4 camera calibration matrix.
+ extrinsics: tensor with shape :math:`(B, 4, 4)`
+ containing the full 4x4 rotation-translation matrix.
+ height: tensor with shape :math:`(B)` containing the image height.
+ width: tensor with shape :math:`(B)` containing the image width.
+
+ .. note::
+ We assume that the class attributes are in batch form in order to take
+ advantage of PyTorch parallelism to boost computing performance.
+ """
+
+ def __init__(
+ self, intrinsics: torch.Tensor, extrinsics: torch.Tensor, height: torch.Tensor, width: torch.Tensor
+ ) -> None:
+ # verify batch size and shapes
+ self._check_valid([intrinsics, extrinsics, height, width])
+ self._check_valid_params(intrinsics, "intrinsics")
+ self._check_valid_params(extrinsics, "extrinsics")
+ self._check_valid_shape(height, "height")
+ self._check_valid_shape(width, "width")
+ # set class attributes
+ self.height: torch.Tensor = height
+ self.width: torch.Tensor = width
+ self._intrinsics: torch.Tensor = intrinsics
+ self._extrinsics: torch.Tensor = extrinsics
+
+ @staticmethod
+ def _check_valid(data_iter: Iterable[torch.Tensor]) -> bool:
+ if not all(data.shape[0] for data in data_iter):
+ raise ValueError("Arguments shapes must match")
+ return True
+
+ @staticmethod
+ def _check_valid_params(data: torch.Tensor, data_name: str) -> bool:
+ if len(data.shape) not in (3, 4) and data.shape[-2:] != (4, 4): # Shouldn't this be an OR logic than AND?
+ raise ValueError(
+ "Argument {} shape must be in the following shape"
+ " Bx4x4 or BxNx4x4. Got {}".format(data_name, data.shape)
+ )
+ return True
+
+ @staticmethod
+ def _check_valid_shape(data: torch.Tensor, data_name: str) -> bool:
+ if not len(data.shape) == 1:
+ raise ValueError(
+ "Argument {} shape must be in the following shape" " B. Got {}".format(data_name, data.shape)
+ )
+ return True
+
+ @property
+ def intrinsics(self) -> torch.Tensor:
+ r"""The full 4x4 intrinsics matrix.
+
+ Returns:
+ tensor of shape :math:`(B, 4, 4)`.
+ """
+ if not self._check_valid_params(self._intrinsics, "intrinsics"):
+ raise AssertionError
+ return self._intrinsics
+
+ @property
+ def extrinsics(self) -> torch.Tensor:
+ r"""The full 4x4 extrinsics matrix.
+
+ Returns:
+ tensor of shape :math:`(B, 4, 4)`.
+ """
+ if not self._check_valid_params(self._extrinsics, "extrinsics"):
+ raise AssertionError
+ return self._extrinsics
+
+ @property
+ def batch_size(self) -> int:
+ r"""Return the batch size of the storage.
+
+ Returns:
+ scalar with the batch size.
+ """
+ return self.intrinsics.shape[0]
+
+ @property
+ def fx(self) -> torch.Tensor:
+ r"""Return the focal length in the x-direction.
+
+ Returns:
+ tensor of shape :math:`(B)`.
+ """
+ return self.intrinsics[..., 0, 0]
+
+ @property
+ def fy(self) -> torch.Tensor:
+ r"""Return the focal length in the y-direction.
+
+ Returns:
+ tensor of shape :math:`(B)`.
+ """
+ return self.intrinsics[..., 1, 1]
+
+ @property
+ def cx(self) -> torch.Tensor:
+ r"""Return the x-coordinate of the principal point.
+
+ Returns:
+ tensor of shape :math:`(B)`.
+ """
+ return self.intrinsics[..., 0, 2]
+
+ @property
+ def cy(self) -> torch.Tensor:
+ r"""Return the y-coordinate of the principal point.
+
+ Returns:
+ tensor of shape :math:`(B)`.
+ """
+ return self.intrinsics[..., 1, 2]
+
+ @property
+ def tx(self) -> torch.Tensor:
+ r"""Return the x-coordinate of the translation vector.
+
+ Returns:
+ tensor of shape :math:`(B)`.
+ """
+ return self.extrinsics[..., 0, -1]
+
+ @tx.setter
+ def tx(self, value) -> 'PinholeCamera':
+ r"""Set the x-coordinate of the translation vector with the given value."""
+ self.extrinsics[..., 0, -1] = value
+ return self
+
+ @property
+ def ty(self) -> torch.Tensor:
+ r"""Return the y-coordinate of the translation vector.
+
+ Returns:
+ tensor of shape :math:`(B)`.
+ """
+ return self.extrinsics[..., 1, -1]
+
+ @ty.setter
+ def ty(self, value) -> 'PinholeCamera':
+ r"""Set the y-coordinate of the translation vector with the given value."""
+ self.extrinsics[..., 1, -1] = value
+ return self
+
+ @property
+ def tz(self) -> torch.Tensor:
+ r"""Returns the z-coordinate of the translation vector.
+
+ Returns:
+ tensor of shape :math:`(B)`.
+ """
+ return self.extrinsics[..., 2, -1]
+
+ @tz.setter
+ def tz(self, value) -> 'PinholeCamera':
+ r"""Set the y-coordinate of the translation vector with the given value."""
+ self.extrinsics[..., 2, -1] = value
+ return self
+
+ @property
+ def rt_matrix(self) -> torch.Tensor:
+ r"""Return the 3x4 rotation-translation matrix.
+
+ Returns:
+ tensor of shape :math:`(B, 3, 4)`.
+ """
+ return self.extrinsics[..., :3, :4]
+
+ @property
+ def camera_matrix(self) -> torch.Tensor:
+ r"""Return the 3x3 camera matrix containing the intrinsics.
+
+ Returns:
+ tensor of shape :math:`(B, 3, 3)`.
+ """
+ return self.intrinsics[..., :3, :3]
+
+ @property
+ def rotation_matrix(self) -> torch.Tensor:
+ r"""Return the 3x3 rotation matrix from the extrinsics.
+
+ Returns:
+ tensor of shape :math:`(B, 3, 3)`.
+ """
+ return self.extrinsics[..., :3, :3]
+
+ @property
+ def translation_vector(self) -> torch.Tensor:
+ r"""Return the translation vector from the extrinsics.
+
+ Returns:
+ tensor of shape :math:`(B, 3, 1)`.
+ """
+ return self.extrinsics[..., :3, -1:]
+
+ def clone(self) -> 'PinholeCamera':
+ r"""Return a deep copy of the current object instance."""
+ height: torch.Tensor = self.height.clone()
+ width: torch.Tensor = self.width.clone()
+ intrinsics: torch.Tensor = self.intrinsics.clone()
+ extrinsics: torch.Tensor = self.extrinsics.clone()
+ return PinholeCamera(intrinsics, extrinsics, height, width)
+
+ def intrinsics_inverse(self) -> torch.Tensor:
+ r"""Return the inverse of the 4x4 instrisics matrix.
+
+ Returns:
+ tensor of shape :math:`(B, 4, 4)`.
+ """
+ return self.intrinsics.inverse()
+
+ def scale(self, scale_factor) -> 'PinholeCamera':
+ r"""Scale the pinhole model.
+
+ Args:
+ scale_factor: a tensor with the scale factor. It has
+ to be broadcastable with class members. The expected shape is
+ :math:`(B)` or :math:`(1)`.
+
+ Returns:
+ the camera model with scaled parameters.
+ """
+ # scale the intrinsic parameters
+ intrinsics: torch.Tensor = self.intrinsics.clone()
+ intrinsics[..., 0, 0] *= scale_factor
+ intrinsics[..., 1, 1] *= scale_factor
+ intrinsics[..., 0, 2] *= scale_factor
+ intrinsics[..., 1, 2] *= scale_factor
+ # scale the image height/width
+ height: torch.Tensor = scale_factor * self.height.clone()
+ width: torch.Tensor = scale_factor * self.width.clone()
+ return PinholeCamera(intrinsics, self.extrinsics, height, width)
+
+ def scale_(self, scale_factor) -> 'PinholeCamera':
+ r"""Scale the pinhole model in-place.
+
+ Args:
+ scale_factor: a tensor with the scale factor. It has
+ to be broadcastable with class members. The expected shape is
+ :math:`(B)` or :math:`(1)`.
+
+ Returns:
+ the camera model with scaled parameters.
+ """
+ # scale the intrinsic parameters
+ self.intrinsics[..., 0, 0] *= scale_factor
+ self.intrinsics[..., 1, 1] *= scale_factor
+ self.intrinsics[..., 0, 2] *= scale_factor
+ self.intrinsics[..., 1, 2] *= scale_factor
+ # scale the image height/width
+ self.height *= scale_factor
+ self.width *= scale_factor
+ return self
+
+ # NOTE: just for test. Decide if we keep it.
+ @classmethod
+ def from_parameters(
+ self,
+ fx,
+ fy,
+ cx,
+ cy,
+ height,
+ width,
+ tx,
+ ty,
+ tz,
+ batch_size=1,
+ device: Optional[torch.device] = None,
+ dtype: Optional[torch.dtype] = None,
+ ):
+ # create the camera matrix
+ intrinsics = torch.zeros(batch_size, 4, 4, device=device, dtype=dtype)
+ intrinsics[..., 0, 0] += fx
+ intrinsics[..., 1, 1] += fy
+ intrinsics[..., 0, 2] += cx
+ intrinsics[..., 1, 2] += cy
+ intrinsics[..., 2, 2] += 1.0
+ intrinsics[..., 3, 3] += 1.0
+ # create the pose matrix
+ extrinsics = torch.eye(4, device=device, dtype=dtype).repeat(batch_size, 1, 1)
+ extrinsics[..., 0, -1] += tx
+ extrinsics[..., 1, -1] += ty
+ extrinsics[..., 2, -1] += tz
+ # create image hegith and width
+ height_tmp = torch.zeros(batch_size, device=device, dtype=dtype)
+ height_tmp[..., 0] += height
+ width_tmp = torch.zeros(batch_size, device=device, dtype=dtype)
+ width_tmp[..., 0] += width
+ return self(intrinsics, extrinsics, height_tmp, width_tmp)
+
+
+class PinholeCamerasList(PinholeCamera):
+ r"""Class that represents a list of pinhole cameras.
+
+ The class inherits from :class:`~kornia.PinholeCamera` meaning that
+ it will keep the same class properties but with an extra dimension.
+
+ .. note::
+ The underlying data tensor will be stacked in the first dimension.
+ That's it, given a list of two camera instances, the intrinsics tensor
+ will have a shape :math:`(B, N, 4, 4)` where :math:`B` is the batch
+ size and :math:`N` is the numbers of cameras (in this case two).
+
+ Args:
+ pinholes_list: a python tuple or list containing a set of `PinholeCamera` instances.
+ """
+
+ def __init__(self, pinholes_list: Iterable[PinholeCamera]) -> None:
+ self._initialize_parameters(pinholes_list)
+
+ def _initialize_parameters(self, pinholes: Iterable[PinholeCamera]) -> 'PinholeCamerasList':
+ r"""Initialise the class attributes given a cameras list."""
+ if not isinstance(pinholes, (list, tuple)):
+ raise TypeError(f"pinhole must of type list or tuple. Got {type(pinholes)}")
+ height, width = [], []
+ intrinsics, extrinsics = [], []
+ for pinhole in pinholes:
+ if not isinstance(pinhole, PinholeCamera):
+ raise TypeError("Argument pinhole must be from type " "PinholeCamera. Got {}".format(type(pinhole)))
+ height.append(pinhole.height)
+ width.append(pinhole.width)
+ intrinsics.append(pinhole.intrinsics)
+ extrinsics.append(pinhole.extrinsics)
+ # contatenate and set members. We will assume BxNx4x4
+ self.height: torch.Tensor = torch.stack(height, dim=1)
+ self.width: torch.Tensor = torch.stack(width, dim=1)
+ self._intrinsics: torch.Tensor = torch.stack(intrinsics, dim=1)
+ self._extrinsics: torch.Tensor = torch.stack(extrinsics, dim=1)
+ return self
+
+ @property
+ def num_cameras(self) -> int:
+ r"""Return the number of pinholes cameras per batch."""
+ num_cameras: int = -1
+ if self.intrinsics is not None:
+ num_cameras = int(self.intrinsics.shape[1])
+ return num_cameras
+
+ def get_pinhole(self, idx: int) -> PinholeCamera:
+ r"""Return a PinholeCamera object with parameters such as Bx4x4."""
+ height: torch.Tensor = self.height[..., idx]
+ width: torch.Tensor = self.width[..., idx]
+ intrinsics: torch.Tensor = self.intrinsics[:, idx]
+ extrinsics: torch.Tensor = self.extrinsics[:, idx]
+ return PinholeCamera(intrinsics, extrinsics, height, width)
+
+
+def pinhole_matrix(pinholes: torch.Tensor, eps: float = 1e-6) -> torch.Tensor:
+ r"""Function that returns the pinhole matrix from a pinhole model
+
+ .. note::
+ This method is going to be deprecated in version 0.2 in favour of
+ :attr:`kornia.PinholeCamera.camera_matrix`.
+
+ Args:
+ pinholes: tensor of pinhole models.
+
+ Returns:
+ tensor of pinhole matrices.
+
+ Shape:
+ - Input: :math:`(N, 12)`
+ - Output: :math:`(N, 4, 4)`
+
+ Example:
+ >>> rng = torch.manual_seed(0)
+ >>> pinhole = torch.rand(1, 12) # Nx12
+ >>> pinhole_matrix(pinhole) # Nx4x4
+ tensor([[[4.9626e-01, 1.0000e-06, 8.8477e-02, 1.0000e-06],
+ [1.0000e-06, 7.6822e-01, 1.3203e-01, 1.0000e-06],
+ [1.0000e-06, 1.0000e-06, 1.0000e+00, 1.0000e-06],
+ [1.0000e-06, 1.0000e-06, 1.0000e-06, 1.0000e+00]]])
+ """
+ # warnings.warn("pinhole_matrix will be deprecated in version 0.2, "
+ # "use PinholeCamera.camera_matrix instead",
+ # PendingDeprecationWarning)
+ if not (len(pinholes.shape) == 2 and pinholes.shape[1] == 12):
+ raise AssertionError(pinholes.shape)
+ # unpack pinhole values
+ fx, fy, cx, cy = torch.chunk(pinholes[..., :4], 4, dim=1) # Nx1
+ # create output container
+ k = torch.eye(4, device=pinholes.device, dtype=pinholes.dtype) + eps
+ k = k.view(1, 4, 4).repeat(pinholes.shape[0], 1, 1) # Nx4x4
+ # fill output with pinhole values
+ k[..., 0, 0:1] = fx
+ k[..., 0, 2:3] = cx
+ k[..., 1, 1:2] = fy
+ k[..., 1, 2:3] = cy
+ return k
+
+
+def inverse_pinhole_matrix(pinhole: torch.Tensor, eps: float = 1e-6) -> torch.Tensor:
+ r"""Return the inverted pinhole matrix from a pinhole model
+
+ .. note::
+ This method is going to be deprecated in version 0.2 in favour of
+ :attr:`kornia.PinholeCamera.intrinsics_inverse()`.
+
+ Args:
+ pinholes: tensor with pinhole models.
+
+ Returns:
+ tensor of inverted pinhole matrices.
+
+ Shape:
+ - Input: :math:`(N, 12)`
+ - Output: :math:`(N, 4, 4)`
+
+ Example:
+ >>> rng = torch.manual_seed(0)
+ >>> pinhole = torch.rand(1, 12) # Nx12
+ >>> inverse_pinhole_matrix(pinhole) # Nx4x4
+ tensor([[[ 2.0151, 0.0000, -0.1783, 0.0000],
+ [ 0.0000, 1.3017, -0.1719, 0.0000],
+ [ 0.0000, 0.0000, 1.0000, 0.0000],
+ [ 0.0000, 0.0000, 0.0000, 1.0000]]])
+ """
+ # warnings.warn("inverse_pinhole_matrix will be deprecated in version 0.2, "
+ # "use PinholeCamera.intrinsics_inverse() instead",
+ # PendingDeprecationWarning)
+ if not (len(pinhole.shape) == 2 and pinhole.shape[1] == 12):
+ raise AssertionError(pinhole.shape)
+ # unpack pinhole values
+ fx, fy, cx, cy = torch.chunk(pinhole[..., :4], 4, dim=1) # Nx1
+ # create output container
+ k = torch.eye(4, device=pinhole.device, dtype=pinhole.dtype)
+ k = k.view(1, 4, 4).repeat(pinhole.shape[0], 1, 1) # Nx4x4
+ # fill output with inverse values
+ k[..., 0, 0:1] = 1.0 / (fx + eps)
+ k[..., 1, 1:2] = 1.0 / (fy + eps)
+ k[..., 0, 2:3] = -1.0 * cx / (fx + eps)
+ k[..., 1, 2:3] = -1.0 * cy / (fy + eps)
+ return k
+
+
+def scale_pinhole(pinholes: torch.Tensor, scale: torch.Tensor) -> torch.Tensor:
+ r"""Scale the pinhole matrix for each pinhole model.
+
+ .. note::
+ This method is going to be deprecated in version 0.2 in favour of
+ :attr:`kornia.PinholeCamera.scale()`.
+
+ Args:
+ pinholes: tensor with the pinhole model.
+ scale: tensor of scales.
+
+ Returns:
+ tensor of scaled pinholes.
+
+ Shape:
+ - Input: :math:`(N, 12)` and :math:`(N, 1)`
+ - Output: :math:`(N, 12)`
+
+ Example:
+ >>> rng = torch.manual_seed(0)
+ >>> pinhole_i = torch.rand(1, 12) # Nx12
+ >>> scales = 2.0 * torch.ones(1) # N
+ >>> scale_pinhole(pinhole_i, scales) # Nx12
+ tensor([[0.9925, 1.5364, 0.1770, 0.2641, 0.6148, 1.2682, 0.4901, 0.8964, 0.4556,
+ 0.6323, 0.3489, 0.4017]])
+ """
+ # warnings.warn("scale_pinhole will be deprecated in version 0.2, "
+ # "use PinholeCamera.scale() instead",
+ # PendingDeprecationWarning)
+ if not (len(pinholes.shape) == 2 and pinholes.shape[1] == 12):
+ raise AssertionError(pinholes.shape)
+ if len(scale.shape) != 1:
+ raise AssertionError(scale.shape)
+ pinholes_scaled = pinholes.clone()
+ pinholes_scaled[..., :6] = pinholes[..., :6] * scale.unsqueeze(-1)
+ return pinholes_scaled
+
+
+def get_optical_pose_base(pinholes: torch.Tensor) -> torch.Tensor:
+ """Compute extrinsic transformation matrices for pinholes.
+
+ Args:
+ pinholes: tensor of form [fx fy cx cy h w rx ry rz tx ty tz]
+ of size (N, 12).
+
+ Returns:
+ tensor of extrinsic transformation matrices of size (N, 4, 4).
+ """
+ if not (len(pinholes.shape) == 2 and pinholes.shape[1] == 12):
+ raise AssertionError(pinholes.shape)
+ # TODO: where is rtvec_to_pose?
+ raise NotImplementedError
+ # TODO: We have rtvec_to_pose in torchgeometry
+ # https://github.com/whh14/torchgeometry/blob/master/torchgeometry/conversions.py#L240
+ # But it relies on angle_axis_to_rotation_matrix
+ # And since then, it was changed from returning Nx4x4 matrix to Nx3x3
+ # return rtvec_to_pose(optical_pose_parent) type: ignore
+
+
+def homography_i_H_ref(pinhole_i: torch.Tensor, pinhole_ref: torch.Tensor) -> torch.Tensor:
+ r"""Homography from reference to ith pinhole
+
+ .. note::
+ The pinhole model is represented in a single vector as follows:
+
+ .. math::
+ pinhole = (f_x, f_y, c_x, c_y, height, width,
+ r_x, r_y, r_z, t_x, t_y, t_z)
+
+ where:
+ :math:`(r_x, r_y, r_z)` is the rotation vector in angle-axis
+ convention.
+
+ :math:`(t_x, t_y, t_z)` is the translation vector.
+
+ .. math::
+
+ H_{ref}^{i} = K_{i} * T_{ref}^{i} * K_{ref}^{-1}
+
+ Args:
+ pinhole_i: tensor with pinhole model for ith frame.
+ pinhole_ref: tensor with pinhole model for reference frame.
+
+ Returns:
+ tensors that convert depth points (u, v, d) from pinhole_ref to pinhole_i.
+
+ Shape:
+ - Input: :math:`(N, 12)` and :math:`(N, 12)`
+ - Output: :math:`(N, 4, 4)`
+
+ Example:
+ pinhole_i = torch.rand(1, 12) # Nx12
+ pinhole_ref = torch.rand(1, 12) # Nx12
+ homography_i_H_ref(pinhole_i, pinhole_ref) # Nx4x4
+ """
+ # TODO: Add doctest once having `rtvec_to_pose`.
+ if not (len(pinhole_i.shape) == 2 and pinhole_i.shape[1] == 12):
+ raise AssertionError(pinhole_i.shape)
+ if pinhole_i.shape != pinhole_ref.shape:
+ raise AssertionError(pinhole_ref.shape)
+ i_pose_base = get_optical_pose_base(pinhole_i)
+ ref_pose_base = get_optical_pose_base(pinhole_ref)
+ i_pose_ref = torch.matmul(i_pose_base, inverse_transformation(ref_pose_base))
+ return torch.matmul(pinhole_matrix(pinhole_i), torch.matmul(i_pose_ref, inverse_pinhole_matrix(pinhole_ref)))
+
+
+# based on:
+# https://github.com/ClementPinard/SfmLearner-Pytorch/blob/master/inverse_warp.py#L26
+
+
+def pixel2cam(depth: torch.Tensor, intrinsics_inv: torch.Tensor, pixel_coords: torch.Tensor) -> torch.Tensor:
+ r"""Transform coordinates in the pixel frame to the camera frame.
+
+ Args:
+ depth: the source depth maps. Shape must be Bx1xHxW.
+ intrinsics_inv: the inverse intrinsics camera matrix. Shape must be Bx4x4.
+ pixel_coords: the grid with (u, v, 1) pixel coordinates. Shape must be BxHxWx3.
+
+ Returns:
+ tensor of shape BxHxWx3 with (x, y, z) cam coordinates.
+ """
+ if not len(depth.shape) == 4 and depth.shape[1] == 1:
+ raise ValueError("Input depth has to be in the shape of " "Bx1xHxW. Got {}".format(depth.shape))
+ if not len(intrinsics_inv.shape) == 3:
+ raise ValueError("Input intrinsics_inv has to be in the shape of " "Bx4x4. Got {}".format(intrinsics_inv.shape))
+ if not len(pixel_coords.shape) == 4 and pixel_coords.shape[3] == 3:
+ raise ValueError("Input pixel_coords has to be in the shape of " "BxHxWx3. Got {}".format(intrinsics_inv.shape))
+ cam_coords: torch.Tensor = transform_points(intrinsics_inv[:, None], pixel_coords)
+ return cam_coords * depth.permute(0, 2, 3, 1)
+
+
+# based on
+# https://github.com/ClementPinard/SfmLearner-Pytorch/blob/master/inverse_warp.py#L43
+
+
+def cam2pixel(cam_coords_src: torch.Tensor, dst_proj_src: torch.Tensor, eps: float = 1e-12) -> torch.Tensor:
+ r"""Transform coordinates in the camera frame to the pixel frame.
+
+ Args:
+ cam_coords: (x, y, z) coordinates defined in the first camera coordinates system. Shape must be BxHxWx3.
+ dst_proj_src: the projection matrix between the
+ reference and the non reference camera frame. Shape must be Bx4x4.
+ eps: small value to avoid division by zero error.
+
+ Returns:
+ tensor of shape BxHxWx2 with (u, v) pixel coordinates.
+ """
+ if not len(cam_coords_src.shape) == 4 and cam_coords_src.shape[3] == 3:
+ raise ValueError(
+ "Input cam_coords_src has to be in the shape of " "BxHxWx3. Got {}".format(cam_coords_src.shape)
+ )
+ if not len(dst_proj_src.shape) == 3 and dst_proj_src.shape[-2:] == (4, 4):
+ raise ValueError("Input dst_proj_src has to be in the shape of " "Bx4x4. Got {}".format(dst_proj_src.shape))
+ # apply projection matrix to points
+ point_coords: torch.Tensor = transform_points(dst_proj_src[:, None], cam_coords_src)
+ x_coord: torch.Tensor = point_coords[..., 0]
+ y_coord: torch.Tensor = point_coords[..., 1]
+ z_coord: torch.Tensor = point_coords[..., 2]
+
+ # compute pixel coordinates
+ u_coord: torch.Tensor = x_coord / (z_coord + eps)
+ v_coord: torch.Tensor = y_coord / (z_coord + eps)
+
+ # stack and return the coordinates, that's the actual flow
+ pixel_coords_dst: torch.Tensor = torch.stack([u_coord, v_coord], dim=-1)
+ return pixel_coords_dst # BxHxWx2
+
+
+# layer api
+'''class PinholeMatrix(nn.Module):
+ r"""Create an object that returns the pinhole matrix from a pinhole model
+
+ Args:
+ pinholes (Tensor): tensor of pinhole models.
+
+ Returns:
+ Tensor: tensor of pinhole matrices.
+
+ Shape:
+ - Input: :math:`(N, 12)`
+ - Output: :math:`(N, 4, 4)`
+
+ Example:
+ >>> pinhole = torch.rand(1, 12) # Nx12
+ >>> transform = PinholeMatrix()
+ >>> pinhole_matrix = transform(pinhole) # Nx4x4
+ """
+
+ def __init__(self):
+ super(PinholeMatrix, self).__init__()
+
+ def forward(self, input):
+ return pinhole_matrix(input)
+
+
+class InversePinholeMatrix(nn.Module):
+ r"""Return and object that inverts a pinhole matrix from a pinhole model
+
+ Args:
+ pinholes (Tensor): tensor with pinhole models.
+
+ Returns:
+ Tensor: tensor of inverted pinhole matrices.
+
+ Shape:
+ - Input: :math:`(N, 12)`
+ - Output: :math:`(N, 4, 4)`
+
+ Example:
+ >>> pinhole = torch.rand(1, 12) # Nx12
+ >>> transform = kornia.InversePinholeMatrix()
+ >>> pinhole_matrix_inv = transform(pinhole) # Nx4x4
+ """
+
+ def __init__(self):
+ super(InversePinholeMatrix, self).__init__()
+
+ def forward(self, input):
+ return inverse_pinhole_matrix(input)'''
diff --git a/kornia/geometry/camera/stereo.py b/kornia/geometry/camera/stereo.py
new file mode 100644
index 0000000000000000000000000000000000000000..0a4776b8e594f0338d1c267f3c5b3085bea2005d
--- /dev/null
+++ b/kornia/geometry/camera/stereo.py
@@ -0,0 +1,307 @@
+import torch
+
+from kornia.geometry.linalg import transform_points
+from kornia.utils.grid import create_meshgrid
+
+
+class StereoException(Exception):
+ def __init__(self, msg: str, *args, **kwargs):
+ r"""Custom exception for the :module:`~kornia.geometry.camera.stereo` module.
+
+ Adds a general helper module redirecting the user to the proper documentation site.
+
+ Args:
+ msg: Custom message to add to the general message.
+ *args:
+ **kwargs:
+ """
+ doc_help = (
+ "\n Please check documents here: "
+ "https://kornia.readthedocs.io/en/latest/geometry.camera.stereo.html for further information and examples."
+ )
+ final_msg = msg + doc_help
+ # type ignore because of mypy error:
+ # Too many arguments for "__init__" of "BaseException"
+ super().__init__(final_msg, *args, **kwargs) # type: ignore
+
+
+class StereoCamera:
+ def __init__(self, rectified_left_camera: torch.Tensor, rectified_right_camera: torch.Tensor):
+ r"""Class representing a horizontal stereo camera setup.
+
+ Args:
+ rectified_left_camera: The rectified left camera projection matrix
+ of shape :math:`(B, 3, 4)`
+ rectified_right_camera: The rectified right camera projection matrix
+ of shape :math:`(B, 3, 4)`
+ """
+ self._check_stereo_camera(rectified_left_camera, rectified_right_camera)
+ self.rectified_left_camera: torch.Tensor = rectified_left_camera
+ self.rectified_right_camera: torch.Tensor = rectified_right_camera
+
+ self.device: torch.device = self.rectified_left_camera.device
+ self.dtype: torch.dtype = self.rectified_left_camera.dtype
+
+ self._Q_matrix = self._init_Q_matrix()
+
+ @staticmethod
+ def _check_stereo_camera(rectified_left_camera: torch.Tensor, rectified_right_camera: torch.Tensor):
+ r"""Utility function to ensure user specified correct camera matrices.
+
+ Args:
+ rectified_left_camera: The rectified left camera projection matrix
+ of shape :math:`(B, 3, 4)`
+ rectified_right_camera: The rectified right camera projection matrix
+ of shape :math:`(B, 3, 4)`
+ """
+ # Ensure correct shapes
+ if len(rectified_left_camera.shape) != 3:
+ raise StereoException(
+ f"Expected 'rectified_left_camera' to have 3 dimensions. " f"Got {rectified_left_camera.shape}."
+ )
+
+ if len(rectified_right_camera.shape) != 3:
+ raise StereoException(
+ f"Expected 'rectified_right_camera' to have 3 dimension. " f"Got {rectified_right_camera.shape}."
+ )
+
+ if rectified_left_camera.shape[:1] == (3, 4):
+ raise StereoException(
+ f"Expected each 'rectified_left_camera' to be of shape (3, 4)."
+ f"Got {rectified_left_camera.shape[:1]}."
+ )
+
+ if rectified_right_camera.shape[:1] == (3, 4):
+ raise StereoException(
+ f"Expected each 'rectified_right_camera' to be of shape (3, 4)."
+ f"Got {rectified_right_camera.shape[:1]}."
+ )
+
+ # Ensure same devices for cameras.
+ if rectified_left_camera.device != rectified_right_camera.device:
+ raise StereoException(
+ f"Expected 'rectified_left_camera' and 'rectified_right_camera' "
+ f"to be on the same devices."
+ f"Got {rectified_left_camera.device} and {rectified_right_camera.device}."
+ )
+
+ # Ensure same dtypes for cameras.
+ if rectified_left_camera.dtype != rectified_right_camera.dtype:
+ raise StereoException(
+ f"Expected 'rectified_left_camera' and 'rectified_right_camera' to"
+ f"have same dtype."
+ f"Got {rectified_left_camera.dtype} and {rectified_right_camera.dtype}."
+ )
+
+ # Ensure all intrinsics parameters (fx, fy, cx, cy) are the same in both cameras.
+ if not torch.all(torch.eq(rectified_left_camera[..., :, :3], rectified_right_camera[..., :, :3])):
+ raise StereoException(
+ f"Expected 'left_rectified_camera' and 'rectified_right_camera' to have"
+ f"same parameters except for the last column."
+ f"Got {rectified_left_camera[..., :, :3]} and {rectified_right_camera[..., :, :3]}."
+ )
+
+ # Ensure that tx * fx is negative and exists.
+ tx_fx = rectified_right_camera[..., 0, 3]
+ if torch.all(torch.gt(tx_fx, 0)):
+ raise StereoException(f"Expected :math:`T_x * f_x` to be negative." f"Got {tx_fx}.")
+
+ @property
+ def batch_size(self) -> int:
+ r"""Return the batch size of the storage.
+
+ Returns:
+ scalar with the batch size
+ """
+ return self.rectified_left_camera.shape[0]
+
+ @property
+ def fx(self) -> torch.Tensor:
+ r"""Return the focal length in the x-direction.
+
+ Note that the focal lengths of the rectified left and right
+ camera are assumed to be equal.
+
+ Returns:
+ tensor of shape :math:`(B)`
+ """
+ return self.rectified_left_camera[..., 0, 0]
+
+ @property
+ def fy(self) -> torch.Tensor:
+ r"""Returns the focal length in the y-direction.
+
+ Note that the focal lengths of the rectified left and right
+ camera are assumed to be equal.
+
+ Returns:
+ tensor of shape :math:`(B)`
+ """
+ return self.rectified_left_camera[..., 1, 1]
+
+ @property
+ def cx_left(self) -> torch.Tensor:
+ r"""Return the x-coordinate of the principal point for the left camera.
+
+ Returns:
+ tensor of shape :math:`(B)`
+ """
+ return self.rectified_left_camera[..., 0, 2]
+
+ @property
+ def cx_right(self) -> torch.Tensor:
+ r"""Return the x-coordinate of the principal point for the right camera.
+
+ Returns:
+ tensor of shape :math:`(B)`
+ """
+ return self.rectified_right_camera[..., 0, 2]
+
+ @property
+ def cy(self) -> torch.Tensor:
+ r"""Return the y-coordinate of the principal point.
+
+ Note that the y-coordinate of the principal points
+ is assumed to be equal for the left and right camera.
+
+ Returns:
+ tensor of shape :math:`(B)`
+ """
+ return self.rectified_left_camera[..., 1, 2]
+
+ @property
+ def tx(self) -> torch.Tensor:
+ r"""The horizontal baseline between the two cameras.
+
+ Returns:
+ Tensor of shape :math:`(B)`
+
+ """
+ return -self.rectified_right_camera[..., 0, 3] / self.fx
+
+ @property
+ def Q(self) -> torch.Tensor:
+ r"""The Q matrix of the horizontal stereo setup.
+
+ This matrix is used for reprojecting a disparity tensor to
+ the corresponding point cloud. Note that this is in a general form that allows different focal
+ lengths in the x and y direction.
+
+ Return:
+ The Q matrix of shape :math:`(B, 4, 4)`.
+ """
+ return self._Q_matrix
+
+ def _init_Q_matrix(self) -> torch.Tensor:
+ r"""Initialized the Q matrix of the horizontal stereo setup. See the Q property.
+
+ Returns:
+ The Q matrix of shape :math:`(B, 4, 4)`.
+ """
+ Q = torch.zeros((self.batch_size, 4, 4), device=self.device, dtype=self.dtype)
+ baseline: torch.Tensor = -self.tx
+ Q[:, 0, 0] = self.fy * baseline
+ Q[:, 0, 3] = -self.fy * self.cx_left * baseline
+ Q[:, 1, 1] = self.fx * baseline
+ Q[:, 1, 3] = -self.fx * self.cy * baseline
+ Q[:, 2, 3] = self.fx * self.fy * baseline
+ Q[:, 3, 2] = -self.fy
+ Q[:, 3, 3] = self.fy * (self.cx_left - self.cx_right) # NOTE: This is usually zero.
+ return Q
+
+ def reproject_disparity_to_3D(self, disparity_tensor: torch.Tensor) -> torch.Tensor:
+ r"""Reproject the disparity tensor to a 3D point cloud.
+
+ Args:
+ disparity_tensor: Disparity tensor of shape :math:`(B, 1, H, W)`.
+
+ Returns:
+ The 3D point cloud of shape :math:`(B, H, W, 3)`
+ """
+ return reproject_disparity_to_3D(disparity_tensor, self.Q)
+
+
+def _check_disparity_tensor(disparity_tensor: torch.Tensor):
+ r"""Utility function to ensure correct user provided correct disparity tensor.
+
+ Args:
+ disparity_tensor: The disparity tensor of shape :math:`(B, 1, H, W)`.
+ """
+ if not isinstance(disparity_tensor, torch.Tensor):
+ raise StereoException(
+ f"Expected 'disparity_tensor' to be an instance of torch.Tensor but got {type(disparity_tensor)}."
+ )
+
+ if len(disparity_tensor.shape) != 4:
+ raise StereoException(f"Expected 'disparity_tensor' to have 4 dimensions." f"Got {disparity_tensor.shape}.")
+
+ if disparity_tensor.shape[-1] != 1:
+ raise StereoException(
+ f"Expected dimension 1 of 'disparity_tensor' to be 1 for as single channeled disparity map."
+ f"Got {disparity_tensor.shape}."
+ )
+
+ if disparity_tensor.dtype not in (torch.float16, torch.float32, torch.float64):
+ raise StereoException(
+ f"Expected 'disparity_tensor' to have dtype torch.float16, torch.float32 or torch.float64."
+ f"Got {disparity_tensor.dtype}"
+ )
+
+
+def _check_Q_matrix(Q_matrix: torch.Tensor):
+ r"""Utility function to ensure Q matrix is of correct form.
+
+ Args:
+ Q_matrix: The Q matrix for reprojecting disparity to a point cloud of shape :math:`(B, 4, 4)`
+ """
+
+ if not isinstance(Q_matrix, torch.Tensor):
+ raise StereoException(f"Expected 'Q_matrix' to be an instance of torch.Tensor but got {type(Q_matrix)}.")
+
+ if not len(Q_matrix.shape) == 3:
+ raise StereoException(f"Expected 'Q_matrix' to have 3 dimensions." f"Got {Q_matrix.shape}")
+
+ if not Q_matrix.shape[1:] == (4, 4):
+ raise StereoException(
+ f"Expected last two dimensions of 'Q_matrix' to be of shape (4, 4)." f"Got {Q_matrix.shape}"
+ )
+
+ if Q_matrix.dtype not in (torch.float16, torch.float32, torch.float64):
+ raise StereoException(
+ f"Expected 'Q_matrix' to be of type torch.float16, torch.float32 or torch.float64." f"Got {Q_matrix.dtype}"
+ )
+
+
+def reproject_disparity_to_3D(disparity_tensor: torch.Tensor, Q_matrix: torch.Tensor) -> torch.Tensor:
+ r"""Reproject the disparity tensor to a 3D point cloud.
+
+ Args:
+ disparity_tensor: Disparity tensor of shape :math:`(B, 1, H, W)`.
+ Q_matrix: Tensor of Q matrices of shapes :math:`(B, 4, 4)`.
+
+ Returns:
+ The 3D point cloud of shape :math:`(B, H, W, 3)`
+ """
+ _check_Q_matrix(Q_matrix)
+ _check_disparity_tensor(disparity_tensor)
+
+ batch_size, rows, cols, _ = disparity_tensor.shape
+ dtype = disparity_tensor.dtype
+ device = disparity_tensor.device
+
+ uv = create_meshgrid(rows, cols, normalized_coordinates=False, device=device, dtype=dtype)
+ uv = uv.expand(batch_size, -1, -1, -1)
+ v, u = torch.unbind(uv, dim=-1)
+ v, u = torch.unsqueeze(v, -1), torch.unsqueeze(u, -1)
+ uvd = torch.stack((u, v, disparity_tensor), 1).reshape(batch_size, 3, -1).permute(0, 2, 1)
+ points = transform_points(Q_matrix, uvd).reshape(batch_size, rows, cols, 3)
+
+ # Final check that everything went well.
+ if not points.shape == (batch_size, rows, cols, 3):
+ raise StereoException(
+ f"Something went wrong in `reproject_disparity_to_3D`. Expected the final output"
+ f"to be of shape {(batch_size, rows, cols, 3)}."
+ f"But the computed point cloud had shape {points.shape}. "
+ f"Please ensure input are correct. If this is an error, please submit an issue."
+ )
+ return points
diff --git a/kornia/geometry/conversions.py b/kornia/geometry/conversions.py
new file mode 100644
index 0000000000000000000000000000000000000000..820d1ac046b5fb4b37e013850cb05dcf1c9729c1
--- /dev/null
+++ b/kornia/geometry/conversions.py
@@ -0,0 +1,1002 @@
+import enum
+import warnings
+from typing import Tuple
+
+import torch
+import torch.nn.functional as F
+
+from kornia.constants import pi
+
+__all__ = [
+ "rad2deg",
+ "deg2rad",
+ "pol2cart",
+ "cart2pol",
+ "convert_points_from_homogeneous",
+ "convert_points_to_homogeneous",
+ "convert_affinematrix_to_homography",
+ "convert_affinematrix_to_homography3d",
+ "angle_axis_to_rotation_matrix",
+ "angle_axis_to_quaternion",
+ "rotation_matrix_to_angle_axis",
+ "rotation_matrix_to_quaternion",
+ "quaternion_to_angle_axis",
+ "quaternion_to_rotation_matrix",
+ "quaternion_log_to_exp",
+ "quaternion_exp_to_log",
+ "denormalize_pixel_coordinates",
+ "normalize_pixel_coordinates",
+ "normalize_quaternion",
+ "denormalize_pixel_coordinates3d",
+ "normalize_pixel_coordinates3d",
+ "angle_to_rotation_matrix",
+]
+
+
+class QuaternionCoeffOrder(enum.Enum):
+ XYZW = 'xyzw'
+ WXYZ = 'wxyz'
+
+
+def rad2deg(tensor: torch.Tensor) -> torch.Tensor:
+ r"""Function that converts angles from radians to degrees.
+
+ Args:
+ tensor: Tensor of arbitrary shape.
+
+ Returns:
+ Tensor with same shape as input.
+
+ Example:
+ >>> input = torch.tensor(3.1415926535)
+ >>> rad2deg(input)
+ tensor(180.)
+ """
+ if not isinstance(tensor, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(tensor)}")
+
+ return 180.0 * tensor / pi.to(tensor.device).type(tensor.dtype)
+
+
+def deg2rad(tensor: torch.Tensor) -> torch.Tensor:
+ r"""Function that converts angles from degrees to radians.
+
+ Args:
+ tensor: Tensor of arbitrary shape.
+
+ Returns:
+ tensor with same shape as input.
+
+ Examples:
+ >>> input = torch.tensor(180.)
+ >>> deg2rad(input)
+ tensor(3.1416)
+ """
+ if not isinstance(tensor, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(tensor)}")
+
+ return tensor * pi.to(tensor.device).type(tensor.dtype) / 180.0
+
+
+def pol2cart(rho: torch.Tensor, phi: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+ r"""Function that converts polar coordinates to cartesian coordinates.
+
+ Args:
+ rho: Tensor of arbitrary shape.
+ phi: Tensor of same arbitrary shape.
+
+ Returns:
+ Tensor with same shape as input.
+
+ Example:
+ >>> rho = torch.rand(1, 3, 3)
+ >>> phi = torch.rand(1, 3, 3)
+ >>> x, y = pol2cart(rho, phi)
+ """
+ if not (isinstance(rho, torch.Tensor) & isinstance(phi, torch.Tensor)):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(rho)}, {type(phi)}")
+
+ x = rho * torch.cos(phi)
+ y = rho * torch.sin(phi)
+ return x, y
+
+
+def cart2pol(x: torch.Tensor, y: torch.Tensor, eps: float = 1.0e-8) -> Tuple[torch.Tensor, torch.Tensor]:
+ """Function that converts cartesian coordinates to polar coordinates.
+
+ Args:
+ rho: Tensor of arbitrary shape.
+ phi: Tensor of same arbitrary shape.
+ eps: To avoid division by zero.
+
+ Returns:
+ Tensor with same shape as input.
+
+ Example:
+ >>> x = torch.rand(1, 3, 3)
+ >>> y = torch.rand(1, 3, 3)
+ >>> rho, phi = cart2pol(x, y)
+ """
+ if not (isinstance(x, torch.Tensor) & isinstance(y, torch.Tensor)):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(x)}, {type(y)}")
+
+ rho = torch.sqrt(x ** 2 + y ** 2 + eps)
+ phi = torch.atan2(y, x)
+ return rho, phi
+
+
+def convert_points_from_homogeneous(points: torch.Tensor, eps: float = 1e-8) -> torch.Tensor:
+ r"""Function that converts points from homogeneous to Euclidean space.
+
+ Args:
+ points: the points to be transformed of shape :math:`(B, N, D)`.
+ eps: to avoid division by zero.
+
+ Returns:
+ the points in Euclidean space :math:`(B, N, D-1)`.
+
+ Examples:
+ >>> input = torch.tensor([[0., 0., 1.]])
+ >>> convert_points_from_homogeneous(input)
+ tensor([[0., 0.]])
+ """
+ if not isinstance(points, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(points)}")
+
+ if len(points.shape) < 2:
+ raise ValueError(f"Input must be at least a 2D tensor. Got {points.shape}")
+
+ # we check for points at max_val
+ z_vec: torch.Tensor = points[..., -1:]
+
+ # set the results of division by zeror/near-zero to 1.0
+ # follow the convention of opencv:
+ # https://github.com/opencv/opencv/pull/14411/files
+ mask: torch.Tensor = torch.abs(z_vec) > eps
+ scale = torch.where(mask, 1.0 / (z_vec + eps), torch.ones_like(z_vec))
+
+ return scale * points[..., :-1]
+
+
+def convert_points_to_homogeneous(points: torch.Tensor) -> torch.Tensor:
+ r"""Function that converts points from Euclidean to homogeneous space.
+
+ Args:
+ points: the points to be transformed with shape :math:`(B, N, D)`.
+
+ Returns:
+ the points in homogeneous coordinates :math:`(B, N, D+1)`.
+
+ Examples:
+ >>> input = torch.tensor([[0., 0.]])
+ >>> convert_points_to_homogeneous(input)
+ tensor([[0., 0., 1.]])
+ """
+ if not isinstance(points, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(points)}")
+ if len(points.shape) < 2:
+ raise ValueError(f"Input must be at least a 2D tensor. Got {points.shape}")
+
+ return torch.nn.functional.pad(points, [0, 1], "constant", 1.0)
+
+
+def _convert_affinematrix_to_homography_impl(A: torch.Tensor) -> torch.Tensor:
+ H: torch.Tensor = torch.nn.functional.pad(A, [0, 0, 0, 1], "constant", value=0.0)
+ H[..., -1, -1] += 1.0
+ return H
+
+
+def convert_affinematrix_to_homography(A: torch.Tensor) -> torch.Tensor:
+ r"""Function that converts batch of affine matrices.
+
+ Args:
+ A: the affine matrix with shape :math:`(B,2,3)`.
+
+ Returns:
+ the homography matrix with shape of :math:`(B,3,3)`.
+
+ Examples:
+ >>> A = torch.tensor([[[1., 0., 0.],
+ ... [0., 1., 0.]]])
+ >>> convert_affinematrix_to_homography(A)
+ tensor([[[1., 0., 0.],
+ [0., 1., 0.],
+ [0., 0., 1.]]])
+ """
+ if not isinstance(A, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(A)}")
+
+ if not (len(A.shape) == 3 and A.shape[-2:] == (2, 3)):
+ raise ValueError(f"Input matrix must be a Bx2x3 tensor. Got {A.shape}")
+
+ return _convert_affinematrix_to_homography_impl(A)
+
+
+def convert_affinematrix_to_homography3d(A: torch.Tensor) -> torch.Tensor:
+ r"""Function that converts batch of 3d affine matrices.
+
+ Args:
+ A: the affine matrix with shape :math:`(B,3,4)`.
+
+ Returns:
+ the homography matrix with shape of :math:`(B,4,4)`.
+
+ Examples:
+ >>> A = torch.tensor([[[1., 0., 0., 0.],
+ ... [0., 1., 0., 0.],
+ ... [0., 0., 1., 0.]]])
+ >>> convert_affinematrix_to_homography3d(A)
+ tensor([[[1., 0., 0., 0.],
+ [0., 1., 0., 0.],
+ [0., 0., 1., 0.],
+ [0., 0., 0., 1.]]])
+ """
+ if not isinstance(A, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(A)}")
+
+ if not (len(A.shape) == 3 and A.shape[-2:] == (3, 4)):
+ raise ValueError(f"Input matrix must be a Bx3x4 tensor. Got {A.shape}")
+
+ return _convert_affinematrix_to_homography_impl(A)
+
+
+def angle_axis_to_rotation_matrix(angle_axis: torch.Tensor) -> torch.Tensor:
+ r"""Convert 3d vector of axis-angle rotation to 3x3 rotation matrix.
+
+ Args:
+ angle_axis: tensor of 3d vector of axis-angle rotations in radians with shape :math:`(N, 3)`.
+
+ Returns:
+ tensor of rotation matrices of shape :math:`(N, 3, 3)`.
+
+ Example:
+ >>> input = torch.tensor([[0., 0., 0.]])
+ >>> angle_axis_to_rotation_matrix(input)
+ tensor([[[1., 0., 0.],
+ [0., 1., 0.],
+ [0., 0., 1.]]])
+
+ >>> input = torch.tensor([[1.5708, 0., 0.]])
+ >>> angle_axis_to_rotation_matrix(input)
+ tensor([[[ 1.0000e+00, 0.0000e+00, 0.0000e+00],
+ [ 0.0000e+00, -3.6200e-06, -1.0000e+00],
+ [ 0.0000e+00, 1.0000e+00, -3.6200e-06]]])
+ """
+ if not isinstance(angle_axis, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(angle_axis)}")
+
+ if not angle_axis.shape[-1] == 3:
+ raise ValueError(f"Input size must be a (*, 3) tensor. Got {angle_axis.shape}")
+
+ def _compute_rotation_matrix(angle_axis, theta2, eps=1e-6):
+ # We want to be careful to only evaluate the square root if the
+ # norm of the angle_axis vector is greater than zero. Otherwise
+ # we get a division by zero.
+ k_one = 1.0
+ theta = torch.sqrt(theta2)
+ wxyz = angle_axis / (theta + eps)
+ wx, wy, wz = torch.chunk(wxyz, 3, dim=1)
+ cos_theta = torch.cos(theta)
+ sin_theta = torch.sin(theta)
+
+ r00 = cos_theta + wx * wx * (k_one - cos_theta)
+ r10 = wz * sin_theta + wx * wy * (k_one - cos_theta)
+ r20 = -wy * sin_theta + wx * wz * (k_one - cos_theta)
+ r01 = wx * wy * (k_one - cos_theta) - wz * sin_theta
+ r11 = cos_theta + wy * wy * (k_one - cos_theta)
+ r21 = wx * sin_theta + wy * wz * (k_one - cos_theta)
+ r02 = wy * sin_theta + wx * wz * (k_one - cos_theta)
+ r12 = -wx * sin_theta + wy * wz * (k_one - cos_theta)
+ r22 = cos_theta + wz * wz * (k_one - cos_theta)
+ rotation_matrix = torch.cat([r00, r01, r02, r10, r11, r12, r20, r21, r22], dim=1)
+ return rotation_matrix.view(-1, 3, 3)
+
+ def _compute_rotation_matrix_taylor(angle_axis):
+ rx, ry, rz = torch.chunk(angle_axis, 3, dim=1)
+ k_one = torch.ones_like(rx)
+ rotation_matrix = torch.cat([k_one, -rz, ry, rz, k_one, -rx, -ry, rx, k_one], dim=1)
+ return rotation_matrix.view(-1, 3, 3)
+
+ # stolen from ceres/rotation.h
+
+ _angle_axis = torch.unsqueeze(angle_axis, dim=1)
+ theta2 = torch.matmul(_angle_axis, _angle_axis.transpose(1, 2))
+ theta2 = torch.squeeze(theta2, dim=1)
+
+ # compute rotation matrices
+ rotation_matrix_normal = _compute_rotation_matrix(angle_axis, theta2)
+ rotation_matrix_taylor = _compute_rotation_matrix_taylor(angle_axis)
+
+ # create mask to handle both cases
+ eps = 1e-6
+ mask = (theta2 > eps).view(-1, 1, 1).to(theta2.device)
+ mask_pos = (mask).type_as(theta2)
+ mask_neg = (~mask).type_as(theta2)
+
+ # create output pose matrix
+ batch_size = angle_axis.shape[0]
+ rotation_matrix = torch.eye(3).to(angle_axis.device).type_as(angle_axis)
+ rotation_matrix = rotation_matrix.view(1, 3, 3).repeat(batch_size, 1, 1)
+ # fill output matrix with masked values
+ rotation_matrix[..., :3, :3] = mask_pos * rotation_matrix_normal + mask_neg * rotation_matrix_taylor
+ return rotation_matrix # Nx3x3
+
+
+def rotation_matrix_to_angle_axis(rotation_matrix: torch.Tensor) -> torch.Tensor:
+ r"""Convert 3x3 rotation matrix to Rodrigues vector in radians.
+
+ Args:
+ rotation_matrix: rotation matrix of shape :math:`(N, 3, 3)`.
+
+ Returns:
+ Rodrigues vector transformation of shape :math:`(N, 3)`.
+
+ Example:
+ >>> input = torch.tensor([[1., 0., 0.],
+ ... [0., 1., 0.],
+ ... [0., 0., 1.]])
+ >>> rotation_matrix_to_angle_axis(input)
+ tensor([0., 0., 0.])
+
+ >>> input = torch.tensor([[1., 0., 0.],
+ ... [0., 0., -1.],
+ ... [0., 1., 0.]])
+ >>> rotation_matrix_to_angle_axis(input)
+ tensor([1.5708, 0.0000, 0.0000])
+ """
+ if not isinstance(rotation_matrix, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(rotation_matrix)}")
+
+ if not rotation_matrix.shape[-2:] == (3, 3):
+ raise ValueError(f"Input size must be a (*, 3, 3) tensor. Got {rotation_matrix.shape}")
+ quaternion: torch.Tensor = rotation_matrix_to_quaternion(rotation_matrix, order=QuaternionCoeffOrder.WXYZ)
+ return quaternion_to_angle_axis(quaternion, order=QuaternionCoeffOrder.WXYZ)
+
+
+def rotation_matrix_to_quaternion(
+ rotation_matrix: torch.Tensor, eps: float = 1.0e-8, order: QuaternionCoeffOrder = QuaternionCoeffOrder.XYZW
+) -> torch.Tensor:
+ r"""Convert 3x3 rotation matrix to 4d quaternion vector.
+
+ The quaternion vector has components in (w, x, y, z) or (x, y, z, w) format.
+
+ .. note::
+ The (x, y, z, w) order is going to be deprecated in favor of efficiency.
+
+ Args:
+ rotation_matrix: the rotation matrix to convert with shape :math:`(*, 3, 3)`.
+ eps: small value to avoid zero division.
+ order: quaternion coefficient order. Note: 'xyzw' will be deprecated in favor of 'wxyz'.
+
+ Return:
+ the rotation in quaternion with shape :math:`(*, 4)`.
+
+ Example:
+ >>> input = torch.tensor([[1., 0., 0.],
+ ... [0., 1., 0.],
+ ... [0., 0., 1.]])
+ >>> rotation_matrix_to_quaternion(input, eps=torch.finfo(input.dtype).eps,
+ ... order=QuaternionCoeffOrder.WXYZ)
+ tensor([1., 0., 0., 0.])
+ """
+ if not isinstance(rotation_matrix, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(rotation_matrix)}")
+
+ if not rotation_matrix.shape[-2:] == (3, 3):
+ raise ValueError(f"Input size must be a (*, 3, 3) tensor. Got {rotation_matrix.shape}")
+
+ if not torch.jit.is_scripting():
+ if order.name not in QuaternionCoeffOrder.__members__.keys():
+ raise ValueError(f"order must be one of {QuaternionCoeffOrder.__members__.keys()}")
+
+ if order == QuaternionCoeffOrder.XYZW:
+ warnings.warn(
+ "`XYZW` quaternion coefficient order is deprecated and"
+ " will be removed after > 0.6. "
+ "Please use `QuaternionCoeffOrder.WXYZ` instead."
+ )
+
+ def safe_zero_division(numerator: torch.Tensor, denominator: torch.Tensor) -> torch.Tensor:
+ eps: float = torch.finfo(numerator.dtype).tiny # type: ignore
+ return numerator / torch.clamp(denominator, min=eps)
+
+ rotation_matrix_vec: torch.Tensor = rotation_matrix.view(*rotation_matrix.shape[:-2], 9)
+
+ m00, m01, m02, m10, m11, m12, m20, m21, m22 = torch.chunk(rotation_matrix_vec, chunks=9, dim=-1)
+
+ trace: torch.Tensor = m00 + m11 + m22
+
+ def trace_positive_cond():
+ sq = torch.sqrt(trace + 1.0) * 2.0 # sq = 4 * qw.
+ qw = 0.25 * sq
+ qx = safe_zero_division(m21 - m12, sq)
+ qy = safe_zero_division(m02 - m20, sq)
+ qz = safe_zero_division(m10 - m01, sq)
+ if order == QuaternionCoeffOrder.XYZW:
+ return torch.cat((qx, qy, qz, qw), dim=-1)
+ return torch.cat((qw, qx, qy, qz), dim=-1)
+
+ def cond_1():
+ sq = torch.sqrt(1.0 + m00 - m11 - m22 + eps) * 2.0 # sq = 4 * qx.
+ qw = safe_zero_division(m21 - m12, sq)
+ qx = 0.25 * sq
+ qy = safe_zero_division(m01 + m10, sq)
+ qz = safe_zero_division(m02 + m20, sq)
+ if order == QuaternionCoeffOrder.XYZW:
+ return torch.cat((qx, qy, qz, qw), dim=-1)
+ return torch.cat((qw, qx, qy, qz), dim=-1)
+
+ def cond_2():
+ sq = torch.sqrt(1.0 + m11 - m00 - m22 + eps) * 2.0 # sq = 4 * qy.
+ qw = safe_zero_division(m02 - m20, sq)
+ qx = safe_zero_division(m01 + m10, sq)
+ qy = 0.25 * sq
+ qz = safe_zero_division(m12 + m21, sq)
+ if order == QuaternionCoeffOrder.XYZW:
+ return torch.cat((qx, qy, qz, qw), dim=-1)
+ return torch.cat((qw, qx, qy, qz), dim=-1)
+
+ def cond_3():
+ sq = torch.sqrt(1.0 + m22 - m00 - m11 + eps) * 2.0 # sq = 4 * qz.
+ qw = safe_zero_division(m10 - m01, sq)
+ qx = safe_zero_division(m02 + m20, sq)
+ qy = safe_zero_division(m12 + m21, sq)
+ qz = 0.25 * sq
+ if order == QuaternionCoeffOrder.XYZW:
+ return torch.cat((qx, qy, qz, qw), dim=-1)
+ return torch.cat((qw, qx, qy, qz), dim=-1)
+
+ where_2 = torch.where(m11 > m22, cond_2(), cond_3())
+ where_1 = torch.where((m00 > m11) & (m00 > m22), cond_1(), where_2)
+
+ quaternion: torch.Tensor = torch.where(trace > 0.0, trace_positive_cond(), where_1)
+ return quaternion
+
+
+def normalize_quaternion(quaternion: torch.Tensor, eps: float = 1.0e-12) -> torch.Tensor:
+ r"""Normalize a quaternion.
+
+ The quaternion should be in (x, y, z, w) or (w, x, y, z) format.
+
+ Args:
+ quaternion: a tensor containing a quaternion to be normalized.
+ The tensor can be of shape :math:`(*, 4)`.
+ eps: small value to avoid division by zero.
+
+ Return:
+ the normalized quaternion of shape :math:`(*, 4)`.
+
+ Example:
+ >>> quaternion = torch.tensor((1., 0., 1., 0.))
+ >>> normalize_quaternion(quaternion)
+ tensor([0.7071, 0.0000, 0.7071, 0.0000])
+ """
+ if not isinstance(quaternion, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(quaternion)}")
+
+ if not quaternion.shape[-1] == 4:
+ raise ValueError(f"Input must be a tensor of shape (*, 4). Got {quaternion.shape}")
+ return F.normalize(quaternion, p=2.0, dim=-1, eps=eps)
+
+
+# based on:
+# https://github.com/matthew-brett/transforms3d/blob/8965c48401d9e8e66b6a8c37c65f2fc200a076fa/transforms3d/quaternions.py#L101
+# https://github.com/tensorflow/graphics/blob/master/tensorflow_graphics/geometry/transformation/rotation_matrix_3d.py#L247
+
+
+def quaternion_to_rotation_matrix(
+ quaternion: torch.Tensor, order: QuaternionCoeffOrder = QuaternionCoeffOrder.XYZW
+) -> torch.Tensor:
+ r"""Convert a quaternion to a rotation matrix.
+
+ The quaternion should be in (x, y, z, w) or (w, x, y, z) format.
+
+ Args:
+ quaternion: a tensor containing a quaternion to be converted.
+ The tensor can be of shape :math:`(*, 4)`.
+ order: quaternion coefficient order. Note: 'xyzw' will be deprecated in favor of 'wxyz'.
+
+ Return:
+ the rotation matrix of shape :math:`(*, 3, 3)`.
+
+ Example:
+ >>> quaternion = torch.tensor((0., 0., 0., 1.))
+ >>> quaternion_to_rotation_matrix(quaternion, order=QuaternionCoeffOrder.WXYZ)
+ tensor([[-1., 0., 0.],
+ [ 0., -1., 0.],
+ [ 0., 0., 1.]])
+ """
+ if not isinstance(quaternion, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(quaternion)}")
+
+ if not quaternion.shape[-1] == 4:
+ raise ValueError(f"Input must be a tensor of shape (*, 4). Got {quaternion.shape}")
+
+ if not torch.jit.is_scripting():
+ if order.name not in QuaternionCoeffOrder.__members__.keys():
+ raise ValueError(f"order must be one of {QuaternionCoeffOrder.__members__.keys()}")
+
+ if order == QuaternionCoeffOrder.XYZW:
+ warnings.warn(
+ "`XYZW` quaternion coefficient order is deprecated and"
+ " will be removed after > 0.6. "
+ "Please use `QuaternionCoeffOrder.WXYZ` instead."
+ )
+
+ # normalize the input quaternion
+ quaternion_norm: torch.Tensor = normalize_quaternion(quaternion)
+
+ # unpack the normalized quaternion components
+ if order == QuaternionCoeffOrder.XYZW:
+ x, y, z, w = torch.chunk(quaternion_norm, chunks=4, dim=-1)
+ else:
+ w, x, y, z = torch.chunk(quaternion_norm, chunks=4, dim=-1)
+
+ # compute the actual conversion
+ tx: torch.Tensor = 2.0 * x
+ ty: torch.Tensor = 2.0 * y
+ tz: torch.Tensor = 2.0 * z
+ twx: torch.Tensor = tx * w
+ twy: torch.Tensor = ty * w
+ twz: torch.Tensor = tz * w
+ txx: torch.Tensor = tx * x
+ txy: torch.Tensor = ty * x
+ txz: torch.Tensor = tz * x
+ tyy: torch.Tensor = ty * y
+ tyz: torch.Tensor = tz * y
+ tzz: torch.Tensor = tz * z
+ one: torch.Tensor = torch.tensor(1.0)
+
+ matrix: torch.Tensor = torch.stack(
+ (
+ one - (tyy + tzz),
+ txy - twz,
+ txz + twy,
+ txy + twz,
+ one - (txx + tzz),
+ tyz - twx,
+ txz - twy,
+ tyz + twx,
+ one - (txx + tyy),
+ ),
+ dim=-1,
+ ).view(-1, 3, 3)
+
+ if len(quaternion.shape) == 1:
+ matrix = torch.squeeze(matrix, dim=0)
+ return matrix
+
+
+def quaternion_to_angle_axis(
+ quaternion: torch.Tensor, order: QuaternionCoeffOrder = QuaternionCoeffOrder.XYZW
+) -> torch.Tensor:
+ """Convert quaternion vector to angle axis of rotation in radians.
+
+ The quaternion should be in (x, y, z, w) or (w, x, y, z) format.
+
+ Adapted from ceres C++ library: ceres-solver/include/ceres/rotation.h
+
+ Args:
+ quaternion: tensor with quaternions.
+ order: quaternion coefficient order. Note: 'xyzw' will be deprecated in favor of 'wxyz'.
+
+ Return:
+ tensor with angle axis of rotation.
+
+ Shape:
+ - Input: :math:`(*, 4)` where `*` means, any number of dimensions
+ - Output: :math:`(*, 3)`
+
+ Example:
+ >>> quaternion = torch.tensor((1., 0., 0., 0.))
+ >>> quaternion_to_angle_axis(quaternion)
+ tensor([3.1416, 0.0000, 0.0000])
+ """
+ if not torch.is_tensor(quaternion):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(quaternion)}")
+
+ if not quaternion.shape[-1] == 4:
+ raise ValueError(f"Input must be a tensor of shape Nx4 or 4. Got {quaternion.shape}")
+
+ if not torch.jit.is_scripting():
+ if order.name not in QuaternionCoeffOrder.__members__.keys():
+ raise ValueError(f"order must be one of {QuaternionCoeffOrder.__members__.keys()}")
+
+ if order == QuaternionCoeffOrder.XYZW:
+ warnings.warn(
+ "`XYZW` quaternion coefficient order is deprecated and"
+ " will be removed after > 0.6. "
+ "Please use `QuaternionCoeffOrder.WXYZ` instead."
+ )
+ # unpack input and compute conversion
+ q1: torch.Tensor = torch.tensor([])
+ q2: torch.Tensor = torch.tensor([])
+ q3: torch.Tensor = torch.tensor([])
+ cos_theta: torch.Tensor = torch.tensor([])
+
+ if order == QuaternionCoeffOrder.XYZW:
+ q1 = quaternion[..., 0]
+ q2 = quaternion[..., 1]
+ q3 = quaternion[..., 2]
+ cos_theta = quaternion[..., 3]
+ else:
+ cos_theta = quaternion[..., 0]
+ q1 = quaternion[..., 1]
+ q2 = quaternion[..., 2]
+ q3 = quaternion[..., 3]
+
+ sin_squared_theta: torch.Tensor = q1 * q1 + q2 * q2 + q3 * q3
+
+ sin_theta: torch.Tensor = torch.sqrt(sin_squared_theta)
+ two_theta: torch.Tensor = 2.0 * torch.where(
+ cos_theta < 0.0, torch.atan2(-sin_theta, -cos_theta), torch.atan2(sin_theta, cos_theta)
+ )
+
+ k_pos: torch.Tensor = two_theta / sin_theta
+ k_neg: torch.Tensor = 2.0 * torch.ones_like(sin_theta)
+ k: torch.Tensor = torch.where(sin_squared_theta > 0.0, k_pos, k_neg)
+
+ angle_axis: torch.Tensor = torch.zeros_like(quaternion)[..., :3]
+ angle_axis[..., 0] += q1 * k
+ angle_axis[..., 1] += q2 * k
+ angle_axis[..., 2] += q3 * k
+ return angle_axis
+
+
+def quaternion_log_to_exp(
+ quaternion: torch.Tensor, eps: float = 1.0e-8, order: QuaternionCoeffOrder = QuaternionCoeffOrder.XYZW
+) -> torch.Tensor:
+ r"""Apply exponential map to log quaternion.
+
+ The quaternion should be in (x, y, z, w) or (w, x, y, z) format.
+
+ Args:
+ quaternion: a tensor containing a quaternion to be converted.
+ The tensor can be of shape :math:`(*, 3)`.
+ eps: a small number for clamping.
+ order: quaternion coefficient order. Note: 'xyzw' will be deprecated in favor of 'wxyz'.
+
+ Return:
+ the quaternion exponential map of shape :math:`(*, 4)`.
+
+ Example:
+ >>> quaternion = torch.tensor((0., 0., 0.))
+ >>> quaternion_log_to_exp(quaternion, eps=torch.finfo(quaternion.dtype).eps,
+ ... order=QuaternionCoeffOrder.WXYZ)
+ tensor([1., 0., 0., 0.])
+ """
+ if not isinstance(quaternion, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(quaternion)}")
+
+ if not quaternion.shape[-1] == 3:
+ raise ValueError(f"Input must be a tensor of shape (*, 3). Got {quaternion.shape}")
+
+ if not torch.jit.is_scripting():
+ if order.name not in QuaternionCoeffOrder.__members__.keys():
+ raise ValueError(f"order must be one of {QuaternionCoeffOrder.__members__.keys()}")
+
+ if order == QuaternionCoeffOrder.XYZW:
+ warnings.warn(
+ "`XYZW` quaternion coefficient order is deprecated and"
+ " will be removed after > 0.6. "
+ "Please use `QuaternionCoeffOrder.WXYZ` instead."
+ )
+
+ # compute quaternion norm
+ norm_q: torch.Tensor = torch.norm(quaternion, p=2, dim=-1, keepdim=True).clamp(min=eps)
+
+ # compute scalar and vector
+ quaternion_vector: torch.Tensor = quaternion * torch.sin(norm_q) / norm_q
+ quaternion_scalar: torch.Tensor = torch.cos(norm_q)
+
+ # compose quaternion and return
+ quaternion_exp: torch.Tensor = torch.tensor([])
+ if order == QuaternionCoeffOrder.XYZW:
+ quaternion_exp = torch.cat((quaternion_vector, quaternion_scalar), dim=-1)
+ else:
+ quaternion_exp = torch.cat((quaternion_scalar, quaternion_vector), dim=-1)
+
+ return quaternion_exp
+
+
+def quaternion_exp_to_log(
+ quaternion: torch.Tensor, eps: float = 1.0e-8, order: QuaternionCoeffOrder = QuaternionCoeffOrder.XYZW
+) -> torch.Tensor:
+ r"""Apply the log map to a quaternion.
+
+ The quaternion should be in (x, y, z, w) format.
+
+ Args:
+ quaternion: a tensor containing a quaternion to be converted.
+ The tensor can be of shape :math:`(*, 4)`.
+ eps: a small number for clamping.
+ order: quaternion coefficient order. Note: 'xyzw' will be deprecated in favor of 'wxyz'.
+
+ Return:
+ the quaternion log map of shape :math:`(*, 3)`.
+
+ Example:
+ >>> quaternion = torch.tensor((1., 0., 0., 0.))
+ >>> quaternion_exp_to_log(quaternion, eps=torch.finfo(quaternion.dtype).eps,
+ ... order=QuaternionCoeffOrder.WXYZ)
+ tensor([0., 0., 0.])
+ """
+ if not isinstance(quaternion, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(quaternion)}")
+
+ if not quaternion.shape[-1] == 4:
+ raise ValueError(f"Input must be a tensor of shape (*, 4). Got {quaternion.shape}")
+
+ if not torch.jit.is_scripting():
+ if order.name not in QuaternionCoeffOrder.__members__.keys():
+ raise ValueError(f"order must be one of {QuaternionCoeffOrder.__members__.keys()}")
+
+ if order == QuaternionCoeffOrder.XYZW:
+ warnings.warn(
+ "`XYZW` quaternion coefficient order is deprecated and"
+ " will be removed after > 0.6. "
+ "Please use `QuaternionCoeffOrder.WXYZ` instead."
+ )
+
+ # unpack quaternion vector and scalar
+ quaternion_vector: torch.Tensor = torch.tensor([])
+ quaternion_scalar: torch.Tensor = torch.tensor([])
+
+ if order == QuaternionCoeffOrder.XYZW:
+ quaternion_vector = quaternion[..., 0:3]
+ quaternion_scalar = quaternion[..., 3:4]
+ else:
+ quaternion_scalar = quaternion[..., 0:1]
+ quaternion_vector = quaternion[..., 1:4]
+
+ # compute quaternion norm
+ norm_q: torch.Tensor = torch.norm(quaternion_vector, p=2, dim=-1, keepdim=True).clamp(min=eps)
+
+ # apply log map
+ quaternion_log: torch.Tensor = (
+ quaternion_vector * torch.acos(torch.clamp(quaternion_scalar, min=-1.0, max=1.0)) / norm_q
+ )
+
+ return quaternion_log
+
+
+# based on:
+# https://github.com/facebookresearch/QuaterNet/blob/master/common/quaternion.py#L138
+
+
+def angle_axis_to_quaternion(
+ angle_axis: torch.Tensor, order: QuaternionCoeffOrder = QuaternionCoeffOrder.XYZW
+) -> torch.Tensor:
+ r"""Convert an angle axis to a quaternion.
+
+ The quaternion vector has components in (x, y, z, w) or (w, x, y, z) format.
+
+ Adapted from ceres C++ library: ceres-solver/include/ceres/rotation.h
+
+ Args:
+ angle_axis: tensor with angle axis in radians.
+ order: quaternion coefficient order. Note: 'xyzw' will be deprecated in favor of 'wxyz'.
+
+ Return:
+ tensor with quaternion.
+
+ Shape:
+ - Input: :math:`(*, 3)` where `*` means, any number of dimensions
+ - Output: :math:`(*, 4)`
+
+ Example:
+ >>> angle_axis = torch.tensor((0., 1., 0.))
+ >>> angle_axis_to_quaternion(angle_axis, order=QuaternionCoeffOrder.WXYZ)
+ tensor([0.8776, 0.0000, 0.4794, 0.0000])
+ """
+ if not torch.is_tensor(angle_axis):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(angle_axis)}")
+
+ if not angle_axis.shape[-1] == 3:
+ raise ValueError(f"Input must be a tensor of shape Nx3 or 3. Got {angle_axis.shape}")
+
+ if not torch.jit.is_scripting():
+ if order.name not in QuaternionCoeffOrder.__members__.keys():
+ raise ValueError(f"order must be one of {QuaternionCoeffOrder.__members__.keys()}")
+
+ if order == QuaternionCoeffOrder.XYZW:
+ warnings.warn(
+ "`XYZW` quaternion coefficient order is deprecated and"
+ " will be removed after > 0.6. "
+ "Please use `QuaternionCoeffOrder.WXYZ` instead."
+ )
+
+ # unpack input and compute conversion
+ a0: torch.Tensor = angle_axis[..., 0:1]
+ a1: torch.Tensor = angle_axis[..., 1:2]
+ a2: torch.Tensor = angle_axis[..., 2:3]
+ theta_squared: torch.Tensor = a0 * a0 + a1 * a1 + a2 * a2
+
+ theta: torch.Tensor = torch.sqrt(theta_squared)
+ half_theta: torch.Tensor = theta * 0.5
+
+ mask: torch.Tensor = theta_squared > 0.0
+ ones: torch.Tensor = torch.ones_like(half_theta)
+
+ k_neg: torch.Tensor = 0.5 * ones
+ k_pos: torch.Tensor = torch.sin(half_theta) / theta
+ k: torch.Tensor = torch.where(mask, k_pos, k_neg)
+ w: torch.Tensor = torch.where(mask, torch.cos(half_theta), ones)
+
+ quaternion: torch.Tensor = torch.zeros(
+ size=(*angle_axis.shape[:-1], 4), dtype=angle_axis.dtype, device=angle_axis.device
+ )
+ if order == QuaternionCoeffOrder.XYZW:
+ quaternion[..., 0:1] = a0 * k
+ quaternion[..., 1:2] = a1 * k
+ quaternion[..., 2:3] = a2 * k
+ quaternion[..., 3:4] = w
+ else:
+ quaternion[..., 1:2] = a0 * k
+ quaternion[..., 2:3] = a1 * k
+ quaternion[..., 3:4] = a2 * k
+ quaternion[..., 0:1] = w
+ return quaternion
+
+
+# based on:
+# https://github.com/ClementPinard/SfmLearner-Pytorch/blob/master/inverse_warp.py#L65-L71
+
+
+def normalize_pixel_coordinates(
+ pixel_coordinates: torch.Tensor, height: int, width: int, eps: float = 1e-8
+) -> torch.Tensor:
+ r"""Normalize pixel coordinates between -1 and 1.
+
+ Normalized, -1 if on extreme left, 1 if on extreme right (x = w-1).
+
+ Args:
+ pixel_coordinates: the grid with pixel coordinates. Shape can be :math:`(*, 2)`.
+ width: the maximum width in the x-axis.
+ height: the maximum height in the y-axis.
+ eps: safe division by zero.
+
+ Return:
+ the normalized pixel coordinates with shape :math:`(*, 2)`.
+
+ Examples:
+ >>> coords = torch.tensor([[50., 100.]])
+ >>> normalize_pixel_coordinates(coords, 100, 50)
+ tensor([[1.0408, 1.0202]])
+ """
+ if pixel_coordinates.shape[-1] != 2:
+ raise ValueError("Input pixel_coordinates must be of shape (*, 2). " "Got {}".format(pixel_coordinates.shape))
+
+ # compute normalization factor
+ hw: torch.Tensor = torch.stack(
+ [
+ torch.tensor(width, device=pixel_coordinates.device, dtype=pixel_coordinates.dtype),
+ torch.tensor(height, device=pixel_coordinates.device, dtype=pixel_coordinates.dtype),
+ ]
+ )
+
+ factor: torch.Tensor = torch.tensor(2.0, device=pixel_coordinates.device, dtype=pixel_coordinates.dtype) / (
+ hw - 1
+ ).clamp(eps)
+
+ return factor * pixel_coordinates - 1
+
+
+def denormalize_pixel_coordinates(
+ pixel_coordinates: torch.Tensor, height: int, width: int, eps: float = 1e-8
+) -> torch.Tensor:
+ r"""Denormalize pixel coordinates.
+
+ The input is assumed to be -1 if on extreme left, 1 if on extreme right (x = w-1).
+
+ Args:
+ pixel_coordinates: the normalized grid coordinates. Shape can be :math:`(*, 2)`.
+ width: the maximum width in the x-axis.
+ height: the maximum height in the y-axis.
+ eps: safe division by zero.
+
+ Return:
+ the denormalized pixel coordinates with shape :math:`(*, 2)`.
+
+ Examples:
+ >>> coords = torch.tensor([[-1., -1.]])
+ >>> denormalize_pixel_coordinates(coords, 100, 50)
+ tensor([[0., 0.]])
+ """
+ if pixel_coordinates.shape[-1] != 2:
+ raise ValueError("Input pixel_coordinates must be of shape (*, 2). " "Got {}".format(pixel_coordinates.shape))
+ # compute normalization factor
+ hw: torch.Tensor = (
+ torch.stack([torch.tensor(width), torch.tensor(height)])
+ .to(pixel_coordinates.device)
+ .to(pixel_coordinates.dtype)
+ )
+
+ factor: torch.Tensor = torch.tensor(2.0) / (hw - 1).clamp(eps)
+
+ return torch.tensor(1.0) / factor * (pixel_coordinates + 1)
+
+
+def normalize_pixel_coordinates3d(
+ pixel_coordinates: torch.Tensor, depth: int, height: int, width: int, eps: float = 1e-8
+) -> torch.Tensor:
+ r"""Normalize pixel coordinates between -1 and 1.
+
+ Normalized, -1 if on extreme left, 1 if on extreme right (x = w-1).
+
+ Args:
+ pixel_coordinates: the grid with pixel coordinates. Shape can be :math:`(*, 3)`.
+ depth: the maximum depth in the z-axis.
+ height: the maximum height in the y-axis.
+ width: the maximum width in the x-axis.
+ eps: safe division by zero.
+
+ Return:
+ the normalized pixel coordinates.
+ """
+ if pixel_coordinates.shape[-1] != 3:
+ raise ValueError("Input pixel_coordinates must be of shape (*, 3). " "Got {}".format(pixel_coordinates.shape))
+ # compute normalization factor
+ dhw: torch.Tensor = (
+ torch.stack([torch.tensor(depth), torch.tensor(width), torch.tensor(height)])
+ .to(pixel_coordinates.device)
+ .to(pixel_coordinates.dtype)
+ )
+
+ factor: torch.Tensor = torch.tensor(2.0) / (dhw - 1).clamp(eps)
+
+ return factor * pixel_coordinates - 1
+
+
+def denormalize_pixel_coordinates3d(
+ pixel_coordinates: torch.Tensor, depth: int, height: int, width: int, eps: float = 1e-8
+) -> torch.Tensor:
+ r"""Denormalize pixel coordinates.
+
+ The input is assumed to be -1 if on extreme left, 1 if on extreme right (x = w-1).
+
+ Args:
+ pixel_coordinates: the normalized grid coordinates. Shape can be :math:`(*, 3)`.
+ depth: the maximum depth in the x-axis.
+ height: the maximum height in the y-axis.
+ width: the maximum width in the x-axis.
+ eps: safe division by zero.
+
+ Return:
+ the denormalized pixel coordinates.
+ """
+ if pixel_coordinates.shape[-1] != 3:
+ raise ValueError("Input pixel_coordinates must be of shape (*, 3). " "Got {}".format(pixel_coordinates.shape))
+ # compute normalization factor
+ dhw: torch.Tensor = (
+ torch.stack([torch.tensor(depth), torch.tensor(width), torch.tensor(height)])
+ .to(pixel_coordinates.device)
+ .to(pixel_coordinates.dtype)
+ )
+
+ factor: torch.Tensor = torch.tensor(2.0) / (dhw - 1).clamp(eps)
+
+ return torch.tensor(1.0) / factor * (pixel_coordinates + 1)
+
+
+def angle_to_rotation_matrix(angle: torch.Tensor) -> torch.Tensor:
+ r"""Create a rotation matrix out of angles in degrees.
+
+ Args:
+ angle: tensor of angles in degrees, any shape.
+
+ Returns:
+ tensor of *x2x2 rotation matrices.
+
+ Shape:
+ - Input: :math:`(*)`
+ - Output: :math:`(*, 2, 2)`
+
+ Example:
+ >>> input = torch.rand(1, 3) # Nx3
+ >>> output = angle_to_rotation_matrix(input) # Nx3x2x2
+ """
+ ang_rad = deg2rad(angle)
+ cos_a: torch.Tensor = torch.cos(ang_rad)
+ sin_a: torch.Tensor = torch.sin(ang_rad)
+ return torch.stack([cos_a, sin_a, -sin_a, cos_a], dim=-1).view(*angle.shape, 2, 2)
diff --git a/kornia/geometry/depth.py b/kornia/geometry/depth.py
new file mode 100644
index 0000000000000000000000000000000000000000..da4d49fa11f5a13d8035c200184050147e890a4b
--- /dev/null
+++ b/kornia/geometry/depth.py
@@ -0,0 +1,380 @@
+"""Module containing operators to work on RGB-Depth images."""
+from typing import Union
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from kornia.filters.sobel import spatial_gradient
+from kornia.utils import create_meshgrid
+
+from .camera import cam2pixel, PinholeCamera, pixel2cam, project_points, unproject_points
+from .conversions import normalize_pixel_coordinates
+from .linalg import compose_transformations, convert_points_to_homogeneous, inverse_transformation, transform_points
+
+__all__ = [
+ "depth_to_3d",
+ "depth_to_normals",
+ "warp_frame_depth",
+ "depth_warp",
+ "DepthWarper"
+]
+
+
+def depth_to_3d(depth: torch.Tensor, camera_matrix: torch.Tensor, normalize_points: bool = False) -> torch.Tensor:
+ """Compute a 3d point per pixel given its depth value and the camera intrinsics.
+
+ Args:
+ depth: image tensor containing a depth value per pixel with shape :math:`(B, 1, H, W)`.
+ camera_matrix: tensor containing the camera intrinsics with shape :math:`(B, 3, 3)`.
+ normalize_points: whether to normalise the pointcloud. This must be set to `True` when the depth is
+ represented as the Euclidean ray length from the camera position.
+
+ Return:
+ tensor with a 3d point per pixel of the same resolution as the input :math:`(B, 3, H, W)`.
+
+ Example:
+ >>> depth = torch.rand(1, 1, 4, 4)
+ >>> K = torch.eye(3)[None]
+ >>> depth_to_3d(depth, K).shape
+ torch.Size([1, 3, 4, 4])
+ """
+ if not isinstance(depth, torch.Tensor):
+ raise TypeError(f"Input depht type is not a torch.Tensor. Got {type(depth)}.")
+
+ if not (len(depth.shape) == 4 and depth.shape[-3] == 1):
+ raise ValueError(f"Input depth musth have a shape (B, 1, H, W). Got: {depth.shape}")
+
+ if not isinstance(camera_matrix, torch.Tensor):
+ raise TypeError(f"Input camera_matrix type is not a torch.Tensor. " f"Got {type(camera_matrix)}.")
+
+ if not (len(camera_matrix.shape) == 3 and camera_matrix.shape[-2:] == (3, 3)):
+ raise ValueError(f"Input camera_matrix must have a shape (B, 3, 3). " f"Got: {camera_matrix.shape}.")
+
+ # create base coordinates grid
+ _, _, height, width = depth.shape
+ points_2d: torch.Tensor = create_meshgrid(height, width, normalized_coordinates=False) # 1xHxWx2
+ points_2d = points_2d.to(depth.device).to(depth.dtype)
+
+ # depth should come in Bx1xHxW
+ points_depth: torch.Tensor = depth.permute(0, 2, 3, 1) # 1xHxWx1
+
+ # project pixels to camera frame
+ camera_matrix_tmp: torch.Tensor = camera_matrix[:, None, None] # Bx1x1x3x3
+ points_3d: torch.Tensor = unproject_points(
+ points_2d, points_depth, camera_matrix_tmp, normalize=normalize_points
+ ) # BxHxWx3
+
+ return points_3d.permute(0, 3, 1, 2) # Bx3xHxW
+
+
+def depth_to_normals(depth: torch.Tensor, camera_matrix: torch.Tensor, normalize_points: bool = False) -> torch.Tensor:
+ """Compute the normal surface per pixel.
+
+ Args:
+ depth: image tensor containing a depth value per pixel with shape :math:`(B, 1, H, W)`.
+ camera_matrix: tensor containing the camera intrinsics with shape :math:`(B, 3, 3)`.
+ normalize_points: whether to normalise the pointcloud. This must be set to `True` when the depth is
+ represented as the Euclidean ray length from the camera position.
+
+ Return:
+ tensor with a normal surface vector per pixel of the same resolution as the input :math:`(B, 3, H, W)`.
+
+ Example:
+ >>> depth = torch.rand(1, 1, 4, 4)
+ >>> K = torch.eye(3)[None]
+ >>> depth_to_normals(depth, K).shape
+ torch.Size([1, 3, 4, 4])
+ """
+ if not isinstance(depth, torch.Tensor):
+ raise TypeError(f"Input depht type is not a torch.Tensor. Got {type(depth)}.")
+
+ if not (len(depth.shape) == 4 and depth.shape[-3] == 1):
+ raise ValueError(f"Input depth musth have a shape (B, 1, H, W). Got: {depth.shape}")
+
+ if not isinstance(camera_matrix, torch.Tensor):
+ raise TypeError(f"Input camera_matrix type is not a torch.Tensor. " f"Got {type(camera_matrix)}.")
+
+ if not (len(camera_matrix.shape) == 3 and camera_matrix.shape[-2:] == (3, 3)):
+ raise ValueError(f"Input camera_matrix must have a shape (B, 3, 3). " f"Got: {camera_matrix.shape}.")
+
+ # compute the 3d points from depth
+ xyz: torch.Tensor = depth_to_3d(depth, camera_matrix, normalize_points) # Bx3xHxW
+
+ # compute the pointcloud spatial gradients
+ gradients: torch.Tensor = spatial_gradient(xyz) # Bx3x2xHxW
+
+ # compute normals
+ a, b = gradients[:, :, 0], gradients[:, :, 1] # Bx3xHxW
+
+ normals: torch.Tensor = torch.cross(a, b, dim=1) # Bx3xHxW
+ return F.normalize(normals, dim=1, p=2)
+
+
+def warp_frame_depth(
+ image_src: torch.Tensor,
+ depth_dst: torch.Tensor,
+ src_trans_dst: torch.Tensor,
+ camera_matrix: torch.Tensor,
+ normalize_points: bool = False,
+) -> torch.Tensor:
+ """Warp a tensor from a source to destination frame by the depth in the destination.
+
+ Compute 3d points from the depth, transform them using given transformation, then project the point cloud to an
+ image plane.
+
+ Args:
+ image_src: image tensor in the source frame with shape :math:`(B,D,H,W)`.
+ depth_dst: depth tensor in the destination frame with shape :math:`(B,1,H,W)`.
+ src_trans_dst: transformation matrix from destination to source with shape :math:`(B,4,4)`.
+ camera_matrix: tensor containing the camera intrinsics with shape :math:`(B,3,3)`.
+ normalize_points: whether to normalise the pointcloud. This must be set to ``True`` when the depth
+ is represented as the Euclidean ray length from the camera position.
+
+ Return:
+ the warped tensor in the source frame with shape :math:`(B,3,H,W)`.
+ """
+ if not isinstance(image_src, torch.Tensor):
+ raise TypeError(f"Input image_src type is not a torch.Tensor. Got {type(image_src)}.")
+
+ if not len(image_src.shape) == 4:
+ raise ValueError(f"Input image_src musth have a shape (B, D, H, W). Got: {image_src.shape}")
+
+ if not isinstance(depth_dst, torch.Tensor):
+ raise TypeError(f"Input depht_dst type is not a torch.Tensor. Got {type(depth_dst)}.")
+
+ if not (len(depth_dst.shape) == 4 and depth_dst.shape[-3] == 1):
+ raise ValueError(f"Input depth_dst musth have a shape (B, 1, H, W). Got: {depth_dst.shape}")
+
+ if not isinstance(src_trans_dst, torch.Tensor):
+ raise TypeError(f"Input src_trans_dst type is not a torch.Tensor. " f"Got {type(src_trans_dst)}.")
+
+ if not (len(src_trans_dst.shape) == 3 and src_trans_dst.shape[-2:] == (4, 4)):
+ raise ValueError(f"Input src_trans_dst must have a shape (B, 4, 4). " f"Got: {src_trans_dst.shape}.")
+
+ if not isinstance(camera_matrix, torch.Tensor):
+ raise TypeError(f"Input camera_matrix type is not a torch.Tensor. " f"Got {type(camera_matrix)}.")
+
+ if not (len(camera_matrix.shape) == 3 and camera_matrix.shape[-2:] == (3, 3)):
+ raise ValueError(f"Input camera_matrix must have a shape (B, 3, 3). " f"Got: {camera_matrix.shape}.")
+ # unproject source points to camera frame
+ points_3d_dst: torch.Tensor = depth_to_3d(depth_dst, camera_matrix, normalize_points) # Bx3xHxW
+
+ # transform points from source to destination
+ points_3d_dst = points_3d_dst.permute(0, 2, 3, 1) # BxHxWx3
+
+ # apply transformation to the 3d points
+ points_3d_src = transform_points(src_trans_dst[:, None], points_3d_dst) # BxHxWx3
+
+ # project back to pixels
+ camera_matrix_tmp: torch.Tensor = camera_matrix[:, None, None] # Bx1x1xHxW
+ points_2d_src: torch.Tensor = project_points(points_3d_src, camera_matrix_tmp) # BxHxWx2
+
+ # normalize points between [-1 / 1]
+ height, width = depth_dst.shape[-2:]
+ points_2d_src_norm: torch.Tensor = normalize_pixel_coordinates(points_2d_src, height, width) # BxHxWx2
+
+ return F.grid_sample(image_src, points_2d_src_norm, align_corners=True) # type: ignore
+
+
+class DepthWarper(nn.Module):
+ r"""Warp a patch by depth.
+
+ .. math::
+ P_{src}^{\{dst\}} = K_{dst} * T_{src}^{\{dst\}}
+
+ I_{src} = \\omega(I_{dst}, P_{src}^{\{dst\}}, D_{src})
+
+ Args:
+ pinholes_dst: the pinhole models for the destination frame.
+ height: the height of the image to warp.
+ width: the width of the image to warp.
+ mode: interpolation mode to calculate output values ``'bilinear'`` | ``'nearest'``.
+ padding_mode: padding mode for outside grid values ``'zeros'`` | ``'border'`` | ``'reflection'``.
+ align_corners: interpolation flag.
+ """
+
+ def __init__(
+ self,
+ pinhole_dst: PinholeCamera,
+ height: int,
+ width: int,
+ mode: str = 'bilinear',
+ padding_mode: str = 'zeros',
+ align_corners: bool = True,
+ ):
+ super().__init__()
+ # constructor members
+ self.width: int = width
+ self.height: int = height
+ self.mode: str = mode
+ self.padding_mode: str = padding_mode
+ self.eps = 1e-6
+ self.align_corners: bool = align_corners
+
+ # state members
+ self._pinhole_dst: PinholeCamera = pinhole_dst
+ self._pinhole_src: Union[None, PinholeCamera] = None
+ self._dst_proj_src: Union[None, torch.Tensor] = None
+
+ self.grid: torch.Tensor = self._create_meshgrid(height, width)
+
+ @staticmethod
+ def _create_meshgrid(height: int, width: int) -> torch.Tensor:
+ grid: torch.Tensor = create_meshgrid(height, width, normalized_coordinates=False) # 1xHxWx2
+ return convert_points_to_homogeneous(grid) # append ones to last dim
+
+ def compute_projection_matrix(self, pinhole_src: PinholeCamera) -> 'DepthWarper':
+ r"""Compute the projection matrix from the source to destination frame."""
+ if not isinstance(self._pinhole_dst, PinholeCamera):
+ raise TypeError(
+ "Member self._pinhole_dst expected to be of class "
+ "PinholeCamera. Got {}".format(type(self._pinhole_dst))
+ )
+ if not isinstance(pinhole_src, PinholeCamera):
+ raise TypeError(
+ "Argument pinhole_src expected to be of class " "PinholeCamera. Got {}".format(type(pinhole_src))
+ )
+ # compute the relative pose between the non reference and the reference
+ # camera frames.
+ dst_trans_src: torch.Tensor = compose_transformations(
+ self._pinhole_dst.extrinsics, inverse_transformation(pinhole_src.extrinsics)
+ )
+
+ # compute the projection matrix between the non reference cameras and
+ # the reference.
+ dst_proj_src: torch.Tensor = torch.matmul(self._pinhole_dst.intrinsics, dst_trans_src)
+
+ # update class members
+ self._pinhole_src = pinhole_src
+ self._dst_proj_src = dst_proj_src
+ return self
+
+ def _compute_projection(self, x, y, invd):
+ if self._dst_proj_src is None or self._pinhole_src is None:
+ raise ValueError("Please, call compute_projection_matrix.")
+
+ point = torch.tensor(
+ [[[x], [y], [1.0], [invd]]], device=self._dst_proj_src.device, dtype=self._dst_proj_src.dtype
+ )
+ flow = torch.matmul(self._dst_proj_src, point)
+ z = 1.0 / flow[:, 2]
+ x = flow[:, 0] * z
+ y = flow[:, 1] * z
+ return torch.cat([x, y], 1)
+
+ def compute_subpixel_step(self) -> torch.Tensor:
+ """Compute the required inverse depth step to achieve sub pixel accurate sampling of the depth cost volume,
+ per camera.
+
+ Szeliski, Richard, and Daniel Scharstein. "Symmetric sub-pixel stereo matching." European Conference on Computer
+ Vision. Springer Berlin Heidelberg, 2002.
+ """
+ delta_d = 0.01
+ xy_m1 = self._compute_projection(self.width / 2, self.height / 2, 1.0 - delta_d)
+ xy_p1 = self._compute_projection(self.width / 2, self.height / 2, 1.0 + delta_d)
+ dx = torch.norm((xy_p1 - xy_m1), 2, dim=-1) / 2.0
+ dxdd = dx / (delta_d) # pixel*(1/meter)
+ # half pixel sampling, we're interested in the min for all cameras
+ return torch.min(0.5 / dxdd)
+
+ def warp_grid(self, depth_src: torch.Tensor) -> torch.Tensor:
+ """Compute a grid for warping a given the depth from the reference pinhole camera.
+
+ The function `compute_projection_matrix` has to be called beforehand in order to have precomputed the relative
+ projection matrices encoding the relative pose and the intrinsics between the reference and a non reference
+ camera.
+ """
+ # TODO: add type and value checkings
+ if self._dst_proj_src is None or self._pinhole_src is None:
+ raise ValueError("Please, call compute_projection_matrix.")
+
+ if len(depth_src.shape) != 4:
+ raise ValueError("Input depth_src has to be in the shape of " "Bx1xHxW. Got {}".format(depth_src.shape))
+
+ # unpack depth attributes
+ batch_size, _, _, _ = depth_src.shape
+ device: torch.device = depth_src.device
+ dtype: torch.dtype = depth_src.dtype
+
+ # expand the base coordinate grid according to the input batch size
+ pixel_coords: torch.Tensor = self.grid.to(device=device, dtype=dtype).expand(batch_size, -1, -1, -1) # BxHxWx3
+
+ # reproject the pixel coordinates to the camera frame
+ cam_coords_src: torch.Tensor = pixel2cam(
+ depth_src, self._pinhole_src.intrinsics_inverse().to(device=device, dtype=dtype), pixel_coords
+ ) # BxHxWx3
+
+ # reproject the camera coordinates to the pixel
+ pixel_coords_src: torch.Tensor = cam2pixel(
+ cam_coords_src, self._dst_proj_src.to(device=device, dtype=dtype)
+ ) # (B*N)xHxWx2
+
+ # normalize between -1 and 1 the coordinates
+ pixel_coords_src_norm: torch.Tensor = normalize_pixel_coordinates(pixel_coords_src, self.height, self.width)
+ return pixel_coords_src_norm
+
+ def forward(self, depth_src: torch.Tensor, patch_dst: torch.Tensor) -> torch.Tensor:
+ """Warp a tensor from destination frame to reference given the depth in the reference frame.
+
+ Args:
+ depth_src: the depth in the reference frame. The tensor must have a shape :math:`(B, 1, H, W)`.
+ patch_dst: the patch in the destination frame. The tensor must have a shape :math:`(B, C, H, W)`.
+
+ Return:
+ the warped patch from destination frame to reference.
+
+ Shape:
+ - Output: :math:`(N, C, H, W)` where C = number of channels.
+
+ Example:
+ >>> # pinholes camera models
+ >>> pinhole_dst = PinholeCamera(torch.randn(1, 4, 4), torch.randn(1, 4, 4),
+ ... torch.tensor([32]), torch.tensor([32]))
+ >>> pinhole_src = PinholeCamera(torch.randn(1, 4, 4), torch.randn(1, 4, 4),
+ ... torch.tensor([32]), torch.tensor([32]))
+ >>> # create the depth warper, compute the projection matrix
+ >>> warper = DepthWarper(pinhole_dst, 32, 32)
+ >>> _ = warper.compute_projection_matrix(pinhole_src)
+ >>> # warp the destination frame to reference by depth
+ >>> depth_src = torch.ones(1, 1, 32, 32) # Nx1xHxW
+ >>> image_dst = torch.rand(1, 3, 32, 32) # NxCxHxW
+ >>> image_src = warper(depth_src, image_dst) # NxCxHxW
+ """
+ return F.grid_sample(
+ patch_dst,
+ self.warp_grid(depth_src), # type: ignore
+ mode=self.mode,
+ padding_mode=self.padding_mode,
+ align_corners=self.align_corners,
+ )
+
+
+def depth_warp(
+ pinhole_dst: PinholeCamera,
+ pinhole_src: PinholeCamera,
+ depth_src: torch.Tensor,
+ patch_dst: torch.Tensor,
+ height: int,
+ width: int,
+ align_corners: bool = True,
+):
+ r"""Function that warps a tensor from destination frame to reference
+ given the depth in the reference frame.
+
+ See :class:`~kornia.geometry.warp.DepthWarper` for details.
+
+ Example:
+ >>> # pinholes camera models
+ >>> pinhole_dst = PinholeCamera(torch.randn(1, 4, 4), torch.randn(1, 4, 4),
+ ... torch.tensor([32]), torch.tensor([32]))
+ >>> pinhole_src = PinholeCamera(torch.randn(1, 4, 4), torch.randn(1, 4, 4),
+ ... torch.tensor([32]), torch.tensor([32]))
+ >>> # warp the destination frame to reference by depth
+ >>> depth_src = torch.ones(1, 1, 32, 32) # Nx1xHxW
+ >>> image_dst = torch.rand(1, 3, 32, 32) # NxCxHxW
+ >>> image_src = depth_warp(pinhole_dst, pinhole_src, depth_src, image_dst, 32, 32) # NxCxHxW
+ """
+ warper = DepthWarper(pinhole_dst, height, width, align_corners=align_corners)
+ warper.compute_projection_matrix(pinhole_src)
+ return warper(depth_src, patch_dst)
diff --git a/kornia/geometry/epipolar/__init__.py b/kornia/geometry/epipolar/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..515e39ef07a94b03f3fe8bd123433524e8c391af
--- /dev/null
+++ b/kornia/geometry/epipolar/__init__.py
@@ -0,0 +1,56 @@
+from ._metrics import sampson_epipolar_distance, symmetrical_epipolar_distance
+from .essential import (
+ decompose_essential_matrix,
+ essential_from_fundamental,
+ essential_from_Rt,
+ motion_from_essential,
+ motion_from_essential_choose_solution,
+ relative_camera_motion,
+)
+from .fundamental import (
+ compute_correspond_epilines,
+ find_fundamental,
+ fundamental_from_essential,
+ fundamental_from_projections,
+ normalize_points,
+ normalize_transformation,
+)
+from .numeric import cross_product_matrix
+from .projection import (
+ depth_from_point,
+ intrinsics_like,
+ KRt_from_projection,
+ projection_from_KRt,
+ projections_from_fundamental,
+ random_intrinsics,
+ scale_intrinsics,
+)
+from .scene import generate_scene
+from .triangulation import triangulate_points
+
+__all__ = [
+ "cross_product_matrix",
+ "sampson_epipolar_distance",
+ "symmetrical_epipolar_distance",
+ "essential_from_fundamental",
+ "decompose_essential_matrix",
+ "essential_from_Rt",
+ "motion_from_essential",
+ "motion_from_essential_choose_solution",
+ "relative_camera_motion",
+ "normalize_points",
+ "normalize_transformation",
+ "find_fundamental",
+ "compute_correspond_epilines",
+ "fundamental_from_essential",
+ "fundamental_from_projections",
+ "intrinsics_like",
+ "random_intrinsics",
+ "scale_intrinsics",
+ "projection_from_KRt",
+ "KRt_from_projection",
+ "depth_from_point",
+ "projections_from_fundamental",
+ "generate_scene",
+ "triangulate_points",
+]
diff --git a/kornia/geometry/epipolar/_metrics.py b/kornia/geometry/epipolar/_metrics.py
new file mode 100644
index 0000000000000000000000000000000000000000..6077e1bac7465043a7fb865acf3b7583a2623d87
--- /dev/null
+++ b/kornia/geometry/epipolar/_metrics.py
@@ -0,0 +1,112 @@
+"""Module including useful metrics for Structure from Motion."""
+
+import torch
+
+from kornia.geometry.conversions import convert_points_to_homogeneous
+
+
+def sampson_epipolar_distance(
+ pts1: torch.Tensor, pts2: torch.Tensor, Fm: torch.Tensor, squared: bool = True, eps: float = 1e-8
+) -> torch.Tensor:
+ r"""Return Sampson distance for correspondences given the fundamental matrix.
+
+ Args:
+ pts1: correspondences from the left images with shape
+ (B, N, 2 or 3). If they are not homogeneous, converted automatically.
+ pts2: correspondences from the right images with shape
+ (B, N, 2 or 3). If they are not homogeneous, converted automatically.
+ Fm: Fundamental matrices with shape :math:`(B, 3, 3)`. Called Fm to
+ avoid ambiguity with torch.nn.functional.
+ squared: if True (default), the squared distance is returned.
+ eps: Small constant for safe sqrt.
+
+ Returns:
+ the computed Sampson distance with shape :math:`(B, N)`.
+
+ """
+ if not isinstance(Fm, torch.Tensor):
+ raise TypeError(f"Fm type is not a torch.Tensor. Got {type(Fm)}")
+
+ if (len(Fm.shape) != 3) or not Fm.shape[-2:] == (3, 3):
+ raise ValueError(f"Fm must be a (*, 3, 3) tensor. Got {Fm.shape}")
+
+ if pts1.size(-1) == 2:
+ pts1 = convert_points_to_homogeneous(pts1)
+
+ if pts2.size(-1) == 2:
+ pts2 = convert_points_to_homogeneous(pts2)
+
+ # From Hartley and Zisserman, Sampson error (11.9)
+ # sam = (x'^T F x) ** 2 / ( (((Fx)_1**2) + (Fx)_2**2)) + (((F^Tx')_1**2) + (F^Tx')_2**2)) )
+
+ # line1_in_2: torch.Tensor = (F @ pts1.permute(0,2,1)).permute(0,2,1)
+ # line2_in_1: torch.Tensor = (F.permute(0,2,1) @ pts2.permute(0,2,1)).permute(0,2,1)
+ # Instead we can just transpose F once and switch the order of multiplication
+ F_t: torch.Tensor = Fm.permute(0, 2, 1)
+ line1_in_2: torch.Tensor = pts1 @ F_t
+ line2_in_1: torch.Tensor = pts2 @ Fm
+
+ # numerator = (x'^T F x) ** 2
+ numerator: torch.Tensor = (pts2 * line1_in_2).sum(2).pow(2)
+
+ # denominator = (((Fx)_1**2) + (Fx)_2**2)) + (((F^Tx')_1**2) + (F^Tx')_2**2))
+ denominator: torch.Tensor = line1_in_2[..., :2].norm(2, dim=2).pow(2) + line2_in_1[..., :2].norm(2, dim=2).pow(2)
+ out: torch.Tensor = numerator / denominator
+ if squared:
+ return out
+ return (out + eps).sqrt()
+
+
+def symmetrical_epipolar_distance(
+ pts1: torch.Tensor, pts2: torch.Tensor, Fm: torch.Tensor, squared: bool = True, eps: float = 1e-8
+) -> torch.Tensor:
+ r"""Return symmetrical epipolar distance for correspondences given the fundamental matrix.
+
+ Args:
+ pts1: correspondences from the left images with shape
+ (B, N, 2 or 3). If they are not homogeneous, converted automatically.
+ pts2: correspondences from the right images with shape
+ (B, N, 2 or 3). If they are not homogeneous, converted automatically.
+ Fm: Fundamental matrices with shape :math:`(B, 3, 3)`. Called Fm to
+ avoid ambiguity with torch.nn.functional.
+ squared: if True (default), the squared distance is returned.
+ eps: Small constant for safe sqrt.
+
+ Returns:
+ the computed Symmetrical distance with shape :math:`(B, N)`.
+
+ """
+ if not isinstance(Fm, torch.Tensor):
+ raise TypeError(f"Fm type is not a torch.Tensor. Got {type(Fm)}")
+
+ if (len(Fm.shape) != 3) or not Fm.shape[-2:] == (3, 3):
+ raise ValueError(f"Fm must be a (*, 3, 3) tensor. Got {Fm.shape}")
+
+ if pts1.size(-1) == 2:
+ pts1 = convert_points_to_homogeneous(pts1)
+
+ if pts2.size(-1) == 2:
+ pts2 = convert_points_to_homogeneous(pts2)
+
+ # From Hartley and Zisserman, symmetric epipolar distance (11.10)
+ # sed = (x'^T F x) ** 2 / (((Fx)_1**2) + (Fx)_2**2)) + 1/ (((F^Tx')_1**2) + (F^Tx')_2**2))
+
+ # line1_in_2: torch.Tensor = (F @ pts1.permute(0,2,1)).permute(0,2,1)
+ # line2_in_1: torch.Tensor = (F.permute(0,2,1) @ pts2.permute(0,2,1)).permute(0,2,1)
+
+ # Instead we can just transpose F once and switch the order of multiplication
+ F_t: torch.Tensor = Fm.permute(0, 2, 1)
+ line1_in_2: torch.Tensor = pts1 @ F_t
+ line2_in_1: torch.Tensor = pts2 @ Fm
+
+ # numerator = (x'^T F x) ** 2
+ numerator: torch.Tensor = (pts2 * line1_in_2).sum(2).pow(2)
+
+ # denominator_inv = 1/ (((Fx)_1**2) + (Fx)_2**2)) + 1/ (((F^Tx')_1**2) + (F^Tx')_2**2))
+ denominator_inv: torch.Tensor = 1.0 / (line1_in_2[..., :2].norm(2, dim=2).pow(2)) + 1.0 / (
+ line2_in_1[..., :2].norm(2, dim=2).pow(2)
+ )
+ out: torch.Tensor = numerator * denominator_inv
+ if squared:
+ return out
+ return (out + eps).sqrt()
diff --git a/kornia/geometry/epipolar/essential.py b/kornia/geometry/epipolar/essential.py
new file mode 100644
index 0000000000000000000000000000000000000000..9ec155b69525bc39cde97dc5b82b82fb0a8381ab
--- /dev/null
+++ b/kornia/geometry/epipolar/essential.py
@@ -0,0 +1,299 @@
+"""Module containing functionalities for the Essential matrix."""
+from typing import Optional, Tuple
+
+import torch
+
+from kornia.utils import eye_like, vec_like
+
+from .numeric import cross_product_matrix
+from .projection import depth_from_point, projection_from_KRt
+from .triangulation import triangulate_points
+
+__all__ = [
+ "essential_from_fundamental",
+ "decompose_essential_matrix",
+ "essential_from_Rt",
+ "motion_from_essential",
+ "motion_from_essential_choose_solution",
+ "relative_camera_motion",
+]
+
+
+def essential_from_fundamental(F_mat: torch.Tensor, K1: torch.Tensor, K2: torch.Tensor) -> torch.Tensor:
+ r"""Get Essential matrix from Fundamental and Camera matrices.
+
+ Uses the method from Hartley/Zisserman 9.6 pag 257 (formula 9.12).
+
+ Args:
+ F_mat: The fundamental matrix with shape of :math:`(*, 3, 3)`.
+ K1: The camera matrix from first camera with shape :math:`(*, 3, 3)`.
+ K2: The camera matrix from second camera with shape :math:`(*, 3, 3)`.
+
+ Returns:
+ The essential matrix with shape :math:`(*, 3, 3)`.
+
+ """
+ if not (len(F_mat.shape) >= 2 and F_mat.shape[-2:] == (3, 3)):
+ raise AssertionError(F_mat.shape)
+ if not (len(K1.shape) >= 2 and K1.shape[-2:] == (3, 3)):
+ raise AssertionError(K1.shape)
+ if not (len(K2.shape) >= 2 and K2.shape[-2:] == (3, 3)):
+ raise AssertionError(K2.shape)
+ if not len(F_mat.shape[:-2]) == len(K1.shape[:-2]) == len(K2.shape[:-2]):
+ raise AssertionError
+
+ return K2.transpose(-2, -1) @ F_mat @ K1
+
+
+def decompose_essential_matrix(E_mat: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+ r"""Decompose an essential matrix to possible rotations and translation.
+
+ This function decomposes the essential matrix E using svd decomposition [96]
+ and give the possible solutions: :math:`R1, R2, t`.
+
+ Args:
+ E_mat: The essential matrix in the form of :math:`(*, 3, 3)`.
+
+ Returns:
+ A tuple containing the first and second possible rotation matrices and the translation vector.
+ The shape of the tensors with be same input :math:`[(*, 3, 3), (*, 3, 3), (*, 3, 1)]`.
+
+ """
+ if not (len(E_mat.shape) >= 2 and E_mat.shape[-2:]):
+ raise AssertionError(E_mat.shape)
+
+ # decompose matrix by its singular values
+ U, _, V = torch.svd(E_mat)
+ Vt = V.transpose(-2, -1)
+
+ mask = torch.ones_like(E_mat)
+ mask[..., -1:] *= -1.0 # fill last column with negative values
+
+ maskt = mask.transpose(-2, -1)
+
+ # avoid singularities
+ U = torch.where((torch.det(U) < 0.0)[..., None, None], U * mask, U)
+ Vt = torch.where((torch.det(Vt) < 0.0)[..., None, None], Vt * maskt, Vt)
+
+ W = cross_product_matrix(torch.tensor([[0.0, 0.0, 1.0]]).type_as(E_mat))
+ W[..., 2, 2] += 1.0
+
+ # reconstruct rotations and retrieve translation vector
+ U_W_Vt = U @ W @ Vt
+ U_Wt_Vt = U @ W.transpose(-2, -1) @ Vt
+
+ # return values
+ R1 = U_W_Vt
+ R2 = U_Wt_Vt
+ T = U[..., -1:]
+ return (R1, R2, T)
+
+
+def essential_from_Rt(R1: torch.Tensor, t1: torch.Tensor, R2: torch.Tensor, t2: torch.Tensor) -> torch.Tensor:
+ r"""Get the Essential matrix from Camera motion (Rs and ts).
+
+ Reference: Hartley/Zisserman 9.6 pag 257 (formula 9.12)
+
+ Args:
+ R1: The first camera rotation matrix with shape :math:`(*, 3, 3)`.
+ t1: The first camera translation vector with shape :math:`(*, 3, 1)`.
+ R2: The second camera rotation matrix with shape :math:`(*, 3, 3)`.
+ t2: The second camera translation vector with shape :math:`(*, 3, 1)`.
+
+ Returns:
+ The Essential matrix with the shape :math:`(*, 3, 3)`.
+
+ """
+ if not (len(R1.shape) >= 2 and R1.shape[-2:] == (3, 3)):
+ raise AssertionError(R1.shape)
+ if not (len(t1.shape) >= 2 and t1.shape[-2:] == (3, 1)):
+ raise AssertionError(t1.shape)
+ if not (len(R2.shape) >= 2 and R2.shape[-2:] == (3, 3)):
+ raise AssertionError(R2.shape)
+ if not (len(t2.shape) >= 2 and t2.shape[-2:] == (3, 1)):
+ raise AssertionError(t2.shape)
+
+ # first compute the camera relative motion
+ R, t = relative_camera_motion(R1, t1, R2, t2)
+
+ # get the cross product from relative translation vector
+ Tx = cross_product_matrix(t[..., 0])
+
+ return Tx @ R
+
+
+def motion_from_essential(E_mat: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+ r"""Get Motion (R's and t's ) from Essential matrix.
+
+ Computes and return four possible poses exist for the decomposition of the Essential
+ matrix. The possible solutions are :math:`[R1,t], [R1,โt], [R2,t], [R2,โt]`.
+
+ Args:
+ E_mat: The essential matrix in the form of :math:`(*, 3, 3)`.
+
+ Returns:
+ The rotation and translation containing the four possible combination for the retrieved motion.
+ The tuple is as following :math:`[(*, 4, 3, 3), (*, 4, 3, 1)]`.
+
+ """
+ if not (len(E_mat.shape) >= 2 and E_mat.shape[-2:] == (3, 3)):
+ raise AssertionError(E_mat.shape)
+
+ # decompose the essential matrix by its possible poses
+ R1, R2, t = decompose_essential_matrix(E_mat)
+
+ # compbine and returns the four possible solutions
+ Rs = torch.stack([R1, R1, R2, R2], dim=-3)
+ Ts = torch.stack([t, -t, t, -t], dim=-3)
+
+ return (Rs, Ts)
+
+
+def motion_from_essential_choose_solution(
+ E_mat: torch.Tensor,
+ K1: torch.Tensor,
+ K2: torch.Tensor,
+ x1: torch.Tensor,
+ x2: torch.Tensor,
+ mask: Optional[torch.Tensor] = None,
+) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+ r"""Recover the relative camera rotation and the translation from an estimated essential matrix.
+
+ The method checks the corresponding points in two images and also returns the triangulated
+ 3d points. Internally uses :py:meth:`~kornia.geometry.epipolar.decompose_essential_matrix` and then chooses
+ the best solution based on the combination that gives more 3d points in front of the camera plane from
+ :py:meth:`~kornia.geometry.epipolar.triangulate_points`.
+
+ Args:
+ E_mat: The essential matrix in the form of :math:`(*, 3, 3)`.
+ K1: The camera matrix from first camera with shape :math:`(*, 3, 3)`.
+ K2: The camera matrix from second camera with shape :math:`(*, 3, 3)`.
+ x1: The set of points seen from the first camera frame in the camera plane
+ coordinates with shape :math:`(*, N, 2)`.
+ x2: The set of points seen from the first camera frame in the camera plane
+ coordinates with shape :math:`(*, N, 2)`.
+ mask: A boolean mask which can be used to exclude some points from choosing
+ the best solution. This is useful for using this function with sets of points of
+ different cardinality (for instance after filtering with RANSAC) while keeping batch
+ semantics. Mask is of shape :math:`(*, N)`.
+
+ Returns:
+ The rotation and translation plus the 3d triangulated points.
+ The tuple is as following :math:`[(*, 3, 3), (*, 3, 1), (*, N, 3)]`.
+
+ """
+ if not (len(E_mat.shape) >= 2 and E_mat.shape[-2:] == (3, 3)):
+ raise AssertionError(E_mat.shape)
+ if not (len(K1.shape) >= 2 and K1.shape[-2:] == (3, 3)):
+ raise AssertionError(K1.shape)
+ if not (len(K2.shape) >= 2 and K2.shape[-2:] == (3, 3)):
+ raise AssertionError(K2.shape)
+ if not (len(x1.shape) >= 2 and x1.shape[-1] == 2):
+ raise AssertionError(x1.shape)
+ if not (len(x2.shape) >= 2 and x2.shape[-1] == 2):
+ raise AssertionError(x2.shape)
+ if not len(E_mat.shape[:-2]) == len(K1.shape[:-2]) == len(K2.shape[:-2]):
+ raise AssertionError
+ if mask is not None:
+ if len(mask.shape) < 1:
+ raise AssertionError(mask.shape)
+ if mask.shape != x1.shape[:-1]:
+ raise AssertionError(mask.shape)
+
+ unbatched = len(E_mat.shape) == 2
+
+ if unbatched:
+ # add a leading batch dimension. We will remove it at the end, before
+ # returning the results
+ E_mat = E_mat[None]
+ K1 = K1[None]
+ K2 = K2[None]
+ x1 = x1[None]
+ x2 = x2[None]
+ if mask is not None:
+ mask = mask[None]
+
+ # compute four possible pose solutions
+ Rs, ts = motion_from_essential(E_mat)
+
+ # set reference view pose and compute projection matrix
+ R1 = eye_like(3, E_mat) # Bx3x3
+ t1 = vec_like(3, E_mat) # Bx3x1
+
+ # compute the projection matrices for first camera
+ R1 = R1[:, None].expand(-1, 4, -1, -1)
+ t1 = t1[:, None].expand(-1, 4, -1, -1)
+ K1 = K1[:, None].expand(-1, 4, -1, -1)
+ P1 = projection_from_KRt(K1, R1, t1) # 1x4x4x4
+
+ # compute the projection matrices for second camera
+ R2 = Rs
+ t2 = ts
+ K2 = K2[:, None].expand(-1, 4, -1, -1)
+ P2 = projection_from_KRt(K2, R2, t2) # Bx4x4x4
+
+ # triangulate the points
+ x1 = x1[:, None].expand(-1, 4, -1, -1)
+ x2 = x2[:, None].expand(-1, 4, -1, -1)
+ X = triangulate_points(P1, P2, x1, x2) # Bx4xNx3
+
+ # project points and compute their depth values
+ d1 = depth_from_point(R1, t1, X)
+ d2 = depth_from_point(R2, t2, X)
+
+ # verify the point values that have a positive depth value
+ depth_mask = (d1 > 0.0) & (d2 > 0.0)
+ if mask is not None:
+ depth_mask &= mask.unsqueeze(1)
+
+ mask_indices = torch.max(depth_mask.sum(-1), dim=-1, keepdim=True)[1]
+
+ # get pose and points 3d and return
+ R_out = Rs[:, mask_indices][:, 0, 0]
+ t_out = ts[:, mask_indices][:, 0, 0]
+ points3d_out = X[:, mask_indices][:, 0, 0]
+
+ if unbatched:
+ R_out = R_out[0]
+ t_out = t_out[0]
+ points3d_out = points3d_out[0]
+
+ return R_out, t_out, points3d_out
+
+
+def relative_camera_motion(
+ R1: torch.Tensor, t1: torch.Tensor, R2: torch.Tensor, t2: torch.Tensor
+) -> Tuple[torch.Tensor, torch.Tensor]:
+ r"""Compute the relative camera motion between two cameras.
+
+ Given the motion parameters of two cameras, computes the motion parameters of the second
+ one assuming the first one to be at the origin. If :math:`T1` and :math:`T2` are the camera motions,
+ the computed relative motion is :math:`T = T_{2}T^{โ1}_{1}`.
+
+ Args:
+ R1: The first camera rotation matrix with shape :math:`(*, 3, 3)`.
+ t1: The first camera translation vector with shape :math:`(*, 3, 1)`.
+ R2: The second camera rotation matrix with shape :math:`(*, 3, 3)`.
+ t2: The second camera translation vector with shape :math:`(*, 3, 1)`.
+
+ Returns:
+ A tuple with the relative rotation matrix and
+ translation vector with the shape of :math:`[(*, 3, 3), (*, 3, 1)]`.
+
+ """
+ if not (len(R1.shape) >= 2 and R1.shape[-2:] == (3, 3)):
+ raise AssertionError(R1.shape)
+ if not (len(t1.shape) >= 2 and t1.shape[-2:] == (3, 1)):
+ raise AssertionError(t1.shape)
+ if not (len(R2.shape) >= 2 and R2.shape[-2:] == (3, 3)):
+ raise AssertionError(R2.shape)
+ if not (len(t2.shape) >= 2 and t2.shape[-2:] == (3, 1)):
+ raise AssertionError(t2.shape)
+
+ # compute first the relative rotation
+ R = R2 @ R1.transpose(-2, -1)
+
+ # compute the relative translation vector
+ t = t2 - R @ t1
+
+ return (R, t)
diff --git a/kornia/geometry/epipolar/fundamental.py b/kornia/geometry/epipolar/fundamental.py
new file mode 100644
index 0000000000000000000000000000000000000000..a797487d577a3d4a4bfd88cf0f8bbede74c1f98c
--- /dev/null
+++ b/kornia/geometry/epipolar/fundamental.py
@@ -0,0 +1,235 @@
+"""Module containing the functionalities for computing the Fundamental Matrix."""
+
+from typing import Tuple
+
+import torch
+
+from kornia.geometry.conversions import convert_points_to_homogeneous
+from kornia.geometry.linalg import transform_points
+
+
+def normalize_points(points: torch.Tensor, eps: float = 1e-8) -> Tuple[torch.Tensor, torch.Tensor]:
+ r"""Normalizes points (isotropic).
+
+ Computes the transformation matrix such that the two principal moments of the set of points
+ are equal to unity, forming an approximately symmetric circular cloud of points of radius 1
+ about the origin. Reference: Hartley/Zisserman 4.4.4 pag.107
+
+ This operation is an essential step before applying the DLT algorithm in order to consider
+ the result as optimal.
+
+ Args:
+ points: Tensor containing the points to be normalized with shape :math:`(B, N, 2)`.
+ eps: epsilon value to avoid numerical instabilities.
+
+ Returns:
+ tuple containing the normalized points in the shape :math:`(B, N, 2)` and the transformation matrix
+ in the shape :math:`(B, 3, 3)`.
+
+ """
+ if len(points.shape) != 3:
+ raise AssertionError(points.shape)
+ if points.shape[-1] != 2:
+ raise AssertionError(points.shape)
+
+ x_mean = torch.mean(points, dim=1, keepdim=True) # Bx1x2
+
+ scale = (points - x_mean).norm(dim=-1, p=2).mean(dim=-1) # B
+ scale = torch.sqrt(torch.tensor(2.0)) / (scale + eps) # B
+
+ ones, zeros = torch.ones_like(scale), torch.zeros_like(scale)
+
+ transform = torch.stack(
+ [scale, zeros, -scale * x_mean[..., 0, 0], zeros, scale, -scale * x_mean[..., 0, 1], zeros, zeros, ones], dim=-1
+ ) # Bx9
+
+ transform = transform.view(-1, 3, 3) # Bx3x3
+ points_norm = transform_points(transform, points) # BxNx2
+
+ return (points_norm, transform)
+
+
+def normalize_transformation(M: torch.Tensor, eps: float = 1e-8) -> torch.Tensor:
+ r"""Normalize a given transformation matrix.
+
+ The function trakes the transformation matrix and normalize so that the value in
+ the last row and column is one.
+
+ Args:
+ M: The transformation to be normalized of any shape with a minimum size of 2x2.
+ eps: small value to avoid unstabilities during the backpropagation.
+
+ Returns:
+ the normalized transformation matrix with same shape as the input.
+
+ """
+ if len(M.shape) < 2:
+ raise AssertionError(M.shape)
+ norm_val: torch.Tensor = M[..., -1:, -1:]
+ return torch.where(norm_val.abs() > eps, M / (norm_val + eps), M)
+
+
+def find_fundamental(points1: torch.Tensor, points2: torch.Tensor, weights: torch.Tensor) -> torch.Tensor:
+ r"""Compute the fundamental matrix using the DLT formulation.
+
+ The linear system is solved by using the Weighted Least Squares Solution for the 8 Points algorithm.
+
+ Args:
+ points1: A set of points in the first image with a tensor shape :math:`(B, N, 2)`.
+ points2: A set of points in the second image with a tensor shape :math:`(B, N, 2)`.
+ weights: Tensor containing the weights per point correspondence with a shape of :math:`(B, N)`.
+
+ Returns:
+ the computed fundamental matrix with shape :math:`(B, 3, 3)`.
+
+ """
+ if points1.shape != points2.shape:
+ raise AssertionError(points1.shape, points2.shape)
+ if not (len(weights.shape) == 2 and weights.shape[1] == points1.shape[1]):
+ raise AssertionError(weights.shape)
+
+ points1_norm, transform1 = normalize_points(points1)
+ points2_norm, transform2 = normalize_points(points2)
+
+ x1, y1 = torch.chunk(points1_norm, dim=-1, chunks=2) # Bx1xN
+ x2, y2 = torch.chunk(points2_norm, dim=-1, chunks=2) # Bx1xN
+
+ ones = torch.ones_like(x1)
+
+ # build equations system and solve DLT
+ # https://www.cc.gatech.edu/~afb/classes/CS4495-Fall2013/slides/CS4495-09-TwoViews-2.pdf
+ # [x * x', x * y', x, y * x', y * y', y, x', y', 1]
+
+ X = torch.cat([x2 * x1, x2 * y1, x2, y2 * x1, y2 * y1, y2, x1, y1, ones], dim=-1) # BxNx9
+
+ # apply the weights to the linear system
+ w_diag = torch.diag_embed(weights)
+ X = X.transpose(-2, -1) @ w_diag @ X
+
+ # compute eigevectors and retrieve the one with the smallest eigenvalue
+ _, _, V = torch.svd(X)
+ F_mat = V[..., -1].view(-1, 3, 3)
+
+ # reconstruct and force the matrix to have rank2
+ U, S, V = torch.svd(F_mat)
+ rank_mask = torch.tensor([1.0, 1.0, 0.0],
+ device=F_mat.device,
+ dtype=F_mat.dtype)
+
+ F_projected = U @ (torch.diag_embed(S * rank_mask) @ V.transpose(-2, -1))
+ F_est = transform2.transpose(-2, -1) @ (F_projected @ transform1)
+
+ return normalize_transformation(F_est)
+
+
+def compute_correspond_epilines(points: torch.Tensor, F_mat: torch.Tensor) -> torch.Tensor:
+ r"""Compute the corresponding epipolar line for a given set of points.
+
+ Args:
+ points: tensor containing the set of points to project in the shape of :math:`(B, N, 2)`.
+ F_mat: the fundamental to use for projection the points in the shape of :math:`(B, 3, 3)`.
+
+ Returns:
+ a tensor with shape :math:`(B, N, 3)` containing a vector of the epipolar
+ lines corresponding to the points to the other image. Each line is described as
+ :math:`ax + by + c = 0` and encoding the vectors as :math:`(a, b, c)`.
+
+ """
+ if not (len(points.shape) == 3 and points.shape[2] == 2):
+ raise AssertionError(points.shape)
+ if not (len(F_mat.shape) == 3 and F_mat.shape[-2:] == (3, 3)):
+ raise AssertionError(F_mat.shape)
+
+ points_h: torch.Tensor = convert_points_to_homogeneous(points)
+
+ # project points and retrieve lines components
+ a, b, c = torch.chunk(F_mat @ points_h.permute(0, 2, 1), dim=1, chunks=3)
+
+ # compute normal and compose equation line
+ nu: torch.Tensor = a * a + b * b
+ nu = torch.where(nu > 0.0, 1.0 / torch.sqrt(nu), torch.ones_like(nu))
+
+ line = torch.cat([a * nu, b * nu, c * nu], dim=1) # Bx3xN
+ return line.permute(0, 2, 1) # BxNx3
+
+
+def fundamental_from_essential(E_mat: torch.Tensor, K1: torch.Tensor, K2: torch.Tensor) -> torch.Tensor:
+ r"""Get the Fundamental matrix from Essential and camera matrices.
+
+ Uses the method from Hartley/Zisserman 9.6 pag 257 (formula 9.12).
+
+ Args:
+ E_mat: The essential matrix with shape of :math:`(*, 3, 3)`.
+ K1: The camera matrix from first camera with shape :math:`(*, 3, 3)`.
+ K2: The camera matrix from second camera with shape :math:`(*, 3, 3)`.
+
+ Returns:
+ The fundamental matrix with shape :math:`(*, 3, 3)`.
+
+ """
+ if not (len(E_mat.shape) >= 2 and E_mat.shape[-2:] == (3, 3)):
+ raise AssertionError(E_mat.shape)
+ if not (len(K1.shape) >= 2 and K1.shape[-2:] == (3, 3)):
+ raise AssertionError(K1.shape)
+ if not (len(K2.shape) >= 2 and K2.shape[-2:] == (3, 3)):
+ raise AssertionError(K2.shape)
+ if not len(E_mat.shape[:-2]) == len(K1.shape[:-2]) == len(K2.shape[:-2]):
+ raise AssertionError
+
+ return K2.inverse().transpose(-2, -1) @ E_mat @ K1.inverse()
+
+
+# adapted from:
+# https://github.com/opencv/opencv_contrib/blob/master/modules/sfm/src/fundamental.cpp#L109
+# https://github.com/openMVG/openMVG/blob/160643be515007580086650f2ae7f1a42d32e9fb/src/openMVG/multiview/projection.cpp#L134
+
+
+def fundamental_from_projections(P1: torch.Tensor, P2: torch.Tensor) -> torch.Tensor:
+ r"""Get the Fundamental matrix from Projection matrices.
+
+ Args:
+ P1: The projection matrix from first camera with shape :math:`(*, 3, 4)`.
+ P2: The projection matrix from second camera with shape :math:`(*, 3, 4)`.
+
+ Returns:
+ The fundamental matrix with shape :math:`(*, 3, 3)`.
+
+ """
+ if not (len(P1.shape) >= 2 and P1.shape[-2:] == (3, 4)):
+ raise AssertionError(P1.shape)
+ if not (len(P2.shape) >= 2 and P2.shape[-2:] == (3, 4)):
+ raise AssertionError(P2.shape)
+ if P1.shape[:-2] != P2.shape[:-2]:
+ raise AssertionError
+
+ def vstack(x, y):
+ return torch.cat([x, y], dim=-2)
+
+ X1 = P1[..., 1:, :]
+ X2 = vstack(P1[..., 2:3, :], P1[..., 0:1, :])
+ X3 = P1[..., :2, :]
+
+ Y1 = P2[..., 1:, :]
+ Y2 = vstack(P2[..., 2:3, :], P2[..., 0:1, :])
+ Y3 = P2[..., :2, :]
+
+ X1Y1, X2Y1, X3Y1 = vstack(X1, Y1), vstack(X2, Y1), vstack(X3, Y1)
+ X1Y2, X2Y2, X3Y2 = vstack(X1, Y2), vstack(X2, Y2), vstack(X3, Y2)
+ X1Y3, X2Y3, X3Y3 = vstack(X1, Y3), vstack(X2, Y3), vstack(X3, Y3)
+
+ F_vec = torch.cat(
+ [
+ X1Y1.det().reshape(-1, 1),
+ X2Y1.det().reshape(-1, 1),
+ X3Y1.det().reshape(-1, 1),
+ X1Y2.det().reshape(-1, 1),
+ X2Y2.det().reshape(-1, 1),
+ X3Y2.det().reshape(-1, 1),
+ X1Y3.det().reshape(-1, 1),
+ X2Y3.det().reshape(-1, 1),
+ X3Y3.det().reshape(-1, 1),
+ ],
+ dim=1,
+ )
+
+ return F_vec.view(*P1.shape[:-2], 3, 3)
diff --git a/kornia/geometry/epipolar/numeric.py b/kornia/geometry/epipolar/numeric.py
new file mode 100644
index 0000000000000000000000000000000000000000..48741911128a714ffa9a10daab7c389acd042746
--- /dev/null
+++ b/kornia/geometry/epipolar/numeric.py
@@ -0,0 +1,26 @@
+"""Module containing numerical functionalities for SfM."""
+
+import torch
+
+
+def cross_product_matrix(x: torch.Tensor) -> torch.Tensor:
+ r"""Return the cross_product_matrix symmetric matrix of a vector.
+
+ Args:
+ x: The input vector to construct the matrix in the shape :math:`(B, 3)`.
+
+ Returns:
+ The constructed cross_product_matrix symmetric matrix with shape :math:`(B, 3, 3)`.
+
+ """
+ if not (len(x.shape) == 2 and x.shape[1] == 3):
+ raise AssertionError(x.shape)
+ # get vector compononens
+ x0 = x[..., 0]
+ x1 = x[..., 1]
+ x2 = x[..., 2]
+
+ # construct the matrix, reshape to 3x3 and return
+ zeros = torch.zeros_like(x0)
+ cross_product_matrix_flat = torch.stack([zeros, -x2, x1, x2, zeros, -x0, -x1, x0, zeros], dim=-1)
+ return cross_product_matrix_flat.view(-1, 3, 3)
diff --git a/kornia/geometry/epipolar/projection.py b/kornia/geometry/epipolar/projection.py
new file mode 100644
index 0000000000000000000000000000000000000000..8e862979fbb1937dc4f685ce0906c6c290129527
--- /dev/null
+++ b/kornia/geometry/epipolar/projection.py
@@ -0,0 +1,212 @@
+"""Module for image projections."""
+from typing import Tuple, Union
+
+import torch
+
+from kornia.utils import eye_like, vec_like
+from kornia.utils._compat import linalg_qr
+
+from .numeric import cross_product_matrix
+
+
+def intrinsics_like(focal: float, input: torch.Tensor) -> torch.Tensor:
+ r"""Return a 3x3 instrinsics matrix, with same size as the input.
+
+ The center of projection will be based in the input image size.
+
+ Args:
+ focal: the focal length for the camera matrix.
+ input: image tensor that will determine the batch size and image height
+ and width. It is assumed to be a tensor in the shape of :math:`(B, C, H, W)`.
+
+ Returns:
+ The camera matrix with the shape of :math:`(B, 3, 3)`.
+
+ """
+ if len(input.shape) != 4:
+ raise AssertionError(input.shape)
+ if focal <= 0:
+ raise AssertionError(focal)
+
+ _, _, H, W = input.shape
+
+ intrinsics = eye_like(3, input)
+ intrinsics[..., 0, 0] *= focal
+ intrinsics[..., 1, 1] *= focal
+ intrinsics[..., 0, 2] += 1.0 * W / 2
+ intrinsics[..., 1, 2] += 1.0 * H / 2
+ return intrinsics
+
+
+def random_intrinsics(low: Union[float, torch.Tensor], high: Union[float, torch.Tensor]) -> torch.Tensor:
+ r"""Generate a random camera matrix based on a given uniform distribution.
+
+ Args:
+ low: lower range (inclusive).
+ high: upper range (exclusive).
+
+ Returns:
+ the random camera matrix with the shape of :math:`(1, 3, 3)`.
+
+ """
+ sampler = torch.distributions.Uniform(low, high)
+ fx, fy, cx, cy = (sampler.sample((1,)) for _ in range(4))
+ zeros, ones = torch.zeros_like(fx), torch.ones_like(fx)
+ camera_matrix: torch.Tensor = torch.cat([fx, zeros, cx, zeros, fy, cy, zeros, zeros, ones])
+ return camera_matrix.view(1, 3, 3)
+
+
+def scale_intrinsics(camera_matrix: torch.Tensor, scale_factor: Union[float, torch.Tensor]) -> torch.Tensor:
+ r"""Scale a camera matrix containing the intrinsics.
+
+ Applies the scaling factor to the focal length and center of projection.
+
+ Args:
+ camera_matrix: the camera calibration matrix containing the intrinsic
+ parameters. The expected shape for the tensor is :math:`(B, 3, 3)`.
+ scale_factor: the scaling factor to be applied.
+
+ Returns:
+ The scaled camera matrix with shame shape as input :math:`(B, 3, 3)`.
+
+ """
+ K_scale = camera_matrix.clone()
+ K_scale[..., 0, 0] *= scale_factor
+ K_scale[..., 1, 1] *= scale_factor
+ K_scale[..., 0, 2] *= scale_factor
+ K_scale[..., 1, 2] *= scale_factor
+ return K_scale
+
+
+def projection_from_KRt(K: torch.Tensor, R: torch.Tensor, t: torch.Tensor) -> torch.Tensor:
+ r"""Get the projection matrix P from K, R and t.
+
+ This function estimate the projection matrix by solving the following equation: :math:`P = K * [R|t]`.
+
+ Args:
+ K: the camera matrix with the instrinsics with shape :math:`(B, 3, 3)`.
+ R: The rotation matrix with shape :math:`(B, 3, 3)`.
+ t: The translation vector with shape :math:`(B, 3, 1)`.
+
+ Returns:
+ The projection matrix P with shape :math:`(B, 4, 4)`.
+
+ """
+ if K.shape[-2:] != (3, 3):
+ raise AssertionError(K.shape)
+ if R.shape[-2:] != (3, 3):
+ raise AssertionError(R.shape)
+ if t.shape[-2:] != (3, 1):
+ raise AssertionError(t.shape)
+ if not len(K.shape) == len(R.shape) == len(t.shape):
+ raise AssertionError
+
+ Rt: torch.Tensor = torch.cat([R, t], dim=-1) # 3x4
+ Rt_h = torch.nn.functional.pad(Rt, [0, 0, 0, 1], "constant", 0.0) # 4x4
+ Rt_h[..., -1, -1] += 1.0
+
+ K_h: torch.Tensor = torch.nn.functional.pad(K, [0, 1, 0, 1], "constant", 0.0) # 4x4
+ K_h[..., -1, -1] += 1.0
+
+ return K @ Rt
+
+
+def KRt_from_projection(P: torch.Tensor, eps: float = 1e-6) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+ r"""Decompose the Projection matrix into Camera-Matrix, Rotation Matrix and Translation vector.
+
+ Args:
+ P: the projection matrix with shape :math:`(B, 3, 4)`.
+
+ Returns:
+ - The Camera matrix with shape :math:`(B, 3, 3)`.
+ - The Rotation matrix with shape :math:`(B, 3, 3)`.
+ - The Translation vector with shape :math:`(B, 3)`.
+
+ """
+ if P.shape[-2:] != (3, 4):
+ raise AssertionError("P must be of shape [B, 3, 4]")
+ if len(P.shape) != 3:
+ raise AssertionError
+
+ submat_3x3 = P[:, 0:3, 0:3]
+ last_column = P[:, 0:3, 3].unsqueeze(-1)
+
+ # Trick to turn QR-decomposition into RQ-decomposition
+ reverse = torch.tensor([[0, 0, 1], [0, 1, 0], [1, 0, 0]], device=P.device, dtype=P.dtype).unsqueeze(0)
+ submat_3x3 = torch.matmul(reverse, submat_3x3).permute(0, 2, 1)
+ ortho_mat, upper_mat = linalg_qr(submat_3x3)
+ ortho_mat = torch.matmul(reverse, ortho_mat.permute(0, 2, 1))
+ upper_mat = torch.matmul(reverse, torch.matmul(upper_mat.permute(0, 2, 1), reverse))
+
+ # Turning the `upper_mat's` diagonal elements to positive.
+ diagonals = torch.diagonal(upper_mat, dim1=-2, dim2=-1) + eps
+ signs = torch.sign(diagonals)
+ signs_mat = torch.diag_embed(signs)
+
+ K = torch.matmul(upper_mat, signs_mat)
+ R = torch.matmul(signs_mat, ortho_mat)
+ t = torch.matmul(torch.inverse(K), last_column)
+
+ return K, R, t
+
+
+def depth_from_point(R: torch.Tensor, t: torch.Tensor, X: torch.Tensor) -> torch.Tensor:
+ r"""Return the depth of a point transformed by a rigid transform.
+
+ Args:
+ R: The rotation matrix with shape :math:`(*, 3, 3)`.
+ t: The translation vector with shape :math:`(*, 3, 1)`.
+ X: The 3d points with shape :math:`(*, 3)`.
+
+ Returns:
+ The depth value per point with shape :math:`(*, 1)`.
+
+ """
+ X_tmp = R @ X.transpose(-2, -1)
+ X_out = X_tmp[..., 2, :] + t[..., 2, :]
+ return X_out
+
+
+# adapted from:
+# https://github.com/opencv/opencv_contrib/blob/master/modules/sfm/src/fundamental.cpp#L61
+# https://github.com/mapillary/OpenSfM/blob/master/opensfm/multiview.py#L14
+
+
+def _nullspace(A):
+ """Compute the null space of A.
+
+ Return the smallest singular value and the corresponding vector.
+ """
+ _, s, vh = torch.svd(A)
+ return s[..., -1], vh[..., -1]
+
+
+def projections_from_fundamental(F_mat: torch.Tensor) -> torch.Tensor:
+ r"""Get the projection matrices from the Fundamental Matrix.
+
+ Args:
+ F_mat: the fundamental matrix with the shape :math:`(B, 3, 3)`.
+
+ Returns:
+ The projection matrices with shape :math:`(B, 3, 4, 2)`.
+
+ """
+ if len(F_mat.shape) != 3:
+ raise AssertionError(F_mat.shape)
+ if F_mat.shape[-2:] != (3, 3):
+ raise AssertionError(F_mat.shape)
+
+ R1 = eye_like(3, F_mat) # Bx3x3
+ t1 = vec_like(3, F_mat) # Bx3
+
+ Ft_mat = F_mat.transpose(-2, -1)
+
+ _, e2 = _nullspace(Ft_mat)
+
+ R2 = cross_product_matrix(e2) @ F_mat # Bx3x3
+ t2 = e2[..., :, None] # Bx3x1
+
+ P1 = torch.cat([R1, t1], dim=-1) # Bx3x4
+ P2 = torch.cat([R2, t2], dim=-1) # Bx3x4
+
+ return torch.stack([P1, P2], dim=-1)
diff --git a/kornia/geometry/epipolar/scene.py b/kornia/geometry/epipolar/scene.py
new file mode 100644
index 0000000000000000000000000000000000000000..5cc506c4ad4b0ad313675b0085e3bc533ed1eaf5
--- /dev/null
+++ b/kornia/geometry/epipolar/scene.py
@@ -0,0 +1,45 @@
+"""Module to generate synthetic 3d scenes."""
+import math
+from typing import Dict
+
+import torch
+
+from kornia.geometry.conversions import angle_axis_to_rotation_matrix
+from kornia.geometry.linalg import transform_points
+
+from .projection import projection_from_KRt, random_intrinsics
+
+
+def generate_scene(num_views: int, num_points: int) -> Dict[str, torch.Tensor]:
+ # Generate the 3d points
+ points3d = torch.rand(1, num_points, 3) # NxMx3
+
+ # Create random camera matrix
+ K = random_intrinsics(0.0, 100.0) # 1x3x3
+
+ # Create random rotation per view
+ ang = torch.rand(num_views, 1) * math.pi * 2.0
+
+ rvec = torch.rand(num_views, 3)
+ rvec = ang * rvec / torch.norm(rvec, dim=1, keepdim=True) # Nx3
+ rot_mat = angle_axis_to_rotation_matrix(rvec) # Nx3x3
+ # matches with cv2.Rodrigues -> yay !
+
+ # Create random translation per view
+ tx = torch.empty(num_views).uniform_(-0.5, 0.5)
+ ty = torch.empty(num_views).uniform_(-0.5, 0.5)
+ tz = torch.empty(num_views).uniform_(-1.0, 2.0)
+ tvec = torch.stack([tx, ty, tz], dim=1)[..., None]
+
+ # Make sure the shape is in front of the camera
+ points3d_trans = (rot_mat @ points3d.transpose(-2, -1)) + tvec
+ min_dist = torch.min(points3d_trans[:, 2], dim=1)[0]
+ tvec[:, 2, 0] = torch.where(min_dist < 0, tz - min_dist + 1.0, tz)
+
+ # compute projection matrices
+ P = projection_from_KRt(K, rot_mat, tvec)
+
+ # project points3d and backproject to image plane
+ points2d = transform_points(P, points3d.expand(num_views, -1, -1))
+
+ return dict(K=K, R=rot_mat, t=tvec, P=P, points3d=points3d, points2d=points2d)
diff --git a/kornia/geometry/epipolar/triangulation.py b/kornia/geometry/epipolar/triangulation.py
new file mode 100644
index 0000000000000000000000000000000000000000..56745933928de64ec899a3d6365ad39ed43ca845
--- /dev/null
+++ b/kornia/geometry/epipolar/triangulation.py
@@ -0,0 +1,65 @@
+"""Module with the functionalites for triangulation."""
+
+import torch
+
+from kornia.geometry.conversions import convert_points_from_homogeneous
+
+# https://github.com/opencv/opencv_contrib/blob/master/modules/sfm/src/triangulation.cpp#L68
+
+
+def triangulate_points(
+ P1: torch.Tensor, P2: torch.Tensor, points1: torch.Tensor, points2: torch.Tensor
+) -> torch.Tensor:
+ r"""Reconstructs a bunch of points by triangulation.
+
+ Triangulates the 3d position of 2d correspondences between several images.
+ Reference: Internally it uses DLT method from Hartley/Zisserman 12.2 pag.312
+
+ The input points are assumed to be in homogeneous coordinate system and being inliers
+ correspondences. The method does not perform any robust estimation.
+
+ Args:
+ P1: The projection matrix for the first camera with shape :math:`(*, 3, 4)`.
+ P2: The projection matrix for the second camera with shape :math:`(*, 3, 4)`.
+ points1: The set of points seen from the first camera frame in the camera plane
+ coordinates with shape :math:`(*, N, 2)`.
+ points2: The set of points seen from the second camera frame in the camera plane
+ coordinates with shape :math:`(*, N, 2)`.
+
+ Returns:
+ The reconstructed 3d points in the world frame with shape :math:`(*, N, 3)`.
+
+ """
+ if not (len(P1.shape) >= 2 and P1.shape[-2:] == (3, 4)):
+ raise AssertionError(P1.shape)
+ if not (len(P2.shape) >= 2 and P2.shape[-2:] == (3, 4)):
+ raise AssertionError(P2.shape)
+ if len(P1.shape[:-2]) != len(P2.shape[:-2]):
+ raise AssertionError(P1.shape, P2.shape)
+ if not (len(points1.shape) >= 2 and points1.shape[-1] == 2):
+ raise AssertionError(points1.shape)
+ if not (len(points2.shape) >= 2 and points2.shape[-1] == 2):
+ raise AssertionError(points2.shape)
+ if len(points1.shape[:-2]) != len(points2.shape[:-2]):
+ raise AssertionError(points1.shape, points2.shape)
+ if len(P1.shape[:-2]) != len(points1.shape[:-2]):
+ raise AssertionError(P1.shape, points1.shape)
+
+ # allocate and construct the equations matrix with shape (*, 4, 4)
+ points_shape = max(points1.shape, points2.shape) # this allows broadcasting
+ X = torch.zeros(points_shape[:-1] + (4, 4)).type_as(points1)
+
+ for i in range(4):
+ X[..., 0, i] = points1[..., 0] * P1[..., 2:3, i] - P1[..., 0:1, i]
+ X[..., 1, i] = points1[..., 1] * P1[..., 2:3, i] - P1[..., 1:2, i]
+ X[..., 2, i] = points2[..., 0] * P2[..., 2:3, i] - P2[..., 0:1, i]
+ X[..., 3, i] = points2[..., 1] * P2[..., 2:3, i] - P2[..., 1:2, i]
+
+ # 1. Solve the system Ax=0 with smallest eigenvalue
+ # 2. Return homogeneous coordinates
+
+ _, _, V = torch.svd(X)
+
+ points3d_h = V[..., -1]
+ points3d: torch.Tensor = convert_points_from_homogeneous(points3d_h)
+ return points3d
diff --git a/kornia/geometry/homography.py b/kornia/geometry/homography.py
new file mode 100644
index 0000000000000000000000000000000000000000..b7b25ac0137ed34a4efd30a99574321f10bf1248
--- /dev/null
+++ b/kornia/geometry/homography.py
@@ -0,0 +1,182 @@
+import warnings
+from typing import Optional, Tuple
+
+import torch
+
+from kornia.utils import _extract_device_dtype, safe_inverse_with_mask
+
+from .conversions import convert_points_from_homogeneous
+from .epipolar import normalize_points
+from .linalg import transform_points
+
+TupleTensor = Tuple[torch.Tensor, torch.Tensor]
+
+
+def oneway_transfer_error(
+ pts1: torch.Tensor, pts2: torch.Tensor, H: torch.Tensor, squared: bool = True, eps: float = 1e-8
+) -> torch.Tensor:
+ r"""Return transfer error in image 2 for correspondences given the homography matrix.
+
+ Args:
+ pts1: correspondences from the left images with shape
+ (B, N, 2 or 3). If they are homogeneous, converted automatically.
+ pts2: correspondences from the right images with shape
+ (B, N, 2 or 3). If they are homogeneous, converted automatically.
+ H: Homographies with shape :math:`(B, 3, 3)`.
+ squared: if True (default), the squared distance is returned.
+ eps: Small constant for safe sqrt.
+
+ Returns:
+ the computed distance with shape :math:`(B, N)`.
+
+ """
+ if not isinstance(H, torch.Tensor):
+ raise TypeError(f"H type is not a torch.Tensor. Got {type(H)}")
+
+ if (len(H.shape) != 3) or not H.shape[-2:] == (3, 3):
+ raise ValueError(f"H must be a (*, 3, 3) tensor. Got {H.shape}")
+
+ if pts1.size(-1) == 3:
+ pts1 = convert_points_from_homogeneous(pts1)
+
+ if pts2.size(-1) == 3:
+ pts2 = convert_points_from_homogeneous(pts2)
+
+ # From Hartley and Zisserman, Error in one image (4.6)
+ # dist = \sum_{i} ( d(x', Hx)**2)
+ pts1_in_2: torch.Tensor = transform_points(H, pts1)
+ error_squared: torch.Tensor = (pts1_in_2 - pts2).pow(2).sum(dim=-1)
+ if squared:
+ return error_squared
+ return (error_squared + eps).sqrt()
+
+
+def symmetric_transfer_error(
+ pts1: torch.Tensor, pts2: torch.Tensor, H: torch.Tensor, squared: bool = True, eps: float = 1e-8
+) -> torch.Tensor:
+ r"""Return Symmetric transfer error for correspondences given the homography matrix.
+
+ Args:
+ pts1: correspondences from the left images with shape
+ (B, N, 2 or 3). If they are homogeneous, converted automatically.
+ pts2: correspondences from the right images with shape
+ (B, N, 2 or 3). If they are homogeneous, converted automatically.
+ H: Homographies with shape :math:`(B, 3, 3)`.
+ squared: if True (default), the squared distance is returned.
+ eps: Small constant for safe sqrt.
+
+ Returns:
+ the computed distance with shape :math:`(B, N)`.
+
+ """
+ if not isinstance(H, torch.Tensor):
+ raise TypeError(f"H type is not a torch.Tensor. Got {type(H)}")
+
+ if (len(H.shape) != 3) or not H.shape[-2:] == (3, 3):
+ raise ValueError(f"H must be a (*, 3, 3) tensor. Got {H.shape}")
+
+ if pts1.size(-1) == 3:
+ pts1 = convert_points_from_homogeneous(pts1)
+
+ if pts2.size(-1) == 3:
+ pts2 = convert_points_from_homogeneous(pts2)
+
+ max_num = torch.finfo(pts1.dtype).max
+ # From Hartley and Zisserman, Symmetric transfer error (4.7)
+ # dist = \sum_{i} (d(x, H^-1 x')**2 + d(x', Hx)**2)
+ H_inv, good_H = safe_inverse_with_mask(H)
+
+ there: torch.Tensor = oneway_transfer_error(pts1, pts2, H, True, eps)
+ back: torch.Tensor = oneway_transfer_error(pts2, pts1, H_inv, True, eps)
+ good_H_reshape: torch.Tensor = good_H.view(-1, 1).expand_as(there)
+ out = (there + back) * good_H_reshape.to(there.dtype) + max_num * (~good_H_reshape).to(there.dtype)
+ if squared:
+ return out
+ return (out + eps).sqrt()
+
+
+def find_homography_dlt(
+ points1: torch.Tensor, points2: torch.Tensor, weights: Optional[torch.Tensor] = None
+) -> torch.Tensor:
+ r"""Compute the homography matrix using the DLT formulation.
+
+ The linear system is solved by using the Weighted Least Squares Solution for the 4 Points algorithm.
+
+ Args:
+ points1: A set of points in the first image with a tensor shape :math:`(B, N, 2)`.
+ points2: A set of points in the second image with a tensor shape :math:`(B, N, 2)`.
+ weights: Tensor containing the weights per point correspondence with a shape of :math:`(B, N)`.
+
+ Returns:
+ the computed homography matrix with shape :math:`(B, 3, 3)`.
+ """
+ if points1.shape != points2.shape:
+ raise AssertionError(points1.shape)
+ if not (len(points1.shape) >= 1 and points1.shape[-1] == 2):
+ raise AssertionError(points1.shape)
+ if points1.shape[1] < 4:
+ raise AssertionError(points1.shape)
+
+ device, dtype = _extract_device_dtype([points1, points2])
+
+ eps: float = 1e-8
+ points1_norm, transform1 = normalize_points(points1)
+ points2_norm, transform2 = normalize_points(points2)
+
+ x1, y1 = torch.chunk(points1_norm, dim=-1, chunks=2) # BxNx1
+ x2, y2 = torch.chunk(points2_norm, dim=-1, chunks=2) # BxNx1
+ ones, zeros = torch.ones_like(x1), torch.zeros_like(x1)
+
+ # DIAPO 11: https://www.uio.no/studier/emner/matnat/its/nedlagte-emner/UNIK4690/v16/forelesninger/lecture_4_3-estimating-homographies-from-feature-correspondences.pdf # noqa: E501
+ ax = torch.cat([zeros, zeros, zeros, -x1, -y1, -ones, y2 * x1, y2 * y1, y2], dim=-1)
+ ay = torch.cat([x1, y1, ones, zeros, zeros, zeros, -x2 * x1, -x2 * y1, -x2], dim=-1)
+ A = torch.cat((ax, ay), dim=-1).reshape(ax.shape[0], -1, ax.shape[-1])
+
+ if weights is None:
+ # All points are equally important
+ A = A.transpose(-2, -1) @ A
+ else:
+ # We should use provided weights
+ if not (len(weights.shape) == 2 and weights.shape == points1.shape[:2]):
+ raise AssertionError(weights.shape)
+ w_diag = torch.diag_embed(weights.unsqueeze(dim=-1).repeat(1, 1, 2).reshape(weights.shape[0], -1))
+ A = A.transpose(-2, -1) @ w_diag @ A
+
+ try:
+ _, _, V = torch.svd(A)
+ except ValueError:
+ warnings.warn('SVD did not converge', RuntimeWarning)
+ return torch.empty((points1_norm.size(0), 3, 3), device=device, dtype=dtype)
+
+ H = V[..., -1].view(-1, 3, 3)
+ H = transform2.inverse() @ (H @ transform1)
+ H_norm = H / (H[..., -1:, -1:] + eps)
+ return H_norm
+
+
+def find_homography_dlt_iterated(
+ points1: torch.Tensor, points2: torch.Tensor, weights: torch.Tensor, soft_inl_th: float = 3.0, n_iter: int = 5
+) -> torch.Tensor:
+ r"""Compute the homography matrix using the iteratively-reweighted least squares (IRWLS).
+
+ The linear system is solved by using the Reweighted Least Squares Solution for the 4 Points algorithm.
+
+ Args:
+ points1: A set of points in the first image with a tensor shape :math:`(B, N, 2)`.
+ points2: A set of points in the second image with a tensor shape :math:`(B, N, 2)`.
+ weights: Tensor containing the weights per point correspondence with a shape of :math:`(B, N)`.
+ Used for the first iteration of the IRWLS.
+ soft_inl_th: Soft inlier threshold used for weight calculation.
+ n_iter: number of iterations.
+
+ Returns:
+ the computed homography matrix with shape :math:`(B, 3, 3)`.
+ """
+ '''Function, which finds homography via iteratively-reweighted
+ least squares ToDo: add citation'''
+ H: torch.Tensor = find_homography_dlt(points1, points2, weights)
+ for _ in range(n_iter - 1):
+ errors: torch.Tensor = symmetric_transfer_error(points1, points2, H, False)
+ weights_new: torch.Tensor = torch.exp(-errors / (2.0 * (soft_inl_th ** 2)))
+ H = find_homography_dlt(points1, points2, weights_new)
+ return H
diff --git a/kornia/geometry/linalg.py b/kornia/geometry/linalg.py
new file mode 100644
index 0000000000000000000000000000000000000000..1ccb643d690ce0f3dc137d7937eee474f4efb569
--- /dev/null
+++ b/kornia/geometry/linalg.py
@@ -0,0 +1,204 @@
+import torch
+
+from kornia.testing import check_is_tensor
+
+from .conversions import convert_points_from_homogeneous, convert_points_to_homogeneous
+
+__all__ = [
+ "compose_transformations",
+ "relative_transformation",
+ "inverse_transformation",
+ "transform_points",
+]
+
+
+def compose_transformations(trans_01: torch.Tensor, trans_12: torch.Tensor) -> torch.Tensor:
+ r"""Function that composes two homogeneous transformations.
+
+ .. math::
+ T_0^{2} = \begin{bmatrix} R_0^1 R_1^{2} & R_0^{1} t_1^{2} + t_0^{1} \\
+ \mathbf{0} & 1\end{bmatrix}
+
+ Args:
+ trans_01: tensor with the homogeneous transformation from
+ a reference frame 1 respect to a frame 0. The tensor has must have a
+ shape of :math:`(N, 4, 4)` or :math:`(4, 4)`.
+ trans_12: tensor with the homogeneous transformation from
+ a reference frame 2 respect to a frame 1. The tensor has must have a
+ shape of :math:`(N, 4, 4)` or :math:`(4, 4)`.
+
+ Returns:
+ the transformation between the two frames with shape :math:`(N, 4, 4)` or :math:`(4, 4)`.
+
+ Example::
+ >>> trans_01 = torch.eye(4) # 4x4
+ >>> trans_12 = torch.eye(4) # 4x4
+ >>> trans_02 = compose_transformations(trans_01, trans_12) # 4x4
+
+ """
+ if not torch.is_tensor(trans_01):
+ raise TypeError(f"Input trans_01 type is not a torch.Tensor. Got {type(trans_01)}")
+
+ if not torch.is_tensor(trans_12):
+ raise TypeError(f"Input trans_12 type is not a torch.Tensor. Got {type(trans_12)}")
+
+ if not ((trans_01.dim() in (2, 3)) and (trans_01.shape[-2:] == (4, 4))):
+ raise ValueError("Input trans_01 must be a of the shape Nx4x4 or 4x4." " Got {}".format(trans_01.shape))
+
+ if not ((trans_12.dim() in (2, 3)) and (trans_12.shape[-2:] == (4, 4))):
+ raise ValueError("Input trans_12 must be a of the shape Nx4x4 or 4x4." " Got {}".format(trans_12.shape))
+
+ if not trans_01.dim() == trans_12.dim():
+ raise ValueError(f"Input number of dims must match. Got {trans_01.dim()} and {trans_12.dim()}")
+
+ # unpack input data
+ rmat_01: torch.Tensor = trans_01[..., :3, :3] # Nx3x3
+ rmat_12: torch.Tensor = trans_12[..., :3, :3] # Nx3x3
+ tvec_01: torch.Tensor = trans_01[..., :3, -1:] # Nx3x1
+ tvec_12: torch.Tensor = trans_12[..., :3, -1:] # Nx3x1
+
+ # compute the actual transforms composition
+ rmat_02: torch.Tensor = torch.matmul(rmat_01, rmat_12)
+ tvec_02: torch.Tensor = torch.matmul(rmat_01, tvec_12) + tvec_01
+
+ # pack output tensor
+ trans_02: torch.Tensor = torch.zeros_like(trans_01)
+ trans_02[..., :3, 0:3] += rmat_02
+ trans_02[..., :3, -1:] += tvec_02
+ trans_02[..., -1, -1:] += 1.0
+ return trans_02
+
+
+def inverse_transformation(trans_12):
+ r"""Function that inverts a 4x4 homogeneous transformation
+ :math:`T_1^{2} = \begin{bmatrix} R_1 & t_1 \\ \mathbf{0} & 1 \end{bmatrix}`
+
+ The inverse transformation is computed as follows:
+
+ .. math::
+
+ T_2^{1} = (T_1^{2})^{-1} = \begin{bmatrix} R_1^T & -R_1^T t_1 \\
+ \mathbf{0} & 1\end{bmatrix}
+
+ Args:
+ trans_12: transformation tensor of shape :math:`(N, 4, 4)` or :math:`(4, 4)`.
+
+ Returns:
+ tensor with inverted transformations with shape :math:`(N, 4, 4)` or :math:`(4, 4)`.
+
+ Example:
+ >>> trans_12 = torch.rand(1, 4, 4) # Nx4x4
+ >>> trans_21 = inverse_transformation(trans_12) # Nx4x4
+ """
+ if not torch.is_tensor(trans_12):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(trans_12)}")
+ if not ((trans_12.dim() in (2, 3)) and (trans_12.shape[-2:] == (4, 4))):
+ raise ValueError(f"Input size must be a Nx4x4 or 4x4. Got {trans_12.shape}")
+ # unpack input tensor
+ rmat_12: torch.Tensor = trans_12[..., :3, 0:3] # Nx3x3
+ tvec_12: torch.Tensor = trans_12[..., :3, 3:4] # Nx3x1
+
+ # compute the actual inverse
+ rmat_21: torch.Tensor = torch.transpose(rmat_12, -1, -2)
+ tvec_21: torch.Tensor = torch.matmul(-rmat_21, tvec_12)
+
+ # pack to output tensor
+ trans_21: torch.Tensor = torch.zeros_like(trans_12)
+ trans_21[..., :3, 0:3] += rmat_21
+ trans_21[..., :3, -1:] += tvec_21
+ trans_21[..., -1, -1:] += 1.0
+ return trans_21
+
+
+def relative_transformation(trans_01: torch.Tensor, trans_02: torch.Tensor) -> torch.Tensor:
+ r"""Function that computes the relative homogeneous transformation from a
+ reference transformation :math:`T_1^{0} = \begin{bmatrix} R_1 & t_1 \\
+ \mathbf{0} & 1 \end{bmatrix}` to destination :math:`T_2^{0} =
+ \begin{bmatrix} R_2 & t_2 \\ \mathbf{0} & 1 \end{bmatrix}`.
+
+ The relative transformation is computed as follows:
+
+ .. math::
+
+ T_1^{2} = (T_0^{1})^{-1} \cdot T_0^{2}
+
+ Args:
+ trans_01: reference transformation tensor of shape :math:`(N, 4, 4)` or :math:`(4, 4)`.
+ trans_02: destination transformation tensor of shape :math:`(N, 4, 4)` or :math:`(4, 4)`.
+
+ Returns:
+ the relative transformation between the transformations with shape :math:`(N, 4, 4)` or :math:`(4, 4)`.
+
+ Example::
+ >>> trans_01 = torch.eye(4) # 4x4
+ >>> trans_02 = torch.eye(4) # 4x4
+ >>> trans_12 = relative_transformation(trans_01, trans_02) # 4x4
+ """
+ if not torch.is_tensor(trans_01):
+ raise TypeError(f"Input trans_01 type is not a torch.Tensor. Got {type(trans_01)}")
+ if not torch.is_tensor(trans_02):
+ raise TypeError(f"Input trans_02 type is not a torch.Tensor. Got {type(trans_02)}")
+ if not ((trans_01.dim() in (2, 3)) and (trans_01.shape[-2:] == (4, 4))):
+ raise ValueError("Input must be a of the shape Nx4x4 or 4x4." " Got {}".format(trans_01.shape))
+ if not ((trans_02.dim() in (2, 3)) and (trans_02.shape[-2:] == (4, 4))):
+ raise ValueError("Input must be a of the shape Nx4x4 or 4x4." " Got {}".format(trans_02.shape))
+ if not trans_01.dim() == trans_02.dim():
+ raise ValueError(f"Input number of dims must match. Got {trans_01.dim()} and {trans_02.dim()}")
+ trans_10: torch.Tensor = inverse_transformation(trans_01)
+ trans_12: torch.Tensor = compose_transformations(trans_10, trans_02)
+ return trans_12
+
+
+def transform_points(trans_01: torch.Tensor, points_1: torch.Tensor) -> torch.Tensor:
+ r"""Function that applies transformations to a set of points.
+
+ Args:
+ trans_01 (torch.Tensor): tensor for transformations of shape
+ :math:`(B, D+1, D+1)`.
+ points_1 (torch.Tensor): tensor of points of shape :math:`(B, N, D)`.
+ Returns:
+ torch.Tensor: tensor of N-dimensional points.
+
+ Shape:
+ - Output: :math:`(B, N, D)`
+
+ Examples:
+
+ >>> points_1 = torch.rand(2, 4, 3) # BxNx3
+ >>> trans_01 = torch.eye(4).view(1, 4, 4) # Bx4x4
+ >>> points_0 = transform_points(trans_01, points_1) # BxNx3
+ """
+ check_is_tensor(trans_01)
+ check_is_tensor(points_1)
+ if not trans_01.shape[0] == points_1.shape[0] and trans_01.shape[0] != 1:
+ raise ValueError(
+ "Input batch size must be the same for both tensors or 1."
+ f"Got {trans_01.shape} and {points_1.shape}"
+ )
+ if not trans_01.shape[-1] == (points_1.shape[-1] + 1):
+ raise ValueError(
+ "Last input dimensions must differ by one unit"
+ f"Got{trans_01} and {points_1}"
+ )
+
+ # We reshape to BxNxD in case we get more dimensions, e.g., MxBxNxD
+ shape_inp = list(points_1.shape)
+ points_1 = points_1.reshape(-1, points_1.shape[-2], points_1.shape[-1])
+ trans_01 = trans_01.reshape(-1, trans_01.shape[-2], trans_01.shape[-1])
+ # We expand trans_01 to match the dimensions needed for bmm
+ trans_01 = torch.repeat_interleave(trans_01, repeats=points_1.shape[0] // trans_01.shape[0], dim=0)
+ # to homogeneous
+ points_1_h = convert_points_to_homogeneous(points_1) # BxNxD+1
+ # transform coordinates
+ points_0_h = torch.bmm(points_1_h, trans_01.permute(0, 2, 1))
+ points_0_h = torch.squeeze(points_0_h, dim=-1)
+ # to euclidean
+ points_0 = convert_points_from_homogeneous(points_0_h) # BxNxD
+ # reshape to the input shape
+ shape_inp[-2] = points_0.shape[-2]
+ shape_inp[-1] = points_0.shape[-1]
+ points_0 = points_0.reshape(shape_inp)
+ return points_0
+
+# TODO:
+# - project_points: from opencv
diff --git a/kornia/geometry/ransac.py b/kornia/geometry/ransac.py
new file mode 100644
index 0000000000000000000000000000000000000000..5fb3c67b1338cc804210d54c18da0c7bea04add7
--- /dev/null
+++ b/kornia/geometry/ransac.py
@@ -0,0 +1,225 @@
+"""Module containing RANSAC modules."""
+import math
+from typing import Optional, Tuple
+
+import torch
+import torch.nn as nn
+
+from kornia.geometry import (
+ find_fundamental,
+ find_homography_dlt,
+ find_homography_dlt_iterated,
+ symmetrical_epipolar_distance,
+)
+from kornia.geometry.homography import symmetric_transfer_error
+
+__all__ = ["RANSAC"]
+
+
+class RANSAC(nn.Module):
+ """Module for robust geometry estimation with RANSAC.
+
+ https://en.wikipedia.org/wiki/Random_sample_consensus
+
+ Args:
+ model_type: type of model to estimate, e.g. "homography" or "fundamental".
+ inliers_threshold: threshold for the correspondence to be an inlier.
+ batch_size: number of generated samples at once.
+ max_iterations: maximum batches to generate. Actual number of models to try is ``batch_size * max_iterations``.
+ confidence: desired confidence of the result, used for the early stopping.
+ max_local_iterations: number of local optimization (polishing) iterations.
+ """
+ supported_models = ['homography', 'fundamental']
+
+ def __init__(self,
+ model_type: str = 'homography',
+ inl_th: float = 2.0,
+ batch_size: int = 2048,
+ max_iter: int = 10,
+ confidence: float = 0.99,
+ max_lo_iters: int = 5):
+ super().__init__()
+ self.inl_th = inl_th
+ self.max_iter = max_iter
+ self.batch_size = batch_size
+ self.model_type = model_type
+ self.confidence = confidence
+ self.max_lo_iters = max_lo_iters
+ self.model_type = model_type
+ if model_type == 'homography':
+ self.error_fn = symmetric_transfer_error # type: ignore
+ self.minimal_solver = find_homography_dlt # type: ignore
+ self.polisher_solver = find_homography_dlt_iterated # type: ignore
+ self.minimal_sample_size = 4
+ elif model_type == 'fundamental':
+ self.error_fn = symmetrical_epipolar_distance # type: ignore
+ self.minimal_solver = find_fundamental # type: ignore
+ self.minimal_sample_size = 8
+ # ToDo: implement 7pt solver instead of 8pt minimal_solver
+ # https://github.com/opencv/opencv/blob/master/modules/calib3d/src/fundam.cpp#L498
+ self.polisher_solver = find_fundamental # type: ignore
+ else:
+ raise NotImplementedError(f"{model_type} is unknown. Try one of {self.supported_models}")
+
+ def sample(self,
+ sample_size: int,
+ pop_size: int,
+ batch_size: int,
+ device: torch.device = torch.device('cpu')) -> torch.Tensor:
+ """Minimal sampler, but unlike traditional RANSAC we sample in batches to get benefit of the parallel
+ processing, esp.
+
+ on GPU
+ """
+ rand = torch.rand(batch_size, pop_size, device=device)
+ _, out = rand.topk(k=sample_size, dim=1)
+ return out
+
+ @staticmethod
+ def max_samples_by_conf(n_inl: int, num_tc: int, sample_size: int, conf: float) -> float:
+ """Formula to update max_iter in order to stop iterations earlier
+ https://en.wikipedia.org/wiki/Random_sample_consensus."""
+ if n_inl == num_tc:
+ return 1.0
+ return math.log(1.0 - conf) / math.log(1. - math.pow(n_inl / num_tc, sample_size))
+
+ def estimate_model_from_minsample(self,
+ kp1: torch.Tensor,
+ kp2: torch.Tensor) -> torch.Tensor:
+ batch_size, sample_size = kp1.shape[:2]
+ H = self.minimal_solver(kp1,
+ kp2,
+ torch.ones(batch_size,
+ sample_size,
+ dtype=kp1.dtype,
+ device=kp1.device))
+ return H
+
+ def verify(self,
+ kp1: torch.Tensor,
+ kp2: torch.Tensor,
+ models: torch.Tensor, inl_th: float) -> Tuple[torch.Tensor, torch.Tensor, float]:
+ if len(kp1.shape) == 2:
+ kp1 = kp1[None]
+ if len(kp2.shape) == 2:
+ kp2 = kp2[None]
+ batch_size = models.shape[0]
+ errors = self.error_fn(kp1.expand(batch_size, -1, 2),
+ kp2.expand(batch_size, -1, 2),
+ models)
+ inl = (errors <= inl_th)
+ models_score = inl.to(kp1).sum(dim=1)
+ best_model_idx = models_score.argmax()
+ best_model_score = models_score[best_model_idx].item()
+ model_best = models[best_model_idx].clone()
+ inliers_best = inl[best_model_idx]
+ return model_best, inliers_best, best_model_score
+
+ def remove_bad_samples(self, kp1: torch.Tensor, kp2: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+ """"""
+ # ToDo: add (model-specific) verification of the samples,
+ # E.g. constraints on not to be a degenerate sample
+ return kp1, kp2
+
+ def remove_bad_models(self, models: torch.Tensor) -> torch.Tensor:
+ # ToDo: add more and better degenerate model rejection
+ # For now it is simple and hardcoded
+ main_diagonal = torch.diagonal(models,
+ dim1=1,
+ dim2=2)
+ mask = main_diagonal.abs().min(dim=1)[0] > 1e-4
+ return models[mask]
+
+ def polish_model(self,
+ kp1: torch.Tensor,
+ kp2: torch.Tensor,
+ inliers: torch.Tensor) -> torch.Tensor:
+ # TODO: Replace this with MAGSAC++ polisher
+ kp1_inl = kp1[inliers][None]
+ kp2_inl = kp2[inliers][None]
+ num_inl = kp1_inl.size(1)
+ model = self.polisher_solver(kp1_inl,
+ kp2_inl,
+ torch.ones(1,
+ num_inl,
+ dtype=kp1_inl.dtype,
+ device=kp1_inl.device))
+ return model
+
+ def forward(self,
+ kp1: torch.Tensor,
+ kp2: torch.Tensor,
+ weights: Optional[torch.Tensor] = None) -> Tuple[torch.Tensor, torch.Tensor]:
+ r"""Main forward method to execute the RANSAC algorithm.
+
+ Args:
+ kp1 (torch.Tensor): source image keypoints :math:`(N, 2)`.
+ kp2 (torch.Tensor): distance image keypoints :math:`(N, 2)`.
+ weights (torch.Tensor): optional correspondences weights. Not used now
+
+ Returns:
+ - Estimated model, shape of :math:`(1, 3, 3)`.
+ - The inlier/outlier mask, shape of :math:`(1, N)`, where N is number of input correspondences.
+ """
+ if not isinstance(kp1, torch.Tensor):
+ raise TypeError(f"Input kp1 is not torch.Tensor. Got {type(kp1)}")
+ if not isinstance(kp2, torch.Tensor):
+ raise TypeError(f"Input kp2 is not torch.Tensor. Got {type(kp2)}")
+ if not len(kp1.shape) == 2:
+ raise ValueError(f"Invalid kp1 shape, we expect Nx2 Got: {kp1.shape}")
+ if not len(kp2.shape) == 2:
+ raise ValueError(f"Invalid kp2 shape, we expect Nx2 Got: {kp2.shape}")
+ if not (kp1.shape[0] == kp2.shape[0]) or (kp1.shape[0] < self.minimal_sample_size):
+ raise ValueError(f"kp1 and kp2 should be \
+ equal shape at at least [{self.minimal_sample_size}, 2], \
+ got {kp1.shape}, {kp2.shape}")
+
+ best_score_total: float = float(self.minimal_sample_size)
+ num_tc: int = len(kp1)
+ best_model_total = torch.zeros(3, 3, dtype=kp1.dtype, device=kp1.device)
+ inliers_best_total: torch.Tensor = torch.zeros(num_tc, 1, device=kp1.device, dtype=torch.bool)
+ for i in range(self.max_iter):
+ # Sample minimal samples in batch to estimate models
+ idxs = self.sample(self.minimal_sample_size, num_tc, self.batch_size, kp1.device)
+ kp1_sampled = kp1[idxs]
+ kp2_sampled = kp2[idxs]
+
+ kp1_sampled, kp2_sampled = self.remove_bad_samples(kp1_sampled, kp2_sampled)
+ # Estimate models
+ models = self.estimate_model_from_minsample(kp1_sampled, kp2_sampled)
+ models = self.remove_bad_models(models)
+ if (models is None) or (len(models) == 0):
+ continue
+ # Score the models and select the best one
+ model, inliers, model_score = self.verify(kp1, kp2, models, self.inl_th)
+ # Store far-the-best model and (optionally) do a local optimization
+ if model_score > best_score_total:
+ # Local optimization
+ for lo_step in range(self.max_lo_iters):
+ model_lo = self.polish_model(kp1, kp2, inliers)
+ if (model_lo is None) or (len(model_lo) == 0):
+ continue
+ _, inliers_lo, score_lo = self.verify(kp1, kp2, model_lo, self.inl_th)
+ # print (f"Orig score = {best_model_score}, LO score = {score_lo} TC={num_tc}")
+ if score_lo > model_score:
+ model = model_lo.clone()[0]
+ inliers = inliers_lo.clone()
+ model_score = score_lo
+ else:
+ break
+ # Now storing the best model
+ best_model_total = model.clone()
+ inliers_best_total = inliers.clone()
+ best_score_total = model_score
+
+ # Should we already stop?
+ new_max_iter = int(self.max_samples_by_conf(int(best_score_total),
+ num_tc,
+ self.minimal_sample_size,
+ self.confidence))
+ # print (f"New max_iter = {new_max_iter}")
+ # Stop estimation, if the model is very good
+ if (i + 1) * self.batch_size >= new_max_iter:
+ break
+ # local optimization with all inliers for better precision
+ return best_model_total, inliers_best_total
diff --git a/kornia/geometry/subpix/__init__.py b/kornia/geometry/subpix/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..62ea4cdd954c1b9db0ef205aea6f0e7b52bf7486
--- /dev/null
+++ b/kornia/geometry/subpix/__init__.py
@@ -0,0 +1,30 @@
+from .dsnt import render_gaussian2d, spatial_expectation2d, spatial_softmax2d
+from .nms import nms2d, nms3d, NonMaximaSuppression2d, NonMaximaSuppression3d
+from .spatial_soft_argmax import (
+ conv_quad_interp3d,
+ conv_soft_argmax2d,
+ conv_soft_argmax3d,
+ ConvQuadInterp3d,
+ ConvSoftArgmax2d,
+ ConvSoftArgmax3d,
+ spatial_soft_argmax2d,
+ SpatialSoftArgmax2d,
+)
+
+__all__ = [
+ "conv_soft_argmax2d",
+ "conv_soft_argmax3d",
+ "ConvSoftArgmax2d",
+ "ConvSoftArgmax3d",
+ "spatial_soft_argmax2d",
+ "SpatialSoftArgmax2d",
+ "conv_quad_interp3d",
+ "ConvQuadInterp3d",
+ "NonMaximaSuppression2d",
+ "NonMaximaSuppression3d",
+ "nms2d",
+ "nms3d",
+ "spatial_softmax2d",
+ "spatial_expectation2d",
+ "render_gaussian2d",
+]
diff --git a/kornia/geometry/subpix/dsnt.py b/kornia/geometry/subpix/dsnt.py
new file mode 100644
index 0000000000000000000000000000000000000000..8b991250cdb4012e26ea0737c913fcd7b292b328
--- /dev/null
+++ b/kornia/geometry/subpix/dsnt.py
@@ -0,0 +1,151 @@
+r"""Implementation of "differentiable spatial to numerical" (soft-argmax)
+operations, as described in the paper "Numerical Coordinate Regression with
+Convolutional Neural Networks" by Nibali et al.
+"""
+
+from typing import Tuple
+
+import torch
+import torch.nn.functional as F
+
+from kornia.testing import check_is_tensor
+from kornia.utils.grid import create_meshgrid
+
+
+def _validate_batched_image_tensor_input(tensor):
+ check_is_tensor(tensor)
+ if not len(tensor.shape) == 4:
+ raise ValueError(f"Invalid input shape, we expect BxCxHxW. Got: {tensor.shape}")
+
+
+def spatial_softmax2d(input: torch.Tensor, temperature: torch.Tensor = torch.tensor(1.0)) -> torch.Tensor:
+ r"""Apply the Softmax function over features in each image channel.
+
+ Note that this function behaves differently to :py:class:`torch.nn.Softmax2d`, which
+ instead applies Softmax over features at each spatial location.
+
+ Args:
+ input: the input tensor with shape :math:`(B, N, H, W)`.
+ temperature: factor to apply to input, adjusting the "smoothness" of the output distribution.
+
+ Returns:
+ a 2D probability distribution per image channel with shape :math:`(B, N, H, W)`.
+
+ Examples:
+ >>> heatmaps = torch.tensor([[[
+ ... [0., 0., 0.],
+ ... [0., 0., 0.],
+ ... [0., 1., 2.]]]])
+ >>> spatial_softmax2d(heatmaps)
+ tensor([[[[0.0585, 0.0585, 0.0585],
+ [0.0585, 0.0585, 0.0585],
+ [0.0585, 0.1589, 0.4319]]]])
+ """
+ _validate_batched_image_tensor_input(input)
+
+ batch_size, channels, height, width = input.shape
+ temperature = temperature.to(device=input.device, dtype=input.dtype)
+ x: torch.Tensor = input.view(batch_size, channels, -1)
+
+ x_soft: torch.Tensor = F.softmax(x * temperature, dim=-1)
+
+ return x_soft.view(batch_size, channels, height, width)
+
+
+def spatial_expectation2d(input: torch.Tensor, normalized_coordinates: bool = True) -> torch.Tensor:
+ r"""Compute the expectation of coordinate values using spatial probabilities.
+
+ The input heatmap is assumed to represent a valid spatial probability distribution,
+ which can be achieved using :func:`~kornia.geometry.subpixel.spatial_softmax2d`.
+
+ Args:
+ input: the input tensor representing dense spatial probabilities with shape :math:`(B, N, H, W)`.
+ normalized_coordinates: whether to return the coordinates normalized in the range
+ of :math:`[-1, 1]`. Otherwise, it will return the coordinates in the range of the input shape.
+
+ Returns:
+ expected value of the 2D coordinates with shape :math:`(B, N, 2)`. Output order of the coordinates is (x, y).
+
+ Examples:
+ >>> heatmaps = torch.tensor([[[
+ ... [0., 0., 0.],
+ ... [0., 0., 0.],
+ ... [0., 1., 0.]]]])
+ >>> spatial_expectation2d(heatmaps, False)
+ tensor([[[1., 2.]]])
+ """
+ _validate_batched_image_tensor_input(input)
+
+ batch_size, channels, height, width = input.shape
+
+ # Create coordinates grid.
+ grid: torch.Tensor = create_meshgrid(height, width, normalized_coordinates, input.device)
+ grid = grid.to(input.dtype)
+
+ pos_x: torch.Tensor = grid[..., 0].reshape(-1)
+ pos_y: torch.Tensor = grid[..., 1].reshape(-1)
+
+ input_flat: torch.Tensor = input.view(batch_size, channels, -1)
+
+ # Compute the expectation of the coordinates.
+ expected_y: torch.Tensor = torch.sum(pos_y * input_flat, -1, keepdim=True)
+ expected_x: torch.Tensor = torch.sum(pos_x * input_flat, -1, keepdim=True)
+
+ output: torch.Tensor = torch.cat([expected_x, expected_y], -1)
+
+ return output.view(batch_size, channels, 2) # BxNx2
+
+
+def _safe_zero_division(numerator: torch.Tensor, denominator: torch.Tensor, eps: float = 1e-32) -> torch.Tensor:
+ return numerator / torch.clamp(denominator, min=eps)
+
+
+def render_gaussian2d(
+ mean: torch.Tensor, std: torch.Tensor, size: Tuple[int, int], normalized_coordinates: bool = True
+):
+ r"""Render the PDF of a 2D Gaussian distribution.
+
+ Args:
+ mean: the mean location of the Gaussian to render, :math:`(\mu_x, \mu_y)`. Shape: :math:`(*, 2)`.
+ std: the standard deviation of the Gaussian to render, :math:`(\sigma_x, \sigma_y)`.
+ Shape :math:`(*, 2)`. Should be able to be broadcast with `mean`.
+ size: the (height, width) of the output image.
+ normalized_coordinates: whether ``mean`` and ``std`` are assumed to use coordinates normalized
+ in the range of :math:`[-1, 1]`. Otherwise, coordinates are assumed to be in the range of the output shape.
+
+ Returns:
+ tensor including rendered points with shape :math:`(*, H, W)`.
+ """
+ if not (std.dtype == mean.dtype and std.device == mean.device):
+ raise TypeError("Expected inputs to have the same dtype and device")
+
+ height, width = size
+
+ # Create coordinates grid.
+ grid: torch.Tensor = create_meshgrid(height, width, normalized_coordinates, mean.device)
+ grid = grid.to(mean.dtype)
+ pos_x: torch.Tensor = grid[..., 0].view(height, width)
+ pos_y: torch.Tensor = grid[..., 1].view(height, width)
+
+ # Gaussian PDF = exp(-(x - \mu)^2 / (2 \sigma^2))
+ # = exp(dists * ks),
+ # where dists = (x - \mu)^2 and ks = -1 / (2 \sigma^2)
+
+ # dists <- (x - \mu)^2
+ dist_x = (pos_x - mean[..., 0, None, None]) ** 2
+ dist_y = (pos_y - mean[..., 1, None, None]) ** 2
+
+ # ks <- -1 / (2 \sigma^2)
+ k_x = -0.5 * torch.reciprocal(std[..., 0, None, None])
+ k_y = -0.5 * torch.reciprocal(std[..., 1, None, None])
+
+ # Assemble the 2D Gaussian.
+ exps_x = torch.exp(dist_x * k_x)
+ exps_y = torch.exp(dist_y * k_y)
+ gauss = exps_x * exps_y
+
+ # Rescale so that values sum to one.
+ val_sum = gauss.sum(-2, keepdim=True).sum(-1, keepdim=True)
+ gauss = _safe_zero_division(gauss, val_sum)
+
+ return gauss
diff --git a/kornia/geometry/subpix/nms.py b/kornia/geometry/subpix/nms.py
new file mode 100644
index 0000000000000000000000000000000000000000..bbd3056fdf5ecd4c4d2f46063f4940fe3cf77378
--- /dev/null
+++ b/kornia/geometry/subpix/nms.py
@@ -0,0 +1,161 @@
+from typing import Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+def _get_nms_kernel2d(kx: int, ky: int) -> torch.Tensor:
+ """Utility function, which returns neigh2channels conv kernel."""
+ numel: int = ky * kx
+ center: int = numel // 2
+ weight = torch.eye(numel)
+ weight[center, center] = 0
+ return weight.view(numel, 1, ky, kx)
+
+
+def _get_nms_kernel3d(kd: int, ky: int, kx: int) -> torch.Tensor:
+ """Utility function, which returns neigh2channels conv kernel."""
+ numel: int = kd * ky * kx
+ center: int = numel // 2
+ weight = torch.eye(numel)
+ weight[center, center] = 0
+ return weight.view(numel, 1, kd, ky, kx)
+
+
+class NonMaximaSuppression2d(nn.Module):
+ r"""Apply non maxima suppression to filter."""
+
+ def __init__(self, kernel_size: Tuple[int, int]):
+ super().__init__()
+ self.kernel_size: Tuple[int, int] = kernel_size
+ self.padding: Tuple[int, int, int, int] = self._compute_zero_padding2d(kernel_size)
+ self.kernel = _get_nms_kernel2d(*kernel_size)
+
+ @staticmethod
+ def _compute_zero_padding2d(kernel_size: Tuple[int, int]) -> Tuple[int, int, int, int]:
+ if not isinstance(kernel_size, tuple):
+ raise AssertionError(type(kernel_size))
+ if len(kernel_size) != 2:
+ raise AssertionError(kernel_size)
+
+ def pad(x):
+ return (x - 1) // 2 # zero padding function
+
+ ky, kx = kernel_size # we assume a cubic kernel
+ return (pad(ky), pad(ky), pad(kx), pad(kx))
+
+ def forward(self, x: torch.Tensor, mask_only: bool = False) -> torch.Tensor: # type: ignore
+ if len(x.shape) != 4:
+ raise AssertionError(x.shape)
+ B, CH, H, W = x.size()
+ # find local maximum values
+ max_non_center = (
+ F.conv2d(
+ F.pad(x, list(self.padding)[::-1], mode='replicate'),
+ self.kernel.repeat(CH, 1, 1, 1).to(x.device, x.dtype),
+ stride=1,
+ groups=CH,
+ )
+ .view(B, CH, -1, H, W)
+ .max(dim=2)[0]
+ )
+ mask = x > max_non_center
+ if mask_only:
+ return mask
+ return x * (mask.to(x.dtype))
+
+
+class NonMaximaSuppression3d(nn.Module):
+ r"""Apply non maxima suppression to filter."""
+
+ def __init__(self, kernel_size: Tuple[int, int, int]):
+ super().__init__()
+ self.kernel_size: Tuple[int, int, int] = kernel_size
+ self.padding: Tuple[int, int, int, int, int, int] = self._compute_zero_padding3d(kernel_size)
+ self.kernel = _get_nms_kernel3d(*kernel_size)
+
+ @staticmethod
+ def _compute_zero_padding3d(kernel_size: Tuple[int, int, int]) -> Tuple[int, int, int, int, int, int]:
+ if not isinstance(kernel_size, tuple):
+ raise AssertionError(type(kernel_size))
+ if len(kernel_size) != 3:
+ raise AssertionError(kernel_size)
+
+ def pad(x):
+ return (x - 1) // 2 # zero padding function
+
+ kd, ky, kx = kernel_size # we assume a cubic kernel
+ return pad(kd), pad(kd), pad(ky), pad(ky), pad(kx), pad(kx)
+
+ def forward(self, x: torch.Tensor, mask_only: bool = False) -> torch.Tensor: # type: ignore
+ if len(x.shape) != 5:
+ raise AssertionError(x.shape)
+ # find local maximum values
+ B, CH, D, H, W = x.size()
+ if self.kernel_size == (3, 3, 3):
+ mask = torch.zeros(B, CH, D, H, W, device=x.device, dtype=torch.bool)
+ center = slice(1, -1)
+ left = slice(0, -2)
+ right = slice(2, None)
+ center_tensor = x[..., center, center, center]
+ mask[..., 1: -1, 1: -1, 1: -1] = ((center_tensor > x[..., center, center, left]) & # noqa: W504
+ (center_tensor > x[..., center, center, right]) & # noqa: W504
+ (center_tensor > x[..., center, left, center]) & # noqa: W504
+ (center_tensor > x[..., center, left, left]) & # noqa: W504
+ (center_tensor > x[..., center, left, right]) & # noqa: W504
+ (center_tensor > x[..., center, right, center]) & # noqa: W504
+ (center_tensor > x[..., center, right, left]) & # noqa: W504
+ (center_tensor > x[..., center, right, right]) & # noqa: W504
+ (center_tensor > x[..., left, center, center]) & # noqa: W504
+ (center_tensor > x[..., left, center, left]) & # noqa: W504
+ (center_tensor > x[..., left, center, right]) & # noqa: W504
+ (center_tensor > x[..., left, left, center]) & # noqa: W504
+ (center_tensor > x[..., left, left, left]) & # noqa: W504
+ (center_tensor > x[..., left, left, right]) & # noqa: W504
+ (center_tensor > x[..., left, right, center]) & # noqa: W504
+ (center_tensor > x[..., left, right, left]) & # noqa: W504
+ (center_tensor > x[..., left, right, right]) & # noqa: W504
+ (center_tensor > x[..., right, center, center]) & # noqa: W504
+ (center_tensor > x[..., right, center, left]) & # noqa: W504
+ (center_tensor > x[..., right, center, right]) & # noqa: W504
+ (center_tensor > x[..., right, left, center]) & # noqa: W504
+ (center_tensor > x[..., right, left, left]) & # noqa: W504
+ (center_tensor > x[..., right, left, right]) & # noqa: W504
+ (center_tensor > x[..., right, right, center]) & # noqa: W504
+ (center_tensor > x[..., right, right, left]) & # noqa: W504
+ (center_tensor > x[..., right, right, right]))
+ else:
+ max_non_center = (
+ F.conv3d(
+ F.pad(x, list(self.padding)[::-1], mode='replicate'),
+ self.kernel.repeat(CH, 1, 1, 1, 1).to(x.device, x.dtype),
+ stride=1,
+ groups=CH,
+ )
+ .view(B, CH, -1, D, H, W)
+ .max(dim=2, keepdim=False)[0]
+ )
+ mask = x > max_non_center
+ if mask_only:
+ return mask
+ return x * (mask.to(x.dtype))
+
+
+# functional api
+
+
+def nms2d(input: torch.Tensor, kernel_size: Tuple[int, int], mask_only: bool = False) -> torch.Tensor:
+ r"""Apply non maxima suppression to filter.
+
+ See :class:`~kornia.geometry.subpix.NonMaximaSuppression2d` for details.
+ """
+ return NonMaximaSuppression2d(kernel_size)(input, mask_only)
+
+
+def nms3d(input: torch.Tensor, kernel_size: Tuple[int, int, int], mask_only: bool = False) -> torch.Tensor:
+ r"""Apply non maxima suppression to filter.
+
+ See :class:`~kornia.feature.NonMaximaSuppression3d` for details.
+ """
+ return NonMaximaSuppression3d(kernel_size)(input, mask_only)
diff --git a/kornia/geometry/subpix/spatial_soft_argmax.py b/kornia/geometry/subpix/spatial_soft_argmax.py
new file mode 100644
index 0000000000000000000000000000000000000000..13efd60e83a1b94c6b4ed1b58b9571d29475c112
--- /dev/null
+++ b/kornia/geometry/subpix/spatial_soft_argmax.py
@@ -0,0 +1,665 @@
+from typing import Tuple, Union
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from kornia.filters.sobel import spatial_gradient3d
+from kornia.geometry.conversions import normalize_pixel_coordinates, normalize_pixel_coordinates3d
+from kornia.utils import create_meshgrid, create_meshgrid3d
+from kornia.utils._compat import torch_version_geq
+from kornia.utils.helpers import safe_solve_with_mask
+
+from .dsnt import spatial_expectation2d, spatial_softmax2d
+from .nms import nms3d
+
+
+def _get_window_grid_kernel2d(h: int, w: int, device: torch.device = torch.device('cpu')) -> torch.Tensor:
+ r"""Helper function, which generates a kernel to with window coordinates,
+ residual to window center.
+
+ Args:
+ h: kernel height.
+ : kernel width.
+ device: device, on which generate.
+
+ Returns:
+ conv_kernel [2x1xhxw]
+ """
+ window_grid2d = create_meshgrid(h, w, False, device=device)
+ window_grid2d = normalize_pixel_coordinates(window_grid2d, h, w)
+ conv_kernel = window_grid2d.permute(3, 0, 1, 2)
+ return conv_kernel
+
+
+def _get_center_kernel2d(h: int, w: int, device: torch.device = torch.device('cpu')) -> torch.Tensor:
+ r"""Helper function, which generates a kernel to return center coordinates,
+ when applied with F.conv2d to 2d coordinates grid.
+
+ Args:
+ h: kernel height.
+ w: kernel width.
+ device: device, on which generate.
+
+ Returns:
+ conv_kernel [2x2xhxw].
+ """
+ center_kernel = torch.zeros(2, 2, h, w, device=device)
+
+ # If the size is odd, we have one pixel for center, if even - 2
+ if h % 2 != 0:
+ h_i1 = h // 2
+ h_i2 = (h // 2) + 1
+ else:
+ h_i1 = (h // 2) - 1
+ h_i2 = (h // 2) + 1
+ if w % 2 != 0:
+ w_i1 = w // 2
+ w_i2 = (w // 2) + 1
+ else:
+ w_i1 = (w // 2) - 1
+ w_i2 = (w // 2) + 1
+ center_kernel[(0, 1), (0, 1), h_i1:h_i2, w_i1:w_i2] = 1.0 / float((h_i2 - h_i1) * (w_i2 - w_i1))
+ return center_kernel
+
+
+def _get_center_kernel3d(d: int, h: int, w: int, device: torch.device = torch.device('cpu')) -> torch.Tensor:
+ r"""Helper function, which generates a kernel to return center coordinates,
+ when applied with F.conv2d to 3d coordinates grid.
+
+ Args:
+ d: kernel depth.
+ h: kernel height.
+ w: kernel width.
+ device: device, on which generate.
+
+ Returns:
+ conv_kernel [3x3xdxhxw].
+ """
+ center_kernel = torch.zeros(3, 3, d, h, w, device=device)
+ # If the size is odd, we have one pixel for center, if even - 2
+ if h % 2 != 0:
+ h_i1 = h // 2
+ h_i2 = (h // 2) + 1
+ else:
+ h_i1 = (h // 2) - 1
+ h_i2 = (h // 2) + 1
+ if w % 2 != 0:
+ w_i1 = w // 2
+ w_i2 = (w // 2) + 1
+ else:
+ w_i1 = (w // 2) - 1
+ w_i2 = (w // 2) + 1
+ if d % 2 != 0:
+ d_i1 = d // 2
+ d_i2 = (d // 2) + 1
+ else:
+ d_i1 = (d // 2) - 1
+ d_i2 = (d // 2) + 1
+ center_num = float((h_i2 - h_i1) * (w_i2 - w_i1) * (d_i2 - d_i1))
+ center_kernel[(0, 1, 2), (0, 1, 2), d_i1:d_i2, h_i1:h_i2, w_i1:w_i2] = 1.0 / center_num
+ return center_kernel
+
+
+def _get_window_grid_kernel3d(d: int, h: int, w: int, device: torch.device = torch.device('cpu')) -> torch.Tensor:
+ r"""Helper function, which generates a kernel to return coordinates,
+ residual to window center.
+
+ Args:
+ d: kernel depth.
+ h: kernel height.
+ w: kernel width.
+ device: device, on which generate.
+
+ Returns:
+ conv_kernel [3x1xdxhxw]
+ """
+ grid2d = create_meshgrid(h, w, True, device=device)
+ if d > 1:
+ z = torch.linspace(-1, 1, d, device=device).view(d, 1, 1, 1)
+ else: # only onr channel with index == 0
+ z = torch.zeros(1, 1, 1, 1, device=device)
+ grid3d = torch.cat([z.repeat(1, h, w, 1).contiguous(), grid2d.repeat(d, 1, 1, 1)], dim=3)
+ conv_kernel = grid3d.permute(3, 0, 1, 2).unsqueeze(1)
+ return conv_kernel
+
+
+class ConvSoftArgmax2d(nn.Module):
+ r"""Module that calculates soft argmax 2d per window.
+
+ See :func:`~kornia.geometry.subpix.conv_soft_argmax2d` for details.
+ """
+
+ def __init__(
+ self,
+ kernel_size: Tuple[int, int] = (3, 3),
+ stride: Tuple[int, int] = (1, 1),
+ padding: Tuple[int, int] = (1, 1),
+ temperature: Union[torch.Tensor, float] = torch.tensor(1.0),
+ normalized_coordinates: bool = True,
+ eps: float = 1e-8,
+ output_value: bool = False,
+ ) -> None:
+ super().__init__()
+ self.kernel_size = kernel_size
+ self.stride = stride
+ self.padding = padding
+ self.temperature = temperature
+ self.normalized_coordinates = normalized_coordinates
+ self.eps = eps
+ self.output_value = output_value
+
+ def __repr__(self) -> str:
+ return (
+ self.__class__.__name__
+ + '('
+ + 'kernel_size='
+ + str(self.kernel_size)
+ + ', '
+ + 'stride='
+ + str(self.stride)
+ + ', '
+ + 'padding='
+ + str(self.padding)
+ + ', '
+ + 'temperature='
+ + str(self.temperature)
+ + ', '
+ + 'normalized_coordinates='
+ + str(self.normalized_coordinates)
+ + ', '
+ + 'eps='
+ + str(self.eps)
+ + ', '
+ + 'output_value='
+ + str(self.output_value)
+ + ')'
+ )
+
+ def forward(self, x: torch.Tensor): # type: ignore
+ return conv_soft_argmax2d(
+ x,
+ self.kernel_size,
+ self.stride,
+ self.padding,
+ self.temperature,
+ self.normalized_coordinates,
+ self.eps,
+ self.output_value,
+ )
+
+
+class ConvSoftArgmax3d(nn.Module):
+ r"""Module that calculates soft argmax 3d per window.
+
+ See :func:`~kornia.geometry.subpix.conv_soft_argmax3d` for details.
+ """
+
+ def __init__(
+ self,
+ kernel_size: Tuple[int, int, int] = (3, 3, 3),
+ stride: Tuple[int, int, int] = (1, 1, 1),
+ padding: Tuple[int, int, int] = (1, 1, 1),
+ temperature: Union[torch.Tensor, float] = torch.tensor(1.0),
+ normalized_coordinates: bool = False,
+ eps: float = 1e-8,
+ output_value: bool = True,
+ strict_maxima_bonus: float = 0.0,
+ ) -> None:
+ super().__init__()
+ self.kernel_size = kernel_size
+ self.stride = stride
+ self.padding = padding
+ self.temperature = temperature
+ self.normalized_coordinates = normalized_coordinates
+ self.eps = eps
+ self.output_value = output_value
+ self.strict_maxima_bonus = strict_maxima_bonus
+ return
+
+ def __repr__(self) -> str:
+ return (
+ self.__class__.__name__
+ + '('
+ + 'kernel_size='
+ + str(self.kernel_size)
+ + ', '
+ + 'stride='
+ + str(self.stride)
+ + ', '
+ + 'padding='
+ + str(self.padding)
+ + ', '
+ + 'temperature='
+ + str(self.temperature)
+ + ', '
+ + 'normalized_coordinates='
+ + str(self.normalized_coordinates)
+ + ', '
+ + 'eps='
+ + str(self.eps)
+ + ', '
+ + 'strict_maxima_bonus='
+ + str(self.strict_maxima_bonus)
+ + ', '
+ + 'output_value='
+ + str(self.output_value)
+ + ')'
+ )
+
+ def forward(self, x: torch.Tensor): # type: ignore
+ return conv_soft_argmax3d(
+ x,
+ self.kernel_size,
+ self.stride,
+ self.padding,
+ self.temperature,
+ self.normalized_coordinates,
+ self.eps,
+ self.output_value,
+ self.strict_maxima_bonus,
+ )
+
+
+def conv_soft_argmax2d(
+ input: torch.Tensor,
+ kernel_size: Tuple[int, int] = (3, 3),
+ stride: Tuple[int, int] = (1, 1),
+ padding: Tuple[int, int] = (1, 1),
+ temperature: Union[torch.Tensor, float] = torch.tensor(1.0),
+ normalized_coordinates: bool = True,
+ eps: float = 1e-8,
+ output_value: bool = False,
+) -> Union[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:
+ r"""Compute the convolutional spatial Soft-Argmax 2D over the windows of a given heatmap.
+
+ .. math::
+ ij(X) = \frac{\sum{(i,j)} * exp(x / T) \in X} {\sum{exp(x / T) \in X}}
+
+ .. math::
+ val(X) = \frac{\sum{x * exp(x / T) \in X}} {\sum{exp(x / T) \in X}}
+
+ where :math:`T` is temperature.
+
+ Args:
+ input: the given heatmap with shape :math:`(N, C, H_{in}, W_{in})`.
+ kernel_size: the size of the window.
+ stride: the stride of the window.
+ padding: input zero padding.
+ temperature: factor to apply to input.
+ normalized_coordinates: whether to return the coordinates normalized in the range of :math:`[-1, 1]`.
+ Otherwise, it will return the coordinates in the range of the input shape.
+ eps: small value to avoid zero division.
+ output_value: if True, val is output, if False, only ij.
+
+ Returns:
+ Function has two outputs - argmax coordinates and the softmaxpooled heatmap values themselves.
+ On each window, the function computed returns with shapes :math:`(N, C, 2, H_{out},
+ W_{out})`, :math:`(N, C, H_{out}, W_{out})`,
+
+ where
+
+ .. math::
+ H_{out} = \left\lfloor\frac{H_{in} + 2 \times \text{padding}[0] -
+ (\text{kernel\_size}[0] - 1) - 1}{\text{stride}[0]} + 1\right\rfloor
+
+ .. math::
+ W_{out} = \left\lfloor\frac{W_{in} + 2 \times \text{padding}[1] -
+ (\text{kernel\_size}[1] - 1) - 1}{\text{stride}[1]} + 1\right\rfloor
+
+ Examples:
+ >>> input = torch.randn(20, 16, 50, 32)
+ >>> nms_coords, nms_val = conv_soft_argmax2d(input, (3,3), (2,2), (1,1), output_value=True)
+ """
+ if not torch.is_tensor(input):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(input)}")
+
+ if not len(input.shape) == 4:
+ raise ValueError(f"Invalid input shape, we expect BxCxHxW. Got: {input.shape}")
+
+ if temperature <= 0:
+ raise ValueError(f"Temperature should be positive float or tensor. Got: {temperature}")
+
+ b, c, h, w = input.shape
+ kx, ky = kernel_size
+ device: torch.device = input.device
+ dtype: torch.dtype = input.dtype
+ input = input.view(b * c, 1, h, w)
+
+ center_kernel: torch.Tensor = _get_center_kernel2d(kx, ky, device).to(dtype)
+ window_kernel: torch.Tensor = _get_window_grid_kernel2d(kx, ky, device).to(dtype)
+
+ # applies exponential normalization trick
+ # https://timvieira.github.io/blog/post/2014/02/11/exp-normalize-trick/
+ # https://github.com/pytorch/pytorch/blob/bcb0bb7e0e03b386ad837015faba6b4b16e3bfb9/aten/src/ATen/native/SoftMax.cpp#L44
+ x_max = F.adaptive_max_pool2d(input, (1, 1))
+
+ # max is detached to prevent undesired backprop loops in the graph
+ x_exp = ((input - x_max.detach()) / temperature).exp()
+
+ # F.avg_pool2d(.., divisor_override = 1.0) - proper way for sum pool in PyTorch 1.2.
+ # Not available yet in version 1.0, so let's do manually
+ pool_coef: float = float(kx * ky)
+
+ # softmax denominator
+ den = pool_coef * F.avg_pool2d(x_exp, kernel_size, stride=stride, padding=padding) + eps
+
+ x_softmaxpool = pool_coef * F.avg_pool2d(x_exp * input, kernel_size, stride=stride, padding=padding) / den
+ x_softmaxpool = x_softmaxpool.view(b, c, x_softmaxpool.size(2), x_softmaxpool.size(3))
+
+ # We need to output also coordinates
+ # Pooled window center coordinates
+ grid_global: torch.Tensor = create_meshgrid(h, w, False, device).to(dtype).permute(0, 3, 1, 2)
+
+ grid_global_pooled = F.conv2d(grid_global, center_kernel, stride=stride, padding=padding)
+
+ # Coordinates of maxima residual to window center
+ # prepare kernel
+ coords_max: torch.Tensor = F.conv2d(x_exp, window_kernel, stride=stride, padding=padding)
+
+ coords_max = coords_max / den.expand_as(coords_max)
+ coords_max = coords_max + grid_global_pooled.expand_as(coords_max)
+ # [:,:, 0, ...] is x
+ # [:,:, 1, ...] is y
+
+ if normalized_coordinates:
+ coords_max = normalize_pixel_coordinates(coords_max.permute(0, 2, 3, 1), h, w)
+ coords_max = coords_max.permute(0, 3, 1, 2)
+
+ # Back B*C -> (b, c)
+ coords_max = coords_max.view(b, c, 2, coords_max.size(2), coords_max.size(3))
+
+ if output_value:
+ return coords_max, x_softmaxpool
+ return coords_max
+
+
+def conv_soft_argmax3d(
+ input: torch.Tensor,
+ kernel_size: Tuple[int, int, int] = (3, 3, 3),
+ stride: Tuple[int, int, int] = (1, 1, 1),
+ padding: Tuple[int, int, int] = (1, 1, 1),
+ temperature: Union[torch.Tensor, float] = torch.tensor(1.0),
+ normalized_coordinates: bool = False,
+ eps: float = 1e-8,
+ output_value: bool = True,
+ strict_maxima_bonus: float = 0.0,
+) -> Union[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:
+ r"""Compute the convolutional spatial Soft-Argmax 3D over the windows of a given heatmap.
+
+ .. math::
+ ijk(X) = \frac{\sum{(i,j,k)} * exp(x / T) \in X} {\sum{exp(x / T) \in X}}
+
+ .. math::
+ val(X) = \frac{\sum{x * exp(x / T) \in X}} {\sum{exp(x / T) \in X}}
+
+ where ``T`` is temperature.
+
+ Args:
+ input: the given heatmap with shape :math:`(N, C, D_{in}, H_{in}, W_{in})`.
+ kernel_size: size of the window.
+ stride: stride of the window.
+ padding: input zero padding.
+ temperature: factor to apply to input.
+ normalized_coordinates: whether to return the coordinates normalized in the range of :math:[-1, 1]`.
+ Otherwise, it will return the coordinates in the range of the input shape.
+ eps: small value to avoid zero division.
+ output_value: if True, val is output, if False, only ij.
+ strict_maxima_bonus: pixels, which are strict maxima will score (1 + strict_maxima_bonus) * value.
+ This is needed for mimic behavior of strict NMS in classic local features
+
+ Returns:
+ Function has two outputs - argmax coordinates and the softmaxpooled heatmap values themselves.
+ On each window, the function computed returns with shapes :math:`(N, C, 3, D_{out}, H_{out}, W_{out})`,
+ :math:`(N, C, D_{out}, H_{out}, W_{out})`,
+
+ where
+
+ .. math::
+ D_{out} = \left\lfloor\frac{D_{in} + 2 \times \text{padding}[0] -
+ (\text{kernel\_size}[0] - 1) - 1}{\text{stride}[0]} + 1\right\rfloor
+
+ .. math::
+ H_{out} = \left\lfloor\frac{H_{in} + 2 \times \text{padding}[1] -
+ (\text{kernel\_size}[1] - 1) - 1}{\text{stride}[1]} + 1\right\rfloor
+
+ .. math::
+ W_{out} = \left\lfloor\frac{W_{in} + 2 \times \text{padding}[2] -
+ (\text{kernel\_size}[2] - 1) - 1}{\text{stride}[2]} + 1\right\rfloor
+
+ Examples:
+ >>> input = torch.randn(20, 16, 3, 50, 32)
+ >>> nms_coords, nms_val = conv_soft_argmax3d(input, (3, 3, 3), (1, 2, 2), (0, 1, 1))
+ """
+ if not torch.is_tensor(input):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(input)}")
+
+ if not len(input.shape) == 5:
+ raise ValueError(f"Invalid input shape, we expect BxCxDxHxW. Got: {input.shape}")
+
+ if temperature <= 0:
+ raise ValueError(f"Temperature should be positive float or tensor. Got: {temperature}")
+
+ b, c, d, h, w = input.shape
+ kx, ky, kz = kernel_size
+ device: torch.device = input.device
+ dtype: torch.dtype = input.dtype
+ input = input.view(b * c, 1, d, h, w)
+
+ center_kernel: torch.Tensor = _get_center_kernel3d(kx, ky, kz, device).to(dtype)
+ window_kernel: torch.Tensor = _get_window_grid_kernel3d(kx, ky, kz, device).to(dtype)
+
+ # applies exponential normalization trick
+ # https://timvieira.github.io/blog/post/2014/02/11/exp-normalize-trick/
+ # https://github.com/pytorch/pytorch/blob/bcb0bb7e0e03b386ad837015faba6b4b16e3bfb9/aten/src/ATen/native/SoftMax.cpp#L44
+ x_max = F.adaptive_max_pool3d(input, (1, 1, 1))
+
+ # max is detached to prevent undesired backprop loops in the graph
+ x_exp = ((input - x_max.detach()) / temperature).exp()
+
+ pool_coef: float = float(kx * ky * kz)
+
+ # softmax denominator
+ den = pool_coef * F.avg_pool3d(x_exp.view_as(input), kernel_size, stride=stride, padding=padding) + eps
+
+ # We need to output also coordinates
+ # Pooled window center coordinates
+ grid_global: torch.Tensor = create_meshgrid3d(d, h, w, False, device=device).to(dtype).permute(0, 4, 1, 2, 3)
+
+ grid_global_pooled = F.conv3d(grid_global, center_kernel, stride=stride, padding=padding)
+
+ # Coordinates of maxima residual to window center
+ # prepare kernel
+ coords_max: torch.Tensor = F.conv3d(x_exp, window_kernel, stride=stride, padding=padding)
+
+ coords_max = coords_max / den.expand_as(coords_max)
+ coords_max = coords_max + grid_global_pooled.expand_as(coords_max)
+ # [:,:, 0, ...] is depth (scale)
+ # [:,:, 1, ...] is x
+ # [:,:, 2, ...] is y
+
+ if normalized_coordinates:
+ coords_max = normalize_pixel_coordinates3d(coords_max.permute(0, 2, 3, 4, 1), d, h, w)
+ coords_max = coords_max.permute(0, 4, 1, 2, 3)
+
+ # Back B*C -> (b, c)
+ coords_max = coords_max.view(b, c, 3, coords_max.size(2), coords_max.size(3), coords_max.size(4))
+
+ if not output_value:
+ return coords_max
+
+ x_softmaxpool = (
+ pool_coef * F.avg_pool3d(x_exp.view(input.size()) * input, kernel_size, stride=stride, padding=padding) / den
+ )
+ if strict_maxima_bonus > 0:
+ in_levels: int = input.size(2)
+ out_levels: int = x_softmaxpool.size(2)
+ skip_levels: int = (in_levels - out_levels) // 2
+ strict_maxima: torch.Tensor = F.avg_pool3d(nms3d(input, kernel_size), 1, stride, 0)
+ strict_maxima = strict_maxima[:, :, skip_levels: out_levels - skip_levels]
+ x_softmaxpool *= 1.0 + strict_maxima_bonus * strict_maxima
+ x_softmaxpool = x_softmaxpool.view(b, c, x_softmaxpool.size(2), x_softmaxpool.size(3), x_softmaxpool.size(4))
+ return coords_max, x_softmaxpool
+
+
+def spatial_soft_argmax2d(
+ input: torch.Tensor,
+ temperature: torch.Tensor = torch.tensor(1.0),
+ normalized_coordinates: bool = True,
+) -> torch.Tensor:
+ r"""Compute the Spatial Soft-Argmax 2D of a given input heatmap.
+
+ Args:
+ input: the given heatmap with shape :math:`(B, N, H, W)`.
+ temperature: factor to apply to input.
+ normalized_coordinates: whether to return the coordinates normalized in the range of :math:`[-1, 1]`.
+ Otherwise, it will return the coordinates in the range of the input shape.
+
+ Returns:
+ the index of the maximum 2d coordinates of the give map :math:`(B, N, 2)`.
+ The output order is x-coord and y-coord.
+
+ Examples:
+ >>> input = torch.tensor([[[
+ ... [0., 0., 0.],
+ ... [0., 10., 0.],
+ ... [0., 0., 0.]]]])
+ >>> spatial_soft_argmax2d(input, normalized_coordinates=False)
+ tensor([[[1.0000, 1.0000]]])
+ """
+ input_soft: torch.Tensor = spatial_softmax2d(input, temperature)
+ output: torch.Tensor = spatial_expectation2d(input_soft, normalized_coordinates)
+ return output
+
+
+class SpatialSoftArgmax2d(nn.Module):
+ r"""Compute the Spatial Soft-Argmax 2D of a given heatmap.
+
+ See :func:`~kornia.geometry.subpix.spatial_soft_argmax2d` for details.
+ """
+
+ def __init__(
+ self, temperature: torch.Tensor = torch.tensor(1.0), normalized_coordinates: bool = True
+ ) -> None:
+ super().__init__()
+ self.temperature: torch.Tensor = temperature
+ self.normalized_coordinates: bool = normalized_coordinates
+
+ def __repr__(self) -> str:
+ return (
+ self.__class__.__name__
+ + '(temperature='
+ + str(self.temperature)
+ + ', '
+ + 'normalized_coordinates='
+ + str(self.normalized_coordinates)
+ + ')'
+ )
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor:
+ return spatial_soft_argmax2d(input, self.temperature, self.normalized_coordinates)
+
+
+def conv_quad_interp3d(
+ input: torch.Tensor, strict_maxima_bonus: float = 10.0, eps: float = 1e-7
+) -> Tuple[torch.Tensor, torch.Tensor]:
+ r"""Compute the single iteration of quadratic interpolation of the extremum (max or min).
+
+ Args:
+ input: the given heatmap with shape :math:`(N, C, D_{in}, H_{in}, W_{in})`.
+ strict_maxima_bonus: pixels, which are strict maxima will score (1 + strict_maxima_bonus) * value.
+ This is needed for mimic behavior of strict NMS in classic local features
+ eps: parameter to control the hessian matrix ill-condition number.
+
+ Returns:
+ the location and value per each 3x3x3 window which contains strict extremum, similar to one done is SIFT.
+ :math:`(N, C, 3, D_{out}, H_{out}, W_{out})`, :math:`(N, C, D_{out}, H_{out}, W_{out})`,
+
+ where
+
+ .. math::
+ D_{out} = \left\lfloor\frac{D_{in} + 2 \times \text{padding}[0] -
+ (\text{kernel\_size}[0] - 1) - 1}{\text{stride}[0]} + 1\right\rfloor
+
+ .. math::
+ H_{out} = \left\lfloor\frac{H_{in} + 2 \times \text{padding}[1] -
+ (\text{kernel\_size}[1] - 1) - 1}{\text{stride}[1]} + 1\right\rfloor
+
+ .. math::
+ W_{out} = \left\lfloor\frac{W_{in} + 2 \times \text{padding}[2] -
+ (\text{kernel\_size}[2] - 1) - 1}{\text{stride}[2]} + 1\right\rfloor
+
+ Examples:
+ >>> input = torch.randn(20, 16, 3, 50, 32)
+ >>> nms_coords, nms_val = conv_quad_interp3d(input, 1.0)
+ """
+ if not torch.is_tensor(input):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(input)}")
+
+ if not len(input.shape) == 5:
+ raise ValueError(f"Invalid input shape, we expect BxCxDxHxW. Got: {input.shape}")
+
+ B, CH, D, H, W = input.shape
+ grid_global: torch.Tensor = create_meshgrid3d(D, H, W, False, device=input.device).permute(0, 4, 1, 2, 3)
+ grid_global = grid_global.to(input.dtype)
+
+ # to determine the location we are solving system of linear equations Ax = b, where b is 1st order gradient
+ # and A is Hessian matrix
+ b: torch.Tensor = spatial_gradient3d(input, order=1, mode='diff') #
+ b = b.permute(0, 1, 3, 4, 5, 2).reshape(-1, 3, 1)
+ A: torch.Tensor = spatial_gradient3d(input, order=2, mode='diff')
+ A = A.permute(0, 1, 3, 4, 5, 2).reshape(-1, 6)
+ dxx = A[..., 0]
+ dyy = A[..., 1]
+ dss = A[..., 2]
+ dxy = 0.25 * A[..., 3] # normalization to match OpenCV implementation
+ dys = 0.25 * A[..., 4] # normalization to match OpenCV implementation
+ dxs = 0.25 * A[..., 5] # normalization to match OpenCV implementation
+
+ Hes = torch.stack([dxx, dxy, dxs, dxy, dyy, dys, dxs, dys, dss], dim=-1).view(-1, 3, 3)
+ if not torch_version_geq(1, 10):
+ # The following is needed to avoid singular cases
+ Hes += torch.rand(Hes[0].size(), device=Hes.device).abs()[None] * eps
+
+ nms_mask: torch.Tensor = nms3d(input, (3, 3, 3), True)
+ x_solved: torch.Tensor = torch.zeros_like(b)
+ x_solved_masked, _, solved_correctly = safe_solve_with_mask(b[nms_mask.view(-1)], Hes[nms_mask.view(-1)])
+
+ # Kill those points, where we cannot solve
+ new_nms_mask = nms_mask.masked_scatter(nms_mask, solved_correctly)
+
+ x_solved.masked_scatter_(new_nms_mask.view(-1, 1, 1), x_solved_masked[solved_correctly])
+ dx: torch.Tensor = -x_solved
+
+ # Ignore ones, which are far from window center
+ mask1 = dx.abs().max(dim=1, keepdim=True)[0] > 0.7
+ dx.masked_fill_(mask1.expand_as(dx), 0)
+ dy: torch.Tensor = 0.5 * torch.bmm(b.permute(0, 2, 1), dx)
+ y_max = input + dy.view(B, CH, D, H, W)
+ if strict_maxima_bonus > 0:
+ y_max += strict_maxima_bonus * new_nms_mask.to(input.dtype)
+
+ dx_res: torch.Tensor = dx.flip(1).reshape(B, CH, D, H, W, 3).permute(0, 1, 5, 2, 3, 4)
+ coords_max: torch.Tensor = grid_global.repeat(B, 1, 1, 1, 1).unsqueeze(1)
+ coords_max = coords_max + dx_res
+
+ return coords_max, y_max
+
+
+class ConvQuadInterp3d(nn.Module):
+ r"""Calculate soft argmax 3d per window
+
+ See :func:`~kornia.geometry.subpix.conv_quad_interp3d` for details.
+ """
+
+ def __init__(self, strict_maxima_bonus: float = 10.0, eps: float = 1e-7) -> None:
+ super().__init__()
+ self.strict_maxima_bonus = strict_maxima_bonus
+ self.eps = eps
+ return
+
+ def __repr__(self) -> str:
+ return self.__class__.__name__ + '(' + 'strict_maxima_bonus=' + str(self.strict_maxima_bonus) + ')'
+
+ def forward(self, x: torch.Tensor): # type: ignore
+ return conv_quad_interp3d(x, self.strict_maxima_bonus, self.eps)
diff --git a/kornia/geometry/transform/__init__.py b/kornia/geometry/transform/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..f853e1842c958a845ac9903aa94d5ed1968cecbb
--- /dev/null
+++ b/kornia/geometry/transform/__init__.py
@@ -0,0 +1,11 @@
+from .affwarp import *
+from .crop2d import *
+from .crop3d import *
+from .elastic_transform import *
+from .flips import *
+from .homography_warper import *
+from .image_registrator import *
+from .imgwarp import *
+from .projwarp import *
+from .pyramid import *
+from .thin_plate_spline import *
diff --git a/kornia/geometry/transform/affwarp.py b/kornia/geometry/transform/affwarp.py
new file mode 100644
index 0000000000000000000000000000000000000000..7390b438bc823332cc91a42f895b929c6dacf7c3
--- /dev/null
+++ b/kornia/geometry/transform/affwarp.py
@@ -0,0 +1,1005 @@
+from typing import Optional, Tuple, Union
+
+import torch
+import torch.nn as nn
+
+from kornia.filters import gaussian_blur2d
+from kornia.utils import _extract_device_dtype
+from kornia.utils.image import perform_keep_shape_image
+
+from .imgwarp import get_affine_matrix2d, get_rotation_matrix2d, warp_affine
+from .projwarp import get_projective_transform, warp_affine3d
+
+__all__ = [
+ "affine",
+ "affine3d",
+ "scale",
+ "rotate",
+ "rotate3d",
+ "translate",
+ "shear",
+ "resize",
+ "rescale",
+ "Scale",
+ "Rotate",
+ "Translate",
+ "Shear",
+ "Resize",
+ "Rescale",
+ "Affine",
+]
+
+# utilities to compute affine matrices
+
+
+def _compute_tensor_center(tensor: torch.Tensor) -> torch.Tensor:
+ """Compute the center of tensor plane for (H, W), (C, H, W) and (B, C, H, W)."""
+ if not 2 <= len(tensor.shape) <= 4:
+ raise AssertionError(f"Must be a 3D tensor as HW, CHW and BCHW. Got {tensor.shape}.")
+ height, width = tensor.shape[-2:]
+ center_x: float = float(width - 1) / 2
+ center_y: float = float(height - 1) / 2
+ center: torch.Tensor = torch.tensor([center_x, center_y], device=tensor.device, dtype=tensor.dtype)
+ return center
+
+
+def _compute_tensor_center3d(tensor: torch.Tensor) -> torch.Tensor:
+ """Compute the center of tensor plane for (D, H, W), (C, D, H, W) and (B, C, D, H, W)."""
+ if not 3 <= len(tensor.shape) <= 5:
+ raise AssertionError(f"Must be a 3D tensor as DHW, CDHW and BCDHW. Got {tensor.shape}.")
+ depth, height, width = tensor.shape[-3:]
+ center_x: float = float(width - 1) / 2
+ center_y: float = float(height - 1) / 2
+ center_z: float = float(depth - 1) / 2
+ center: torch.Tensor = torch.tensor([center_x, center_y, center_z], device=tensor.device, dtype=tensor.dtype)
+ return center
+
+
+def _compute_rotation_matrix(angle: torch.Tensor, center: torch.Tensor) -> torch.Tensor:
+ """Compute a pure affine rotation matrix."""
+ scale: torch.Tensor = torch.ones_like(center)
+ matrix: torch.Tensor = get_rotation_matrix2d(center, angle, scale)
+ return matrix
+
+
+def _compute_rotation_matrix3d(
+ yaw: torch.Tensor, pitch: torch.Tensor, roll: torch.Tensor, center: torch.Tensor
+) -> torch.Tensor:
+ """Compute a pure affine rotation matrix."""
+ if len(yaw.shape) == len(pitch.shape) == len(roll.shape) == 0:
+ yaw = yaw.unsqueeze(dim=0)
+ pitch = pitch.unsqueeze(dim=0)
+ roll = roll.unsqueeze(dim=0)
+
+ if len(yaw.shape) == len(pitch.shape) == len(roll.shape) == 1:
+ yaw = yaw.unsqueeze(dim=1)
+ pitch = pitch.unsqueeze(dim=1)
+ roll = roll.unsqueeze(dim=1)
+
+ if not (len(yaw.shape) == len(pitch.shape) == len(roll.shape) == 2):
+ raise AssertionError(f"Expected yaw, pitch, roll to be (B, 1). Got {yaw.shape}, {pitch.shape}, {roll.shape}.")
+
+ angles: torch.Tensor = torch.cat([yaw, pitch, roll], dim=1)
+ scales: torch.Tensor = torch.ones_like(yaw)
+ matrix: torch.Tensor = get_projective_transform(center, angles, scales)
+ return matrix
+
+
+def _compute_translation_matrix(translation: torch.Tensor) -> torch.Tensor:
+ """Compute affine matrix for translation."""
+ matrix: torch.Tensor = torch.eye(3, device=translation.device, dtype=translation.dtype)
+ matrix = matrix.repeat(translation.shape[0], 1, 1)
+
+ dx, dy = torch.chunk(translation, chunks=2, dim=-1)
+ matrix[..., 0, 2:3] += dx
+ matrix[..., 1, 2:3] += dy
+ return matrix
+
+
+def _compute_scaling_matrix(scale: torch.Tensor, center: torch.Tensor) -> torch.Tensor:
+ """Compute affine matrix for scaling."""
+ angle: torch.Tensor = torch.zeros(scale.shape[:1], device=scale.device, dtype=scale.dtype)
+ matrix: torch.Tensor = get_rotation_matrix2d(center, angle, scale)
+ return matrix
+
+
+def _compute_shear_matrix(shear: torch.Tensor) -> torch.Tensor:
+ """Compute affine matrix for shearing."""
+ matrix: torch.Tensor = torch.eye(3, device=shear.device, dtype=shear.dtype)
+ matrix = matrix.repeat(shear.shape[0], 1, 1)
+
+ shx, shy = torch.chunk(shear, chunks=2, dim=-1)
+ matrix[..., 0, 1:2] += shx
+ matrix[..., 1, 0:1] += shy
+ return matrix
+
+
+# based on:
+# https://github.com/anibali/tvl/blob/master/src/tvl/transforms.py#L166
+
+
+def affine(
+ tensor: torch.Tensor,
+ matrix: torch.Tensor,
+ mode: str = 'bilinear',
+ padding_mode: str = 'zeros',
+ align_corners: bool = True,
+) -> torch.Tensor:
+ r"""Apply an affine transformation to the image.
+
+ .. image:: _static/img/warp_affine.png
+
+ Args:
+ tensor: The image tensor to be warped in shapes of
+ :math:`(H, W)`, :math:`(D, H, W)` and :math:`(B, C, H, W)`.
+ matrix: The 2x3 affine transformation matrix.
+ mode: interpolation mode to calculate output values ``'bilinear'`` | ``'nearest'``.
+ padding_mode: padding mode for outside grid values
+ ``'zeros'`` | ``'border'`` | ``'reflection'``.
+ align_corners: interpolation flag.
+
+ Returns:
+ The warped image with the same shape as the input.
+
+ Example:
+ >>> img = torch.rand(1, 2, 3, 5)
+ >>> aff = torch.eye(2, 3)[None]
+ >>> out = affine(img, aff)
+ >>> print(out.shape)
+ torch.Size([1, 2, 3, 5])
+ """
+ # warping needs data in the shape of BCHW
+ is_unbatched: bool = tensor.ndimension() == 3
+ if is_unbatched:
+ tensor = torch.unsqueeze(tensor, dim=0)
+
+ # we enforce broadcasting since by default grid_sample it does not
+ # give support for that
+ matrix = matrix.expand(tensor.shape[0], -1, -1)
+
+ # warp the input tensor
+ height: int = tensor.shape[-2]
+ width: int = tensor.shape[-1]
+ warped: torch.Tensor = warp_affine(tensor, matrix, (height, width), mode, padding_mode, align_corners)
+
+ # return in the original shape
+ if is_unbatched:
+ warped = torch.squeeze(warped, dim=0)
+
+ return warped
+
+
+def affine3d(
+ tensor: torch.Tensor,
+ matrix: torch.Tensor,
+ mode: str = 'bilinear',
+ padding_mode: str = 'zeros',
+ align_corners: bool = False,
+) -> torch.Tensor:
+ r"""Apply an affine transformation to the 3d volume.
+
+ Args:
+ tensor: The image tensor to be warped in shapes of
+ :math:`(D, H, W)`, :math:`(C, D, H, W)` and :math:`(B, C, D, H, W)`.
+ matrix: The affine transformation matrix with shape :math:`(B, 3, 4)`.
+ mode: interpolation mode to calculate output values
+ ``'bilinear'`` | ``'nearest'``.
+ padding_mode: padding mode for outside grid values
+ `` 'zeros'`` | ``'border'`` | ``'reflection'``.
+ align_corners: interpolation flag.
+
+ Returns:
+ The warped image.
+
+ Example:
+ >>> img = torch.rand(1, 2, 4, 3, 5)
+ >>> aff = torch.eye(3, 4)[None]
+ >>> out = affine3d(img, aff)
+ >>> print(out.shape)
+ torch.Size([1, 2, 4, 3, 5])
+ """
+ # warping needs data in the shape of BCDHW
+ is_unbatched: bool = tensor.ndimension() == 4
+ if is_unbatched:
+ tensor = torch.unsqueeze(tensor, dim=0)
+
+ # we enforce broadcasting since by default grid_sample it does not
+ # give support for that
+ matrix = matrix.expand(tensor.shape[0], -1, -1)
+
+ # warp the input tensor
+ depth: int = tensor.shape[-3]
+ height: int = tensor.shape[-2]
+ width: int = tensor.shape[-1]
+ warped: torch.Tensor = warp_affine3d(tensor, matrix, (depth, height, width), mode, padding_mode, align_corners)
+
+ # return in the original shape
+ if is_unbatched:
+ warped = torch.squeeze(warped, dim=0)
+
+ return warped
+
+
+# based on:
+# https://github.com/anibali/tvl/blob/master/src/tvl/transforms.py#L185
+
+
+def rotate(
+ tensor: torch.Tensor,
+ angle: torch.Tensor,
+ center: Union[None, torch.Tensor] = None,
+ mode: str = 'bilinear',
+ padding_mode: str = 'zeros',
+ align_corners: bool = True,
+) -> torch.Tensor:
+ r"""Rotate the tensor anti-clockwise about the center.
+
+ .. image:: _static/img/rotate.png
+
+ Args:
+ tensor: The image tensor to be warped in shapes of :math:`(B, C, H, W)`.
+ angle: The angle through which to rotate. The tensor
+ must have a shape of (B), where B is batch size.
+ center: The center through which to rotate. The tensor
+ must have a shape of (B, 2), where B is batch size and last
+ dimension contains cx and cy.
+ mode: interpolation mode to calculate output values
+ ``'bilinear'`` | ``'nearest'``.
+ padding_mode: padding mode for outside grid values
+ ``'zeros'`` | ``'border'`` | ``'reflection'``.
+ align_corners: interpolation flag.
+
+ Returns:
+ The rotated tensor with shape as input.
+
+ .. note::
+ See a working example `here `__.
+
+ Example:
+ >>> img = torch.rand(1, 3, 4, 4)
+ >>> angle = torch.tensor([90.])
+ >>> out = rotate(img, angle)
+ >>> print(out.shape)
+ torch.Size([1, 3, 4, 4])
+ """
+ if not isinstance(tensor, torch.Tensor):
+ raise TypeError(f"Input tensor type is not a torch.Tensor. Got {type(tensor)}")
+
+ if not isinstance(angle, torch.Tensor):
+ raise TypeError(f"Input angle type is not a torch.Tensor. Got {type(angle)}")
+
+ if center is not None and not isinstance(center, torch.Tensor):
+ raise TypeError(f"Input center type is not a torch.Tensor. Got {type(center)}")
+
+ if len(tensor.shape) not in (3, 4):
+ raise ValueError("Invalid tensor shape, we expect CxHxW or BxCxHxW. " "Got: {}".format(tensor.shape))
+
+ # compute the rotation center
+ if center is None:
+ center = _compute_tensor_center(tensor)
+
+ # compute the rotation matrix
+ # TODO: add broadcasting to get_rotation_matrix2d for center
+ angle = angle.expand(tensor.shape[0])
+ center = center.expand(tensor.shape[0], -1)
+ rotation_matrix: torch.Tensor = _compute_rotation_matrix(angle, center)
+
+ # warp using the affine transform
+ return affine(tensor, rotation_matrix[..., :2, :3], mode, padding_mode, align_corners)
+
+
+def rotate3d(
+ tensor: torch.Tensor,
+ yaw: torch.Tensor,
+ pitch: torch.Tensor,
+ roll: torch.Tensor,
+ center: Union[None, torch.Tensor] = None,
+ mode: str = 'bilinear',
+ padding_mode: str = 'zeros',
+ align_corners: bool = False,
+) -> torch.Tensor:
+ r"""Rotate 3D the tensor anti-clockwise about the centre.
+
+ Args:
+ tensor: The image tensor to be warped in shapes of :math:`(B, C, D, H, W)`.
+ yaw: The yaw angle through which to rotate. The tensor
+ must have a shape of (B), where B is batch size.
+ pitch: The pitch angle through which to rotate. The tensor
+ must have a shape of (B), where B is batch size.
+ roll: The roll angle through which to rotate. The tensor
+ must have a shape of (B), where B is batch size.
+ center: The center through which to rotate. The tensor
+ must have a shape of (B, 2), where B is batch size and last
+ dimension contains cx and cy.
+ mode: interpolation mode to calculate output values
+ ``'bilinear'`` | ``'nearest'``.
+ padding_mode: padding mode for outside grid values
+ ``'zeros'`` | ``'border'`` | ``'reflection'``.
+ align_corners: interpolation flag.
+
+ Returns:
+ torch.Tensor: The rotated tensor with shape as input.
+ """
+ if not isinstance(tensor, torch.Tensor):
+ raise TypeError(f"Input tensor type is not a torch.Tensor. Got {type(tensor)}")
+
+ if not isinstance(yaw, torch.Tensor):
+ raise TypeError(f"yaw is not a torch.Tensor. Got {type(yaw)}")
+
+ if not isinstance(pitch, torch.Tensor):
+ raise TypeError(f"pitch is not a torch.Tensor. Got {type(pitch)}")
+
+ if not isinstance(roll, torch.Tensor):
+ raise TypeError(f"roll is not a torch.Tensor. Got {type(roll)}")
+
+ if center is not None and not isinstance(center, torch.Tensor):
+ raise TypeError(f"Input center type is not a torch.Tensor. Got {type(center)}")
+
+ if len(tensor.shape) not in (4, 5):
+ raise ValueError("Invalid tensor shape, we expect CxDxHxW or BxCxDxHxW. " "Got: {}".format(tensor.shape))
+
+ # compute the rotation center
+ if center is None:
+ center = _compute_tensor_center3d(tensor)
+
+ # compute the rotation matrix
+ # TODO: add broadcasting to get_rotation_matrix2d for center
+ yaw = yaw.expand(tensor.shape[0])
+ pitch = pitch.expand(tensor.shape[0])
+ roll = roll.expand(tensor.shape[0])
+ center = center.expand(tensor.shape[0], -1)
+ rotation_matrix: torch.Tensor = _compute_rotation_matrix3d(yaw, pitch, roll, center)
+
+ # warp using the affine transform
+ return affine3d(tensor, rotation_matrix[..., :3, :4], mode, padding_mode, align_corners)
+
+
+def translate(
+ tensor: torch.Tensor,
+ translation: torch.Tensor,
+ mode: str = 'bilinear',
+ padding_mode: str = 'zeros',
+ align_corners: bool = True,
+) -> torch.Tensor:
+ r"""Translate the tensor in pixel units.
+
+ .. image:: _static/img/translate.png
+
+ Args:
+ tensor: The image tensor to be warped in shapes of :math:`(B, C, H, W)`.
+ translation: tensor containing the amount of pixels to
+ translate in the x and y direction. The tensor must have a shape of
+ (B, 2), where B is batch size, last dimension contains dx dy.
+ mode: interpolation mode to calculate output values
+ ``'bilinear'`` | ``'nearest'``.
+ padding_mode: padding mode for outside grid values
+ ``'zeros'`` | ``'border'`` | ``'reflection'``.
+ align_corners: interpolation flag.
+
+ Returns:
+ The translated tensor with shape as input.
+
+ Example:
+ >>> img = torch.rand(1, 3, 4, 4)
+ >>> translation = torch.tensor([[1., 0.]])
+ >>> out = translate(img, translation)
+ >>> print(out.shape)
+ torch.Size([1, 3, 4, 4])
+ """
+ if not isinstance(tensor, torch.Tensor):
+ raise TypeError(f"Input tensor type is not a torch.Tensor. Got {type(tensor)}")
+
+ if not isinstance(translation, torch.Tensor):
+ raise TypeError(f"Input translation type is not a torch.Tensor. Got {type(translation)}")
+
+ if len(tensor.shape) not in (3, 4):
+ raise ValueError("Invalid tensor shape, we expect CxHxW or BxCxHxW. " "Got: {}".format(tensor.shape))
+
+ # compute the translation matrix
+ translation_matrix: torch.Tensor = _compute_translation_matrix(translation)
+
+ # warp using the affine transform
+ return affine(tensor, translation_matrix[..., :2, :3], mode, padding_mode, align_corners)
+
+
+def scale(
+ tensor: torch.Tensor,
+ scale_factor: torch.Tensor,
+ center: Union[None, torch.Tensor] = None,
+ mode: str = 'bilinear',
+ padding_mode: str = 'zeros',
+ align_corners: bool = True,
+) -> torch.Tensor:
+ r"""Scale the tensor by a factor.
+
+ .. image:: _static/img/scale.png
+
+ Args:
+ tensor: The image tensor to be warped in shapes of :math:`(B, C, H, W)`.
+ scale_factor: The scale factor apply. The tensor
+ must have a shape of (B) or (B, 2), where B is batch size.
+ If (B), isotropic scaling will perform.
+ If (B, 2), x-y-direction specific scaling will perform.
+ center: The center through which to scale. The tensor
+ must have a shape of (B, 2), where B is batch size and last
+ dimension contains cx and cy.
+ mode: interpolation mode to calculate output values
+ ``'bilinear'`` | ``'nearest'``.
+ padding_mode: padding mode for outside grid values
+ ``'zeros'`` | ``'border'`` | ``'reflection'``.
+ align_corners: interpolation flag.
+
+ Returns:
+ The scaled tensor with the same shape as the input.
+
+ Example:
+ >>> img = torch.rand(1, 3, 4, 4)
+ >>> scale_factor = torch.tensor([[2., 2.]])
+ >>> out = scale(img, scale_factor)
+ >>> print(out.shape)
+ torch.Size([1, 3, 4, 4])
+ """
+ if not isinstance(tensor, torch.Tensor):
+ raise TypeError(f"Input tensor type is not a torch.Tensor. Got {type(tensor)}")
+
+ if not isinstance(scale_factor, torch.Tensor):
+ raise TypeError(f"Input scale_factor type is not a torch.Tensor. Got {type(scale_factor)}")
+
+ if len(scale_factor.shape) == 1:
+ # convert isotropic scaling to x-y direction
+ scale_factor = scale_factor.repeat(1, 2)
+
+ # compute the tensor center
+ if center is None:
+ center = _compute_tensor_center(tensor)
+
+ # compute the rotation matrix
+ # TODO: add broadcasting to get_rotation_matrix2d for center
+ center = center.expand(tensor.shape[0], -1)
+ scale_factor = scale_factor.expand(tensor.shape[0], 2)
+ scaling_matrix: torch.Tensor = _compute_scaling_matrix(scale_factor, center)
+
+ # warp using the affine transform
+ return affine(tensor, scaling_matrix[..., :2, :3], mode, padding_mode, align_corners)
+
+
+def shear(
+ tensor: torch.Tensor,
+ shear: torch.Tensor,
+ mode: str = 'bilinear',
+ padding_mode: str = 'zeros',
+ align_corners: bool = False,
+) -> torch.Tensor:
+ r"""Shear the tensor.
+
+ .. image:: _static/img/shear.png
+
+ Args:
+ tensor: The image tensor to be skewed with shape of :math:`(B, C, H, W)`.
+ shear: tensor containing the angle to shear
+ in the x and y direction. The tensor must have a shape of
+ (B, 2), where B is batch size, last dimension contains shx shy.
+ mode: interpolation mode to calculate output values
+ ``'bilinear'`` | ``'nearest'``.
+ padding_mode: padding mode for outside grid values
+ ``'zeros'`` | ``'border'`` | ``'reflection'``.
+ align_corners: interpolation flag.
+
+ Returns:
+ The skewed tensor with shape same as the input.
+
+ Example:
+ >>> img = torch.rand(1, 3, 4, 4)
+ >>> shear_factor = torch.tensor([[0.5, 0.0]])
+ >>> out = shear(img, shear_factor)
+ >>> print(out.shape)
+ torch.Size([1, 3, 4, 4])
+ """
+ if not isinstance(tensor, torch.Tensor):
+ raise TypeError(f"Input tensor type is not a torch.Tensor. Got {type(tensor)}")
+
+ if not isinstance(shear, torch.Tensor):
+ raise TypeError(f"Input shear type is not a torch.Tensor. Got {type(shear)}")
+
+ if len(tensor.shape) not in (3, 4):
+ raise ValueError("Invalid tensor shape, we expect CxHxW or BxCxHxW. " "Got: {}".format(tensor.shape))
+
+ # compute the translation matrix
+ shear_matrix: torch.Tensor = _compute_shear_matrix(shear)
+
+ # warp using the affine transform
+ return affine(tensor, shear_matrix[..., :2, :3], mode, padding_mode, align_corners)
+
+
+def _side_to_image_size(side_size: int, aspect_ratio: float, side: str = "short") -> Tuple[int, int]:
+ if side not in ("short", "long", "vert", "horz"):
+ raise ValueError(f"side can be one of 'short', 'long', 'vert', and 'horz'. Got '{side}'")
+ if side == "vert":
+ return side_size, int(side_size * aspect_ratio)
+ if side == "horz":
+ return int(side_size / aspect_ratio), side_size
+ if (side == "short") ^ (aspect_ratio < 1.0):
+ return side_size, int(side_size * aspect_ratio)
+ return int(side_size / aspect_ratio), side_size
+
+
+@perform_keep_shape_image
+def resize(
+ input: torch.Tensor,
+ size: Union[int, Tuple[int, int]],
+ interpolation: str = 'bilinear',
+ align_corners: Optional[bool] = None,
+ side: str = "short",
+ antialias: bool = False,
+) -> torch.Tensor:
+ r"""Resize the input torch.Tensor to the given size.
+
+ .. image:: _static/img/resize.png
+
+ Args:
+ tensor: The image tensor to be skewed with shape of :math:`(..., H, W)`.
+ `...` means there can be any number of dimensions.
+ size: Desired output size. If size is a sequence like (h, w),
+ output size will be matched to this. If size is an int, smaller edge of the image will
+ be matched to this number. i.e, if height > width, then image will be rescaled
+ to (size * height / width, size)
+ interpolation: algorithm used for upsampling: ``'nearest'`` | ``'linear'`` | ``'bilinear'`` |
+ 'bicubic' | 'trilinear' | 'area'.
+ align_corners: interpolation flag.
+ side: Corresponding side if ``size`` is an integer. Can be one of ``'short'``, ``'long'``, ``'vert'``,
+ or ``'horz'``.
+ antialias: if True, then image will be filtered with Gaussian before downscaling.
+ No effect for upscaling.
+
+ Returns:
+ The resized tensor with the shape as the specified size.
+
+ Example:
+ >>> img = torch.rand(1, 3, 4, 4)
+ >>> out = resize(img, (6, 8))
+ >>> print(out.shape)
+ torch.Size([1, 3, 6, 8])
+ """
+ if not isinstance(input, torch.Tensor):
+ raise TypeError(f"Input tensor type is not a torch.Tensor. Got {type(input)}")
+
+ if len(input.shape) < 2:
+ raise ValueError(f'Input tensor must have at least two dimensions. Got {len(input.shape)}')
+
+ input_size = h, w = input.shape[-2:]
+ if isinstance(size, int):
+ aspect_ratio = w / h
+ size = _side_to_image_size(size, aspect_ratio, side)
+
+ if size == input_size:
+ return input
+
+ factors = (h / size[0], w / size[1])
+
+ # We do bluring only for downscaling
+ antialias = antialias and (max(factors) > 1)
+
+ if antialias:
+ # First, we have to determine sigma
+ sigmas = (max(factors[0], 1.0), max(factors[1], 1.0))
+
+ # Now kernel size. Good results are for 3 sigma, but that is kind of slow. Pillow uses 1 sigma
+ # https://github.com/python-pillow/Pillow/blob/master/src/libImaging/Resample.c#L206
+ # But they do it in the 2 passes, which gives better results. Let's try 2 sigmas for now
+ ks = int(2.0 * 2 * sigmas[0]), int(2.0 * 2 * sigmas[1])
+
+ # Make sure it is odd
+ if (ks[0] % 2) == 0:
+ ks = ks[0] + 1, ks[1]
+
+ if (ks[1] % 2) == 0:
+ ks = ks[0], ks[1] + 1
+
+ input = gaussian_blur2d(input, ks, sigmas)
+
+ output = torch.nn.functional.interpolate(input, size=size, mode=interpolation, align_corners=align_corners)
+ return output
+
+
+def rescale(
+ input: torch.Tensor,
+ factor: Union[float, Tuple[float, float]],
+ interpolation: str = "bilinear",
+ align_corners: Optional[bool] = None,
+ antialias: bool = False,
+) -> torch.Tensor:
+ r"""Rescale the input torch.Tensor with the given factor.
+
+ .. image:: _static/img/rescale.png
+
+ Args:
+ input: The image tensor to be scale with shape of :math:`(B, C, H, W)`.
+ factor: Desired scaling factor in each direction. If scalar, the value is used
+ for both the x- and y-direction.
+ interpolation: algorithm used for upsampling: ``'nearest'`` | ``'linear'`` | ``'bilinear'`` |
+ ``'bicubic'`` | ``'trilinear'`` | ``'area'``.
+ align_corners: interpolation flag.
+ side: Corresponding side if ``size`` is an integer. Can be one of ``'short'``, ``'long'``, ``'vert'``,
+ or ``'horz'``.
+ antialias: if True, then image will be filtered with Gaussian before downscaling.
+ No effect for upscaling.
+
+ Returns:
+ The rescaled tensor with the shape as the specified size.
+
+ Example:
+ >>> img = torch.rand(1, 3, 4, 4)
+ >>> out = rescale(img, (2, 3))
+ >>> print(out.shape)
+ torch.Size([1, 3, 8, 12])
+ """
+ if isinstance(factor, float):
+ factor_vert = factor_horz = factor
+ else:
+ factor_vert, factor_horz = factor
+
+ height, width = input.size()[-2:]
+ size = (int(height * factor_vert), int(width * factor_horz))
+ return resize(input, size, interpolation=interpolation, align_corners=align_corners, antialias=antialias)
+
+
+class Resize(nn.Module):
+ r"""Resize the input torch.Tensor to the given size.
+
+ Args:
+ size: Desired output size. If size is a sequence like (h, w),
+ output size will be matched to this. If size is an int, smaller edge of the image will
+ be matched to this number. i.e, if height > width, then image will be rescaled
+ to (size * height / width, size)
+ interpolation: algorithm used for upsampling: ``'nearest'`` | ``'linear'`` | ``'bilinear'`` |
+ 'bicubic' | 'trilinear' | 'area'.
+ align_corners: interpolation flag.
+ side: Corresponding side if ``size`` is an integer. Can be one of ``'short'``, ``'long'``, ``'vert'``,
+ or ``'horz'``.
+ antialias: if True, then image will be filtered with Gaussian before downscaling.
+ No effect for upscaling.
+
+ Returns:
+ The resized tensor with the shape of the given size.
+
+ Example:
+ >>> img = torch.rand(1, 3, 4, 4)
+ >>> out = Resize((6, 8))(img)
+ >>> print(out.shape)
+ torch.Size([1, 3, 6, 8])
+ """
+
+ def __init__(
+ self,
+ size: Union[int, Tuple[int, int]],
+ interpolation: str = 'bilinear',
+ align_corners: Optional[bool] = None,
+ side: str = "short",
+ antialias: bool = False,
+ ) -> None:
+ super().__init__()
+ self.size: Union[int, Tuple[int, int]] = size
+ self.interpolation: str = interpolation
+ self.align_corners: Optional[bool] = align_corners
+ self.side: str = side
+ self.antialias: bool = antialias
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor:
+ return resize(
+ input,
+ self.size,
+ self.interpolation,
+ align_corners=self.align_corners,
+ side=self.side,
+ antialias=self.antialias,
+ )
+
+
+class Affine(nn.Module):
+ r"""Apply multiple elementary affine transforms simultaneously.
+
+ Args:
+ angle: Angle in degrees for counter-clockwise rotation around the center. The tensor
+ must have a shape of (B), where B is the batch size.
+ translation: Amount of pixels for translation in x- and y-direction. The tensor must
+ have a shape of (B, 2), where B is the batch size and the last dimension contains dx and dy.
+ scale_factor: Factor for scaling. The tensor must have a shape of (B), where B is the
+ batch size.
+ shear: Angles in degrees for shearing in x- and y-direction around the center. The
+ tensor must have a shape of (B, 2), where B is the batch size and the last dimension contains sx and sy.
+ center: Transformation center in pixels. The tensor must have a shape of (B, 2), where
+ B is the batch size and the last dimension contains cx and cy. Defaults to the center of image to be
+ transformed.
+ mode: interpolation mode to calculate output values
+ ``'bilinear'`` | ``'nearest'``.
+ padding_mode: padding mode for outside grid values
+ ``'zeros'`` | ``'border'`` | ``'reflection'``.
+ align_corners: interpolation flag.
+
+ Raises:
+ RuntimeError: If not one of ``angle``, ``translation``, ``scale_factor``, or ``shear`` is set.
+
+ Returns:
+ The transformed tensor with same shape as input.
+
+ Example:
+ >>> img = torch.rand(1, 2, 3, 5)
+ >>> angle = 90. * torch.rand(1)
+ >>> out = Affine(angle)(img)
+ >>> print(out.shape)
+ torch.Size([1, 2, 3, 5])
+ """
+
+ def __init__(
+ self,
+ angle: Optional[torch.Tensor] = None,
+ translation: Optional[torch.Tensor] = None,
+ scale_factor: Optional[torch.Tensor] = None,
+ shear: Optional[torch.Tensor] = None,
+ center: Optional[torch.Tensor] = None,
+ mode: str = 'bilinear',
+ padding_mode: str = 'zeros',
+ align_corners: bool = True,
+ ) -> None:
+ batch_sizes = [arg.size()[0] for arg in (angle, translation, scale_factor, shear) if arg is not None]
+ if not batch_sizes:
+ msg = (
+ "Affine was created without any affine parameter. At least one of angle, translation, scale_factor, or "
+ "shear has to be set."
+ )
+ raise RuntimeError(msg)
+
+ batch_size = batch_sizes[0]
+ if not all(other == batch_size for other in batch_sizes[1:]):
+ raise RuntimeError(f"The batch sizes of the affine parameters mismatch: {batch_sizes}")
+
+ self._batch_size = batch_size
+
+ super().__init__()
+ device, dtype = _extract_device_dtype([angle, translation, scale_factor])
+
+ if angle is None:
+ angle = torch.zeros(batch_size, device=device, dtype=dtype)
+ self.angle = angle
+
+ if translation is None:
+ translation = torch.zeros(batch_size, 2, device=device, dtype=dtype)
+ self.translation = translation
+
+ if scale_factor is None:
+ scale_factor = torch.ones(batch_size, 2, device=device, dtype=dtype)
+ self.scale_factor = scale_factor
+
+ self.shear = shear
+ self.center = center
+ self.mode = mode
+ self.padding_mode = padding_mode
+ self.align_corners = align_corners
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor:
+ if self.shear is None:
+ sx = sy = None
+ else:
+ sx, sy = self.shear[..., 0], self.shear[..., 1]
+
+ if self.center is None:
+ center = _compute_tensor_center(input).expand(input.size()[0], -1)
+ else:
+ center = self.center
+
+ matrix = get_affine_matrix2d(self.translation, center, self.scale_factor, -self.angle, sx=sx, sy=sy)
+ return affine(input, matrix[..., :2, :3], self.mode, self.padding_mode, self.align_corners)
+
+
+class Rescale(nn.Module):
+ r"""Rescale the input torch.Tensor with the given factor.
+
+ Args:
+ factor: Desired scaling factor in each direction. If scalar, the value is used
+ for both the x- and y-direction.
+ interpolation: algorithm used for upsampling: ``'nearest'`` | ``'linear'`` | ``'bilinear'`` |
+ ``'bicubic'`` | ``'trilinear'`` | ``'area'``.
+ align_corners: interpolation flag.
+ side: Corresponding side if ``size`` is an integer. Can be one of ``'short'``, ``'long'``, ``'vert'``,
+ or ``'horz'``.
+ antialias: if True, then image will be filtered with Gaussian before downscaling.
+ No effect for upscaling.
+
+ Returns:
+ The rescaled tensor with the shape according to the given factor.
+
+ Example:
+ >>> img = torch.rand(1, 3, 4, 4)
+ >>> out = Rescale((2, 3))(img)
+ >>> print(out.shape)
+ torch.Size([1, 3, 8, 12])
+ """
+
+ def __init__(
+ self,
+ factor: Union[float, Tuple[float, float]],
+ interpolation: str = "bilinear",
+ align_corners: bool = True,
+ antialias: bool = False,
+ ) -> None:
+ super().__init__()
+ self.factor: Union[float, Tuple[float, float]] = factor
+ self.interpolation: str = interpolation
+ self.align_corners: Optional[bool] = align_corners
+ self.antialias: bool = antialias
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor:
+ return rescale(
+ input, self.factor, self.interpolation, align_corners=self.align_corners, antialias=self.antialias
+ )
+
+
+class Rotate(nn.Module):
+ r"""Rotate the tensor anti-clockwise about the centre.
+
+ Args:
+ angle: The angle through which to rotate. The tensor
+ must have a shape of (B), where B is batch size.
+ center: The center through which to rotate. The tensor
+ must have a shape of (B, 2), where B is batch size and last
+ dimension contains cx and cy.
+ mode: interpolation mode to calculate output values
+ ``'bilinear'`` | ``'nearest'``.
+ padding_mode: padding mode for outside grid values
+ ``'zeros'`` | ``'border'`` | ``'reflection'``.
+ align_corners: interpolation flag.
+
+ Returns:
+ The rotated tensor with the same shape as the input.
+
+ Example:
+ >>> img = torch.rand(1, 3, 4, 4)
+ >>> angle = torch.tensor([90.])
+ >>> out = Rotate(angle)(img)
+ >>> print(out.shape)
+ torch.Size([1, 3, 4, 4])
+ """
+
+ def __init__(
+ self,
+ angle: torch.Tensor,
+ center: Union[None, torch.Tensor] = None,
+ mode: str = 'bilinear',
+ padding_mode: str = 'zeros',
+ align_corners: bool = True,
+ ) -> None:
+ super().__init__()
+ self.angle: torch.Tensor = angle
+ self.center: Union[None, torch.Tensor] = center
+ self.mode: str = mode
+ self.padding_mode: str = padding_mode
+ self.align_corners: bool = align_corners
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor:
+ return rotate(input, self.angle, self.center, self.mode, self.padding_mode, self.align_corners)
+
+
+class Translate(nn.Module):
+ r"""Translate the tensor in pixel units.
+
+ Args:
+ translation: tensor containing the amount of pixels to
+ translate in the x and y direction. The tensor must have a shape of
+ (B, 2), where B is batch size, last dimension contains dx dy.
+ mode: interpolation mode to calculate output values
+ ``'bilinear'`` | ``'nearest'``.
+ padding_mode: padding mode for outside grid values
+ ``'zeros'`` | ``'border'`` | ``'reflection'``.
+ align_corners: interpolation flag.
+
+ Returns:
+ The translated tensor with the same shape as the input.
+
+ Example:
+ >>> img = torch.rand(1, 3, 4, 4)
+ >>> translation = torch.tensor([[1., 0.]])
+ >>> out = Translate(translation)(img)
+ >>> print(out.shape)
+ torch.Size([1, 3, 4, 4])
+ """
+
+ def __init__(
+ self,
+ translation: torch.Tensor,
+ mode: str = 'bilinear',
+ padding_mode: str = 'zeros',
+ align_corners: bool = True,
+ ) -> None:
+ super().__init__()
+ self.translation: torch.Tensor = translation
+ self.mode: str = mode
+ self.padding_mode: str = padding_mode
+ self.align_corners: bool = align_corners
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor:
+ return translate(input, self.translation, self.mode, self.padding_mode, self.align_corners)
+
+
+class Scale(nn.Module):
+ r"""Scale the tensor by a factor.
+
+ Args:
+ scale_factor: The scale factor apply. The tensor
+ must have a shape of (B) or (B, 2), where B is batch size.
+ If (B), isotropic scaling will perform.
+ If (B, 2), x-y-direction specific scaling will perform.
+ center: The center through which to scale. The tensor
+ must have a shape of (B, 2), where B is batch size and last
+ dimension contains cx and cy.
+ mode: interpolation mode to calculate output values
+ ``'bilinear'`` | ``'nearest'``.
+ padding_mode: padding mode for outside grid values
+ ``'zeros'`` | ``'border'`` | ``'reflection'``.
+ align_corners: interpolation flag.
+
+ Returns:
+ The scaled tensor with the same shape as the input.
+
+ Example:
+ >>> img = torch.rand(1, 3, 4, 4)
+ >>> scale_factor = torch.tensor([[2., 2.]])
+ >>> out = Scale(scale_factor)(img)
+ >>> print(out.shape)
+ torch.Size([1, 3, 4, 4])
+ """
+
+ def __init__(
+ self,
+ scale_factor: torch.Tensor,
+ center: Union[None, torch.Tensor] = None,
+ mode: str = 'bilinear',
+ padding_mode: str = 'zeros',
+ align_corners: bool = True,
+ ) -> None:
+ super().__init__()
+ self.scale_factor: torch.Tensor = scale_factor
+ self.center: Union[None, torch.Tensor] = center
+ self.mode: str = mode
+ self.padding_mode: str = padding_mode
+ self.align_corners: bool = align_corners
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor:
+ return scale(input, self.scale_factor, self.center, self.mode, self.padding_mode, self.align_corners)
+
+
+class Shear(nn.Module):
+ r"""Shear the tensor.
+
+ Args:
+ shear: tensor containing the angle to shear
+ in the x and y direction. The tensor must have a shape of
+ (B, 2), where B is batch size, last dimension contains shx shy.
+ mode: interpolation mode to calculate output values
+ ``'bilinear'`` | ``'nearest'``.
+ padding_mode: padding mode for outside grid values
+ ``'zeros'`` | ``'border'`` | ``'reflection'``.
+ align_corners: interpolation flag.
+
+ Returns:
+ The skewed tensor with the same shape as the input.
+
+ Example:
+ >>> img = torch.rand(1, 3, 4, 4)
+ >>> shear_factor = torch.tensor([[0.5, 0.0]])
+ >>> out = Shear(shear_factor)(img)
+ >>> print(out.shape)
+ torch.Size([1, 3, 4, 4])
+ """
+
+ def __init__(
+ self, shear: torch.Tensor, mode: str = 'bilinear', padding_mode: str = 'zeros', align_corners: bool = True
+ ) -> None:
+ super().__init__()
+ self.shear: torch.Tensor = shear
+ self.mode: str = mode
+ self.padding_mode: str = padding_mode
+ self.align_corners: bool = align_corners
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor:
+ return shear(input, self.shear, self.mode, self.padding_mode, self.align_corners)
diff --git a/kornia/geometry/transform/crop2d.py b/kornia/geometry/transform/crop2d.py
new file mode 100644
index 0000000000000000000000000000000000000000..d91b045e81190c35ffe1bdeb35671defaa10a6aa
--- /dev/null
+++ b/kornia/geometry/transform/crop2d.py
@@ -0,0 +1,274 @@
+from typing import Tuple
+
+import torch
+
+from kornia.geometry.bbox import infer_bbox_shape, validate_bbox
+
+from .imgwarp import get_perspective_transform, warp_affine
+
+__all__ = [
+ "crop_and_resize",
+ "crop_by_boxes",
+ "crop_by_transform_mat",
+ "center_crop",
+]
+
+
+def crop_and_resize(
+ tensor: torch.Tensor,
+ boxes: torch.Tensor,
+ size: Tuple[int, int],
+ mode: str = 'bilinear',
+ padding_mode: str = 'zeros',
+ align_corners: bool = True,
+) -> torch.Tensor:
+ r"""Extract crops from 2D images (4D tensor) and resize given a bounding box.
+
+ Args:
+ tensor: the 2D image tensor with shape (B, C, H, W).
+ boxes : a tensor containing the coordinates of the bounding boxes to be extracted.
+ The tensor must have the shape of Bx4x2, where each box is defined in the following (clockwise)
+ order: top-left, top-right, bottom-right and bottom-left. The coordinates must be in the x, y order.
+ The coordinates would compose a rectangle with a shape of (N1, N2).
+ size: a tuple with the height and width that will be
+ used to resize the extracted patches.
+ mode: interpolation mode to calculate output values
+ ``'bilinear'`` | ``'nearest'``.
+ padding_mode: padding mode for outside grid values
+ ``'zeros'`` | ``'border'`` | 'reflection'.
+ align_corners: mode for grid_generation.
+
+ Returns:
+ torch.Tensor: tensor containing the patches with shape BxCxN1xN2.
+
+ Example:
+ >>> input = torch.tensor([[[
+ ... [1., 2., 3., 4.],
+ ... [5., 6., 7., 8.],
+ ... [9., 10., 11., 12.],
+ ... [13., 14., 15., 16.],
+ ... ]]])
+ >>> boxes = torch.tensor([[
+ ... [1., 1.],
+ ... [2., 1.],
+ ... [2., 2.],
+ ... [1., 2.],
+ ... ]]) # 1x4x2
+ >>> crop_and_resize(input, boxes, (2, 2), mode='nearest', align_corners=True)
+ tensor([[[[ 6., 7.],
+ [10., 11.]]]])
+ """
+ if not isinstance(tensor, torch.Tensor):
+ raise TypeError(f"Input tensor type is not a torch.Tensor. Got {type(tensor)}")
+
+ if not isinstance(boxes, torch.Tensor):
+ raise TypeError(f"Input boxes type is not a torch.Tensor. Got {type(boxes)}")
+
+ if not isinstance(size, (tuple, list)) and len(size) == 2:
+ raise ValueError(f"Input size must be a tuple/list of length 2. Got {size}")
+
+ if len(tensor.shape) != 4:
+ raise AssertionError(f"Only tensor with shape (B, C, H, W) supported. Got {tensor.shape}.")
+
+ # unpack input data
+ dst_h, dst_w = size
+
+ # [x, y] origin
+ # top-left, top-right, bottom-right, bottom-left
+ points_src: torch.Tensor = boxes.to(tensor)
+
+ # [x, y] destination
+ # top-left, top-right, bottom-right, bottom-left
+ points_dst: torch.Tensor = torch.tensor(
+ [[[0, 0], [dst_w - 1, 0], [dst_w - 1, dst_h - 1], [0, dst_h - 1]]], device=tensor.device, dtype=tensor.dtype
+ ).expand(points_src.shape[0], -1, -1)
+
+ return crop_by_boxes(tensor, points_src, points_dst, mode, padding_mode, align_corners)
+
+
+def center_crop(
+ tensor: torch.Tensor,
+ size: Tuple[int, int],
+ mode: str = 'bilinear',
+ padding_mode: str = 'zeros',
+ align_corners: bool = True,
+) -> torch.Tensor:
+ r"""Crop the 2D images (4D tensor) from the center.
+
+ Args:
+ tensor: the 2D image tensor with shape (B, C, H, W).
+ size: a tuple with the expected height and width
+ of the output patch.
+ mode: interpolation mode to calculate output values
+ ``'bilinear'`` | ``'nearest'``.
+ padding_mode: padding mode for outside grid values
+ ``'zeros'`` | ``'border'`` | ``'reflection'``.
+ align_corners: mode for grid_generation.
+
+ Returns:
+ the output tensor with patches.
+
+ Examples:
+ >>> input = torch.tensor([[[
+ ... [1., 2., 3., 4.],
+ ... [5., 6., 7., 8.],
+ ... [9., 10., 11., 12.],
+ ... [13., 14., 15., 16.],
+ ... ]]])
+ >>> center_crop(input, (2, 4), mode='nearest', align_corners=True)
+ tensor([[[[ 5., 6., 7., 8.],
+ [ 9., 10., 11., 12.]]]])
+ """
+ if not isinstance(tensor, torch.Tensor):
+ raise TypeError(f"Input tensor type is not a torch.Tensor. Got {type(tensor)}")
+
+ if not isinstance(size, (tuple, list)) and len(size) == 2:
+ raise ValueError(f"Input size must be a tuple/list of length 2. Got {size}")
+
+ if len(tensor.shape) != 4:
+ raise AssertionError(f"Only tensor with shape (B, C, H, W) supported. Got {tensor.shape}.")
+
+ # unpack input sizes
+ dst_h, dst_w = size
+ src_h, src_w = tensor.shape[-2:]
+
+ # compute start/end offsets
+ dst_h_half: float = dst_h / 2
+ dst_w_half: float = dst_w / 2
+ src_h_half: float = src_h / 2
+ src_w_half: float = src_w / 2
+
+ start_x: float = src_w_half - dst_w_half
+ start_y: float = src_h_half - dst_h_half
+
+ end_x: float = start_x + dst_w - 1
+ end_y: float = start_y + dst_h - 1
+
+ # [y, x] origin
+ # top-left, top-right, bottom-right, bottom-left
+ points_src: torch.Tensor = torch.tensor(
+ [[[start_x, start_y], [end_x, start_y], [end_x, end_y], [start_x, end_y]]],
+ device=tensor.device,
+ dtype=tensor.dtype,
+ )
+
+ # [y, x] destination
+ # top-left, top-right, bottom-right, bottom-left
+ points_dst: torch.Tensor = torch.tensor(
+ [[[0, 0], [dst_w - 1, 0], [dst_w - 1, dst_h - 1], [0, dst_h - 1]]], device=tensor.device, dtype=tensor.dtype
+ ).expand(points_src.shape[0], -1, -1)
+
+ return crop_by_boxes(tensor, points_src, points_dst, mode, padding_mode, align_corners)
+
+
+def crop_by_boxes(
+ tensor: torch.Tensor,
+ src_box: torch.Tensor,
+ dst_box: torch.Tensor,
+ mode: str = 'bilinear',
+ padding_mode: str = 'zeros',
+ align_corners: bool = True,
+) -> torch.Tensor:
+ """Perform crop transform on 2D images (4D tensor) given two bounding boxes.
+
+ Given an input tensor, this function selected the interested areas by the provided bounding boxes (src_box).
+ Then the selected areas would be fitted into the targeted bounding boxes (dst_box) by a perspective transformation.
+ So far, the ragged tensor is not supported by PyTorch right now. This function hereby requires the bounding boxes
+ in a batch must be rectangles with same width and height.
+
+ Args:
+ tensor: the 2D image tensor with shape (B, C, H, W).
+ src_box: a tensor with shape (B, 4, 2) containing the coordinates of the bounding boxes
+ to be extracted. The tensor must have the shape of Bx4x2, where each box is defined in the clockwise
+ order: top-left, top-right, bottom-right and bottom-left. The coordinates must be in x, y order.
+ dst_box: a tensor with shape (B, 4, 2) containing the coordinates of the bounding boxes
+ to be placed. The tensor must have the shape of Bx4x2, where each box is defined in the clockwise
+ order: top-left, top-right, bottom-right and bottom-left. The coordinates must be in x, y order.
+ mode: interpolation mode to calculate output values
+ ``'bilinear'`` | ``'nearest'``.
+ padding_mode: padding mode for outside grid values
+ ``'zeros'`` | ``'border'`` | ``'reflection'``.
+ align_corners: mode for grid_generation.
+
+ Returns:
+ torch.Tensor: the output tensor with patches.
+
+ Examples:
+ >>> input = torch.arange(16, dtype=torch.float32).reshape((1, 1, 4, 4))
+ >>> src_box = torch.tensor([[
+ ... [1., 1.],
+ ... [2., 1.],
+ ... [2., 2.],
+ ... [1., 2.],
+ ... ]]) # 1x4x2
+ >>> dst_box = torch.tensor([[
+ ... [0., 0.],
+ ... [1., 0.],
+ ... [1., 1.],
+ ... [0., 1.],
+ ... ]]) # 1x4x2
+ >>> crop_by_boxes(input, src_box, dst_box, align_corners=True)
+ tensor([[[[ 5.0000, 6.0000],
+ [ 9.0000, 10.0000]]]])
+
+ Note:
+ If the src_box is smaller than dst_box, the following error will be thrown.
+ RuntimeError: solve_cpu: For batch 0: U(2,2) is zero, singular U.
+ """
+ # TODO: improve this since might slow down the function
+ validate_bbox(src_box)
+ validate_bbox(dst_box)
+
+ if len(tensor.shape) != 4:
+ raise AssertionError(f"Only tensor with shape (B, C, H, W) supported. Got {tensor.shape}.")
+
+ # compute transformation between points and warp
+ # Note: Tensor.dtype must be float. "solve_cpu" not implemented for 'Long'
+ dst_trans_src: torch.Tensor = get_perspective_transform(src_box.to(tensor), dst_box.to(tensor))
+
+ bbox: Tuple[torch.Tensor, torch.Tensor] = infer_bbox_shape(dst_box)
+ if not ((bbox[0] == bbox[0][0]).all() and (bbox[1] == bbox[1][0]).all()):
+ raise AssertionError(
+ f"Cropping height, width and depth must be exact same in a batch. "
+ f"Got height {bbox[0]} and width {bbox[1]}."
+ )
+
+ h_out: int = int(bbox[0][0].item())
+ w_out: int = int(bbox[1][0].item())
+
+ return crop_by_transform_mat(
+ tensor, dst_trans_src, (h_out, w_out), mode=mode, padding_mode=padding_mode, align_corners=align_corners
+ )
+
+
+def crop_by_transform_mat(
+ tensor: torch.Tensor,
+ transform: torch.Tensor,
+ out_size: Tuple[int, int],
+ mode: str = 'bilinear',
+ padding_mode: str = 'zeros',
+ align_corners: bool = True,
+) -> torch.Tensor:
+ """Perform crop transform on 2D images (4D tensor) given a perspective transformation matrix.
+
+ Args:
+ tensor: the 2D image tensor with shape (B, C, H, W).
+ transform: a perspective transformation matrix with shape (B, 3, 3).
+ out_size: size of the output image (height, width).
+ mode: interpolation mode to calculate output values
+ ``'bilinear'`` | ``'nearest'``.
+ padding_mode (str): padding mode for outside grid values
+ ``'zeros'`` | ``'border'`` | ``'reflection'``.
+ align_corners: mode for grid_generation.
+
+ Returns:
+ the output tensor with patches.
+ """
+ # simulate broadcasting
+ dst_trans_src = torch.as_tensor(transform.expand(tensor.shape[0], -1, -1), device=tensor.device, dtype=tensor.dtype)
+
+ patches: torch.Tensor = warp_affine(
+ tensor, dst_trans_src[:, :2, :], out_size, mode=mode, padding_mode=padding_mode, align_corners=align_corners
+ )
+
+ return patches
diff --git a/kornia/geometry/transform/crop3d.py b/kornia/geometry/transform/crop3d.py
new file mode 100644
index 0000000000000000000000000000000000000000..1a3ff7e322479c306c63b05a7b0654c93ae82438
--- /dev/null
+++ b/kornia/geometry/transform/crop3d.py
@@ -0,0 +1,366 @@
+from typing import Tuple
+
+import torch
+
+from kornia.geometry.bbox import infer_bbox_shape3d, validate_bbox3d
+
+from .projwarp import get_perspective_transform3d, warp_affine3d
+
+__all__ = [
+ "crop_and_resize3d",
+ "crop_by_boxes3d",
+ "crop_by_transform_mat3d",
+ "center_crop3d",
+]
+
+
+def crop_and_resize3d(
+ tensor: torch.Tensor,
+ boxes: torch.Tensor,
+ size: Tuple[int, int, int],
+ interpolation: str = 'bilinear',
+ align_corners: bool = False,
+) -> torch.Tensor:
+ r"""Extract crops from 3D volumes (5D tensor) and resize them.
+
+ Args:
+ tensor: the 3D volume tensor with shape (B, C, D, H, W).
+ boxes: a tensor with shape (B, 8, 3) containing the coordinates of the bounding boxes
+ to be extracted. The tensor must have the shape of Bx8x3, where each box is defined in the clockwise
+ order: front-top-left, front-top-right, front-bottom-right, front-bottom-left, back-top-left,
+ back-top-right, back-bottom-right, back-bottom-left. The coordinates must be in x, y, z order.
+ size: a tuple with the height and width that will be
+ used to resize the extracted patches.
+ interpolation: Interpolation flag.
+ align_corners: mode for grid_generation.
+
+ Returns:
+ tensor containing the patches with shape (Bx)CxN1xN2xN3.
+
+ Example:
+ >>> input = torch.arange(64, dtype=torch.float32).view(1, 1, 4, 4, 4)
+ >>> input
+ tensor([[[[[ 0., 1., 2., 3.],
+ [ 4., 5., 6., 7.],
+ [ 8., 9., 10., 11.],
+ [12., 13., 14., 15.]],
+
+ [[16., 17., 18., 19.],
+ [20., 21., 22., 23.],
+ [24., 25., 26., 27.],
+ [28., 29., 30., 31.]],
+
+ [[32., 33., 34., 35.],
+ [36., 37., 38., 39.],
+ [40., 41., 42., 43.],
+ [44., 45., 46., 47.]],
+
+ [[48., 49., 50., 51.],
+ [52., 53., 54., 55.],
+ [56., 57., 58., 59.],
+ [60., 61., 62., 63.]]]]])
+ >>> boxes = torch.tensor([[
+ ... [1., 1., 1.],
+ ... [3., 1., 1.],
+ ... [3., 3., 1.],
+ ... [1., 3., 1.],
+ ... [1., 1., 2.],
+ ... [3., 1., 2.],
+ ... [3., 3., 2.],
+ ... [1., 3., 2.],
+ ... ]]) # 1x8x3
+ >>> crop_and_resize3d(input, boxes, (2, 2, 2), align_corners=True)
+ tensor([[[[[21.0000, 23.0000],
+ [29.0000, 31.0000]],
+
+ [[37.0000, 39.0000],
+ [45.0000, 47.0000]]]]])
+ """
+ if not isinstance(tensor, (torch.Tensor)):
+ raise TypeError(f"Input tensor type is not a torch.Tensor. Got {type(tensor)}")
+ if not isinstance(boxes, (torch.Tensor)):
+ raise TypeError(f"Input boxes type is not a torch.Tensor. Got {type(boxes)}")
+ if not isinstance(size, (tuple, list)) and len(size) != 3:
+ raise ValueError(f"Input size must be a tuple/list of length 3. Got {size}")
+ if len(tensor.shape) != 5:
+ raise AssertionError(f"Only tensor with shape (B, C, D, H, W) supported. Got {tensor.shape}.")
+ # unpack input data
+ dst_d, dst_h, dst_w = size[0], size[1], size[2]
+
+ # [x, y, z] origin
+ # from front to back
+ # top-left, top-right, bottom-right, bottom-left
+ points_src: torch.Tensor = boxes
+
+ # [x, y, z] destination
+ # from front to back
+ # top-left, top-right, bottom-right, bottom-left
+ points_dst: torch.Tensor = torch.tensor(
+ [
+ [
+ [0, 0, 0],
+ [dst_w - 1, 0, 0],
+ [dst_w - 1, dst_h - 1, 0],
+ [0, dst_h - 1, 0],
+ [0, 0, dst_d - 1],
+ [dst_w - 1, 0, dst_d - 1],
+ [dst_w - 1, dst_h - 1, dst_d - 1],
+ [0, dst_h - 1, dst_d - 1],
+ ]
+ ],
+ dtype=tensor.dtype,
+ device=tensor.device,
+ ).expand(points_src.shape[0], -1, -1)
+
+ return crop_by_boxes3d(tensor, points_src, points_dst, interpolation, align_corners)
+
+
+def center_crop3d(
+ tensor: torch.Tensor, size: Tuple[int, int, int], interpolation: str = 'bilinear', align_corners: bool = True
+) -> torch.Tensor:
+ r"""Crop the 3D volumes (5D tensor) at the center.
+
+ Args:
+ tensor: the 3D volume tensor with shape (B, C, D, H, W).
+ size: a tuple with the expected depth, height and width
+ of the output patch.
+ interpolation: Interpolation flag.
+ align_corners : mode for grid_generation.
+
+ Returns:
+ the output tensor with patches.
+
+ Examples:
+ >>> input = torch.arange(64, dtype=torch.float32).view(1, 1, 4, 4, 4)
+ >>> input
+ tensor([[[[[ 0., 1., 2., 3.],
+ [ 4., 5., 6., 7.],
+ [ 8., 9., 10., 11.],
+ [12., 13., 14., 15.]],
+
+ [[16., 17., 18., 19.],
+ [20., 21., 22., 23.],
+ [24., 25., 26., 27.],
+ [28., 29., 30., 31.]],
+
+ [[32., 33., 34., 35.],
+ [36., 37., 38., 39.],
+ [40., 41., 42., 43.],
+ [44., 45., 46., 47.]],
+
+ [[48., 49., 50., 51.],
+ [52., 53., 54., 55.],
+ [56., 57., 58., 59.],
+ [60., 61., 62., 63.]]]]])
+ >>> center_crop3d(input, (2, 2, 2), align_corners=True)
+ tensor([[[[[21.0000, 22.0000],
+ [25.0000, 26.0000]],
+
+ [[37.0000, 38.0000],
+ [41.0000, 42.0000]]]]])
+ """
+ if not isinstance(tensor, (torch.Tensor)):
+ raise TypeError(f"Input tensor type is not a torch.Tensor. Got {type(tensor)}")
+
+ if len(tensor.shape) != 5:
+ raise AssertionError(f"Only tensor with shape (B, C, D, H, W) supported. Got {tensor.shape}.")
+
+ if not isinstance(size, (tuple, list)) and len(size) == 3:
+ raise ValueError(f"Input size must be a tuple/list of length 3. Got {size}")
+
+ # unpack input sizes
+ dst_d, dst_h, dst_w = size
+ src_d, src_h, src_w = tensor.shape[-3:]
+
+ # compute start/end offsets
+ dst_d_half = dst_d / 2
+ dst_h_half = dst_h / 2
+ dst_w_half = dst_w / 2
+ src_d_half = src_d / 2
+ src_h_half = src_h / 2
+ src_w_half = src_w / 2
+
+ start_x = src_w_half - dst_w_half
+ start_y = src_h_half - dst_h_half
+ start_z = src_d_half - dst_d_half
+
+ end_x = start_x + dst_w - 1
+ end_y = start_y + dst_h - 1
+ end_z = start_z + dst_d - 1
+ # [x, y, z] origin
+ # top-left-front, top-right-front, bottom-right-front, bottom-left-front
+ # top-left-back, top-right-back, bottom-right-back, bottom-left-back
+ points_src: torch.Tensor = torch.tensor(
+ [
+ [
+ [start_x, start_y, start_z],
+ [end_x, start_y, start_z],
+ [end_x, end_y, start_z],
+ [start_x, end_y, start_z],
+ [start_x, start_y, end_z],
+ [end_x, start_y, end_z],
+ [end_x, end_y, end_z],
+ [start_x, end_y, end_z],
+ ]
+ ],
+ device=tensor.device,
+ )
+
+ # [x, y, z] destination
+ # top-left-front, top-right-front, bottom-right-front, bottom-left-front
+ # top-left-back, top-right-back, bottom-right-back, bottom-left-back
+ points_dst: torch.Tensor = torch.tensor(
+ [
+ [
+ [0, 0, 0],
+ [dst_w - 1, 0, 0],
+ [dst_w - 1, dst_h - 1, 0],
+ [0, dst_h - 1, 0],
+ [0, 0, dst_d - 1],
+ [dst_w - 1, 0, dst_d - 1],
+ [dst_w - 1, dst_h - 1, dst_d - 1],
+ [0, dst_h - 1, dst_d - 1],
+ ]
+ ],
+ device=tensor.device,
+ ).expand(points_src.shape[0], -1, -1)
+
+ return crop_by_boxes3d(
+ tensor, points_src.to(tensor.dtype), points_dst.to(tensor.dtype), interpolation, align_corners
+ )
+
+
+def crop_by_boxes3d(
+ tensor: torch.Tensor,
+ src_box: torch.Tensor,
+ dst_box: torch.Tensor,
+ interpolation: str = 'bilinear',
+ align_corners: bool = False,
+) -> torch.Tensor:
+ """Perform crop transform on 3D volumes (5D tensor) by bounding boxes.
+
+ Given an input tensor, this function selected the interested areas by the provided bounding boxes (src_box).
+ Then the selected areas would be fitted into the targeted bounding boxes (dst_box) by a perspective transformation.
+ So far, the ragged tensor is not supported by PyTorch right now. This function hereby requires the bounding boxes
+ in a batch must be rectangles with same width, height and depth.
+
+ Args:
+ tensor : the 3D volume tensor with shape (B, C, D, H, W).
+ src_box : a tensor with shape (B, 8, 3) containing the coordinates of the bounding boxes
+ to be extracted. The tensor must have the shape of Bx8x3, where each box is defined in the clockwise
+ order: front-top-left, front-top-right, front-bottom-right, front-bottom-left, back-top-left,
+ back-top-right, back-bottom-right, back-bottom-left. The coordinates must be in x, y, z order.
+ dst_box: a tensor with shape (B, 8, 3) containing the coordinates of the bounding boxes
+ to be placed. The tensor must have the shape of Bx8x3, where each box is defined in the clockwise
+ order: front-top-left, front-top-right, front-bottom-right, front-bottom-left, back-top-left,
+ back-top-right, back-bottom-right, back-bottom-left. The coordinates must be in x, y, z order.
+ interpolation: Interpolation flag.
+ align_corners: mode for grid_generation.
+
+ Returns:
+ the output tensor with patches.
+
+ Examples:
+ >>> input = torch.tensor([[[
+ ... [[ 0., 1., 2., 3.],
+ ... [ 4., 5., 6., 7.],
+ ... [ 8., 9., 10., 11.],
+ ... [12., 13., 14., 15.]],
+ ... [[16., 17., 18., 19.],
+ ... [20., 21., 22., 23.],
+ ... [24., 25., 26., 27.],
+ ... [28., 29., 30., 31.]],
+ ... [[32., 33., 34., 35.],
+ ... [36., 37., 38., 39.],
+ ... [40., 41., 42., 43.],
+ ... [44., 45., 46., 47.]]]]])
+ >>> src_box = torch.tensor([[
+ ... [1., 1., 1.],
+ ... [3., 1., 1.],
+ ... [3., 3., 1.],
+ ... [1., 3., 1.],
+ ... [1., 1., 2.],
+ ... [3., 1., 2.],
+ ... [3., 3., 2.],
+ ... [1., 3., 2.],
+ ... ]]) # 1x8x3
+ >>> dst_box = torch.tensor([[
+ ... [0., 0., 0.],
+ ... [2., 0., 0.],
+ ... [2., 2., 0.],
+ ... [0., 2., 0.],
+ ... [0., 0., 1.],
+ ... [2., 0., 1.],
+ ... [2., 2., 1.],
+ ... [0., 2., 1.],
+ ... ]]) # 1x8x3
+ >>> crop_by_boxes3d(input, src_box, dst_box, interpolation='nearest', align_corners=True)
+ tensor([[[[[21., 22., 23.],
+ [25., 26., 27.],
+ [29., 30., 31.]],
+
+ [[37., 38., 39.],
+ [41., 42., 43.],
+ [45., 46., 47.]]]]])
+ """
+ validate_bbox3d(src_box)
+ validate_bbox3d(dst_box)
+
+ if len(tensor.shape) != 5:
+ raise AssertionError(f"Only tensor with shape (B, C, D, H, W) supported. Got {tensor.shape}.")
+
+ # compute transformation between points and warp
+ # Note: Tensor.dtype must be float. "solve_cpu" not implemented for 'Long'
+ dst_trans_src: torch.Tensor = get_perspective_transform3d(src_box.to(tensor.dtype), dst_box.to(tensor.dtype))
+ # simulate broadcasting
+ dst_trans_src = dst_trans_src.expand(tensor.shape[0], -1, -1).type_as(tensor)
+
+ bbox = infer_bbox_shape3d(dst_box)
+ if not ((bbox[0] == bbox[0][0]).all() and (bbox[1] == bbox[1][0]).all() and (bbox[2] == bbox[2][0]).all()):
+ raise AssertionError(
+ "Cropping height, width and depth must be exact same in a batch."
+ f"Got height {bbox[0]}, width {bbox[1]} and depth {bbox[2]}."
+ )
+
+ patches: torch.Tensor = crop_by_transform_mat3d(
+ tensor,
+ dst_trans_src,
+ (int(bbox[0][0].item()), int(bbox[1][0].item()), int(bbox[2][0].item())),
+ mode=interpolation,
+ align_corners=align_corners,
+ )
+
+ return patches
+
+
+def crop_by_transform_mat3d(
+ tensor: torch.Tensor,
+ transform: torch.Tensor,
+ out_size: Tuple[int, int, int],
+ mode: str = 'bilinear',
+ padding_mode: str = 'zeros',
+ align_corners: bool = True,
+) -> torch.Tensor:
+ """Perform crop transform on 3D volumes (5D tensor) given a perspective transformation matrix.
+
+ Args:
+ tensor: the 2D image tensor with shape (B, C, H, W).
+ transform: a perspective transformation matrix with shape (B, 4, 4).
+ out_size: size of the output image (depth, height, width).
+ mode: interpolation mode to calculate output values
+ ``'bilinear'`` | ``'nearest'``.
+ padding_mode: padding mode for outside grid values
+ ``'zeros'`` | ``'border'`` | ``'reflection'``.
+ align_corners: mode for grid_generation.
+
+ Returns:
+ the output tensor with patches.
+ """
+ # simulate broadcasting
+ dst_trans_src = transform.expand(tensor.shape[0], -1, -1)
+
+ patches: torch.Tensor = warp_affine3d(
+ tensor, dst_trans_src[:, :3, :], out_size, flags=mode, padding_mode=padding_mode, align_corners=align_corners
+ )
+
+ return patches
diff --git a/kornia/geometry/transform/elastic_transform.py b/kornia/geometry/transform/elastic_transform.py
new file mode 100644
index 0000000000000000000000000000000000000000..5997d266eb8354429653a32af8282aeee8059093
--- /dev/null
+++ b/kornia/geometry/transform/elastic_transform.py
@@ -0,0 +1,94 @@
+from typing import Tuple
+
+import torch
+import torch.nn.functional as F
+
+from kornia.filters import filter2d, get_gaussian_kernel2d
+from kornia.utils import create_meshgrid
+
+__all__ = ["elastic_transform2d"]
+
+
+def elastic_transform2d(
+ image: torch.Tensor,
+ noise: torch.Tensor,
+ kernel_size: Tuple[int, int] = (63, 63),
+ sigma: Tuple[float, float] = (32.0, 32.0),
+ alpha: Tuple[float, float] = (1.0, 1.0),
+ align_corners: bool = False,
+ mode: str = 'bilinear',
+) -> torch.Tensor:
+ r"""Apply elastic transform of images as described in :cite:`Simard2003BestPF`.
+
+ .. image:: _static/img/elastic_transform2d.png
+
+ Args:
+ image: Input image to be transformed with shape :math:`(B, C, H, W)`.
+ noise: Noise image used to spatially transform the input image. Same
+ resolution as the input image with shape :math:`(B, 2, H, W)`. The coordinates order
+ it is expected to be in x-y.
+ kernel_size: the size of the Gaussian kernel.
+ sigma: The standard deviation of the Gaussian in the y and x directions,
+ respectively. Larger sigma results in smaller pixel displacements.
+ alpha : The scaling factor that controls the intensity of the deformation
+ in the y and x directions, respectively.
+ align_corners: Interpolation flag used by ```grid_sample```.
+ mode: Interpolation mode used by ```grid_sample```. Either ``'bilinear'`` or ``'nearest'``.
+
+ .. note:
+ ```sigma``` and ```alpha``` can also be a ``torch.Tensor``. However, you could not torchscript
+ this function with tensor until PyTorch 1.8 is released.
+
+ Returns:
+ the elastically transformed input image with shape :math:`(B,C,H,W)`.
+
+ Example:
+ >>> image = torch.rand(1, 3, 5, 5)
+ >>> noise = torch.rand(1, 2, 5, 5, requires_grad=True)
+ >>> image_hat = elastic_transform2d(image, noise, (3, 3))
+ >>> image_hat.mean().backward()
+
+ >>> image = torch.rand(1, 3, 5, 5)
+ >>> noise = torch.rand(1, 2, 5, 5)
+ >>> sigma = torch.tensor([4., 4.], requires_grad=True)
+ >>> image_hat = elastic_transform2d(image, noise, (3, 3), sigma)
+ >>> image_hat.mean().backward()
+
+ >>> image = torch.rand(1, 3, 5, 5)
+ >>> noise = torch.rand(1, 2, 5, 5)
+ >>> alpha = torch.tensor([16., 32.], requires_grad=True)
+ >>> image_hat = elastic_transform2d(image, noise, (3, 3), alpha=alpha)
+ >>> image_hat.mean().backward()
+ """
+ if not isinstance(image, torch.Tensor):
+ raise TypeError(f"Input image is not torch.Tensor. Got {type(image)}")
+
+ if not isinstance(noise, torch.Tensor):
+ raise TypeError(f"Input noise is not torch.Tensor. Got {type(noise)}")
+
+ if not len(image.shape) == 4:
+ raise ValueError(f"Invalid image shape, we expect BxCxHxW. Got: {image.shape}")
+
+ if not len(noise.shape) == 4 or noise.shape[1] != 2:
+ raise ValueError(f"Invalid noise shape, we expect Bx2xHxW. Got: {noise.shape}")
+
+ # Get Gaussian kernel for 'y' and 'x' displacement
+ kernel_x: torch.Tensor = get_gaussian_kernel2d(kernel_size, (sigma[0], sigma[0]))[None]
+ kernel_y: torch.Tensor = get_gaussian_kernel2d(kernel_size, (sigma[1], sigma[1]))[None]
+
+ # Convolve over a random displacement matrix and scale them with 'alpha'
+ disp_x: torch.Tensor = noise[:, :1]
+ disp_y: torch.Tensor = noise[:, 1:]
+
+ disp_x = filter2d(disp_x, kernel=kernel_y, border_type='constant') * alpha[0]
+ disp_y = filter2d(disp_y, kernel=kernel_x, border_type='constant') * alpha[1]
+
+ # stack and normalize displacement
+ disp = torch.cat([disp_x, disp_y], dim=1).permute(0, 2, 3, 1)
+
+ # Warp image based on displacement matrix
+ _, _, h, w = image.shape
+ grid = create_meshgrid(h, w, device=image.device).to(image.dtype)
+ warped = F.grid_sample(image, (grid + disp).clamp(-1, 1), align_corners=align_corners, mode=mode)
+
+ return warped
diff --git a/kornia/geometry/transform/flips.py b/kornia/geometry/transform/flips.py
new file mode 100644
index 0000000000000000000000000000000000000000..2804644bbaee406099ba3796c2954647825bc102
--- /dev/null
+++ b/kornia/geometry/transform/flips.py
@@ -0,0 +1,156 @@
+import torch
+import torch.nn as nn
+
+__all__ = [
+ "Vflip",
+ "Hflip",
+ "Rot180",
+ "rot180",
+ "hflip",
+ "vflip",
+]
+
+
+class Vflip(nn.Module):
+ r"""Vertically flip a tensor image or a batch of tensor images.
+
+ Input must be a tensor of shape (C, H, W) or a batch of tensors :math:`(*, C, H, W)`.
+
+ Args:
+ input: input tensor.
+
+ Returns:
+ The vertically flipped image tensor.
+
+ Examples:
+ >>> vflip = Vflip()
+ >>> input = torch.tensor([[[
+ ... [0., 0., 0.],
+ ... [0., 0., 0.],
+ ... [0., 1., 1.]
+ ... ]]])
+ >>> vflip(input)
+ tensor([[[[0., 1., 1.],
+ [0., 0., 0.],
+ [0., 0., 0.]]]])
+ """
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor: # type: ignore
+ return vflip(input)
+
+ def __repr__(self):
+ return self.__class__.__name__
+
+
+class Hflip(nn.Module):
+ r"""Horizontally flip a tensor image or a batch of tensor images.
+
+ Input must be a tensor of shape (C, H, W) or a batch of tensors :math:`(*, C, H, W)`.
+
+ Args:
+ input: input tensor.
+
+ Returns:
+ The horizontally flipped image tensor.
+
+ Examples:
+ >>> hflip = Hflip()
+ >>> input = torch.tensor([[[
+ ... [0., 0., 0.],
+ ... [0., 0., 0.],
+ ... [0., 1., 1.]
+ ... ]]])
+ >>> hflip(input)
+ tensor([[[[0., 0., 0.],
+ [0., 0., 0.],
+ [1., 1., 0.]]]])
+ """
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor: # type: ignore
+ return hflip(input)
+
+ def __repr__(self):
+ return self.__class__.__name__
+
+
+class Rot180(nn.Module):
+ r"""Rotate a tensor image or a batch of tensor images 180 degrees.
+
+ Input must be a tensor of shape (C, H, W) or a batch of tensors :math:`(*, C, H, W)`.
+
+ Args:
+ input: input tensor.
+
+ Examples:
+ >>> rot180 = Rot180()
+ >>> input = torch.tensor([[[
+ ... [0., 0., 0.],
+ ... [0., 0., 0.],
+ ... [0., 1., 1.]
+ ... ]]])
+ >>> rot180(input)
+ tensor([[[[1., 1., 0.],
+ [0., 0., 0.],
+ [0., 0., 0.]]]])
+ """
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor: # type: ignore
+ return rot180(input)
+
+ def __repr__(self):
+ return self.__class__.__name__
+
+
+def rot180(input: torch.Tensor) -> torch.Tensor:
+ r"""Rotate a tensor image or a batch of tensor images 180 degrees.
+
+ .. image:: _static/img/rot180.png
+
+ Input must be a tensor of shape (C, H, W) or a batch of tensors :math:`(*, C, H, W)`.
+
+ Args:
+ input: input tensor.
+
+ Returns:
+ The rotated image tensor.
+
+ """
+
+ return torch.flip(input, [-2, -1])
+
+
+def hflip(input: torch.Tensor) -> torch.Tensor:
+ r"""Horizontally flip a tensor image or a batch of tensor images.
+
+ .. image:: _static/img/hflip.png
+
+ Input must be a tensor of shape (C, H, W) or a batch of tensors :math:`(*, C, H, W)`.
+
+ Args:
+ input: input tensor.
+
+ Returns:
+ The horizontally flipped image tensor.
+
+ """
+ w = input.shape[-1]
+ return input[..., torch.arange(w - 1, -1, -1, device=input.device)]
+
+
+def vflip(input: torch.Tensor) -> torch.Tensor:
+ r"""Vertically flip a tensor image or a batch of tensor images.
+
+ .. image:: _static/img/vflip.png
+
+ Input must be a tensor of shape (C, H, W) or a batch of tensors :math:`(*, C, H, W)`.
+
+ Args:
+ input: input tensor.
+
+ Returns:
+ The vertically flipped image tensor.
+
+ """
+
+ h = input.shape[-2]
+ return input[..., torch.arange(h - 1, -1, -1, device=input.device), :]
diff --git a/kornia/geometry/transform/homography_warper.py b/kornia/geometry/transform/homography_warper.py
new file mode 100644
index 0000000000000000000000000000000000000000..273d61346ff942bae02740c735b32cd0f23b504f
--- /dev/null
+++ b/kornia/geometry/transform/homography_warper.py
@@ -0,0 +1,451 @@
+from typing import Optional, Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from kornia.geometry.linalg import transform_points
+from kornia.testing import check_is_tensor
+from kornia.utils import create_meshgrid, create_meshgrid3d
+from kornia.utils.helpers import _torch_inverse_cast
+
+__all__ = [
+ "HomographyWarper",
+ "homography_warp",
+ "homography_warp3d",
+ "warp_grid",
+ "warp_grid3d",
+ "normalize_homography",
+ "denormalize_homography",
+ "normalize_homography3d",
+ "normal_transform_pixel",
+ "normal_transform_pixel3d",
+]
+
+
+def warp_grid(grid: torch.Tensor, src_homo_dst: torch.Tensor) -> torch.Tensor:
+ r"""Compute the grid to warp the coordinates grid by the homography/ies.
+
+ Args:
+ grid: Unwrapped grid of the shape :math:`(1, N, W, 2)`.
+ src_homo_dst: Homography or homographies (stacked) to
+ transform all points in the grid. Shape of the homography
+ has to be :math:`(1, 3, 3)` or :math:`(N, 1, 3, 3)`.
+
+ Returns:
+ the transformed grid of shape :math:`(N, H, W, 2)`.
+ """
+ batch_size: int = src_homo_dst.size(0)
+ _, height, width, _ = grid.size()
+ # expand grid to match the input batch size
+ grid = grid.expand(batch_size, -1, -1, -1) # NxHxWx2
+ if len(src_homo_dst.shape) == 3: # local homography case
+ src_homo_dst = src_homo_dst.view(batch_size, 1, 3, 3) # Nx1x3x3
+ # perform the actual grid transformation,
+ # the grid is copied to input device and casted to the same type
+ flow: torch.Tensor = transform_points(src_homo_dst, grid.to(src_homo_dst)) # NxHxWx2
+ return flow.view(batch_size, height, width, 2) # NxHxWx2
+
+
+def warp_grid3d(grid: torch.Tensor, src_homo_dst: torch.Tensor) -> torch.Tensor:
+ r"""Compute the grid to warp the coordinates grid by the homography/ies.
+
+ Args:
+ grid: Unwrapped grid of the shape :math:`(1, D, H, W, 3)`.
+ src_homo_dst: Homography or homographies (stacked) to
+ transform all points in the grid. Shape of the homography
+ has to be :math:`(1, 4, 4)` or :math:`(N, 1, 4, 4)`.
+
+ Returns:
+ the transformed grid of shape :math:`(N, H, W, 3)`.
+ """
+ batch_size: int = src_homo_dst.size(0)
+ _, depth, height, width, _ = grid.size()
+ # expand grid to match the input batch size
+ grid = grid.expand(batch_size, -1, -1, -1, -1) # NxDxHxWx3
+ if len(src_homo_dst.shape) == 3: # local homography case
+ src_homo_dst = src_homo_dst.view(batch_size, 1, 4, 4) # Nx1x3x3
+ # perform the actual grid transformation,
+ # the grid is copied to input device and casted to the same type
+ flow: torch.Tensor = transform_points(src_homo_dst, grid.to(src_homo_dst)) # NxDxHxWx3
+ return flow.view(batch_size, depth, height, width, 3) # NxDxHxWx3
+
+
+# functional api
+def homography_warp(
+ patch_src: torch.Tensor,
+ src_homo_dst: torch.Tensor,
+ dsize: Tuple[int, int],
+ mode: str = 'bilinear',
+ padding_mode: str = 'zeros',
+ align_corners: bool = False,
+ normalized_coordinates: bool = True,
+) -> torch.Tensor:
+ r"""Warp image patches or tensors by normalized 2D homographies.
+
+ See :class:`~kornia.geometry.warp.HomographyWarper` for details.
+
+ Args:
+ patch_src: The image or tensor to warp. Should be from source of shape :math:`(N, C, H, W)`.
+ src_homo_dst: The homography or stack of homographies from destination to source of shape
+ :math:`(N, 3, 3)`.
+ dsize: The height and width of the image to warp.
+ mode: interpolation mode to calculate output values ``'bilinear'`` | ``'nearest'``.
+ padding_mode: padding mode for outside grid values ``'zeros'`` | ``'border'`` | ``'reflection'``.
+ align_corners: interpolation flag.
+ normalized_coordinates: Whether the homography assumes [-1, 1] normalized coordinates or not.
+
+ Return:
+ Patch sampled at locations from source to destination.
+
+ Example:
+ >>> input = torch.rand(1, 3, 32, 32)
+ >>> homography = torch.eye(3).view(1, 3, 3)
+ >>> output = homography_warp(input, homography, (32, 32))
+ """
+ if not src_homo_dst.device == patch_src.device:
+ raise TypeError(
+ "Patch and homography must be on the same device. \
+ Got patch.device: {} src_H_dst.device: {}.".format(
+ patch_src.device, src_homo_dst.device
+ )
+ )
+
+ height, width = dsize
+ grid = create_meshgrid(height, width, normalized_coordinates=normalized_coordinates)
+ warped_grid = warp_grid(grid, src_homo_dst)
+
+ return F.grid_sample(patch_src, warped_grid, mode=mode, padding_mode=padding_mode, align_corners=align_corners)
+
+
+def homography_warp3d(
+ patch_src: torch.Tensor,
+ src_homo_dst: torch.Tensor,
+ dsize: Tuple[int, int, int],
+ mode: str = 'bilinear',
+ padding_mode: str = 'zeros',
+ align_corners: bool = False,
+ normalized_coordinates: bool = True,
+) -> torch.Tensor:
+ r"""Warp image patches or tensors by normalized 3D homographies.
+
+ Args:
+ patch_src: The image or tensor to warp. Should be from source of shape :math:`(N, C, D, H, W)`.
+ src_homo_dst: The homography or stack of homographies from destination to source of shape
+ :math:`(N, 4, 4)`.
+ dsize: The height and width of the image to warp.
+ mode: interpolation mode to calculate output values ``'bilinear'`` | ``'nearest'``.
+ padding_mode: padding mode for outside grid values ``'zeros'`` | ``'border'`` | ``'reflection'``.
+ align_corners: interpolation flag.
+ normalized_coordinates: Whether the homography assumes [-1, 1] normalized coordinates or not.
+
+ Return:
+ Patch sampled at locations from source to destination.
+
+ Example:
+ >>> input = torch.rand(1, 3, 32, 32)
+ >>> homography = torch.eye(3).view(1, 3, 3)
+ >>> output = homography_warp(input, homography, (32, 32))
+ """
+ if not src_homo_dst.device == patch_src.device:
+ raise TypeError(
+ "Patch and homography must be on the same device. \
+ Got patch.device: {} src_H_dst.device: {}.".format(
+ patch_src.device, src_homo_dst.device
+ )
+ )
+
+ depth, height, width = dsize
+ grid = create_meshgrid3d(
+ depth, height, width, normalized_coordinates=normalized_coordinates, device=patch_src.device
+ )
+ warped_grid = warp_grid3d(grid, src_homo_dst)
+
+ return F.grid_sample(patch_src, warped_grid, mode=mode, padding_mode=padding_mode, align_corners=align_corners)
+
+
+# layer api
+class HomographyWarper(nn.Module):
+ r"""Warp tensors by homographies.
+
+ .. math::
+
+ X_{dst} = H_{src}^{\{dst\}} * X_{src}
+
+ Args:
+ height: The height of the destination tensor.
+ width: The width of the destination tensor.
+ mode: interpolation mode to calculate output values ``'bilinear'`` | ``'nearest'``.
+ padding_mode: padding mode for outside grid values
+ ``'zeros'`` | ``'border'`` | ``'reflection'``.
+ normalized_coordinates: whether to use a grid with normalized coordinates.
+ align_corners: interpolation flag.
+ """
+ _warped_grid: Optional[torch.Tensor]
+
+ def __init__(
+ self,
+ height: int,
+ width: int,
+ mode: str = 'bilinear',
+ padding_mode: str = 'zeros',
+ normalized_coordinates: bool = True,
+ align_corners: bool = False,
+ ) -> None:
+ super().__init__()
+ self.width: int = width
+ self.height: int = height
+ self.mode: str = mode
+ self.padding_mode: str = padding_mode
+ self.normalized_coordinates: bool = normalized_coordinates
+ self.align_corners: bool = align_corners
+ # create base grid to compute the flow
+ self.grid: torch.Tensor = create_meshgrid(height, width, normalized_coordinates=normalized_coordinates)
+
+ # initialice the warped destination grid
+ self._warped_grid = None
+
+ def precompute_warp_grid(self, src_homo_dst: torch.Tensor) -> None:
+ r"""Compute and store internally the transformations of the points.
+
+ Useful when the same homography/homographies are reused.
+
+ Args:
+ src_homo_dst: Homography or homographies (stacked) to
+ transform all points in the grid. Shape of the homography
+ has to be :math:`(1, 3, 3)` or :math:`(N, 1, 3, 3)`.
+ The homography assumes normalized coordinates [-1, 1] if
+ normalized_coordinates is True.
+ """
+ self._warped_grid = warp_grid(self.grid, src_homo_dst)
+
+ def forward(self, patch_src: torch.Tensor, src_homo_dst: Optional[torch.Tensor] = None) -> torch.Tensor:
+ r"""Warp a tensor from source into reference frame.
+
+ Args:
+ patch_src: The tensor to warp.
+ src_homo_dst: The homography or stack of
+ homographies from destination to source. The homography assumes
+ normalized coordinates [-1, 1] if normalized_coordinates is True.
+
+ Return:
+ Patch sampled at locations from source to destination.
+
+ Shape:
+ - Input: :math:`(N, C, H, W)` and :math:`(N, 3, 3)`
+ - Output: :math:`(N, C, H, W)`
+
+ Example:
+ >>> input = torch.rand(1, 3, 32, 32)
+ >>> homography = torch.eye(3).view(1, 3, 3)
+ >>> warper = HomographyWarper(32, 32)
+ >>> # without precomputing the warp
+ >>> output = warper(input, homography) # NxCxHxW
+ >>> # precomputing the warp
+ >>> warper.precompute_warp_grid(homography)
+ >>> output = warper(input) # NxCxHxW
+ """
+ _warped_grid = self._warped_grid
+ if src_homo_dst is not None:
+ warped_patch = homography_warp(
+ patch_src,
+ src_homo_dst,
+ (self.height, self.width),
+ mode=self.mode,
+ padding_mode=self.padding_mode,
+ align_corners=self.align_corners,
+ normalized_coordinates=self.normalized_coordinates,
+ )
+ elif _warped_grid is not None:
+ if not _warped_grid.device == patch_src.device:
+ raise TypeError(
+ "Patch and warped grid must be on the same device. \
+ Got patch.device: {} warped_grid.device: {}. Whether \
+ recall precompute_warp_grid() with the correct device \
+ for the homograhy or change the patch device.".format(
+ patch_src.device, _warped_grid.device
+ )
+ )
+ warped_patch = F.grid_sample(
+ patch_src,
+ _warped_grid,
+ mode=self.mode,
+ padding_mode=self.padding_mode,
+ align_corners=self.align_corners,
+ )
+ else:
+ raise RuntimeError(
+ "Unknown warping. If homographies are not provided \
+ they must be preset using the method: \
+ precompute_warp_grid()."
+ )
+
+ return warped_patch
+
+
+def normal_transform_pixel(
+ height: int,
+ width: int,
+ eps: float = 1e-14,
+ device: Optional[torch.device] = None,
+ dtype: Optional[torch.dtype] = None,
+) -> torch.Tensor:
+ r"""Compute the normalization matrix from image size in pixels to [-1, 1].
+
+ Args:
+ height image height.
+ width: image width.
+ eps: epsilon to prevent divide-by-zero errors
+
+ Returns:
+ normalized transform with shape :math:`(1, 3, 3)`.
+ """
+ tr_mat = torch.tensor([[1.0, 0.0, -1.0], [0.0, 1.0, -1.0], [0.0, 0.0, 1.0]], device=device, dtype=dtype) # 3x3
+
+ # prevent divide by zero bugs
+ width_denom: float = eps if width == 1 else width - 1.0
+ height_denom: float = eps if height == 1 else height - 1.0
+
+ tr_mat[0, 0] = tr_mat[0, 0] * 2.0 / width_denom
+ tr_mat[1, 1] = tr_mat[1, 1] * 2.0 / height_denom
+
+ return tr_mat.unsqueeze(0) # 1x3x3
+
+
+def normal_transform_pixel3d(
+ depth: int,
+ height: int,
+ width: int,
+ eps: float = 1e-14,
+ device: Optional[torch.device] = None,
+ dtype: Optional[torch.dtype] = None,
+) -> torch.Tensor:
+ r"""Compute the normalization matrix from image size in pixels to [-1, 1].
+
+ Args:
+ depth: image depth.
+ height: image height.
+ width: image width.
+ eps: epsilon to prevent divide-by-zero errors
+
+ Returns:
+ normalized transform with shape :math:`(1, 4, 4)`.
+ """
+ tr_mat = torch.tensor(
+ [[1.0, 0.0, 0.0, -1.0], [0.0, 1.0, 0.0, -1.0], [0.0, 0.0, 1.0, -1.0], [0.0, 0.0, 0.0, 1.0]],
+ device=device,
+ dtype=dtype,
+ ) # 4x4
+
+ # prevent divide by zero bugs
+ width_denom: float = eps if width == 1 else width - 1.0
+ height_denom: float = eps if height == 1 else height - 1.0
+ depth_denom: float = eps if depth == 1 else depth - 1.0
+
+ tr_mat[0, 0] = tr_mat[0, 0] * 2.0 / width_denom
+ tr_mat[1, 1] = tr_mat[1, 1] * 2.0 / height_denom
+ tr_mat[2, 2] = tr_mat[2, 2] * 2.0 / depth_denom
+
+ return tr_mat.unsqueeze(0) # 1x4x4
+
+
+def normalize_homography(
+ dst_pix_trans_src_pix: torch.Tensor, dsize_src: Tuple[int, int], dsize_dst: Tuple[int, int]
+) -> torch.Tensor:
+ r"""Normalize a given homography in pixels to [-1, 1].
+
+ Args:
+ dst_pix_trans_src_pix: homography/ies from source to destination to be
+ normalized. :math:`(B, 3, 3)`
+ dsize_src: size of the source image (height, width).
+ dsize_dst: size of the destination image (height, width).
+
+ Returns:
+ the normalized homography of shape :math:`(B, 3, 3)`.
+ """
+ check_is_tensor(dst_pix_trans_src_pix)
+
+ if not (len(dst_pix_trans_src_pix.shape) == 3 or dst_pix_trans_src_pix.shape[-2:] == (3, 3)):
+ raise ValueError(f"Input dst_pix_trans_src_pix must be a Bx3x3 tensor. Got {dst_pix_trans_src_pix.shape}")
+
+ # source and destination sizes
+ src_h, src_w = dsize_src
+ dst_h, dst_w = dsize_dst
+
+ # compute the transformation pixel/norm for src/dst
+ src_norm_trans_src_pix: torch.Tensor = normal_transform_pixel(src_h, src_w).to(dst_pix_trans_src_pix)
+
+ src_pix_trans_src_norm = _torch_inverse_cast(src_norm_trans_src_pix)
+ dst_norm_trans_dst_pix: torch.Tensor = normal_transform_pixel(dst_h, dst_w).to(dst_pix_trans_src_pix)
+
+ # compute chain transformations
+ dst_norm_trans_src_norm: torch.Tensor = dst_norm_trans_dst_pix @ (dst_pix_trans_src_pix @ src_pix_trans_src_norm)
+ return dst_norm_trans_src_norm
+
+
+def denormalize_homography(
+ dst_pix_trans_src_pix: torch.Tensor, dsize_src: Tuple[int, int], dsize_dst: Tuple[int, int]
+) -> torch.Tensor:
+ r"""De-normalize a given homography in pixels from [-1, 1] to actual height and width.
+
+ Args:
+ dst_pix_trans_src_pix: homography/ies from source to destination to be
+ denormalized. :math:`(B, 3, 3)`
+ dsize_src: size of the source image (height, width).
+ dsize_dst: size of the destination image (height, width).
+
+ Returns:
+ the denormalized homography of shape :math:`(B, 3, 3)`.
+ """
+ check_is_tensor(dst_pix_trans_src_pix)
+
+ if not (len(dst_pix_trans_src_pix.shape) == 3 or dst_pix_trans_src_pix.shape[-2:] == (3, 3)):
+ raise ValueError(f"Input dst_pix_trans_src_pix must be a Bx3x3 tensor. Got {dst_pix_trans_src_pix.shape}")
+
+ # source and destination sizes
+ src_h, src_w = dsize_src
+ dst_h, dst_w = dsize_dst
+
+ # compute the transformation pixel/norm for src/dst
+ src_norm_trans_src_pix: torch.Tensor = normal_transform_pixel(src_h, src_w).to(dst_pix_trans_src_pix)
+
+ dst_norm_trans_dst_pix: torch.Tensor = normal_transform_pixel(dst_h, dst_w).to(dst_pix_trans_src_pix)
+ dst_denorm_trans_dst_pix = _torch_inverse_cast(dst_norm_trans_dst_pix)
+ # compute chain transformations
+ dst_norm_trans_src_norm: torch.Tensor = dst_denorm_trans_dst_pix @ (dst_pix_trans_src_pix @ src_norm_trans_src_pix)
+ return dst_norm_trans_src_norm
+
+
+def normalize_homography3d(
+ dst_pix_trans_src_pix: torch.Tensor, dsize_src: Tuple[int, int, int], dsize_dst: Tuple[int, int, int]
+) -> torch.Tensor:
+ r"""Normalize a given homography in pixels to [-1, 1].
+
+ Args:
+ dst_pix_trans_src_pix: homography/ies from source to destination to be
+ normalized. :math:`(B, 4, 4)`
+ dsize_src: size of the source image (depth, height, width).
+ dsize_src: size of the destination image (depth, height, width).
+
+ Returns:
+ the normalized homography.
+
+ Shape:
+ Output: :math:`(B, 4, 4)`
+ """
+ check_is_tensor(dst_pix_trans_src_pix)
+
+ if not (len(dst_pix_trans_src_pix.shape) == 3 or dst_pix_trans_src_pix.shape[-2:] == (4, 4)):
+ raise ValueError(f"Input dst_pix_trans_src_pix must be a Bx3x3 tensor. Got {dst_pix_trans_src_pix.shape}")
+
+ # source and destination sizes
+ src_d, src_h, src_w = dsize_src
+ dst_d, dst_h, dst_w = dsize_dst
+ # compute the transformation pixel/norm for src/dst
+ src_norm_trans_src_pix: torch.Tensor = normal_transform_pixel3d(src_d, src_h, src_w).to(dst_pix_trans_src_pix)
+
+ src_pix_trans_src_norm = _torch_inverse_cast(src_norm_trans_src_pix)
+ dst_norm_trans_dst_pix: torch.Tensor = normal_transform_pixel3d(dst_d, dst_h, dst_w).to(dst_pix_trans_src_pix)
+ # compute chain transformations
+ dst_norm_trans_src_norm: torch.Tensor = dst_norm_trans_dst_pix @ (dst_pix_trans_src_pix @ src_pix_trans_src_norm)
+ return dst_norm_trans_src_norm
diff --git a/kornia/geometry/transform/image_registrator.py b/kornia/geometry/transform/image_registrator.py
new file mode 100644
index 0000000000000000000000000000000000000000..c1628ea459a03d8833fdeeefafd03b4dada9c030
--- /dev/null
+++ b/kornia/geometry/transform/image_registrator.py
@@ -0,0 +1,270 @@
+from typing import Callable, List, Tuple, Union
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+
+from kornia.geometry.conversions import angle_to_rotation_matrix, convert_affinematrix_to_homography
+
+from .homography_warper import HomographyWarper
+from .pyramid import build_pyramid
+
+__all__ = [
+ "ImageRegistrator",
+ "Homography",
+ "Similarity"
+]
+
+
+class Homography(nn.Module):
+ r"""Homography geometric model to be used together with ImageRegistrator
+ module for the optimization-based image
+ registration."""
+
+ def __init__(self) -> None:
+ super().__init__()
+ self.model = nn.Parameter(torch.eye(3))
+ self.reset_model()
+
+ def __repr__(self) -> str:
+ return f'{self.__class__.__name__}({self.model})'
+
+ def reset_model(self):
+ """Initializes the model with identity transform."""
+ torch.nn.init.eye_(self.model)
+
+ def forward(self) -> torch.Tensor:
+ r"""Single-batch homography".
+
+ Returns:
+ Homography matrix with shape :math:`(1, 3, 3)`.
+ """
+ return torch.unsqueeze(self.model / self.model[2, 2], dim=0) # 1x3x3
+
+ def forward_inverse(self) -> torch.Tensor:
+ r"""Interted Single-batch homography".
+
+ Returns:
+ Homography martix with shape :math:`(1, 3, 3)`.
+ """
+ return torch.unsqueeze(torch.inverse(self.model), dim=0)
+
+
+class Similarity(nn.Module):
+ """Similarity geometric model to be used together with ImageRegistrator module for the optimization-based image
+ registration.
+
+ Args:
+ rotation: if True, the rotation is optimizable, else constant zero.
+ scale: if True, the scale is optimizable, else constant zero.
+ shift: if True, the shift is optimizable, else constant one.
+ """
+
+ def __init__(self,
+ rotation: bool = True,
+ scale: bool = True,
+ shift: bool = True) -> None:
+ super().__init__()
+ if rotation:
+ self.rot = nn.Parameter(torch.zeros(1))
+ else:
+ self.register_buffer('rot', torch.zeros(1))
+ if shift:
+ self.shift = nn.Parameter(torch.zeros(1, 2, 1))
+ else:
+ self.register_buffer('shift', torch.zeros(1, 2, 1))
+ if scale:
+ self.scale = nn.Parameter(torch.ones(1))
+ else:
+ self.register_buffer('scale', torch.ones(1))
+ self.reset_model()
+
+ def __repr__(self) -> str:
+ return f'{self.__class__.__name__}(angle = {self.rot},\
+ \n shift={self.shift}, \n scale={self.scale})'
+
+ def reset_model(self) -> None:
+ """Initialize the model with identity transform."""
+ torch.nn.init.zeros_(self.rot)
+ torch.nn.init.zeros_(self.shift)
+ torch.nn.init.ones_(self.scale)
+
+ def forward(self) -> torch.Tensor:
+ r"""Single-batch similarity transform".
+
+ Returns:
+ Similarity with shape :math:`(1, 3, 3)`"""
+ rot = self.scale * angle_to_rotation_matrix(self.rot)
+ out = convert_affinematrix_to_homography(torch.cat([rot, self.shift],
+ dim=2))
+ return out
+
+ def forward_inverse(self) -> torch.Tensor:
+ r"""Single-batch inverse similarity transform".
+
+ Returns:
+ Similarity with shape :math:`(1, 3, 3)`"""
+ return torch.inverse(self.forward())
+
+
+class ImageRegistrator(nn.Module):
+ r"""Module, which performs optimization-based image registration.
+
+ Args:
+ model_type: Geometrical model for registration. Can be string or Module.
+ optimizer: optimizer class used for the optimization.
+ loss_fn: torch loss function.
+ pyramid_levels: number of scale pyramid levels.
+ lr: learning rate for optimization.
+ num_iterations: maximum number of iterations.
+ tolerance: stop optimizing if loss difference is less. default 1e-4.
+ warper: if model_type is not string, one needs to provide warper object.
+
+ Example:
+ >>> from kornia.geometry import ImageRegistrator
+ >>> img_src = torch.rand(1, 1, 32, 32)
+ >>> img_dst = torch.rand(1, 1, 32, 32)
+ >>> registrator = ImageRegistrator('similarity')
+ >>> homo = registrator.register(img_src, img_dst)
+ """
+ known_models = ['homography',
+ 'similarity',
+ 'translation',
+ 'scale',
+ 'rotation']
+
+ # TODO: resolve better type, potentially using factory.
+ def __init__(self,
+ model_type='homography',
+ optimizer=optim.Adam,
+ loss_fn: Callable = F.l1_loss,
+ pyramid_levels: int = 5,
+ lr: float = 1e-3,
+ num_iterations: int = 100,
+ tolerance: float = 1e-4,
+ warper=None) -> None:
+ super().__init__()
+ # We provide pre-defined combinations or allow user to supply model
+ # together with warper
+ if not isinstance(model_type, str):
+ if warper is None:
+ raise ValueError("You must supply warper together with custom model")
+ self.warper = warper
+ self.model = model_type
+ else:
+ if model_type.lower() == "homography":
+ self.warper = HomographyWarper
+ self.model = Homography()
+ elif model_type.lower() == "similarity":
+ self.warper = HomographyWarper
+ self.model = Similarity(True, True, True)
+ elif model_type.lower() == "translation":
+ self.warper = HomographyWarper
+ self.model = Similarity(False, False, True)
+ elif model_type.lower() == "rotation":
+ self.warper = HomographyWarper
+ self.model = Similarity(True, False, False)
+ elif model_type.lower() == "scale":
+ self.warper = HomographyWarper
+ self.model = Similarity(False, True, False)
+ else:
+ raise ValueError(f"{model_type} is not supported. Try {self.known_models}")
+ self.pyramid_levels = pyramid_levels
+ self.optimizer = optimizer
+ self.lr = lr
+ self.loss_fn = loss_fn
+ self.num_iterations = num_iterations
+ self.tolerance = tolerance
+
+ def get_single_level_loss(self,
+ img_src: torch.Tensor,
+ img_dst: torch.Tensor,
+ transform_model: torch.Tensor) -> torch.Tensor:
+ """Warp img_src into img_dst with transform_model and returns loss."""
+ # ToDo: Make possible registration of images of different shape
+ if img_src.shape != img_dst.shape:
+ raise ValueError(f"Cannot register images of different shapes\
+ {img_src.shape} {img_dst.shape:} ")
+ _height, _width = img_dst.shape[-2:]
+ warper = self.warper(_height, _width)
+ img_src_to_dst = warper(img_src, transform_model)
+ # compute and mask loss
+ loss = self.loss_fn(img_src_to_dst, img_dst, reduction='none') # 1xCxHxW
+ ones = warper(torch.ones_like(img_src), transform_model)
+ loss = loss.masked_select(ones > 0.9).mean()
+ return loss
+
+ def reset_model(self) -> None:
+ """Calls model reset function."""
+ self.model.reset_model()
+
+ def register(self,
+ src_img: torch.Tensor,
+ dst_img: torch.Tensor,
+ verbose: bool = False,
+ output_intermediate_models: bool = False) -> \
+ Union[torch.Tensor, Tuple[torch.Tensor, List[torch.Tensor]]]:
+ r"""Estimate the tranformation' which warps src_img into dst_img by gradient descent.
+ The shape of the tensors is not checked, because it may depend on the model, e.g. volume registration
+
+ Args:
+ src_img: Input image tensor.
+ dst_img: Input image tensor.
+ verbose: if True, outputs loss every 10 iterations.
+ output_intermediate_models: if True with intermediate models
+
+ Returns:
+ the transformation between two images, shape depends on the model,
+ typically [1x3x3] tensor for string model_types.
+
+ """
+ self.reset_model()
+ # ToDo: better parameter passing to optimizer
+ opt: optim.Optimizer = self.optimizer(self.model.parameters(), lr=self.lr)
+
+ # compute the gaussian pyramids
+ # [::-1] because we have to register from coarse to fine
+ img_src_pyr = build_pyramid(src_img, self.pyramid_levels)[::-1]
+ img_dst_pyr = build_pyramid(dst_img, self.pyramid_levels)[::-1]
+ prev_loss = 1e10
+ aux_models = []
+ if len(img_dst_pyr) != len(img_src_pyr):
+ raise ValueError("Cannot register images of different sizes")
+ for img_src_level, img_dst_level in zip(img_src_pyr, img_dst_pyr):
+ for i in range(self.num_iterations):
+ # compute gradient and update optimizer parameters
+ opt.zero_grad()
+ loss = self.get_single_level_loss(img_src_level,
+ img_dst_level,
+ self.model())
+ loss += self.get_single_level_loss(img_dst_level,
+ img_src_level,
+ self.model.forward_inverse())
+ current_loss = loss.item()
+ if abs(current_loss - prev_loss) < self.tolerance:
+ break
+ prev_loss = current_loss
+ loss.backward()
+ if verbose and (i % 10 == 0):
+ print(f"Loss = {current_loss:.4f}, iter={i}")
+ opt.step()
+ if output_intermediate_models:
+ aux_models.append(self.model().clone().detach())
+ if output_intermediate_models:
+ return self.model(), aux_models
+ return self.model()
+
+ def warp_src_into_dst(self, src_img: torch.Tensor) -> torch.Tensor:
+ r"""Warp src_img with estimated model."""
+ _height, _width = src_img.shape[-2:]
+ warper = self.warper(_height, _width)
+ img_src_to_dst = warper(src_img, self.model())
+ return img_src_to_dst
+
+ def warp_dst_inro_src(self, dst_img: torch.Tensor) -> torch.Tensor:
+ r"""Warp src_img with inverted estimated model."""
+ _height, _width = dst_img.shape[-2:]
+ warper = self.warper(_height, _width)
+ img_dst_to_src = warper(dst_img, self.model.forward_inverse())
+ return img_dst_to_src
diff --git a/kornia/geometry/transform/imgwarp.py b/kornia/geometry/transform/imgwarp.py
new file mode 100644
index 0000000000000000000000000000000000000000..30bfd25d7872e104886a6d527a5f01d088833e8f
--- /dev/null
+++ b/kornia/geometry/transform/imgwarp.py
@@ -0,0 +1,737 @@
+from typing import Optional, Tuple
+
+import torch
+import torch.nn.functional as F
+
+from kornia.geometry.conversions import (
+ angle_to_rotation_matrix,
+ convert_affinematrix_to_homography,
+ convert_affinematrix_to_homography3d,
+ normalize_pixel_coordinates,
+)
+from kornia.geometry.linalg import transform_points
+from kornia.utils import create_meshgrid, eye_like
+from kornia.utils.helpers import _torch_inverse_cast, _torch_solve_cast
+
+from .homography_warper import normalize_homography
+from .projwarp import get_projective_transform
+
+__all__ = [
+ "warp_perspective",
+ "warp_affine",
+ "get_perspective_transform",
+ "get_rotation_matrix2d",
+ "remap",
+ "invert_affine_transform",
+ "get_affine_matrix2d",
+ "get_affine_matrix3d",
+ "get_shear_matrix2d",
+ "get_shear_matrix3d",
+]
+
+
+def warp_perspective(
+ src: torch.Tensor,
+ M: torch.Tensor,
+ dsize: Tuple[int, int],
+ mode: str = 'bilinear',
+ padding_mode: str = 'zeros',
+ align_corners: bool = True,
+) -> torch.Tensor:
+ r"""Apply a perspective transformation to an image.
+
+ .. image:: https://kornia-tutorials.readthedocs.io/en/latest/_images/warp_perspective_10_1.png
+
+ The function warp_perspective transforms the source image using
+ the specified matrix:
+
+ .. math::
+ \text{dst} (x, y) = \text{src} \left(
+ \frac{M^{-1}_{11} x + M^{-1}_{12} y + M^{-1}_{13}}{M^{-1}_{31} x + M^{-1}_{32} y + M^{-1}_{33}} ,
+ \frac{M^{-1}_{21} x + M^{-1}_{22} y + M^{-1}_{23}}{M^{-1}_{31} x + M^{-1}_{32} y + M^{-1}_{33}}
+ \right )
+
+ Args:
+ src: input image with shape :math:`(B, C, H, W)`.
+ M: transformation matrix with shape :math:`(B, 3, 3)`.
+ dsize: size of the output image (height, width).
+ mode: interpolation mode to calculate output values ``'bilinear'`` | ``'nearest'``.
+ padding_mode: padding mode for outside grid values ``'zeros'`` | ``'border'`` | ``'reflection'``.
+ align_corners(bool, optional): interpolation flag.
+
+ Returns:
+ the warped input image :math:`(B, C, H, W)`.
+
+ Example:
+ >>> img = torch.rand(1, 4, 5, 6)
+ >>> H = torch.eye(3)[None]
+ >>> out = warp_perspective(img, H, (4, 2), align_corners=True)
+ >>> print(out.shape)
+ torch.Size([1, 4, 4, 2])
+
+ .. note::
+ This function is often used in conjunction with :func:`get_perspective_transform`.
+
+ .. note::
+ See a working example `here `_.
+ """
+ if not isinstance(src, torch.Tensor):
+ raise TypeError(f"Input src type is not a torch.Tensor. Got {type(src)}")
+
+ if not isinstance(M, torch.Tensor):
+ raise TypeError(f"Input M type is not a torch.Tensor. Got {type(M)}")
+
+ if not len(src.shape) == 4:
+ raise ValueError(f"Input src must be a BxCxHxW tensor. Got {src.shape}")
+
+ if not (len(M.shape) == 3 and M.shape[-2:] == (3, 3)):
+ raise ValueError(f"Input M must be a Bx3x3 tensor. Got {M.shape}")
+
+ B, _, H, W = src.size()
+ h_out, w_out = dsize
+
+ # we normalize the 3x3 transformation matrix and convert to 3x4
+ dst_norm_trans_src_norm: torch.Tensor = normalize_homography(M, (H, W), (h_out, w_out)) # Bx3x3
+
+ src_norm_trans_dst_norm = _torch_inverse_cast(dst_norm_trans_src_norm) # Bx3x3
+
+ # this piece of code substitutes F.affine_grid since it does not support 3x3
+ grid = (
+ create_meshgrid(h_out, w_out, normalized_coordinates=True, device=src.device).to(src.dtype).repeat(B, 1, 1, 1)
+ )
+ grid = transform_points(src_norm_trans_dst_norm[:, None, None], grid)
+
+ return F.grid_sample(src, grid, align_corners=align_corners, mode=mode, padding_mode=padding_mode)
+
+
+def warp_affine(
+ src: torch.Tensor,
+ M: torch.Tensor,
+ dsize: Tuple[int, int],
+ mode: str = 'bilinear',
+ padding_mode: str = 'zeros',
+ align_corners: bool = True,
+) -> torch.Tensor:
+ r"""Apply an affine transformation to a tensor.
+
+ .. image:: _static/img/warp_affine.png
+
+ The function warp_affine transforms the source tensor using
+ the specified matrix:
+
+ .. math::
+ \text{dst}(x, y) = \text{src} \left( M_{11} x + M_{12} y + M_{13} ,
+ M_{21} x + M_{22} y + M_{23} \right )
+
+ Args:
+ src: input tensor of shape :math:`(B, C, H, W)`.
+ M: affine transformation of shape :math:`(B, 2, 3)`.
+ dsize: size of the output image (height, width).
+ mode: interpolation mode to calculate output values ``'bilinear'`` | ``'nearest'``.
+ padding_mode (str): padding mode for outside grid values ``'zeros'`` | ``'border'`` | ``'reflection'``.
+ align_corners : mode for grid_generation.
+
+ Returns:
+ the warped tensor with shape :math:`(B, C, H, W)`.
+
+ .. note::
+ This function is often used in conjunction with :func:`get_rotation_matrix2d`,
+ :func:`get_shear_matrix2d`, :func:`get_affine_matrix2d`, :func:`invert_affine_transform`.
+
+ .. note::
+ See a working example `here `__.
+
+ Example:
+ >>> img = torch.rand(1, 4, 5, 6)
+ >>> A = torch.eye(2, 3)[None]
+ >>> out = warp_affine(img, A, (4, 2), align_corners=True)
+ >>> print(out.shape)
+ torch.Size([1, 4, 4, 2])
+ """
+ if not isinstance(src, torch.Tensor):
+ raise TypeError(f"Input src type is not a torch.Tensor. Got {type(src)}")
+
+ if not isinstance(M, torch.Tensor):
+ raise TypeError(f"Input M type is not a torch.Tensor. Got {type(M)}")
+
+ if not len(src.shape) == 4:
+ raise ValueError(f"Input src must be a BxCxHxW tensor. Got {src.shape}")
+
+ if not (len(M.shape) == 3 or M.shape[-2:] == (2, 3)):
+ raise ValueError(f"Input M must be a Bx2x3 tensor. Got {M.shape}")
+
+ B, C, H, W = src.size()
+
+ # we generate a 3x3 transformation matrix from 2x3 affine
+ M_3x3: torch.Tensor = convert_affinematrix_to_homography(M)
+ dst_norm_trans_src_norm: torch.Tensor = normalize_homography(M_3x3, (H, W), dsize)
+
+ # src_norm_trans_dst_norm = torch.inverse(dst_norm_trans_src_norm)
+ src_norm_trans_dst_norm = _torch_inverse_cast(dst_norm_trans_src_norm)
+
+ grid = F.affine_grid(src_norm_trans_dst_norm[:, :2, :], [B, C, dsize[0], dsize[1]], align_corners=align_corners)
+
+ return F.grid_sample(src, grid, align_corners=align_corners, mode=mode, padding_mode=padding_mode)
+
+
+def get_perspective_transform(src, dst):
+ r"""Calculate a perspective transform from four pairs of the corresponding
+ points.
+
+ The function calculates the matrix of a perspective transform so that:
+
+ .. math ::
+
+ \begin{bmatrix}
+ t_{i}x_{i}^{'} \\
+ t_{i}y_{i}^{'} \\
+ t_{i} \\
+ \end{bmatrix}
+ =
+ \textbf{map_matrix} \cdot
+ \begin{bmatrix}
+ x_{i} \\
+ y_{i} \\
+ 1 \\
+ \end{bmatrix}
+
+ where
+
+ .. math ::
+ dst(i) = (x_{i}^{'},y_{i}^{'}), src(i) = (x_{i}, y_{i}), i = 0,1,2,3
+
+ Args:
+ src: coordinates of quadrangle vertices in the source image with shape :math:`(B, 4, 2)`.
+ dst: coordinates of the corresponding quadrangle vertices in
+ the destination image with shape :math:`(B, 4, 2)`.
+
+ Returns:
+ the perspective transformation with shape :math:`(B, 3, 3)`.
+
+ .. note::
+ This function is often used in conjunction with :func:`warp_perspective`.
+ """
+ if not isinstance(src, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(src)}")
+
+ if not isinstance(dst, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(dst)}")
+
+ if not src.dtype == dst.dtype:
+ raise TypeError(f"Source data type {src.dtype} must match Destination data type {dst.dtype}")
+
+ if not src.shape[-2:] == (4, 2):
+ raise ValueError(f"Inputs must be a Bx4x2 tensor. Got {src.shape}")
+
+ if not src.shape == dst.shape:
+ raise ValueError(f"Inputs must have the same shape. Got {dst.shape}")
+
+ if not (src.shape[0] == dst.shape[0]):
+ raise ValueError(f"Inputs must have same batch size dimension. Expect {src.shape} but got {dst.shape}")
+
+ # we build matrix A by using only 4 point correspondence. The linear
+ # system is solved with the least square method, so here
+ # we could even pass more correspondence
+ p = []
+ for i in [0, 1, 2, 3]:
+ p.append(_build_perspective_param(src[:, i], dst[:, i], 'x'))
+ p.append(_build_perspective_param(src[:, i], dst[:, i], 'y'))
+
+ # A is Bx8x8
+ A = torch.stack(p, dim=1)
+
+ # b is a Bx8x1
+ b = torch.stack(
+ [
+ dst[:, 0:1, 0],
+ dst[:, 0:1, 1],
+ dst[:, 1:2, 0],
+ dst[:, 1:2, 1],
+ dst[:, 2:3, 0],
+ dst[:, 2:3, 1],
+ dst[:, 3:4, 0],
+ dst[:, 3:4, 1],
+ ],
+ dim=1,
+ )
+
+ # solve the system Ax = b
+ X, _ = _torch_solve_cast(b, A)
+
+ # create variable to return
+ batch_size = src.shape[0]
+ M = torch.ones(batch_size, 9, device=src.device, dtype=src.dtype)
+ M[..., :8] = torch.squeeze(X, dim=-1)
+
+ return M.view(-1, 3, 3) # Bx3x3
+
+
+def _build_perspective_param(p: torch.Tensor, q: torch.Tensor, axis: str) -> torch.Tensor:
+ ones = torch.ones_like(p)[..., 0:1]
+ zeros = torch.zeros_like(p)[..., 0:1]
+ if axis == 'x':
+ return torch.cat(
+ [p[:, 0:1], p[:, 1:2], ones, zeros, zeros, zeros, -p[:, 0:1] * q[:, 0:1], -p[:, 1:2] * q[:, 0:1]], dim=1
+ )
+
+ if axis == 'y':
+ return torch.cat(
+ [zeros, zeros, zeros, p[:, 0:1], p[:, 1:2], ones, -p[:, 0:1] * q[:, 1:2], -p[:, 1:2] * q[:, 1:2]], dim=1
+ )
+
+ raise NotImplementedError(f"perspective params for axis `{axis}` is not implemented.")
+
+
+def get_rotation_matrix2d(center: torch.Tensor, angle: torch.Tensor, scale: torch.Tensor) -> torch.Tensor:
+ r"""Calculate an affine matrix of 2D rotation.
+
+ The function calculates the following matrix:
+
+ .. math::
+ \begin{bmatrix}
+ \alpha & \beta & (1 - \alpha) \cdot \text{x}
+ - \beta \cdot \text{y} \\
+ -\beta & \alpha & \beta \cdot \text{x}
+ + (1 - \alpha) \cdot \text{y}
+ \end{bmatrix}
+
+ where
+
+ .. math::
+ \alpha = \text{scale} \cdot cos(\text{angle}) \\
+ \beta = \text{scale} \cdot sin(\text{angle})
+
+ The transformation maps the rotation center to itself
+ If this is not the target, adjust the shift.
+
+ Args:
+ center: center of the rotation in the source image with shape :math:`(B, 2)`.
+ angle: rotation angle in degrees. Positive values mean
+ counter-clockwise rotation (the coordinate origin is assumed to
+ be the top-left corner) with shape :math:`(B)`.
+ scale: scale factor for x, y scaling with shape :math:`(B, 2)`.
+
+ Returns:
+ the affine matrix of 2D rotation with shape :math:`(B, 2, 3)`.
+
+ Example:
+ >>> center = torch.zeros(1, 2)
+ >>> scale = torch.ones((1, 2))
+ >>> angle = 45. * torch.ones(1)
+ >>> get_rotation_matrix2d(center, angle, scale)
+ tensor([[[ 0.7071, 0.7071, 0.0000],
+ [-0.7071, 0.7071, 0.0000]]])
+
+ .. note::
+ This function is often used in conjunction with :func:`warp_affine`.
+ """
+ if not isinstance(center, torch.Tensor):
+ raise TypeError(f"Input center type is not a torch.Tensor. Got {type(center)}")
+
+ if not isinstance(angle, torch.Tensor):
+ raise TypeError(f"Input angle type is not a torch.Tensor. Got {type(angle)}")
+
+ if not isinstance(scale, torch.Tensor):
+ raise TypeError(f"Input scale type is not a torch.Tensor. Got {type(scale)}")
+
+ if not (len(center.shape) == 2 and center.shape[1] == 2):
+ raise ValueError(f"Input center must be a Bx2 tensor. Got {center.shape}")
+
+ if not len(angle.shape) == 1:
+ raise ValueError(f"Input angle must be a B tensor. Got {angle.shape}")
+
+ if not (len(scale.shape) == 2 and scale.shape[1] == 2):
+ raise ValueError(f"Input scale must be a Bx2 tensor. Got {scale.shape}")
+
+ if not (center.shape[0] == angle.shape[0] == scale.shape[0]):
+ raise ValueError(
+ "Inputs must have same batch size dimension. Got center {}, angle {} and scale {}".format(
+ center.shape, angle.shape, scale.shape
+ )
+ )
+
+ if not (center.device == angle.device == scale.device) or not (center.dtype == angle.dtype == scale.dtype):
+ raise ValueError(
+ "Inputs must have same device Got center ({}, {}), angle ({}, {}) and scale ({}, {})".format(
+ center.device, center.dtype, angle.device, angle.dtype, scale.device, scale.dtype
+ )
+ )
+
+ shift_m = eye_like(3, center)
+ shift_m[:, :2, 2] = center
+
+ shift_m_inv = eye_like(3, center)
+ shift_m_inv[:, :2, 2] = -center
+
+ scale_m = eye_like(3, center)
+ scale_m[:, 0, 0] *= scale[:, 0]
+ scale_m[:, 1, 1] *= scale[:, 1]
+
+ rotat_m = eye_like(3, center)
+ rotat_m[:, :2, :2] = angle_to_rotation_matrix(angle)
+
+ affine_m = shift_m @ rotat_m @ scale_m @ shift_m_inv
+ return affine_m[:, :2, :] # Bx2x3
+
+
+def remap(
+ tensor: torch.Tensor,
+ map_x: torch.Tensor,
+ map_y: torch.Tensor,
+ mode: str = 'bilinear',
+ padding_mode: str = 'zeros',
+ align_corners: Optional[bool] = None,
+ normalized_coordinates: bool = False,
+) -> torch.Tensor:
+ r"""Apply a generic geometrical transformation to a tensor.
+
+ .. image:: _static/img/remap.png
+
+ The function remap transforms the source tensor using the specified map:
+
+ .. math::
+ \text{dst}(x, y) = \text{src}(map_x(x, y), map_y(x, y))
+
+ Args:
+ tensor: the tensor to remap with shape (B, D, H, W).
+ Where D is the number of channels.
+ map_x: the flow in the x-direction in pixel coordinates.
+ The tensor must be in the shape of (B, H, W).
+ map_y: the flow in the y-direction in pixel coordinates.
+ The tensor must be in the shape of (B, H, W).
+ mode: interpolation mode to calculate output values
+ ``'bilinear'`` | ``'nearest'``.
+ padding_mode: padding mode for outside grid values
+ ``'zeros'`` | ``'border'`` | ``'reflection'``.
+ align_corners: mode for grid_generation.
+ normalized_coordinates: whether the input coordinates are
+ normalised in the range of [-1, 1].
+
+ Returns:
+ the warped tensor with same shape as the input grid maps.
+
+ Example:
+ >>> from kornia.utils import create_meshgrid
+ >>> grid = create_meshgrid(2, 2, False) # 1x2x2x2
+ >>> grid += 1 # apply offset in both directions
+ >>> input = torch.ones(1, 1, 2, 2)
+ >>> remap(input, grid[..., 0], grid[..., 1], align_corners=True) # 1x1x2x2
+ tensor([[[[1., 0.],
+ [0., 0.]]]])
+
+ .. note::
+ This function is often used in conjunction with :func:`kornia.utils.create_meshgrid`.
+ """
+ if not isinstance(tensor, torch.Tensor):
+ raise TypeError(f"Input tensor type is not a torch.Tensor. Got {type(tensor)}")
+
+ if not isinstance(map_x, torch.Tensor):
+ raise TypeError(f"Input map_x type is not a torch.Tensor. Got {type(map_x)}")
+
+ if not isinstance(map_y, torch.Tensor):
+ raise TypeError(f"Input map_y type is not a torch.Tensor. Got {type(map_y)}")
+
+ if not tensor.shape[-2:] == map_x.shape[-2:] == map_y.shape[-2:]:
+ raise ValueError("Inputs last two dimensions must match.")
+
+ batch_size, _, height, width = tensor.shape
+
+ # grid_sample need the grid between -1/1
+ map_xy: torch.Tensor = torch.stack([map_x, map_y], dim=-1)
+
+ # normalize coordinates if not already normalized
+ if not normalized_coordinates:
+ map_xy = normalize_pixel_coordinates(map_xy, height, width)
+
+ # simulate broadcasting since grid_sample does not support it
+ map_xy_norm: torch.Tensor = map_xy.expand(batch_size, -1, -1, -1)
+
+ # warp ans return
+ tensor_warped: torch.Tensor = F.grid_sample(
+ tensor, map_xy_norm, mode=mode, padding_mode=padding_mode, align_corners=align_corners
+ )
+ return tensor_warped
+
+
+def invert_affine_transform(matrix: torch.Tensor) -> torch.Tensor:
+ r"""Invert an affine transformation.
+
+ The function computes an inverse affine transformation represented by
+ 2ร3 matrix:
+
+ .. math::
+ \begin{bmatrix}
+ a_{11} & a_{12} & b_{1} \\
+ a_{21} & a_{22} & b_{2} \\
+ \end{bmatrix}
+
+ The result is also a 2ร3 matrix of the same type as M.
+
+ Args:
+ matrix: original affine transform. The tensor must be
+ in the shape of :math:`(B, 2, 3)`.
+
+ Return:
+ the reverse affine transform with shape :math:`(B, 2, 3)`.
+
+ .. note::
+ This function is often used in conjunction with :func:`warp_affine`.
+ """
+ if not isinstance(matrix, torch.Tensor):
+ raise TypeError(f"Input matrix type is not a torch.Tensor. Got {type(matrix)}")
+
+ if not (len(matrix.shape) == 3 and matrix.shape[-2:] == (2, 3)):
+ raise ValueError(f"Input matrix must be a Bx2x3 tensor. Got {matrix.shape}")
+
+ matrix_tmp: torch.Tensor = convert_affinematrix_to_homography(matrix)
+ matrix_inv: torch.Tensor = torch.inverse(matrix_tmp)
+
+ return matrix_inv[..., :2, :3]
+
+
+def get_affine_matrix2d(
+ translations: torch.Tensor,
+ center: torch.Tensor,
+ scale: torch.Tensor,
+ angle: torch.Tensor,
+ sx: Optional[torch.Tensor] = None,
+ sy: Optional[torch.Tensor] = None,
+) -> torch.Tensor:
+ r"""Compose affine matrix from the components.
+
+ Args:
+ translations: tensor containing the translation vector with shape :math:`(B, 2)`.
+ center: tensor containing the center vector with shape :math:`(B, 2)`.
+ scale: tensor containing the scale factor with shape :math:`(B, 2)`.
+ angle: tensor of angles in degrees :math:`(B)`.
+ sx: tensor containing the shear factor in the x-direction with shape :math:`(B)`.
+ sy: tensor containing the shear factor in the y-direction with shape :math:`(B)`.
+
+ Returns:
+ the affine transformation matrix :math:`(B, 3, 3)`.
+
+ .. note::
+ This function is often used in conjunction with :func:`warp_affine`, :func:`warp_perspective`.
+ """
+ transform: torch.Tensor = get_rotation_matrix2d(center, -angle, scale)
+ transform[..., 2] += translations # tx/ty
+
+ # pad transform to get Bx3x3
+ transform_h = convert_affinematrix_to_homography(transform)
+
+ if any(s is not None for s in [sx, sy]):
+ shear_mat = get_shear_matrix2d(center, sx, sy)
+ transform_h = transform_h @ shear_mat
+
+ return transform_h
+
+
+def get_shear_matrix2d(center: torch.Tensor, sx: Optional[torch.Tensor] = None, sy: Optional[torch.Tensor] = None):
+ r"""Compose shear matrix Bx4x4 from the components.
+
+ Note: Ordered shearing, shear x-axis then y-axis.
+
+ .. math::
+ \begin{bmatrix}
+ 1 & b \\
+ a & ab + 1 \\
+ \end{bmatrix}
+
+ Args:
+ center: shearing center coordinates of (x, y).
+ sx: shearing degree along x axis.
+ sy: shearing degree along y axis.
+
+ Returns:
+ params to be passed to the affine transformation with shape :math:`(B, 3, 3)`.
+
+ Examples:
+ >>> rng = torch.manual_seed(0)
+ >>> sx = torch.randn(1)
+ >>> sx
+ tensor([1.5410])
+ >>> center = torch.tensor([[0., 0.]]) # Bx2
+ >>> get_shear_matrix2d(center, sx=sx)
+ tensor([[[ 1.0000, -33.5468, 0.0000],
+ [ -0.0000, 1.0000, 0.0000],
+ [ 0.0000, 0.0000, 1.0000]]])
+
+ .. note::
+ This function is often used in conjunction with :func:`warp_affine`, :func:`warp_perspective`.
+ """
+ sx = torch.tensor([0.0]).repeat(center.size(0)) if sx is None else sx
+ sy = torch.tensor([0.0]).repeat(center.size(0)) if sy is None else sy
+
+ x, y = torch.split(center, 1, dim=-1)
+ x, y = x.view(-1), y.view(-1)
+
+ sx_tan = torch.tan(sx) # type: ignore
+ sy_tan = torch.tan(sy) # type: ignore
+ ones = torch.ones_like(sx) # type: ignore
+ shear_mat = torch.stack(
+ [
+ ones,
+ -sx_tan,
+ sx_tan * y, # type: ignore
+ -sy_tan,
+ ones + sx_tan * sy_tan,
+ sy_tan * (sx_tan * y + x),
+ ],
+ dim=-1,
+ ).view(-1, 2, 3)
+
+ shear_mat = convert_affinematrix_to_homography(shear_mat)
+ return shear_mat
+
+
+def get_affine_matrix3d(
+ translations: torch.Tensor,
+ center: torch.Tensor,
+ scale: torch.Tensor,
+ angles: torch.Tensor,
+ sxy: Optional[torch.Tensor] = None,
+ sxz: Optional[torch.Tensor] = None,
+ syx: Optional[torch.Tensor] = None,
+ syz: Optional[torch.Tensor] = None,
+ szx: Optional[torch.Tensor] = None,
+ szy: Optional[torch.Tensor] = None,
+) -> torch.Tensor:
+ r"""Compose 3d affine matrix from the components.
+
+ Args:
+ translations: tensor containing the translation vector (dx,dy,dz) with shape :math:`(B, 3)`.
+ center: tensor containing the center vector (x,y,z) with shape :math:`(B, 3)`.
+ scale: tensor containing the scale factor with shape :math:`(B)`.
+ angle: angle axis vector containing the rotation angles in degrees in the form
+ of (rx, ry, rz) with shape :math:`(B, 3)`. Internally it calls Rodrigues to compute
+ the rotation matrix from axis-angle.
+ sxy: tensor containing the shear factor in the xy-direction with shape :math:`(B)`.
+ sxz: tensor containing the shear factor in the xz-direction with shape :math:`(B)`.
+ syx: tensor containing the shear factor in the yx-direction with shape :math:`(B)`.
+ syz: tensor containing the shear factor in the yz-direction with shape :math:`(B)`.
+ szx: tensor containing the shear factor in the zx-direction with shape :math:`(B)`.
+ szy: tensor containing the shear factor in the zy-direction with shape :math:`(B)`.
+
+ Returns:
+ the 3d affine transformation matrix :math:`(B, 3, 3)`.
+
+ .. note::
+ This function is often used in conjunction with :func:`warp_perspective`.
+ """
+ transform: torch.Tensor = get_projective_transform(center, -angles, scale)
+ transform[..., 3] += translations # tx/ty/tz
+
+ # pad transform to get Bx3x3
+ transform_h = convert_affinematrix_to_homography3d(transform)
+ if any(s is not None for s in [sxy, sxz, syx, syz, szx, szy]):
+ shear_mat = get_shear_matrix3d(center, sxy, sxz, syx, syz, szx, szy)
+ transform_h = transform_h @ shear_mat
+
+ return transform_h
+
+
+def get_shear_matrix3d(
+ center: torch.Tensor,
+ sxy: Optional[torch.Tensor] = None,
+ sxz: Optional[torch.Tensor] = None,
+ syx: Optional[torch.Tensor] = None,
+ syz: Optional[torch.Tensor] = None,
+ szx: Optional[torch.Tensor] = None,
+ szy: Optional[torch.Tensor] = None,
+):
+ r"""Compose shear matrix Bx4x4 from the components.
+ Note: Ordered shearing, shear x-axis then y-axis then z-axis.
+
+ .. math::
+ \begin{bmatrix}
+ 1 & o & r & oy + rz \\
+ m & p & s & mx + py + sz -y \\
+ n & q & t & nx + qy + tz -z \\
+ 0 & 0 & 0 & 1 \\
+ \end{bmatrix}
+ Where:
+ m = S_{xy}
+ n = S_{xz}
+ o = S_{yx}
+ p = S_{xy}S_{yx} + 1
+ q = S_{xz}S_{yx} + S_{yz}
+ r = S_{zx} + S_{yx}S_{zy}
+ s = S_{xy}S_{zx} + (S_{xy}S_{yx} + 1)S_{zy}
+ t = S_{xz}S_{zx} + (S_{xz}S_{yx} + S_{yz})S_{zy} + 1
+
+ Params:
+ center: shearing center coordinates of (x, y, z).
+ sxy: shearing degree along x axis, towards y plane.
+ sxz: shearing degree along x axis, towards z plane.
+ syx: shearing degree along y axis, towards x plane.
+ syz: shearing degree along y axis, towards z plane.
+ szx: shearing degree along z axis, towards x plane.
+ szy: shearing degree along z axis, towards y plane.
+
+ Returns:
+ params to be passed to the affine transformation.
+
+ Examples:
+ >>> rng = torch.manual_seed(0)
+ >>> sxy, sxz, syx, syz = torch.randn(4, 1)
+ >>> sxy, sxz, syx, syz
+ (tensor([1.5410]), tensor([-0.2934]), tensor([-2.1788]), tensor([0.5684]))
+ >>> center = torch.tensor([[0., 0., 0.]]) # Bx3
+ >>> get_shear_matrix3d(center, sxy=sxy, sxz=sxz, syx=syx, syz=syz)
+ tensor([[[ 1.0000, -1.4369, 0.0000, 0.0000],
+ [-33.5468, 49.2039, 0.0000, 0.0000],
+ [ 0.3022, -1.0729, 1.0000, 0.0000],
+ [ 0.0000, 0.0000, 0.0000, 1.0000]]])
+
+ .. note::
+ This function is often used in conjunction with :func:`warp_perspective3d`.
+ """
+ sxy = torch.tensor([0.0]).repeat(center.size(0)) if sxy is None else sxy
+ sxz = torch.tensor([0.0]).repeat(center.size(0)) if sxz is None else sxz
+ syx = torch.tensor([0.0]).repeat(center.size(0)) if syx is None else syx
+ syz = torch.tensor([0.0]).repeat(center.size(0)) if syz is None else syz
+ szx = torch.tensor([0.0]).repeat(center.size(0)) if szx is None else szx
+ szy = torch.tensor([0.0]).repeat(center.size(0)) if szy is None else szy
+
+ x, y, z = torch.split(center, 1, dim=-1)
+ x, y, z = x.view(-1), y.view(-1), z.view(-1)
+ # Prepare parameters
+ sxy_tan = torch.tan(sxy) # type: ignore
+ sxz_tan = torch.tan(sxz) # type: ignore
+ syx_tan = torch.tan(syx) # type: ignore
+ syz_tan = torch.tan(syz) # type: ignore
+ szx_tan = torch.tan(szx) # type: ignore
+ szy_tan = torch.tan(szy) # type: ignore
+
+ # compute translation matrix
+ m00, m10, m20, m01, m11, m21, m02, m12, m22 = _compute_shear_matrix_3d(
+ sxy_tan, sxz_tan, syx_tan, syz_tan, szx_tan, szy_tan
+ )
+
+ m03 = m01 * y + m02 * z
+ m13 = m10 * x + m11 * y + m12 * z - y
+ m23 = m20 * x + m21 * y + m22 * z - z
+
+ # shear matrix is implemented with negative values
+ sxy_tan, sxz_tan, syx_tan, syz_tan, szx_tan, szy_tan = -sxy_tan, -sxz_tan, -syx_tan, -syz_tan, -szx_tan, -szy_tan
+ m00, m10, m20, m01, m11, m21, m02, m12, m22 = _compute_shear_matrix_3d(
+ sxy_tan, sxz_tan, syx_tan, syz_tan, szx_tan, szy_tan
+ )
+
+ shear_mat = torch.stack([m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23], dim=-1).view(-1, 3, 4)
+ shear_mat = convert_affinematrix_to_homography3d(shear_mat)
+
+ return shear_mat
+
+
+def _compute_shear_matrix_3d(sxy_tan, sxz_tan, syx_tan, syz_tan, szx_tan, szy_tan):
+ ones = torch.ones_like(sxy_tan) # type: ignore
+
+ m00, m10, m20 = ones, sxy_tan, sxz_tan
+ m01, m11, m21 = syx_tan, sxy_tan * syx_tan + ones, sxz_tan * syx_tan + syz_tan
+ m02 = syx_tan * szy_tan + szx_tan
+ m12 = sxy_tan * szx_tan + szy_tan * m11
+ m22 = sxz_tan * szx_tan + szy_tan * m21 + ones
+ return m00, m10, m20, m01, m11, m21, m02, m12, m22
diff --git a/kornia/geometry/transform/projwarp.py b/kornia/geometry/transform/projwarp.py
new file mode 100644
index 0000000000000000000000000000000000000000..cc51c1a510266403b8c55937822a0373e66cd613
--- /dev/null
+++ b/kornia/geometry/transform/projwarp.py
@@ -0,0 +1,430 @@
+"""Module to perform projective transformations to tensors."""
+from typing import List, Tuple
+
+import torch
+
+from kornia.geometry.conversions import angle_axis_to_rotation_matrix, convert_affinematrix_to_homography3d, deg2rad
+from kornia.testing import check_is_tensor
+from kornia.utils import eye_like
+from kornia.utils.helpers import _torch_inverse_cast, _torch_solve_cast
+
+from .homography_warper import homography_warp3d, normalize_homography3d
+
+__all__ = [
+ "warp_affine3d",
+ "get_projective_transform",
+ "projection_from_Rt",
+ "get_perspective_transform3d",
+ "warp_perspective3d",
+]
+
+
+def warp_affine3d(
+ src: torch.Tensor,
+ M: torch.Tensor,
+ dsize: Tuple[int, int, int],
+ flags: str = 'bilinear',
+ padding_mode: str = 'zeros',
+ align_corners: bool = True,
+) -> torch.Tensor:
+ r"""Apply a projective transformation a to 3d tensor.
+
+ .. warning::
+ This API signature it is experimental and might suffer some changes in the future.
+
+ Args:
+ src : input tensor of shape :math:`(B, C, D, H, W)`.
+ M: projective transformation matrix of shape :math:`(B, 3, 4)`.
+ dsize: size of the output image (depth, height, width).
+ mode: interpolation mode to calculate output values
+ ``'bilinear'`` | ``'nearest'``.
+ padding_mode: padding mode for outside grid values
+ ``'zeros'`` | ``'border'`` | ``'reflection'``.
+ align_corners : mode for grid_generation.
+
+ Returns:
+ torch.Tensor: the warped 3d tensor with shape :math:`(B, C, D, H, W)`.
+
+ .. note::
+ This function is often used in conjunction with :func:`get_perspective_transform3d`.
+ """
+ if len(src.shape) != 5:
+ raise AssertionError(src.shape)
+ if not (len(M.shape) == 3 and M.shape[-2:] == (3, 4)):
+ raise AssertionError(M.shape)
+ if len(dsize) != 3:
+ raise AssertionError(dsize)
+ B, C, D, H, W = src.size()
+
+ size_src: Tuple[int, int, int] = (D, H, W)
+ size_out: Tuple[int, int, int] = dsize
+
+ M_4x4 = convert_affinematrix_to_homography3d(M) # Bx4x4
+
+ # we need to normalize the transformation since grid sample needs -1/1 coordinates
+ dst_norm_trans_src_norm: torch.Tensor = normalize_homography3d(M_4x4, size_src, size_out) # Bx4x4
+
+ src_norm_trans_dst_norm = _torch_inverse_cast(dst_norm_trans_src_norm)
+ P_norm: torch.Tensor = src_norm_trans_dst_norm[:, :3] # Bx3x4
+
+ # compute meshgrid and apply to input
+ dsize_out: List[int] = [B, C] + list(size_out)
+ grid = torch.nn.functional.affine_grid(P_norm, dsize_out, align_corners=align_corners)
+ return torch.nn.functional.grid_sample(
+ src, grid, align_corners=align_corners, mode=flags, padding_mode=padding_mode
+ )
+
+
+def projection_from_Rt(rmat: torch.Tensor, tvec: torch.Tensor) -> torch.Tensor:
+ r"""Compute the projection matrix from Rotation and translation.
+
+ .. warning::
+ This API signature it is experimental and might suffer some changes in the future.
+
+ Concatenates the batch of rotations and translations such that :math:`P = [R | t]`.
+
+ Args:
+ rmat: the rotation matrix with shape :math:`(*, 3, 3)`.
+ tvec: the translation vector with shape :math:`(*, 3, 1)`.
+
+ Returns:
+ the projection matrix with shape :math:`(*, 3, 4)`.
+
+ """
+ if not (len(rmat.shape) >= 2 and rmat.shape[-2:] == (3, 3)):
+ raise AssertionError(rmat.shape)
+ if not (len(tvec.shape) >= 2 and tvec.shape[-2:] == (3, 1)):
+ raise AssertionError(tvec.shape)
+
+ return torch.cat([rmat, tvec], dim=-1) # Bx3x4
+
+
+def get_projective_transform(center: torch.Tensor, angles: torch.Tensor, scales: torch.Tensor) -> torch.Tensor:
+ r"""Calculate the projection matrix for a 3D rotation.
+
+ .. warning::
+ This API signature it is experimental and might suffer some changes in the future.
+
+ The function computes the projection matrix given the center and angles per axis.
+
+ Args:
+ center: center of the rotation (x,y,z) in the source with shape :math:`(B, 3)`.
+ angles: angle axis vector containing the rotation angles in degrees in the form
+ of (rx, ry, rz) with shape :math:`(B, 3)`. Internally it calls Rodrigues to compute
+ the rotation matrix from axis-angle.
+ scales: scale factor for x-y-z-directions with shape :math:`(B, 3)`.
+
+ Returns:
+ the projection matrix of 3D rotation with shape :math:`(B, 3, 4)`.
+
+ .. note::
+ This function is often used in conjunction with :func:`warp_affine3d`.
+ """
+ if not (len(center.shape) == 2 and center.shape[-1] == 3):
+ raise AssertionError(center.shape)
+ if not (len(angles.shape) == 2 and angles.shape[-1] == 3):
+ raise AssertionError(angles.shape)
+ if center.device != angles.device:
+ raise AssertionError(center.device, angles.device)
+ if center.dtype != angles.dtype:
+ raise AssertionError(center.dtype, angles.dtype)
+
+ # create rotation matrix
+ angle_axis_rad: torch.Tensor = deg2rad(angles)
+ rmat: torch.Tensor = angle_axis_to_rotation_matrix(angle_axis_rad) # Bx3x3
+ scaling_matrix: torch.Tensor = eye_like(3, rmat)
+ scaling_matrix = scaling_matrix * scales.unsqueeze(dim=1)
+ rmat = rmat @ scaling_matrix.to(rmat)
+
+ # define matrix to move forth and back to origin
+ from_origin_mat = torch.eye(4)[None].repeat(rmat.shape[0], 1, 1).type_as(center) # Bx4x4
+ from_origin_mat[..., :3, -1] += center
+
+ to_origin_mat = from_origin_mat.clone()
+ to_origin_mat = _torch_inverse_cast(from_origin_mat)
+
+ # append translation with zeros
+ proj_mat = projection_from_Rt(rmat, torch.zeros_like(center)[..., None]) # Bx3x4
+
+ # chain 4x4 transforms
+ proj_mat = convert_affinematrix_to_homography3d(proj_mat) # Bx4x4
+ proj_mat = from_origin_mat @ proj_mat @ to_origin_mat
+
+ return proj_mat[..., :3, :] # Bx3x4
+
+
+def get_perspective_transform3d(src: torch.Tensor, dst: torch.Tensor) -> torch.Tensor:
+ r"""Calculate a 3d perspective transform from four pairs of the corresponding points.
+
+ The function calculates the matrix of a perspective transform so that:
+
+ .. math ::
+
+ \begin{bmatrix}
+ t_{i}x_{i}^{'} \\
+ t_{i}y_{i}^{'} \\
+ t_{i}z_{i}^{'} \\
+ t_{i} \\
+ \end{bmatrix}
+ =
+ \textbf{map_matrix} \cdot
+ \begin{bmatrix}
+ x_{i} \\
+ y_{i} \\
+ z_{i} \\
+ 1 \\
+ \end{bmatrix}
+
+ where
+
+ .. math ::
+ dst(i) = (x_{i}^{'},y_{i}^{'},z_{i}^{'}), src(i) = (x_{i}, y_{i}, z_{i}), i = 0,1,2,5,7
+
+ Concrete math is as below:
+
+ .. math ::
+
+ \[ u_i =\frac{c_{00} * x_i + c_{01} * y_i + c_{02} * z_i + c_{03}}
+ {c_{30} * x_i + c_{31} * y_i + c_{32} * z_i + c_{33}} \]
+ \[ v_i =\frac{c_{10} * x_i + c_{11} * y_i + c_{12} * z_i + c_{13}}
+ {c_{30} * x_i + c_{31} * y_i + c_{32} * z_i + c_{33}} \]
+ \[ w_i =\frac{c_{20} * x_i + c_{21} * y_i + c_{22} * z_i + c_{23}}
+ {c_{30} * x_i + c_{31} * y_i + c_{32} * z_i + c_{33}} \]
+
+ .. math ::
+
+ \begin{pmatrix}
+ x_0 & y_0 & z_0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -x_0*u_0 & -y_0*u_0 & -z_0 * u_0 \\
+ x_1 & y_1 & z_1 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -x_1*u_1 & -y_1*u_1 & -z_1 * u_1 \\
+ x_2 & y_2 & z_2 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -x_2*u_2 & -y_2*u_2 & -z_2 * u_2 \\
+ x_5 & y_5 & z_5 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -x_5*u_5 & -y_5*u_5 & -z_5 * u_5 \\
+ x_7 & y_7 & z_7 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -x_7*u_7 & -y_7*u_7 & -z_7 * u_7 \\
+ 0 & 0 & 0 & 0 & x_0 & y_0 & z_0 & 1 & 0 & 0 & 0 & 0 & -x_0*v_0 & -y_0*v_0 & -z_0 * v_0 \\
+ 0 & 0 & 0 & 0 & x_1 & y_1 & z_1 & 1 & 0 & 0 & 0 & 0 & -x_1*v_1 & -y_1*v_1 & -z_1 * v_1 \\
+ 0 & 0 & 0 & 0 & x_2 & y_2 & z_2 & 1 & 0 & 0 & 0 & 0 & -x_2*v_2 & -y_2*v_2 & -z_2 * v_2 \\
+ 0 & 0 & 0 & 0 & x_5 & y_5 & z_5 & 1 & 0 & 0 & 0 & 0 & -x_5*v_5 & -y_5*v_5 & -z_5 * v_5 \\
+ 0 & 0 & 0 & 0 & x_7 & y_7 & z_7 & 1 & 0 & 0 & 0 & 0 & -x_7*v_7 & -y_7*v_7 & -z_7 * v_7 \\
+ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & x_0 & y_0 & z_0 & 1 & -x_0*w_0 & -y_0*w_0 & -z_0 * w_0 \\
+ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & x_1 & y_1 & z_1 & 1 & -x_1*w_1 & -y_1*w_1 & -z_1 * w_1 \\
+ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & x_2 & y_2 & z_2 & 1 & -x_2*w_2 & -y_2*w_2 & -z_2 * w_2 \\
+ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & x_5 & y_5 & z_5 & 1 & -x_5*w_5 & -y_5*w_5 & -z_5 * w_5 \\
+ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & x_7 & y_7 & z_7 & 1 & -x_7*w_7 & -y_7*w_7 & -z_7 * w_7 \\
+ \end{pmatrix}
+
+ Args:
+ src: coordinates of quadrangle vertices in the source image with shape :math:`(B, 8, 3)`.
+ dst: coordinates of the corresponding quadrangle vertices in
+ the destination image with shape :math:`(B, 8, 3)`.
+
+ Returns:
+ the perspective transformation with shape :math:`(B, 4, 4)`.
+
+ .. note::
+ This function is often used in conjunction with :func:`warp_perspective3d`.
+ """
+ if not isinstance(src, (torch.Tensor)):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(src)}")
+
+ if not isinstance(dst, (torch.Tensor)):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(dst)}")
+
+ if not src.shape[-2:] == (8, 3):
+ raise ValueError(f"Inputs must be a Bx8x3 tensor. Got {src.shape}")
+
+ if not src.shape == dst.shape:
+ raise ValueError(f"Inputs must have the same shape. Got {dst.shape}")
+
+ if not (src.shape[0] == dst.shape[0]):
+ raise ValueError(f"Inputs must have same batch size dimension. Expect {src.shape} but got {dst.shape}")
+
+ if not (src.device == dst.device and src.dtype == dst.dtype):
+ raise AssertionError(
+ f"Expect `src` and `dst` to be in the same device (Got {src.dtype}, {dst.dtype}) "
+ f"with the same dtype (Got {src.dtype}, {dst.dtype})."
+ )
+
+ # we build matrix A by using only 4 point correspondence. The linear
+ # system is solved with the least square method, so here
+ # we could even pass more correspondence
+ p = []
+
+ # 000, 100, 110, 101, 011
+ for i in [0, 1, 2, 5, 7]:
+ p.append(_build_perspective_param3d(src[:, i], dst[:, i], 'x'))
+ p.append(_build_perspective_param3d(src[:, i], dst[:, i], 'y'))
+ p.append(_build_perspective_param3d(src[:, i], dst[:, i], 'z'))
+
+ # A is Bx15x15
+ A = torch.stack(p, dim=1)
+
+ # b is a Bx15x1
+ b = torch.stack(
+ [
+ dst[:, 0:1, 0],
+ dst[:, 0:1, 1],
+ dst[:, 0:1, 2],
+ dst[:, 1:2, 0],
+ dst[:, 1:2, 1],
+ dst[:, 1:2, 2],
+ dst[:, 2:3, 0],
+ dst[:, 2:3, 1],
+ dst[:, 2:3, 2],
+ # dst[:, 3:4, 0], dst[:, 3:4, 1], dst[:, 3:4, 2],
+ # dst[:, 4:5, 0], dst[:, 4:5, 1], dst[:, 4:5, 2],
+ dst[:, 5:6, 0],
+ dst[:, 5:6, 1],
+ dst[:, 5:6, 2],
+ # dst[:, 6:7, 0], dst[:, 6:7, 1], dst[:, 6:7, 2],
+ dst[:, 7:8, 0],
+ dst[:, 7:8, 1],
+ dst[:, 7:8, 2],
+ ],
+ dim=1,
+ )
+
+ # solve the system Ax = b
+ X, _ = _torch_solve_cast(b, A)
+
+ # create variable to return
+ batch_size = src.shape[0]
+ M = torch.ones(batch_size, 16, device=src.device, dtype=src.dtype)
+ M[..., :15] = torch.squeeze(X, dim=-1)
+ return M.view(-1, 4, 4) # Bx4x4
+
+
+def _build_perspective_param3d(p: torch.Tensor, q: torch.Tensor, axis: str) -> torch.Tensor:
+ ones = torch.ones_like(p)[..., 0:1]
+ zeros = torch.zeros_like(p)[..., 0:1]
+
+ if axis == 'x':
+ return torch.cat(
+ [
+ p[:, 0:1],
+ p[:, 1:2],
+ p[:, 2:3],
+ ones,
+ zeros,
+ zeros,
+ zeros,
+ zeros,
+ zeros,
+ zeros,
+ zeros,
+ zeros,
+ -p[:, 0:1] * q[:, 0:1],
+ -p[:, 1:2] * q[:, 0:1],
+ -p[:, 2:3] * q[:, 0:1],
+ ],
+ dim=1,
+ )
+
+ if axis == 'y':
+ return torch.cat(
+ [
+ zeros,
+ zeros,
+ zeros,
+ zeros,
+ p[:, 0:1],
+ p[:, 1:2],
+ p[:, 2:3],
+ ones,
+ zeros,
+ zeros,
+ zeros,
+ zeros,
+ -p[:, 0:1] * q[:, 1:2],
+ -p[:, 1:2] * q[:, 1:2],
+ -p[:, 2:3] * q[:, 1:2],
+ ],
+ dim=1,
+ )
+
+ if axis == 'z':
+ return torch.cat(
+ [
+ zeros,
+ zeros,
+ zeros,
+ zeros,
+ zeros,
+ zeros,
+ zeros,
+ zeros,
+ p[:, 0:1],
+ p[:, 1:2],
+ p[:, 2:3],
+ ones,
+ -p[:, 0:1] * q[:, 2:3],
+ -p[:, 1:2] * q[:, 2:3],
+ -p[:, 2:3] * q[:, 2:3],
+ ],
+ dim=1,
+ )
+
+ raise NotImplementedError(f"perspective params for axis `{axis}` is not implemented.")
+
+
+def warp_perspective3d(
+ src: torch.Tensor,
+ M: torch.Tensor,
+ dsize: Tuple[int, int, int],
+ flags: str = 'bilinear',
+ border_mode: str = 'zeros',
+ align_corners: bool = False,
+) -> torch.Tensor:
+ r"""Apply a perspective transformation to an image.
+
+ The function warp_perspective transforms the source image using
+ the specified matrix:
+
+ .. math::
+ \text{dst} (x, y) = \text{src} \left(
+ \frac{M_{11} x + M_{12} y + M_{13}}{M_{31} x + M_{32} y + M_{33}} ,
+ \frac{M_{21} x + M_{22} y + M_{23}}{M_{31} x + M_{32} y + M_{33}}
+ \right )
+
+ Args:
+ src: input image with shape :math:`(B, C, D, H, W)`.
+ M: transformation matrix with shape :math:`(B, 4, 4)`.
+ dsize: size of the output image (height, width).
+ flags: interpolation mode to calculate output values
+ ``'bilinear'`` | ``'nearest'``.
+ border_mode: padding mode for outside grid values
+ ``'zeros'`` | ``'border'`` | ``'reflection'``.
+ align_corners: interpolation flag.
+
+ Returns:
+ the warped input image :math:`(B, C, D, H, W)`.
+
+ .. note::
+ This function is often used in conjunction with :func:`get_perspective_transform3d`.
+ """
+ check_is_tensor(src)
+ check_is_tensor(M)
+
+ if not len(src.shape) == 5:
+ raise ValueError(f"Input src must be a BxCxDxHxW tensor. Got {src.shape}")
+
+ if not (len(M.shape) == 3 or M.shape[-2:] == (4, 4)):
+ raise ValueError(f"Input M must be a Bx4x4 tensor. Got {M.shape}")
+
+ # launches the warper
+ d, h, w = src.shape[-3:]
+ return transform_warp_impl3d(src, M, (d, h, w), dsize, flags, border_mode, align_corners)
+
+
+def transform_warp_impl3d(
+ src: torch.Tensor,
+ dst_pix_trans_src_pix: torch.Tensor,
+ dsize_src: Tuple[int, int, int],
+ dsize_dst: Tuple[int, int, int],
+ grid_mode: str,
+ padding_mode: str,
+ align_corners: bool,
+) -> torch.Tensor:
+ """Compute the transform in normalized coordinates and perform the warping."""
+ dst_norm_trans_src_norm: torch.Tensor = normalize_homography3d(dst_pix_trans_src_pix, dsize_src, dsize_dst)
+
+ src_norm_trans_dst_norm = torch.inverse(dst_norm_trans_src_norm)
+ return homography_warp3d(src, src_norm_trans_dst_norm, dsize_dst, grid_mode, padding_mode, align_corners, True)
diff --git a/kornia/geometry/transform/pyramid.py b/kornia/geometry/transform/pyramid.py
new file mode 100644
index 0000000000000000000000000000000000000000..3a345372247f6dd1560958cb751774b6db379f29
--- /dev/null
+++ b/kornia/geometry/transform/pyramid.py
@@ -0,0 +1,351 @@
+import math
+from typing import List, Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from kornia.filters import filter2d, gaussian_blur2d
+
+__all__ = [
+ "PyrDown",
+ "PyrUp",
+ "ScalePyramid",
+ "pyrdown",
+ "pyrup",
+ "build_pyramid"
+]
+
+
+def _get_pyramid_gaussian_kernel() -> torch.Tensor:
+ """Utility function that return a pre-computed gaussian kernel."""
+ return (
+ torch.tensor(
+ [
+ [
+ [1.0, 4.0, 6.0, 4.0, 1.0],
+ [4.0, 16.0, 24.0, 16.0, 4.0],
+ [6.0, 24.0, 36.0, 24.0, 6.0],
+ [4.0, 16.0, 24.0, 16.0, 4.0],
+ [1.0, 4.0, 6.0, 4.0, 1.0],
+ ]
+ ]
+ )
+ / 256.0
+ )
+
+
+class PyrDown(nn.Module):
+ r"""Blur a tensor and downsamples it.
+
+ Args:
+ border_type: the padding mode to be applied before convolving.
+ The expected modes are: ``'constant'``, ``'reflect'``,
+ ``'replicate'`` or ``'circular'``.
+ align_corners: interpolation flag.
+
+ Return:
+ the downsampled tensor.
+
+ Shape:
+ - Input: :math:`(B, C, H, W)`
+ - Output: :math:`(B, C, H / 2, W / 2)`
+
+ Examples:
+ >>> input = torch.rand(1, 2, 4, 4)
+ >>> output = PyrDown()(input) # 1x2x2x2
+ """
+
+ def __init__(self, border_type: str = 'reflect', align_corners: bool = False) -> None:
+ super().__init__()
+ self.border_type: str = border_type
+ self.align_corners: bool = align_corners
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor:
+ return pyrdown(input, self.border_type, self.align_corners)
+
+
+class PyrUp(nn.Module):
+ r"""Upsample a tensor and then blurs it.
+
+ Args:
+ borde_type: the padding mode to be applied before convolving.
+ The expected modes are: ``'constant'``, ``'reflect'``,
+ ``'replicate'`` or ``'circular'``.
+ align_corners: interpolation flag.
+
+ Return:
+ the upsampled tensor.
+
+ Shape:
+ - Input: :math:`(B, C, H, W)`
+ - Output: :math:`(B, C, H * 2, W * 2)`
+
+ Examples:
+ >>> input = torch.rand(1, 2, 4, 4)
+ >>> output = PyrUp()(input) # 1x2x8x8
+ """
+
+ def __init__(self, border_type: str = 'reflect', align_corners: bool = False):
+ super().__init__()
+ self.border_type: str = border_type
+ self.align_corners: bool = align_corners
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor:
+ return pyrup(input, self.border_type, self.align_corners)
+
+
+class ScalePyramid(nn.Module):
+ r"""Create an scale pyramid of image, usually used for local feature detection.
+
+ Images are consequently smoothed with Gaussian blur and downscaled.
+
+ Args:
+ n_levels: number of the levels in octave.
+ init_sigma: initial blur level.
+ min_size: the minimum size of the octave in pixels.
+ double_image: add 2x upscaled image as 1st level of pyramid. OpenCV SIFT does this.
+
+ Returns:
+ 1st output: images
+ 2nd output: sigmas (coefficients for scale conversion)
+ 3rd output: pixelDists (coefficients for coordinate conversion)
+
+ Shape:
+ - Input: :math:`(B, C, H, W)`
+ - Output 1st: :math:`[(B, C, NL, H, W), (B, C, NL, H/2, W/2), ...]`
+ - Output 2nd: :math:`[(B, NL), (B, NL), (B, NL), ...]`
+ - Output 3rd: :math:`[(B, NL), (B, NL), (B, NL), ...]`
+
+ Examples:
+ >>> input = torch.rand(2, 4, 100, 100)
+ >>> sp, sigmas, pds = ScalePyramid(3, 15)(input)
+ """
+
+ def __init__(self, n_levels: int = 3, init_sigma: float = 1.6, min_size: int = 15, double_image: bool = False):
+ super().__init__()
+ # 3 extra levels are needed for DoG nms.
+ self.n_levels = n_levels
+ self.extra_levels: int = 3
+ self.init_sigma = init_sigma
+ self.min_size = min_size
+ self.border = min_size // 2 - 1
+ self.sigma_step = 2 ** (1.0 / float(self.n_levels))
+ self.double_image = double_image
+
+ def __repr__(self) -> str:
+ return (
+ self.__class__.__name__
+ + '(n_levels='
+ + str(self.n_levels)
+ + ', '
+ + 'init_sigma='
+ + str(self.init_sigma)
+ + ', '
+ + 'min_size='
+ + str(self.min_size)
+ + ', '
+ + 'extra_levels='
+ + str(self.extra_levels)
+ + ', '
+ + 'border='
+ + str(self.border)
+ + ', '
+ + 'sigma_step='
+ + str(self.sigma_step)
+ + ', '
+ + 'double_image='
+ + str(self.double_image)
+ + ')'
+ )
+
+ def get_kernel_size(self, sigma: float):
+ ksize = int(2.0 * 4.0 * sigma + 1.0)
+
+ # matches OpenCV, but may cause padding problem for small images
+ # PyTorch does not allow to pad more than original size.
+ # Therefore there is a hack in forward function
+
+ if ksize % 2 == 0:
+ ksize += 1
+ return ksize
+
+ def get_first_level(self, input):
+ pixel_distance = 1.0
+ cur_sigma = 0.5
+ # Same as in OpenCV up to interpolation difference
+ if self.double_image:
+ x = F.interpolate(input, scale_factor=2.0, mode='bilinear', align_corners=False)
+ pixel_distance = 0.5
+ cur_sigma *= 2.0
+ else:
+ x = input
+ if self.init_sigma > cur_sigma:
+ sigma = max(math.sqrt(self.init_sigma ** 2 - cur_sigma ** 2), 0.01)
+ ksize = self.get_kernel_size(sigma)
+ cur_level = gaussian_blur2d(x, (ksize, ksize), (sigma, sigma))
+ cur_sigma = self.init_sigma
+ else:
+ cur_level = x
+ return cur_level, cur_sigma, pixel_distance
+
+ def forward(self, x: torch.Tensor) -> Tuple[List, List, List]: # type: ignore
+ bs, _, _, _ = x.size()
+ cur_level, cur_sigma, pixel_distance = self.get_first_level(x)
+
+ sigmas = [cur_sigma * torch.ones(bs, self.n_levels + self.extra_levels).to(x.device).to(x.dtype)]
+ pixel_dists = [pixel_distance * torch.ones(bs, self.n_levels + self.extra_levels).to(x.device).to(x.dtype)]
+ pyr = [[cur_level]]
+ oct_idx = 0
+ while True:
+ cur_level = pyr[-1][0]
+ for level_idx in range(1, self.n_levels + self.extra_levels):
+ sigma = cur_sigma * math.sqrt(self.sigma_step ** 2 - 1.0)
+ ksize = self.get_kernel_size(sigma)
+
+ # Hack, because PyTorch does not allow to pad more than original size.
+ # But for the huge sigmas, one needs huge kernel and padding...
+
+ ksize = min(ksize, min(cur_level.size(2), cur_level.size(3)))
+ if ksize % 2 == 0:
+ ksize += 1
+
+ cur_level = gaussian_blur2d(cur_level, (ksize, ksize), (sigma, sigma))
+ cur_sigma *= self.sigma_step
+ pyr[-1].append(cur_level)
+ sigmas[-1][:, level_idx] = cur_sigma
+ pixel_dists[-1][:, level_idx] = pixel_distance
+ _pyr = pyr[-1][-self.extra_levels]
+ nextOctaveFirstLevel = F.interpolate(
+ _pyr, size=(_pyr.size(-2) // 2, _pyr.size(-1) // 2), mode='nearest'
+ ) # Nearest matches OpenCV SIFT
+ pixel_distance *= 2.0
+ cur_sigma = self.init_sigma
+ if min(nextOctaveFirstLevel.size(2), nextOctaveFirstLevel.size(3)) <= self.min_size:
+ break
+ pyr.append([nextOctaveFirstLevel])
+ sigmas.append(cur_sigma * torch.ones(bs, self.n_levels + self.extra_levels).to(x.device))
+ pixel_dists.append(pixel_distance * torch.ones(bs, self.n_levels + self.extra_levels).to(x.device))
+ oct_idx += 1
+ for i in range(len(pyr)):
+ pyr[i] = torch.stack(pyr[i], dim=2) # type: ignore
+ return pyr, sigmas, pixel_dists
+
+
+def pyrdown(input: torch.Tensor, border_type: str = 'reflect', align_corners: bool = False) -> torch.Tensor:
+ r"""Blur a tensor and downsamples it.
+
+ .. image:: _static/img/pyrdown.png
+
+ Args:
+ input: the tensor to be downsampled.
+ border_type: the padding mode to be applied before convolving.
+ The expected modes are: ``'constant'``, ``'reflect'``,
+ ``'replicate'`` or ``'circular'``.
+ align_corners: interpolation flag.
+
+ Return:
+ the downsampled tensor.
+
+ Examples:
+ >>> input = torch.arange(16, dtype=torch.float32).reshape(1, 1, 4, 4)
+ >>> pyrdown(input, align_corners=True)
+ tensor([[[[ 3.7500, 5.2500],
+ [ 9.7500, 11.2500]]]])
+ """
+ if not len(input.shape) == 4:
+ raise ValueError(f"Invalid input shape, we expect BxCxHxW. Got: {input.shape}")
+ kernel: torch.Tensor = _get_pyramid_gaussian_kernel()
+ _, _, height, width = input.shape
+ # blur image
+ x_blur: torch.Tensor = filter2d(input, kernel, border_type)
+
+ # TODO: use kornia.geometry.resize/rescale
+ # downsample.
+ out: torch.Tensor = F.interpolate(
+ x_blur, size=(height // 2, width // 2), mode='bilinear', align_corners=align_corners
+ )
+ return out
+
+
+def pyrup(input: torch.Tensor, border_type: str = 'reflect', align_corners: bool = False) -> torch.Tensor:
+ r"""Upsample a tensor and then blurs it.
+
+ .. image:: _static/img/pyrup.png
+
+ Args:
+ input: the tensor to be downsampled.
+ border_type: the padding mode to be applied before convolving.
+ The expected modes are: ``'constant'``, ``'reflect'``, ``'replicate'`` or ``'circular'``.
+ align_corners: interpolation flag.
+
+ Return:
+ the downsampled tensor.
+
+ Examples:
+ >>> input = torch.arange(4, dtype=torch.float32).reshape(1, 1, 2, 2)
+ >>> pyrup(input, align_corners=True)
+ tensor([[[[0.7500, 0.8750, 1.1250, 1.2500],
+ [1.0000, 1.1250, 1.3750, 1.5000],
+ [1.5000, 1.6250, 1.8750, 2.0000],
+ [1.7500, 1.8750, 2.1250, 2.2500]]]])
+ """
+ if not len(input.shape) == 4:
+ raise ValueError(f"Invalid input shape, we expect BxCxHxW. Got: {input.shape}")
+ kernel: torch.Tensor = _get_pyramid_gaussian_kernel()
+ # upsample tensor
+ _, _, height, width = input.shape
+ # TODO: use kornia.geometry.resize/rescale
+ x_up: torch.Tensor = F.interpolate(
+ input, size=(height * 2, width * 2), mode='bilinear', align_corners=align_corners
+ )
+
+ # blurs upsampled tensor
+ x_blur: torch.Tensor = filter2d(x_up, kernel, border_type)
+ return x_blur
+
+
+def build_pyramid(
+ input: torch.Tensor, max_level: int, border_type: str = 'reflect', align_corners: bool = False
+) -> List[torch.Tensor]:
+ r"""Construct the Gaussian pyramid for an image.
+
+ .. image:: _static/img/build_pyramid.png
+
+ The function constructs a vector of images and builds the Gaussian pyramid
+ by recursively applying pyrDown to the previously built pyramid layers.
+
+ Args:
+ input : the tensor to be used to construct the pyramid.
+ max_level: 0-based index of the last (the smallest) pyramid layer.
+ It must be non-negative.
+ border_type: the padding mode to be applied before convolving.
+ The expected modes are: ``'constant'``, ``'reflect'``,
+ ``'replicate'`` or ``'circular'``.
+ align_corners: interpolation flag.
+
+ Shape:
+ - Input: :math:`(B, C, H, W)`
+ - Output :math:`[(B, C, H, W), (B, C, H/2, W/2), ...]`
+ """
+ if not isinstance(input, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(input)}")
+
+ if not len(input.shape) == 4:
+ raise ValueError(f"Invalid input shape, we expect BxCxHxW. Got: {input.shape}")
+
+ if not isinstance(max_level, int) or max_level < 0:
+ raise ValueError(f"Invalid max_level, it must be a positive integer. Got: {max_level}")
+
+ # create empty list and append the original image
+ pyramid: List[torch.Tensor] = []
+ pyramid.append(input)
+
+ # iterate and downsample
+
+ for _ in range(max_level - 1):
+ img_curr: torch.Tensor = pyramid[-1]
+ img_down: torch.Tensor = pyrdown(img_curr, border_type, align_corners)
+ pyramid.append(img_down)
+
+ return pyramid
diff --git a/kornia/geometry/transform/thin_plate_spline.py b/kornia/geometry/transform/thin_plate_spline.py
new file mode 100644
index 0000000000000000000000000000000000000000..b90537bb84201655bb75c286d1f2f09856375c93
--- /dev/null
+++ b/kornia/geometry/transform/thin_plate_spline.py
@@ -0,0 +1,232 @@
+from typing import Tuple
+
+import torch
+import torch.nn as nn
+
+from kornia.utils import create_meshgrid
+from kornia.utils.helpers import _torch_solve_cast
+
+__all__ = ["get_tps_transform", "warp_points_tps", "warp_image_tps"]
+
+# utilities for computing thin plate spline transforms
+
+
+def _pair_square_euclidean(tensor1: torch.Tensor, tensor2: torch.Tensor) -> torch.Tensor:
+ r"""Compute the pairwise squared euclidean distance matrices :math:`(B, N, M)` between two tensors
+ with shapes (B, N, C) and (B, M, C)."""
+ # ||t1-t2||^2 = (t1-t2)^T(t1-t2) = t1^T*t1 + t2^T*t2 - 2*t1^T*t2
+ t1_sq: torch.Tensor = tensor1.mul(tensor1).sum(dim=-1, keepdim=True)
+ t2_sq: torch.Tensor = tensor2.mul(tensor2).sum(dim=-1, keepdim=True).transpose(1, 2)
+ t1_t2: torch.Tensor = tensor1.matmul(tensor2.transpose(1, 2))
+ square_dist: torch.Tensor = -2 * t1_t2 + t1_sq + t2_sq
+ square_dist = square_dist.clamp(min=0) # handle possible numerical errors
+ return square_dist
+
+
+def _kernel_distance(squared_distances: torch.Tensor, eps: float = 1e-8) -> torch.Tensor:
+ r"""Compute the TPS kernel distance function: :math:`r^2 log(r)`, where `r` is the euclidean distance.
+ Since :math:`\log(r) = 1/2 \log(r^2)`, this function takes the squared distance matrix and calculates
+ :math:`0.5 r^2 log(r^2)`."""
+ # r^2 * log(r) = 1/2 * r^2 * log(r^2)
+ return 0.5 * squared_distances * squared_distances.add(eps).log()
+
+
+def get_tps_transform(points_src: torch.Tensor, points_dst: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+ r"""Compute the TPS transform parameters that warp source points to target points.
+
+ The input to this function is a tensor of :math:`(x, y)` source points :math:`(B, N, 2)` and a corresponding
+ tensor of target :math:`(x, y)` points :math:`(B, N, 2)`.
+
+ Args:
+ points_src: batch of source points :math:`(B, N, 2)` as :math:`(x, y)` coordinate vectors.
+ points_dst: batch of target points :math:`(B, N, 2)` as :math:`(x, y)` coordinate vectors.
+
+ Returns:
+ :math:`(B, N, 2)` tensor of kernel weights and :math:`(B, 3, 2)`
+ tensor of affine weights. The last dimension contains the x-transform and y-transform weights
+ as separate columns.
+
+ Example:
+ >>> points_src = torch.rand(1, 5, 2)
+ >>> points_dst = torch.rand(1, 5, 2)
+ >>> kernel_weights, affine_weights = get_tps_transform(points_src, points_dst)
+
+ .. note::
+ This function is often used in conjunction with :func:`warp_points_tps`, :func:`warp_image_tps`.
+ """
+ if not isinstance(points_src, torch.Tensor):
+ raise TypeError(f"Input points_src is not torch.Tensor. Got {type(points_src)}")
+
+ if not isinstance(points_dst, torch.Tensor):
+ raise TypeError(f"Input points_dst is not torch.Tensor. Got {type(points_dst)}")
+
+ if not len(points_src.shape) == 3:
+ raise ValueError(f"Invalid shape for points_src, expected BxNx2. Got {points_src.shape}")
+
+ if not len(points_dst.shape) == 3:
+ raise ValueError(f"Invalid shape for points_dst, expected BxNx2. Got {points_dst.shape}")
+
+ device, dtype = points_src.device, points_src.dtype
+ batch_size, num_points = points_src.shape[:2]
+
+ # set up and solve linear system
+ # [K P] [w] = [dst]
+ # [P^T 0] [a] [ 0 ]
+ pair_distance: torch.Tensor = _pair_square_euclidean(points_src, points_dst)
+ k_matrix: torch.Tensor = _kernel_distance(pair_distance)
+
+ zero_mat: torch.Tensor = torch.zeros(batch_size, 3, 3, device=device, dtype=dtype)
+ one_mat: torch.Tensor = torch.ones(batch_size, num_points, 1, device=device, dtype=dtype)
+ dest_with_zeros: torch.Tensor = torch.cat((points_dst, zero_mat[:, :, :2]), 1)
+ p_matrix: torch.Tensor = torch.cat((one_mat, points_src), -1)
+ p_matrix_t: torch.Tensor = torch.cat((p_matrix, zero_mat), 1).transpose(1, 2)
+ l_matrix: torch.Tensor = torch.cat((k_matrix, p_matrix), -1)
+ l_matrix = torch.cat((l_matrix, p_matrix_t), 1)
+
+ weights, _ = _torch_solve_cast(dest_with_zeros, l_matrix)
+ kernel_weights: torch.Tensor = weights[:, :-3]
+ affine_weights: torch.Tensor = weights[:, -3:]
+
+ return (kernel_weights, affine_weights)
+
+
+def warp_points_tps(
+ points_src: torch.Tensor, kernel_centers: torch.Tensor, kernel_weights: torch.Tensor, affine_weights: torch.Tensor
+) -> torch.Tensor:
+ r"""Warp a tensor of coordinate points using the thin plate spline defined by kernel points, kernel weights,
+ and affine weights.
+
+ The source points should be a :math:`(B, N, 2)` tensor of :math:`(x, y)` coordinates. The kernel centers are
+ a :math:`(B, K, 2)` tensor of :math:`(x, y)` coordinates. The kernel weights are a :math:`(B, K, 2)` tensor,
+ and the affine weights are a :math:`(B, 3, 2)` tensor. For the weight tensors, tensor[..., 0] contains the
+ weights for the x-transform and tensor[..., 1] the weights for the y-transform.
+
+ Args:
+ points_src: tensor of source points :math:`(B, N, 2)`.
+ kernel_centers: tensor of kernel center points :math:`(B, K, 2)`.
+ kernel_weights: tensor of kernl weights :math:`(B, K, 2)`.
+ affine_weights: tensor of affine weights :math:`(B, 3, 2)`.
+
+ Returns:
+ The :math:`(B, N, 2)` tensor of warped source points, from applying the TPS transform.
+
+ Example:
+ >>> points_src = torch.rand(1, 5, 2)
+ >>> points_dst = torch.rand(1, 5, 2)
+ >>> kernel_weights, affine_weights = get_tps_transform(points_src, points_dst)
+ >>> warped = warp_points_tps(points_src, points_dst, kernel_weights, affine_weights)
+ >>> warped_correct = torch.allclose(warped, points_dst)
+
+ .. note::
+ This function is often used in conjunction with :func:`get_tps_transform`.
+ """
+ if not isinstance(points_src, torch.Tensor):
+ raise TypeError(f"Input points_src is not torch.Tensor. Got {type(points_src)}")
+
+ if not isinstance(kernel_centers, torch.Tensor):
+ raise TypeError(f"Input kernel_centers is not torch.Tensor. Got {type(kernel_centers)}")
+
+ if not isinstance(kernel_weights, torch.Tensor):
+ raise TypeError(f"Input kernel_weights is not torch.Tensor. Got {type(kernel_weights)}")
+
+ if not isinstance(affine_weights, torch.Tensor):
+ raise TypeError(f"Input affine_weights is not torch.Tensor. Got {type(affine_weights)}")
+
+ if not len(points_src.shape) == 3:
+ raise ValueError(f"Invalid shape for points_src, expected BxNx2. Got {points_src.shape}")
+
+ if not len(kernel_centers.shape) == 3:
+ raise ValueError(f"Invalid shape for kernel_centers, expected BxNx2. Got {kernel_centers.shape}")
+
+ if not len(kernel_weights.shape) == 3:
+ raise ValueError(f"Invalid shape for kernel_weights, expected BxNx2. Got {kernel_weights.shape}")
+
+ if not len(affine_weights.shape) == 3:
+ raise ValueError(f"Invalid shape for affine_weights, expected BxNx2. Got {affine_weights.shape}")
+
+ # f_{x|y}(v) = a_0 + [a_x a_y].v + \sum_i w_i * U(||v-u_i||)
+ pair_distance: torch.Tensor = _pair_square_euclidean(points_src, kernel_centers)
+ k_matrix: torch.Tensor = _kernel_distance(pair_distance)
+
+ # broadcast the kernel distance matrix against the x and y weights to compute the x and y
+ # transforms simultaneously
+ k_mul_kernel = k_matrix[..., None].mul(kernel_weights[:, None]).sum(-2)
+ points_mul_affine = points_src[..., None].mul(affine_weights[:, None, 1:]).sum(-2)
+ warped: torch.Tensor = k_mul_kernel + points_mul_affine + affine_weights[:, None, 0]
+
+ return warped
+
+
+def warp_image_tps(
+ image: torch.Tensor,
+ kernel_centers: torch.Tensor,
+ kernel_weights: torch.Tensor,
+ affine_weights: torch.Tensor,
+ align_corners: bool = False,
+) -> torch.Tensor:
+ r"""Warp an image tensor according to the thin plate spline transform defined by kernel centers,
+ kernel weights, and affine weights.
+
+ .. image:: _static/img/warp_image_tps.png
+
+ The transform is applied to each pixel coordinate in the output image to obtain a point in the input
+ image for interpolation of the output pixel. So the TPS parameters should correspond to a warp from
+ output space to input space.
+
+ The input `image` is a :math:`(B, C, H, W)` tensor. The kernel centers, kernel weight and affine weights
+ are the same as in `warp_points_tps`.
+
+ Args:
+ image: input image tensor :math:`(B, C, H, W)`.
+ kernel_centers: kernel center points :math:`(B, K, 2)`.
+ kernel_weights: tensor of kernl weights :math:`(B, K, 2)`.
+ affine_weights: tensor of affine weights :math:`(B, 3, 2)`.
+ align_corners: interpolation flag used by `grid_sample`.
+
+ Returns:
+ warped image tensor :math:`(B, C, H, W)`.
+
+ Example:
+ >>> points_src = torch.rand(1, 5, 2)
+ >>> points_dst = torch.rand(1, 5, 2)
+ >>> image = torch.rand(1, 3, 32, 32)
+ >>> # note that we are getting the reverse transform: dst -> src
+ >>> kernel_weights, affine_weights = get_tps_transform(points_dst, points_src)
+ >>> warped_image = warp_image_tps(image, points_src, kernel_weights, affine_weights)
+
+ .. note::
+ This function is often used in conjunction with :func:`get_tps_transform`.
+ """
+ if not isinstance(image, torch.Tensor):
+ raise TypeError(f"Input image is not torch.Tensor. Got {type(image)}")
+
+ if not isinstance(kernel_centers, torch.Tensor):
+ raise TypeError(f"Input kernel_centers is not torch.Tensor. Got {type(kernel_centers)}")
+
+ if not isinstance(kernel_weights, torch.Tensor):
+ raise TypeError(f"Input kernel_weights is not torch.Tensor. Got {type(kernel_weights)}")
+
+ if not isinstance(affine_weights, torch.Tensor):
+ raise TypeError(f"Input affine_weights is not torch.Tensor. Got {type(affine_weights)}")
+
+ if not len(image.shape) == 4:
+ raise ValueError(f"Invalid shape for image, expected BxCxHxW. Got {image.shape}")
+
+ if not len(kernel_centers.shape) == 3:
+ raise ValueError(f"Invalid shape for kernel_centers, expected BxNx2. Got {kernel_centers.shape}")
+
+ if not len(kernel_weights.shape) == 3:
+ raise ValueError(f"Invalid shape for kernel_weights, expected BxNx2. Got {kernel_weights.shape}")
+
+ if not len(affine_weights.shape) == 3:
+ raise ValueError(f"Invalid shape for affine_weights, expected BxNx2. Got {affine_weights.shape}")
+
+ device, dtype = image.device, image.dtype
+ batch_size, _, h, w = image.shape
+ coords: torch.Tensor = create_meshgrid(h, w, device=device).to(dtype=dtype)
+ coords = coords.reshape(-1, 2).expand(batch_size, -1, -1)
+ warped: torch.Tensor = warp_points_tps(coords, kernel_centers, kernel_weights, affine_weights)
+ warped = warped.view(-1, h, w, 2)
+ warped_image: torch.Tensor = nn.functional.grid_sample(image, warped, align_corners=align_corners)
+
+ return warped_image
diff --git a/kornia/losses/__init__.py b/kornia/losses/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..7da3980e2af2355c31ab9d46bfe491d13c9421a1
--- /dev/null
+++ b/kornia/losses/__init__.py
@@ -0,0 +1,32 @@
+from .depth_smooth import inverse_depth_smoothness_loss, InverseDepthSmoothnessLoss
+from .dice import dice_loss, DiceLoss
+from .divergence import js_div_loss_2d, kl_div_loss_2d
+from .focal import binary_focal_loss_with_logits, BinaryFocalLossWithLogits, focal_loss, FocalLoss
+from .hausdorff import HausdorffERLoss, HausdorffERLoss3D
+from .psnr import psnr_loss, PSNRLoss
+from .ssim import ssim_loss, SSIMLoss
+from .total_variation import total_variation, TotalVariation
+from .tversky import tversky_loss, TverskyLoss
+
+__all__ = [
+ "inverse_depth_smoothness_loss",
+ "InverseDepthSmoothnessLoss",
+ "dice_loss",
+ "DiceLoss",
+ "js_div_loss_2d",
+ "kl_div_loss_2d",
+ "binary_focal_loss_with_logits",
+ "BinaryFocalLossWithLogits",
+ "focal_loss",
+ "FocalLoss",
+ "HausdorffERLoss",
+ "HausdorffERLoss3D",
+ "psnr_loss",
+ "PSNRLoss",
+ "ssim_loss",
+ "SSIMLoss",
+ "total_variation",
+ "TotalVariation",
+ "tversky_loss",
+ "TverskyLoss"
+]
diff --git a/kornia/losses/depth_smooth.py b/kornia/losses/depth_smooth.py
new file mode 100644
index 0000000000000000000000000000000000000000..ba97da229fa492a400dce38f6897ab1add45f85f
--- /dev/null
+++ b/kornia/losses/depth_smooth.py
@@ -0,0 +1,101 @@
+import torch
+import torch.nn as nn
+
+# Based on
+# https://github.com/tensorflow/models/blob/master/research/struct2depth/model.py#L625-L641
+
+
+def _gradient_x(img: torch.Tensor) -> torch.Tensor:
+ if len(img.shape) != 4:
+ raise AssertionError(img.shape)
+ return img[:, :, :, :-1] - img[:, :, :, 1:]
+
+
+def _gradient_y(img: torch.Tensor) -> torch.Tensor:
+ if len(img.shape) != 4:
+ raise AssertionError(img.shape)
+ return img[:, :, :-1, :] - img[:, :, 1:, :]
+
+
+def inverse_depth_smoothness_loss(idepth: torch.Tensor, image: torch.Tensor) -> torch.Tensor:
+ r"""Criterion that computes image-aware inverse depth smoothness loss.
+
+ .. math::
+
+ \text{loss} = \left | \partial_x d_{ij} \right | e^{-\left \|
+ \partial_x I_{ij} \right \|} + \left |
+ \partial_y d_{ij} \right | e^{-\left \| \partial_y I_{ij} \right \|}
+
+ Args:
+ idepth: tensor with the inverse depth with shape :math:`(N, 1, H, W)`.
+ image: tensor with the input image with shape :math:`(N, 3, H, W)`.
+
+ Return:
+ a scalar with the computed loss.
+
+ Examples:
+ >>> idepth = torch.rand(1, 1, 4, 5)
+ >>> image = torch.rand(1, 3, 4, 5)
+ >>> loss = inverse_depth_smoothness_loss(idepth, image)
+ """
+ if not isinstance(idepth, torch.Tensor):
+ raise TypeError(f"Input idepth type is not a torch.Tensor. Got {type(idepth)}")
+
+ if not isinstance(image, torch.Tensor):
+ raise TypeError(f"Input image type is not a torch.Tensor. Got {type(image)}")
+
+ if not len(idepth.shape) == 4:
+ raise ValueError(f"Invalid idepth shape, we expect BxCxHxW. Got: {idepth.shape}")
+
+ if not len(image.shape) == 4:
+ raise ValueError(f"Invalid image shape, we expect BxCxHxW. Got: {image.shape}")
+
+ if not idepth.shape[-2:] == image.shape[-2:]:
+ raise ValueError(f"idepth and image shapes must be the same. Got: {idepth.shape} and {image.shape}")
+
+ if not idepth.device == image.device:
+ raise ValueError(f"idepth and image must be in the same device. Got: {idepth.device} and {image.device}")
+
+ if not idepth.dtype == image.dtype:
+ raise ValueError(f"idepth and image must be in the same dtype. Got: {idepth.dtype} and {image.dtype}")
+
+ # compute the gradients
+ idepth_dx: torch.Tensor = _gradient_x(idepth)
+ idepth_dy: torch.Tensor = _gradient_y(idepth)
+ image_dx: torch.Tensor = _gradient_x(image)
+ image_dy: torch.Tensor = _gradient_y(image)
+
+ # compute image weights
+ weights_x: torch.Tensor = torch.exp(-torch.mean(torch.abs(image_dx), dim=1, keepdim=True))
+ weights_y: torch.Tensor = torch.exp(-torch.mean(torch.abs(image_dy), dim=1, keepdim=True))
+
+ # apply image weights to depth
+ smoothness_x: torch.Tensor = torch.abs(idepth_dx * weights_x)
+ smoothness_y: torch.Tensor = torch.abs(idepth_dy * weights_y)
+
+ return torch.mean(smoothness_x) + torch.mean(smoothness_y)
+
+
+class InverseDepthSmoothnessLoss(nn.Module):
+ r"""Criterion that computes image-aware inverse depth smoothness loss.
+
+ .. math::
+
+ \text{loss} = \left | \partial_x d_{ij} \right | e^{-\left \|
+ \partial_x I_{ij} \right \|} + \left |
+ \partial_y d_{ij} \right | e^{-\left \| \partial_y I_{ij} \right \|}
+
+ Shape:
+ - Inverse Depth: :math:`(N, 1, H, W)`
+ - Image: :math:`(N, 3, H, W)`
+ - Output: scalar
+
+ Examples:
+ >>> idepth = torch.rand(1, 1, 4, 5)
+ >>> image = torch.rand(1, 3, 4, 5)
+ >>> smooth = InverseDepthSmoothnessLoss()
+ >>> loss = smooth(idepth, image)
+ """
+
+ def forward(self, idepth: torch.Tensor, image: torch.Tensor) -> torch.Tensor:
+ return inverse_depth_smoothness_loss(idepth, image)
diff --git a/kornia/losses/dice.py b/kornia/losses/dice.py
new file mode 100644
index 0000000000000000000000000000000000000000..f5a3ac0f6d24b7f2f59027b509fdc86231cd4bc1
--- /dev/null
+++ b/kornia/losses/dice.py
@@ -0,0 +1,121 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from kornia.utils.one_hot import one_hot
+
+# based on:
+# https://github.com/kevinzakka/pytorch-goodies/blob/master/losses.py
+
+
+def dice_loss(input: torch.Tensor, target: torch.Tensor, eps: float = 1e-8) -> torch.Tensor:
+ r"""Criterion that computes Sรธrensen-Dice Coefficient loss.
+
+ According to [1], we compute the Sรธrensen-Dice Coefficient as follows:
+
+ .. math::
+
+ \text{Dice}(x, class) = \frac{2 |X| \cap |Y|}{|X| + |Y|}
+
+ Where:
+ - :math:`X` expects to be the scores of each class.
+ - :math:`Y` expects to be the one-hot tensor with the class labels.
+
+ the loss, is finally computed as:
+
+ .. math::
+
+ \text{loss}(x, class) = 1 - \text{Dice}(x, class)
+
+ Reference:
+ [1] https://en.wikipedia.org/wiki/S%C3%B8rensen%E2%80%93Dice_coefficient
+
+ Args:
+ input: logits tensor with shape :math:`(N, C, H, W)` where C = number of classes.
+ labels: labels tensor with shape :math:`(N, H, W)` where each value
+ is :math:`0 โค targets[i] โค Cโ1`.
+ eps: Scalar to enforce numerical stabiliy.
+
+ Return:
+ the computed loss.
+
+ Example:
+ >>> N = 5 # num_classes
+ >>> input = torch.randn(1, N, 3, 5, requires_grad=True)
+ >>> target = torch.empty(1, 3, 5, dtype=torch.long).random_(N)
+ >>> output = dice_loss(input, target)
+ >>> output.backward()
+ """
+ if not isinstance(input, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(input)}")
+
+ if not len(input.shape) == 4:
+ raise ValueError(f"Invalid input shape, we expect BxNxHxW. Got: {input.shape}")
+
+ if not input.shape[-2:] == target.shape[-2:]:
+ raise ValueError(f"input and target shapes must be the same. Got: {input.shape} and {target.shape}")
+
+ if not input.device == target.device:
+ raise ValueError(f"input and target must be in the same device. Got: {input.device} and {target.device}")
+
+ # compute softmax over the classes axis
+ input_soft: torch.Tensor = F.softmax(input, dim=1)
+
+ # create the labels one hot tensor
+ target_one_hot: torch.Tensor = one_hot(target, num_classes=input.shape[1], device=input.device, dtype=input.dtype)
+
+ # compute the actual dice score
+ dims = (1, 2, 3)
+ intersection = torch.sum(input_soft * target_one_hot, dims)
+ cardinality = torch.sum(input_soft + target_one_hot, dims)
+
+ dice_score = 2.0 * intersection / (cardinality + eps)
+
+ return torch.mean(-dice_score + 1.0)
+
+
+class DiceLoss(nn.Module):
+ r"""Criterion that computes Sรธrensen-Dice Coefficient loss.
+
+ According to [1], we compute the Sรธrensen-Dice Coefficient as follows:
+
+ .. math::
+
+ \text{Dice}(x, class) = \frac{2 |X| \cap |Y|}{|X| + |Y|}
+
+ Where:
+ - :math:`X` expects to be the scores of each class.
+ - :math:`Y` expects to be the one-hot tensor with the class labels.
+
+ the loss, is finally computed as:
+
+ .. math::
+
+ \text{loss}(x, class) = 1 - \text{Dice}(x, class)
+
+ Reference:
+ [1] https://en.wikipedia.org/wiki/S%C3%B8rensen%E2%80%93Dice_coefficient
+
+ Args:
+ eps: Scalar to enforce numerical stabiliy.
+
+ Shape:
+ - Input: :math:`(N, C, H, W)` where C = number of classes.
+ - Target: :math:`(N, H, W)` where each value is
+ :math:`0 โค targets[i] โค Cโ1`.
+
+ Example:
+ >>> N = 5 # num_classes
+ >>> criterion = DiceLoss()
+ >>> input = torch.randn(1, N, 3, 5, requires_grad=True)
+ >>> target = torch.empty(1, 3, 5, dtype=torch.long).random_(N)
+ >>> output = criterion(input, target)
+ >>> output.backward()
+ """
+
+ def __init__(self, eps: float = 1e-8) -> None:
+ super().__init__()
+ self.eps: float = eps
+
+ def forward(self, input: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
+ return dice_loss(input, target, self.eps)
diff --git a/kornia/losses/divergence.py b/kornia/losses/divergence.py
new file mode 100644
index 0000000000000000000000000000000000000000..8237127ed839d67c0d919871100d81bd26c90529
--- /dev/null
+++ b/kornia/losses/divergence.py
@@ -0,0 +1,71 @@
+r"""Losses based on the divergence between probability distributions."""
+
+import torch
+import torch.nn.functional as F
+
+
+def _kl_div_2d(p: torch.Tensor, q: torch.Tensor) -> torch.Tensor:
+ # D_KL(P || Q)
+ batch, chans, height, width = p.shape
+ unsummed_kl = F.kl_div(
+ q.reshape(batch * chans, height * width).log(), p.reshape(batch * chans, height * width), reduction='none'
+ )
+ kl_values = unsummed_kl.sum(-1).view(batch, chans)
+ return kl_values
+
+
+def _js_div_2d(p: torch.Tensor, q: torch.Tensor) -> torch.Tensor:
+ # JSD(P || Q)
+ m = 0.5 * (p + q)
+ return 0.5 * _kl_div_2d(p, m) + 0.5 * _kl_div_2d(q, m)
+
+
+# TODO: add this to the main module
+
+
+def _reduce_loss(losses: torch.Tensor, reduction: str) -> torch.Tensor:
+ if reduction == 'none':
+ return losses
+ return torch.mean(losses) if reduction == 'mean' else torch.sum(losses)
+
+
+def js_div_loss_2d(input: torch.Tensor, target: torch.Tensor, reduction: str = 'mean'):
+ r"""Calculate the Jensen-Shannon divergence loss between heatmaps.
+
+ Args:
+ input: the input tensor with shape :math:`(B, N, H, W)`.
+ target: the target tensor with shape :math:`(B, N, H, W)`.
+ reduction: Specifies the reduction to apply to the
+ output: ``'none'`` | ``'mean'`` | ``'sum'``. ``'none'``: no reduction
+ will be applied, ``'mean'``: the sum of the output will be divided by
+ the number of elements in the output, ``'sum'``: the output will be
+ summed.
+
+ Examples:
+ >>> input = torch.full((1, 1, 2, 4), 0.125)
+ >>> loss = js_div_loss_2d(input, input)
+ >>> loss.item()
+ 0.0
+ """
+ return _reduce_loss(_js_div_2d(target, input), reduction)
+
+
+def kl_div_loss_2d(input: torch.Tensor, target: torch.Tensor, reduction: str = 'mean'):
+ r"""Calculate the Kullback-Leibler divergence loss between heatmaps.
+
+ Args:
+ input: the input tensor with shape :math:`(B, N, H, W)`.
+ target: the target tensor with shape :math:`(B, N, H, W)`.
+ reduction: Specifies the reduction to apply to the
+ output: ``'none'`` | ``'mean'`` | ``'sum'``. ``'none'``: no reduction
+ will be applied, ``'mean'``: the sum of the output will be divided by
+ the number of elements in the output, ``'sum'``: the output will be
+ summed.
+
+ Examples:
+ >>> input = torch.full((1, 1, 2, 4), 0.125)
+ >>> loss = js_div_loss_2d(input, input)
+ >>> loss.item()
+ 0.0
+ """
+ return _reduce_loss(_kl_div_2d(target, input), reduction)
diff --git a/kornia/losses/focal.py b/kornia/losses/focal.py
new file mode 100644
index 0000000000000000000000000000000000000000..a4dd344d6327622632e1f5e70e84fd4c7c1e948d
--- /dev/null
+++ b/kornia/losses/focal.py
@@ -0,0 +1,268 @@
+import warnings
+from typing import Optional
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from kornia.utils.one_hot import one_hot
+
+# based on:
+# https://github.com/zhezh/focalloss/blob/master/focalloss.py
+
+
+def focal_loss(
+ input: torch.Tensor,
+ target: torch.Tensor,
+ alpha: float,
+ gamma: float = 2.0,
+ reduction: str = 'none',
+ eps: Optional[float] = None,
+) -> torch.Tensor:
+ r"""Criterion that computes Focal loss.
+
+ According to :cite:`lin2018focal`, the Focal loss is computed as follows:
+
+ .. math::
+
+ \text{FL}(p_t) = -\alpha_t (1 - p_t)^{\gamma} \, \text{log}(p_t)
+
+ Where:
+ - :math:`p_t` is the model's estimated probability for each class.
+
+ Args:
+ input: logits tensor with shape :math:`(N, C, *)` where C = number of classes.
+ target: labels tensor with shape :math:`(N, *)` where each value is :math:`0 โค targets[i] โค Cโ1`.
+ alpha: Weighting factor :math:`\alpha \in [0, 1]`.
+ gamma: Focusing parameter :math:`\gamma >= 0`.
+ reduction: Specifies the reduction to apply to the
+ output: ``'none'`` | ``'mean'`` | ``'sum'``. ``'none'``: no reduction
+ will be applied, ``'mean'``: the sum of the output will be divided by
+ the number of elements in the output, ``'sum'``: the output will be
+ summed.
+ eps: Deprecated: scalar to enforce numerical stabiliy. This is no longer used.
+
+ Return:
+ the computed loss.
+
+ Example:
+ >>> N = 5 # num_classes
+ >>> input = torch.randn(1, N, 3, 5, requires_grad=True)
+ >>> target = torch.empty(1, 3, 5, dtype=torch.long).random_(N)
+ >>> output = focal_loss(input, target, alpha=0.5, gamma=2.0, reduction='mean')
+ >>> output.backward()
+ """
+ if eps is not None and not torch.jit.is_scripting():
+ warnings.warn(
+ "`focal_loss` has been reworked for improved numerical stability "
+ "and the `eps` argument is no longer necessary",
+ DeprecationWarning,
+ stacklevel=2,
+ )
+
+ if not isinstance(input, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(input)}")
+
+ if not len(input.shape) >= 2:
+ raise ValueError(f"Invalid input shape, we expect BxCx*. Got: {input.shape}")
+
+ if input.size(0) != target.size(0):
+ raise ValueError(f'Expected input batch_size ({input.size(0)}) to match target batch_size ({target.size(0)}).')
+
+ n = input.size(0)
+ out_size = (n,) + input.size()[2:]
+ if target.size()[1:] != input.size()[2:]:
+ raise ValueError(f'Expected target size {out_size}, got {target.size()}')
+
+ if not input.device == target.device:
+ raise ValueError(f"input and target must be in the same device. Got: {input.device} and {target.device}")
+
+ # compute softmax over the classes axis
+ input_soft: torch.Tensor = F.softmax(input, dim=1)
+ log_input_soft: torch.Tensor = F.log_softmax(input, dim=1)
+
+ # create the labels one hot tensor
+ target_one_hot: torch.Tensor = one_hot(target, num_classes=input.shape[1], device=input.device, dtype=input.dtype)
+
+ # compute the actual focal loss
+ weight = torch.pow(-input_soft + 1.0, gamma)
+
+ focal = -alpha * weight * log_input_soft
+ loss_tmp = torch.einsum('bc...,bc...->b...', (target_one_hot, focal))
+
+ if reduction == 'none':
+ loss = loss_tmp
+ elif reduction == 'mean':
+ loss = torch.mean(loss_tmp)
+ elif reduction == 'sum':
+ loss = torch.sum(loss_tmp)
+ else:
+ raise NotImplementedError(f"Invalid reduction mode: {reduction}")
+ return loss
+
+
+class FocalLoss(nn.Module):
+ r"""Criterion that computes Focal loss.
+
+ According to :cite:`lin2018focal`, the Focal loss is computed as follows:
+
+ .. math::
+
+ \text{FL}(p_t) = -\alpha_t (1 - p_t)^{\gamma} \, \text{log}(p_t)
+
+ Where:
+ - :math:`p_t` is the model's estimated probability for each class.
+
+ Args:
+ alpha: Weighting factor :math:`\alpha \in [0, 1]`.
+ gamma: Focusing parameter :math:`\gamma >= 0`.
+ reduction: Specifies the reduction to apply to the
+ output: ``'none'`` | ``'mean'`` | ``'sum'``. ``'none'``: no reduction
+ will be applied, ``'mean'``: the sum of the output will be divided by
+ the number of elements in the output, ``'sum'``: the output will be
+ summed.
+ eps: Deprecated: scalar to enforce numerical stability. This is no longer
+ used.
+
+ Shape:
+ - Input: :math:`(N, C, *)` where C = number of classes.
+ - Target: :math:`(N, *)` where each value is
+ :math:`0 โค targets[i] โค Cโ1`.
+
+ Example:
+ >>> N = 5 # num_classes
+ >>> kwargs = {"alpha": 0.5, "gamma": 2.0, "reduction": 'mean'}
+ >>> criterion = FocalLoss(**kwargs)
+ >>> input = torch.randn(1, N, 3, 5, requires_grad=True)
+ >>> target = torch.empty(1, 3, 5, dtype=torch.long).random_(N)
+ >>> output = criterion(input, target)
+ >>> output.backward()
+ """
+
+ def __init__(self, alpha: float, gamma: float = 2.0, reduction: str = 'none', eps: Optional[float] = None) -> None:
+ super().__init__()
+ self.alpha: float = alpha
+ self.gamma: float = gamma
+ self.reduction: str = reduction
+ self.eps: Optional[float] = eps
+
+ def forward(self, input: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
+ return focal_loss(input, target, self.alpha, self.gamma, self.reduction, self.eps)
+
+
+def binary_focal_loss_with_logits(
+ input: torch.Tensor,
+ target: torch.Tensor,
+ alpha: float = 0.25,
+ gamma: float = 2.0,
+ reduction: str = 'none',
+ eps: Optional[float] = None,
+) -> torch.Tensor:
+ r"""Function that computes Binary Focal loss.
+
+ .. math::
+
+ \text{FL}(p_t) = -\alpha_t (1 - p_t)^{\gamma} \, \text{log}(p_t)
+
+ where:
+ - :math:`p_t` is the model's estimated probability for each class.
+
+ Args:
+ input: input data tensor of arbitrary shape.
+ target: the target tensor with shape matching input.
+ alpha: Weighting factor for the rare class :math:`\alpha \in [0, 1]`.
+ gamma: Focusing parameter :math:`\gamma >= 0`.
+ reduction: Specifies the reduction to apply to the
+ output: ``'none'`` | ``'mean'`` | ``'sum'``. ``'none'``: no reduction
+ will be applied, ``'mean'``: the sum of the output will be divided by
+ the number of elements in the output, ``'sum'``: the output will be
+ summed.
+ eps: Deprecated: scalar for numerically stability when dividing. This is no longer used.
+
+ Returns:
+ the computed loss.
+
+ Examples:
+ >>> kwargs = {"alpha": 0.25, "gamma": 2.0, "reduction": 'mean'}
+ >>> logits = torch.tensor([[[6.325]],[[5.26]],[[87.49]]])
+ >>> labels = torch.tensor([[[1.]],[[1.]],[[0.]]])
+ >>> binary_focal_loss_with_logits(logits, labels, **kwargs)
+ tensor(21.8725)
+ """
+
+ if eps is not None and not torch.jit.is_scripting():
+ warnings.warn(
+ "`binary_focal_loss_with_logits` has been reworked for improved numerical stability "
+ "and the `eps` argument is no longer necessary",
+ DeprecationWarning,
+ stacklevel=2,
+ )
+
+ if not isinstance(input, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(input)}")
+
+ if not len(input.shape) >= 2:
+ raise ValueError(f"Invalid input shape, we expect BxCx*. Got: {input.shape}")
+
+ if input.size(0) != target.size(0):
+ raise ValueError(f'Expected input batch_size ({input.size(0)}) to match target batch_size ({target.size(0)}).')
+
+ probs_pos = torch.sigmoid(input)
+ probs_neg = torch.sigmoid(-input)
+ loss_tmp = -alpha * torch.pow(probs_neg, gamma) * target * F.logsigmoid(input) - (
+ 1 - alpha
+ ) * torch.pow(probs_pos, gamma) * (1.0 - target) * F.logsigmoid(-input)
+
+ if reduction == 'none':
+ loss = loss_tmp
+ elif reduction == 'mean':
+ loss = torch.mean(loss_tmp)
+ elif reduction == 'sum':
+ loss = torch.sum(loss_tmp)
+ else:
+ raise NotImplementedError(f"Invalid reduction mode: {reduction}")
+ return loss
+
+
+class BinaryFocalLossWithLogits(nn.Module):
+ r"""Criterion that computes Focal loss.
+
+ According to :cite:`lin2018focal`, the Focal loss is computed as follows:
+
+ .. math::
+
+ \text{FL}(p_t) = -\alpha_t (1 - p_t)^{\gamma} \, \text{log}(p_t)
+
+ where:
+ - :math:`p_t` is the model's estimated probability for each class.
+
+ Args:
+ alpha): Weighting factor for the rare class :math:`\alpha \in [0, 1]`.
+ gamma: Focusing parameter :math:`\gamma >= 0`.
+ reduction: Specifies the reduction to apply to the
+ output: ``'none'`` | ``'mean'`` | ``'sum'``. ``'none'``: no reduction
+ will be applied, ``'mean'``: the sum of the output will be divided by
+ the number of elements in the output, ``'sum'``: the output will be
+ summed.
+
+ Shape:
+ - Input: :math:`(N, *)`.
+ - Target: :math:`(N, *)`.
+
+ Examples:
+ >>> kwargs = {"alpha": 0.25, "gamma": 2.0, "reduction": 'mean'}
+ >>> loss = BinaryFocalLossWithLogits(**kwargs)
+ >>> input = torch.randn(1, 3, 5, requires_grad=True)
+ >>> target = torch.empty(1, 3, 5, dtype=torch.long).random_(2)
+ >>> output = loss(input, target)
+ >>> output.backward()
+ """
+
+ def __init__(self, alpha: float, gamma: float = 2.0, reduction: str = 'none') -> None:
+ super().__init__()
+ self.alpha: float = alpha
+ self.gamma: float = gamma
+ self.reduction: str = reduction
+
+ def forward(self, input: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
+ return binary_focal_loss_with_logits(input, target, self.alpha, self.gamma, self.reduction)
diff --git a/kornia/losses/hausdorff.py b/kornia/losses/hausdorff.py
new file mode 100644
index 0000000000000000000000000000000000000000..b0c844fd3abe49c2e8140f0719b00302c041e1a0
--- /dev/null
+++ b/kornia/losses/hausdorff.py
@@ -0,0 +1,255 @@
+from typing import Callable
+
+import torch
+import torch.nn as nn
+
+
+class _HausdorffERLossBase(torch.jit.ScriptModule):
+ """Base class for binary Hausdorff loss based on morphological erosion.
+
+ This is an Hausdorff Distance (HD) Loss that based on morphological erosion,which provided
+ a differentiable approximation of Hausdorff distance as stated in :cite:`karimi2019reducing`.
+ The code is refactored on top of `here `__.
+
+ Args:
+ alpha: controls the erosion rate in each iteration.
+ k: the number of iterations of erosion.
+ reduction: Specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'.
+ 'none': no reduction will be applied, 'mean': the weighted mean of the output is taken,
+ 'sum': the output will be summed.
+
+ Returns:
+ Estimated Hausdorff Loss.
+ """
+
+ conv: Callable
+ max_pool: Callable
+
+ def __init__(self, alpha: float = 2.0, k: int = 10, reduction: str = 'mean') -> None:
+ super().__init__()
+ self.alpha = alpha
+ self.k = k
+ self.reduction = reduction
+ self.register_buffer("kernel", self.get_kernel())
+
+ def get_kernel(self) -> torch.Tensor:
+ """Get kernel for image morphology convolution."""
+ raise NotImplementedError
+
+ def perform_erosion(
+ self, pred: torch.Tensor, target: torch.Tensor
+ ) -> torch.Tensor:
+ bound = (pred - target) ** 2
+
+ kernel = torch.as_tensor(self.kernel, device=pred.device, dtype=pred.dtype)
+ eroded = torch.zeros_like(bound, device=pred.device, dtype=pred.dtype)
+ mask = torch.ones_like(bound, device=pred.device, dtype=torch.bool)
+
+ # Same padding, assuming kernel is odd and square (cube) shaped.
+ # NOTE: int() has to be added for enabling JIT.
+ padding = int((kernel.size(-1) - 1) // 2)
+ for k in range(self.k):
+ # compute convolution with kernel
+ dilation = self.conv(bound, weight=kernel, padding=padding, groups=1)
+ # apply soft thresholding at 0.5 and normalize
+ erosion = dilation - 0.5
+ erosion[erosion < 0] = 0
+
+ # image-wise differences for 2D images
+ erosion_max = self.max_pool(erosion)
+ erosion_min = - self.max_pool(- erosion)
+ # No normalization needed if `max - min = 0`
+ _to_norm = (erosion_max - erosion_min) != 0
+ to_norm = _to_norm.squeeze()
+ if to_norm.any():
+ # NOTE: avoid in-place ops like below, which will not pass gradcheck:
+ # erosion[to_norm] = (erosion[to_norm] - erosion_min[to_norm]) / (
+ # erosion_max[to_norm] - erosion_min[to_norm])
+ _erosion_to_fill = (erosion - erosion_min) / (erosion_max - erosion_min)
+ erosion = torch.where(mask * _to_norm, _erosion_to_fill, erosion)
+
+ # save erosion and add to loss
+ eroded = eroded + erosion * (k + 1) ** self.alpha
+ bound = erosion
+
+ return eroded
+
+ # NOTE: we add type ignore because the forward pass does not work well with subclassing
+ def forward(self, pred: torch.Tensor, target: torch.Tensor) -> torch.Tensor: # type: ignore
+ """Compute Hausdorff loss.
+
+ Args:
+ pred: predicted tensor with a shape of :math:`(B, C, H, W)` or :math:`(B, C, D, H, W)`.
+ Each channel is as binary as: 1 -> fg, 0 -> bg.
+ target: target tensor with a shape of :math:`(B, 1, H, W)` or :math:`(B, C, D, H, W)`.
+
+ Returns:
+ Estimated Hausdorff Loss.
+ """
+ if not (pred.shape[2:] == target.shape[2:] and pred.size(0) == target.size(0) and target.size(1) == 1):
+ raise ValueError(
+ "Prediction and target need to be of same size, and target should not be one-hot."
+ f"Got {pred.shape} and {target.shape}."
+ )
+
+ if pred.size(1) < target.max().item():
+ raise ValueError("Invalid target value.")
+
+ out = torch.stack([
+ self.perform_erosion(
+ pred[:, i:i + 1],
+ torch.where(
+ target == i,
+ torch.tensor(1, device=target.device, dtype=target.dtype),
+ torch.tensor(0, device=target.device, dtype=target.dtype)
+ )
+ )
+ for i in range(pred.size(1))
+ ])
+
+ if self.reduction == 'mean':
+ out = out.mean()
+ elif self.reduction == 'sum':
+ out = out.sum()
+ elif self.reduction == 'none':
+ pass
+ else:
+ raise NotImplementedError(f"reduction `{self.reduction}` has not been implemented yet.")
+
+ return out
+
+
+class HausdorffERLoss(_HausdorffERLossBase):
+ r"""Binary Hausdorff loss based on morphological erosion.
+
+ Hausdorff Distance loss measures the maximum distance of a predicted segmentation boundary to
+ the nearest ground-truth edge pixel. For two segmentation point sets X and Y ,
+ the one-sided HD from X to Y is defined as:
+
+ .. math::
+
+ hd(X,Y) = \max_{x \in X} \min_{y \in Y}||x - y||_2
+
+ Furthermore, the bidirectional HD is:
+
+ .. math::
+
+ HD(X,Y) = max(hd(X, Y), hd(Y, X))
+
+ This is an Hausdorff Distance (HD) Loss that based on morphological erosion, which provided
+ a differentiable approximation of Hausdorff distance as stated in :cite:`karimi2019reducing`.
+ The code is refactored on top of `here `__.
+
+ Args:
+ alpha: controls the erosion rate in each iteration.
+ k: the number of iterations of erosion.
+ reduction: Specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'.
+ 'none': no reduction will be applied, 'mean': the weighted mean of the output is taken,
+ 'sum': the output will be summed.
+
+ Examples:
+ >>> hdloss = HausdorffERLoss()
+ >>> input = torch.randn(5, 3, 20, 20)
+ >>> target = (torch.rand(5, 1, 20, 20) * 2).long()
+ >>> res = hdloss(input, target)
+ """
+
+ conv = torch.conv2d
+ max_pool = nn.AdaptiveMaxPool2d(1)
+
+ def get_kernel(self) -> torch.Tensor:
+ """Get kernel for image morphology convolution."""
+ cross = torch.tensor([[[0, 1, 0], [1, 1, 1], [0, 1, 0]]])
+ kernel = cross * 0.2
+ return kernel[None]
+
+ # NOTE: we add type ignore because the forward pass does not work well with subclassing
+ def forward(self, pred: torch.Tensor, target: torch.Tensor) -> torch.Tensor: # type: ignore
+ """Compute Hausdorff loss.
+
+ Args:
+ pred: predicted tensor with a shape of :math:`(B, C, H, W)`.
+ Each channel is as binary as: 1 -> fg, 0 -> bg.
+ target: target tensor with a shape of :math:`(B, 1, H, W)`.
+
+ Returns:
+ Estimated Hausdorff Loss.
+ """
+ if pred.dim() != 4:
+ raise ValueError(f"Only 2D images supported. Got {pred.dim()}.")
+
+ if not (target.max() < pred.size(1) and target.min() >= 0 and target.dtype == torch.long):
+ raise ValueError(
+ f"Expect long type target value in range (0, {pred.size(1)})."
+ f"({target.min()}, {target.max()})"
+ )
+ return super().forward(pred, target)
+
+
+class HausdorffERLoss3D(_HausdorffERLossBase):
+ r"""Binary 3D Hausdorff loss based on morphological erosion.
+
+ Hausdorff Distance loss measures the maximum distance of a predicted segmentation boundary to
+ the nearest ground-truth edge pixel. For two segmentation point sets X and Y ,
+ the one-sided HD from X to Y is defined as:
+
+ .. math::
+
+ hd(X,Y) = \max_{x \in X} \min_{y \in Y}||x - y||_2
+
+ Furthermore, the bidirectional HD is:
+
+ .. math::
+
+ HD(X,Y) = max(hd(X, Y), hd(Y, X))
+
+ This is a 3D Hausdorff Distance (HD) Loss that based on morphological erosion, which provided
+ a differentiable approximation of Hausdorff distance as stated in :cite:`karimi2019reducing`.
+ The code is refactored on top of `here `__.
+
+ Args:
+ alpha: controls the erosion rate in each iteration.
+ k: the number of iterations of erosion.
+ reduction: Specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'.
+ 'none': no reduction will be applied, 'mean': the weighted mean of the output is taken,
+ 'sum': the output will be summed.
+
+ Examples:
+ >>> hdloss = HausdorffERLoss3D()
+ >>> input = torch.randn(5, 3, 20, 20, 20)
+ >>> target = (torch.rand(5, 1, 20, 20, 20) * 2).long()
+ >>> res = hdloss(input, target)
+ """
+
+ conv = torch.conv3d
+ max_pool = nn.AdaptiveMaxPool3d(1)
+
+ def get_kernel(self) -> torch.Tensor:
+ """Get kernel for image morphology convolution."""
+ cross = torch.tensor([[[0, 1, 0], [1, 1, 1], [0, 1, 0]]])
+ bound = torch.tensor([[[0, 0, 0], [0, 1, 0], [0, 0, 0]]])
+ # NOTE: The original repo claimed it shaped as (3, 1, 3, 3)
+ # which Jian suspect it is wrongly implemented.
+ # https://github.com/PatRyg99/HausdorffLoss/blob/9f580acd421af648e74b45d46555ccb7a876c27c/hausdorff_loss.py#L94
+ kernel = torch.stack([bound, cross, bound], dim=1) * (1 / 7)
+ return kernel[None]
+
+ # NOTE: we add type ignore because the forward pass does not work well with subclassing
+ def forward(self, pred: torch.Tensor, target: torch.Tensor) -> torch.Tensor: # type: ignore
+ """Compute 3D Hausdorff loss.
+
+ Args:
+ pred: predicted tensor with a shape of :math:`(B, C, D, H, W)`.
+ Each channel is as binary as: 1 -> fg, 0 -> bg.
+ target: target tensor with a shape of :math:`(B, 1, D, H, W)`.
+
+ Returns:
+ Estimated Hausdorff Loss.
+ """
+ if pred.dim() != 5:
+ raise ValueError(f"Only 3D images supported. Got {pred.dim()}.")
+
+ return super().forward(pred, target)
diff --git a/kornia/losses/psnr.py b/kornia/losses/psnr.py
new file mode 100644
index 0000000000000000000000000000000000000000..895b44b05f78e64d05f294bbd6e1921dc5617403
--- /dev/null
+++ b/kornia/losses/psnr.py
@@ -0,0 +1,66 @@
+import torch
+import torch.nn as nn
+
+import kornia.metrics as metrics
+
+
+def psnr_loss(input: torch.Tensor, target: torch.Tensor, max_val: float) -> torch.Tensor:
+ r"""Function that computes the PSNR loss.
+
+ The loss is computed as follows:
+
+ .. math::
+
+ \text{loss} = -\text{psnr(x, y)}
+
+ See :meth:`~kornia.losses.psnr` for details abut PSNR.
+
+ Args:
+ input: the input image with shape :math:`(*)`.
+ labels : the labels image with shape :math:`(*)`.
+ max_val: The maximum value in the input tensor.
+
+ Return:
+ the computed loss as a scalar.
+
+ Examples:
+ >>> ones = torch.ones(1)
+ >>> psnr_loss(ones, 1.2 * ones, 2.) # 10 * log(4/((1.2-1)**2)) / log(10)
+ tensor(-20.0000)
+ """
+
+ return -1.0 * metrics.psnr(input, target, max_val)
+
+
+class PSNRLoss(nn.Module):
+ r"""Create a criterion that calculates the PSNR loss.
+
+ The loss is computed as follows:
+
+ .. math::
+
+ \text{loss} = -\text{psnr(x, y)}
+
+ See :meth:`~kornia.losses.psnr` for details abut PSNR.
+
+ Args:
+ max_val: The maximum value in the input tensor.
+
+ Shape:
+ - Input: arbitrary dimensional tensor :math:`(*)`.
+ - Target: arbitrary dimensional tensor :math:`(*)` same shape as input.
+ - Output: a scalar.
+
+ Examples:
+ >>> ones = torch.ones(1)
+ >>> criterion = PSNRLoss(2.)
+ >>> criterion(ones, 1.2 * ones) # 10 * log(4/((1.2-1)**2)) / log(10)
+ tensor(-20.0000)
+ """
+
+ def __init__(self, max_val: float) -> None:
+ super().__init__()
+ self.max_val: float = max_val
+
+ def forward(self, input: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
+ return psnr_loss(input, target, self.max_val)
diff --git a/kornia/losses/ssim.py b/kornia/losses/ssim.py
new file mode 100644
index 0000000000000000000000000000000000000000..33026ba34dc4194ade48d5238911cac6bc524bc4
--- /dev/null
+++ b/kornia/losses/ssim.py
@@ -0,0 +1,97 @@
+import torch
+import torch.nn as nn
+
+import kornia.metrics as metrics
+
+
+def ssim_loss(
+ img1: torch.Tensor,
+ img2: torch.Tensor,
+ window_size: int,
+ max_val: float = 1.0,
+ eps: float = 1e-12,
+ reduction: str = 'mean',
+) -> torch.Tensor:
+ r"""Function that computes a loss based on the SSIM measurement.
+
+ The loss, or the Structural dissimilarity (DSSIM) is described as:
+
+ .. math::
+
+ \text{loss}(x, y) = \frac{1 - \text{SSIM}(x, y)}{2}
+
+ See :meth:`~kornia.losses.ssim` for details about SSIM.
+
+ Args:
+ img1: the first input image with shape :math:`(B, C, H, W)`.
+ img2: the second input image with shape :math:`(B, C, H, W)`.
+ window_size: the size of the gaussian kernel to smooth the images.
+ max_val: the dynamic range of the images.
+ eps: Small value for numerically stability when dividing.
+ reduction : Specifies the reduction to apply to the
+ output: ``'none'`` | ``'mean'`` | ``'sum'``. ``'none'``: no reduction will be applied,
+ ``'mean'``: the sum of the output will be divided by the number of elements
+ in the output, ``'sum'``: the output will be summed.
+
+ Returns:
+ The loss based on the ssim index.
+
+ Examples:
+ >>> input1 = torch.rand(1, 4, 5, 5)
+ >>> input2 = torch.rand(1, 4, 5, 5)
+ >>> loss = ssim_loss(input1, input2, 5)
+ """
+ # compute the ssim map
+ ssim_map: torch.Tensor = metrics.ssim(img1, img2, window_size, max_val, eps)
+
+ # compute and reduce the loss
+ loss = torch.clamp((1.0 - ssim_map) / 2, min=0, max=1)
+
+ if reduction == "mean":
+ loss = torch.mean(loss)
+ elif reduction == "sum":
+ loss = torch.sum(loss)
+ elif reduction == "none":
+ pass
+ return loss
+
+
+class SSIMLoss(nn.Module):
+ r"""Create a criterion that computes a loss based on the SSIM measurement.
+
+ The loss, or the Structural dissimilarity (DSSIM) is described as:
+
+ .. math::
+
+ \text{loss}(x, y) = \frac{1 - \text{SSIM}(x, y)}{2}
+
+ See :meth:`~kornia.losses.ssim_loss` for details about SSIM.
+
+ Args:
+ window_size: the size of the gaussian kernel to smooth the images.
+ max_val: the dynamic range of the images.
+ eps: Small value for numerically stability when dividing.
+ reduction : Specifies the reduction to apply to the
+ output: ``'none'`` | ``'mean'`` | ``'sum'``. ``'none'``: no reduction will be applied,
+ ``'mean'``: the sum of the output will be divided by the number of elements
+ in the output, ``'sum'``: the output will be summed.
+
+ Returns:
+ The loss based on the ssim index.
+
+ Examples:
+ >>> input1 = torch.rand(1, 4, 5, 5)
+ >>> input2 = torch.rand(1, 4, 5, 5)
+ >>> criterion = SSIMLoss(5)
+ >>> loss = criterion(input1, input2)
+ """
+
+ def __init__(self, window_size: int, max_val: float = 1.0, eps: float = 1e-12, reduction: str = 'mean') -> None:
+ super().__init__()
+ self.window_size: int = window_size
+ self.max_val: float = max_val
+ self.eps: float = eps
+ self.reduction: str = reduction
+
+ def forward(self, img1: torch.Tensor, img2: torch.Tensor) -> torch.Tensor:
+ return ssim_loss(img1, img2, self.window_size, self.max_val, self.eps, self.reduction)
diff --git a/kornia/losses/total_variation.py b/kornia/losses/total_variation.py
new file mode 100644
index 0000000000000000000000000000000000000000..e6ccb1d5d38211ba3ccebfc2a3c5c5997643263d
--- /dev/null
+++ b/kornia/losses/total_variation.py
@@ -0,0 +1,60 @@
+import torch
+import torch.nn as nn
+
+
+def total_variation(img: torch.Tensor) -> torch.Tensor:
+ r"""Function that computes Total Variation according to [1].
+
+ Args:
+ img: the input image with shape :math:`(N, C, H, W)` or :math:`(C, H, W)`.
+
+ Return:
+ a scalar with the computer loss.
+
+ Examples:
+ >>> total_variation(torch.ones(3, 4, 4))
+ tensor(0.)
+
+ .. note::
+ See a working example `here `__.
+
+ Reference:
+ [1] https://en.wikipedia.org/wiki/Total_variation
+ """
+ if not isinstance(img, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(img)}")
+
+ if len(img.shape) < 3 or len(img.shape) > 4:
+ raise ValueError(f"Expected input tensor to be of ndim 3 or 4, but got {len(img.shape)}.")
+
+ pixel_dif1 = img[..., 1:, :] - img[..., :-1, :]
+ pixel_dif2 = img[..., :, 1:] - img[..., :, :-1]
+
+ reduce_axes = (-3, -2, -1)
+ res1 = pixel_dif1.abs().sum(dim=reduce_axes)
+ res2 = pixel_dif2.abs().sum(dim=reduce_axes)
+
+ return res1 + res2
+
+
+class TotalVariation(nn.Module):
+ r"""Compute the Total Variation according to [1].
+
+ Shape:
+ - Input: :math:`(N, C, H, W)` or :math:`(C, H, W)`.
+ - Output: :math:`(N,)` or scalar.
+
+ Examples:
+ >>> tv = TotalVariation()
+ >>> output = tv(torch.ones((2, 3, 4, 4), requires_grad=True))
+ >>> output.data
+ tensor([0., 0.])
+ >>> output.sum().backward() # grad can be implicitly created only for scalar outputs
+
+ Reference:
+ [1] https://en.wikipedia.org/wiki/Total_variation
+ """
+
+ def forward(self, img) -> torch.Tensor:
+ return total_variation(img)
diff --git a/kornia/losses/tversky.py b/kornia/losses/tversky.py
new file mode 100644
index 0000000000000000000000000000000000000000..ae73fb39f14e582151fd2f57ce7b2348846c3370
--- /dev/null
+++ b/kornia/losses/tversky.py
@@ -0,0 +1,130 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from kornia.utils.one_hot import one_hot
+
+# based on:
+# https://github.com/kevinzakka/pytorch-goodies/blob/master/losses.py
+
+
+def tversky_loss(
+ input: torch.Tensor, target: torch.Tensor, alpha: float, beta: float, eps: float = 1e-8
+) -> torch.Tensor:
+ r"""Criterion that computes Tversky Coefficient loss.
+
+ According to :cite:`salehi2017tversky`, we compute the Tversky Coefficient as follows:
+
+ .. math::
+
+ \text{S}(P, G, \alpha; \beta) =
+ \frac{|PG|}{|PG| + \alpha |P \setminus G| + \beta |G \setminus P|}
+
+ Where:
+ - :math:`P` and :math:`G` are the predicted and ground truth binary
+ labels.
+ - :math:`\alpha` and :math:`\beta` control the magnitude of the
+ penalties for FPs and FNs, respectively.
+
+ Note:
+ - :math:`\alpha = \beta = 0.5` => dice coeff
+ - :math:`\alpha = \beta = 1` => tanimoto coeff
+ - :math:`\alpha + \beta = 1` => F beta coeff
+
+ Args:
+ input: logits tensor with shape :math:`(N, C, H, W)` where C = number of classes.
+ target: labels tensor with shape :math:`(N, H, W)` where each value
+ is :math:`0 โค targets[i] โค Cโ1`.
+ alpha: the first coefficient in the denominator.
+ beta: the second coefficient in the denominator.
+ eps: scalar for numerical stability.
+
+ Return:
+ the computed loss.
+
+ Example:
+ >>> N = 5 # num_classes
+ >>> input = torch.randn(1, N, 3, 5, requires_grad=True)
+ >>> target = torch.empty(1, 3, 5, dtype=torch.long).random_(N)
+ >>> output = tversky_loss(input, target, alpha=0.5, beta=0.5)
+ >>> output.backward()
+ """
+ if not isinstance(input, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(input)}")
+
+ if not len(input.shape) == 4:
+ raise ValueError(f"Invalid input shape, we expect BxNxHxW. Got: {input.shape}")
+
+ if not input.shape[-2:] == target.shape[-2:]:
+ raise ValueError(f"input and target shapes must be the same. Got: {input.shape} and {input.shape}")
+
+ if not input.device == target.device:
+ raise ValueError(f"input and target must be in the same device. Got: {input.device} and {target.device}")
+
+ # compute softmax over the classes axis
+ input_soft: torch.Tensor = F.softmax(input, dim=1)
+
+ # create the labels one hot tensor
+ target_one_hot: torch.Tensor = one_hot(target, num_classes=input.shape[1], device=input.device, dtype=input.dtype)
+
+ # compute the actual dice score
+ dims = (1, 2, 3)
+ intersection = torch.sum(input_soft * target_one_hot, dims)
+ fps = torch.sum(input_soft * (-target_one_hot + 1.0), dims)
+ fns = torch.sum((-input_soft + 1.0) * target_one_hot, dims)
+
+ numerator = intersection
+ denominator = intersection + alpha * fps + beta * fns
+ tversky_loss = numerator / (denominator + eps)
+
+ return torch.mean(-tversky_loss + 1.0)
+
+
+class TverskyLoss(nn.Module):
+ r"""Criterion that computes Tversky Coefficient loss.
+
+ According to :cite:`salehi2017tversky`, we compute the Tversky Coefficient as follows:
+
+ .. math::
+
+ \text{S}(P, G, \alpha; \beta) =
+ \frac{|PG|}{|PG| + \alpha |P \setminus G| + \beta |G \setminus P|}
+
+ Where:
+ - :math:`P` and :math:`G` are the predicted and ground truth binary
+ labels.
+ - :math:`\alpha` and :math:`\beta` control the magnitude of the
+ penalties for FPs and FNs, respectively.
+
+ Note:
+ - :math:`\alpha = \beta = 0.5` => dice coeff
+ - :math:`\alpha = \beta = 1` => tanimoto coeff
+ - :math:`\alpha + \beta = 1` => F beta coeff
+
+ Args:
+ alpha: the first coefficient in the denominator.
+ beta: the second coefficient in the denominator.
+ eps: scalar for numerical stability.
+
+ Shape:
+ - Input: :math:`(N, C, H, W)` where C = number of classes.
+ - Target: :math:`(N, H, W)` where each value is
+ :math:`0 โค targets[i] โค Cโ1`.
+
+ Examples:
+ >>> N = 5 # num_classes
+ >>> criterion = TverskyLoss(alpha=0.5, beta=0.5)
+ >>> input = torch.randn(1, N, 3, 5, requires_grad=True)
+ >>> target = torch.empty(1, 3, 5, dtype=torch.long).random_(N)
+ >>> output = criterion(input, target)
+ >>> output.backward()
+ """
+
+ def __init__(self, alpha: float, beta: float, eps: float = 1e-8) -> None:
+ super().__init__()
+ self.alpha: float = alpha
+ self.beta: float = beta
+ self.eps: float = eps
+
+ def forward(self, input: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
+ return tversky_loss(input, target, self.alpha, self.beta, self.eps)
diff --git a/kornia/metrics/__init__.py b/kornia/metrics/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..40dada0af234129998c808153c2518fb056826d7
--- /dev/null
+++ b/kornia/metrics/__init__.py
@@ -0,0 +1,16 @@
+from .accuracy import accuracy
+from .average_meter import AverageMeter
+from .confusion_matrix import confusion_matrix
+from .mean_iou import mean_iou
+from .psnr import psnr
+from .ssim import ssim, SSIM
+
+__all__ = [
+ "accuracy",
+ "AverageMeter",
+ "confusion_matrix",
+ "mean_iou",
+ "psnr",
+ "ssim",
+ "SSIM",
+]
diff --git a/kornia/metrics/accuracy.py b/kornia/metrics/accuracy.py
new file mode 100644
index 0000000000000000000000000000000000000000..b06a88ed205d3932a351004d1c674e38867c9600
--- /dev/null
+++ b/kornia/metrics/accuracy.py
@@ -0,0 +1,25 @@
+from typing import List
+
+import torch
+
+
+def accuracy(input: torch.Tensor, target: torch.Tensor, topk=(1,)) -> List[torch.Tensor]:
+ """Computes the accuracy over the k top predictions for the specified values of k.
+
+ Args:
+ input: the input tensor with the logits to evaluate.
+ target: the tensor containing the ground truth.
+ topk: the expected topk ranking.
+
+ Example:
+ >>> logits = torch.tensor([[0, 1, 0]])
+ >>> target = torch.tensor([[1]])
+ >>> accuracy(logits, target)
+ [tensor(100.)]
+ """
+ maxk = min(max(topk), input.size()[1])
+ batch_size = target.size(0)
+ _, pred = input.topk(maxk, 1, True, True)
+ pred = pred.t()
+ correct = pred.eq(target.reshape(1, -1).expand_as(pred))
+ return [correct[:min(k, maxk)].reshape(-1).float().sum(0) * 100. / batch_size for k in topk]
diff --git a/kornia/metrics/average_meter.py b/kornia/metrics/average_meter.py
new file mode 100644
index 0000000000000000000000000000000000000000..54fb988584ed93302dbe5493044f372773df9ac7
--- /dev/null
+++ b/kornia/metrics/average_meter.py
@@ -0,0 +1,29 @@
+from typing import Union
+
+import torch
+
+
+class AverageMeter:
+ """Computes and stores the average and current value.
+
+ Example:
+ >>> stats = AverageMeter()
+ >>> acc1 = torch.tensor(0.99) # coming from K.metrics.accuracy
+ >>> stats.update(acc1, n=1) # where n is batch size usually
+ >>> stats.avg
+ tensor(0.9900)
+ """
+ def __init__(self) -> None:
+ self.reset()
+
+ def reset(self):
+ self.val = 0
+ self.avg = 0
+ self.sum = 0
+ self.count = 0
+
+ def update(self, val: Union[int, float, bool, torch.Tensor], n: int = 1) -> None:
+ self.val = val
+ self.sum += val * n
+ self.count += n
+ self.avg = self.sum / self.count
diff --git a/kornia/metrics/confusion_matrix.py b/kornia/metrics/confusion_matrix.py
new file mode 100644
index 0000000000000000000000000000000000000000..0e3aa01ac1e40ae2be7afeceea3b515f8487820d
--- /dev/null
+++ b/kornia/metrics/confusion_matrix.py
@@ -0,0 +1,72 @@
+import torch
+
+# Inspired by:
+# https://github.com/pytorch/tnt/blob/master/torchnet/meter/confusionmeter.py#L68-L73
+
+
+def confusion_matrix(
+ input: torch.Tensor, target: torch.Tensor, num_classes: int, normalized: bool = False
+) -> torch.Tensor:
+ r"""Compute confusion matrix to evaluate the accuracy of a classification.
+
+ Args:
+ input: tensor with estimated targets returned by a
+ classifier. The shape can be :math:`(B, *)` and must contain integer
+ values between 0 and K-1.
+ target: tensor with ground truth (correct) target
+ values. The shape can be :math:`(B, *)` and must contain integer
+ values between 0 and K-1, where targets are assumed to be provided as
+ one-hot vectors.
+ num_classes: total possible number of classes in target.
+ normalized: whether to return the confusion matrix normalized.
+
+ Returns:
+ a tensor containing the confusion matrix with shape
+ :math:`(B, K, K)` where K is the number of classes.
+
+ Example:
+ >>> logits = torch.tensor([[0, 1, 0]])
+ >>> target = torch.tensor([[0, 1, 0]])
+ >>> confusion_matrix(logits, target, num_classes=3)
+ tensor([[[2., 0., 0.],
+ [0., 1., 0.],
+ [0., 0., 0.]]])
+ """
+ if not torch.is_tensor(input) and input.dtype is not torch.int64:
+ raise TypeError("Input input type is not a torch.Tensor with " "torch.int64 dtype. Got {}".format(type(input)))
+
+ if not torch.is_tensor(target) and target.dtype is not torch.int64:
+ raise TypeError(
+ "Input target type is not a torch.Tensor with " "torch.int64 dtype. Got {}".format(type(target))
+ )
+ if not input.shape == target.shape:
+ raise ValueError(
+ "Inputs input and target must have the same shape. " "Got: {} and {}".format(input.shape, target.shape)
+ )
+ if not input.device == target.device:
+ raise ValueError("Inputs must be in the same device. " "Got: {} - {}".format(input.device, target.device))
+
+ if not isinstance(num_classes, int) or num_classes < 2:
+ raise ValueError("The number of classes must be an integer bigger " "than two. Got: {}".format(num_classes))
+
+ batch_size: int = input.shape[0]
+
+ # hack for bitcounting 2 arrays together
+ # NOTE: torch.bincount does not implement batched version
+ pre_bincount: torch.Tensor = input + target * num_classes
+ pre_bincount_vec: torch.Tensor = pre_bincount.view(batch_size, -1)
+
+ confusion_list = []
+ for iter_id in range(batch_size):
+ pb: torch.Tensor = pre_bincount_vec[iter_id]
+ bin_count: torch.Tensor = torch.bincount(pb, minlength=num_classes ** 2)
+ confusion_list.append(bin_count)
+
+ confusion_vec: torch.Tensor = torch.stack(confusion_list)
+ confusion_mat: torch.Tensor = confusion_vec.view(batch_size, num_classes, num_classes).to(torch.float32) # BxKxK
+
+ if normalized:
+ norm_val: torch.Tensor = torch.sum(confusion_mat, dim=1, keepdim=True)
+ confusion_mat = confusion_mat / (norm_val + 1e-6)
+
+ return confusion_mat
diff --git a/kornia/metrics/mean_iou.py b/kornia/metrics/mean_iou.py
new file mode 100644
index 0000000000000000000000000000000000000000..9d9b4b1cddef51012e49c748f32482e5263568b1
--- /dev/null
+++ b/kornia/metrics/mean_iou.py
@@ -0,0 +1,60 @@
+import torch
+
+from .confusion_matrix import confusion_matrix
+
+
+def mean_iou(input: torch.Tensor, target: torch.Tensor, num_classes: int, eps: float = 1e-6) -> torch.Tensor:
+ r"""Calculate mean Intersection-Over-Union (mIOU).
+
+ The function internally computes the confusion matrix.
+
+ Args:
+ input : tensor with estimated targets returned by a
+ classifier. The shape can be :math:`(B, *)` and must contain integer
+ values between 0 and K-1.
+ target: tensor with ground truth (correct) target
+ values. The shape can be :math:`(B, *)` and must contain integer
+ values between 0 and K-1, where targets are assumed to be provided as
+ one-hot vectors.
+ num_classes: total possible number of classes in target.
+
+ Returns:
+ ta tensor representing the mean intersection-over union
+ with shape :math:`(B, K)` where K is the number of classes.
+
+ Example:
+ >>> logits = torch.tensor([[0, 1, 0]])
+ >>> target = torch.tensor([[0, 1, 0]])
+ >>> mean_iou(logits, target, num_classes=3)
+ tensor([[1., 1., 1.]])
+ """
+ if not torch.is_tensor(input) and input.dtype is not torch.int64:
+ raise TypeError("Input input type is not a torch.Tensor with " "torch.int64 dtype. Got {}".format(type(input)))
+
+ if not torch.is_tensor(target) and target.dtype is not torch.int64:
+ raise TypeError(
+ "Input target type is not a torch.Tensor with " "torch.int64 dtype. Got {}".format(type(target))
+ )
+ if not input.shape == target.shape:
+ raise ValueError(
+ "Inputs input and target must have the same shape. " "Got: {} and {}".format(input.shape, target.shape)
+ )
+ if not input.device == target.device:
+ raise ValueError("Inputs must be in the same device. " "Got: {} - {}".format(input.device, target.device))
+
+ if not isinstance(num_classes, int) or num_classes < 2:
+ raise ValueError("The number of classes must be an integer bigger " "than two. Got: {}".format(num_classes))
+
+ # we first compute the confusion matrix
+ conf_mat: torch.Tensor = confusion_matrix(input, target, num_classes)
+
+ # compute the actual intersection over union
+ sum_over_row = torch.sum(conf_mat, dim=1)
+ sum_over_col = torch.sum(conf_mat, dim=2)
+ conf_mat_diag = torch.diagonal(conf_mat, dim1=-2, dim2=-1)
+ denominator = sum_over_row + sum_over_col - conf_mat_diag
+
+ # NOTE: we add epsilon so that samples that are neither in the
+ # prediction or ground truth are taken into account.
+ ious = (conf_mat_diag + eps) / (denominator + eps)
+ return ious
diff --git a/kornia/metrics/psnr.py b/kornia/metrics/psnr.py
new file mode 100644
index 0000000000000000000000000000000000000000..86f319dc49c37b5edb8b9d2110cd5fa179d43d55
--- /dev/null
+++ b/kornia/metrics/psnr.py
@@ -0,0 +1,49 @@
+import torch
+from torch.nn.functional import mse_loss as mse
+
+
+def psnr(input: torch.Tensor, target: torch.Tensor, max_val: float) -> torch.Tensor:
+ r"""Create a function that calculates the PSNR between 2 images.
+
+ PSNR is Peek Signal to Noise Ratio, which is similar to mean squared error.
+ Given an m x n image, the PSNR is:
+
+ .. math::
+
+ \text{PSNR} = 10 \log_{10} \bigg(\frac{\text{MAX}_I^2}{MSE(I,T)}\bigg)
+
+ where
+
+ .. math::
+
+ \text{MSE}(I,T) = \frac{1}{mn}\sum_{i=0}^{m-1}\sum_{j=0}^{n-1} [I(i,j) - T(i,j)]^2
+
+ and :math:`\text{MAX}_I` is the maximum possible input value
+ (e.g for floating point images :math:`\text{MAX}_I=1`).
+
+ Args:
+ input: the input image with arbitrary shape :math:`(*)`.
+ labels: the labels image with arbitrary shape :math:`(*)`.
+ max_val: The maximum value in the input tensor.
+
+ Return:
+ the computed loss as a scalar.
+
+ Examples:
+ >>> ones = torch.ones(1)
+ >>> psnr(ones, 1.2 * ones, 2.) # 10 * log(4/((1.2-1)**2)) / log(10)
+ tensor(20.0000)
+
+ Reference:
+ https://en.wikipedia.org/wiki/Peak_signal-to-noise_ratio#Definition
+ """
+ if not isinstance(input, torch.Tensor):
+ raise TypeError(f"Expected torch.Tensor but got {type(target)}.")
+
+ if not isinstance(target, torch.Tensor):
+ raise TypeError(f"Expected torch.Tensor but got {type(input)}.")
+
+ if input.shape != target.shape:
+ raise TypeError(f"Expected tensors of equal shapes, but got {input.shape} and {target.shape}")
+
+ return 10.0 * torch.log10(max_val ** 2 / mse(input, target, reduction='mean'))
diff --git a/kornia/metrics/ssim.py b/kornia/metrics/ssim.py
new file mode 100644
index 0000000000000000000000000000000000000000..e2be903a0956af7d127886374b0d448f795fac21
--- /dev/null
+++ b/kornia/metrics/ssim.py
@@ -0,0 +1,129 @@
+import torch
+import torch.nn as nn
+
+from kornia.filters import filter2d, get_gaussian_kernel2d
+
+
+def ssim(
+ img1: torch.Tensor, img2: torch.Tensor, window_size: int, max_val: float = 1.0, eps: float = 1e-12
+) -> torch.Tensor:
+ r"""Function that computes the Structural Similarity (SSIM) index map between two images.
+
+ Measures the (SSIM) index between each element in the input `x` and target `y`.
+
+ The index can be described as:
+
+ .. math::
+
+ \text{SSIM}(x, y) = \frac{(2\mu_x\mu_y+c_1)(2\sigma_{xy}+c_2)}
+ {(\mu_x^2+\mu_y^2+c_1)(\sigma_x^2+\sigma_y^2+c_2)}
+
+ where:
+ - :math:`c_1=(k_1 L)^2` and :math:`c_2=(k_2 L)^2` are two variables to
+ stabilize the division with weak denominator.
+ - :math:`L` is the dynamic range of the pixel-values (typically this is
+ :math:`2^{\#\text{bits per pixel}}-1`).
+
+ Args:
+ img1: the first input image with shape :math:`(B, C, H, W)`.
+ img2: the second input image with shape :math:`(B, C, H, W)`.
+ window_size: the size of the gaussian kernel to smooth the images.
+ max_val: the dynamic range of the images.
+ eps: Small value for numerically stability when dividing.
+
+ Returns:
+ The ssim index map with shape :math:`(B, C, H, W)`.
+
+ Examples:
+ >>> input1 = torch.rand(1, 4, 5, 5)
+ >>> input2 = torch.rand(1, 4, 5, 5)
+ >>> ssim_map = ssim(input1, input2, 5) # 1x4x5x5
+ """
+ if not isinstance(img1, torch.Tensor):
+ raise TypeError(f"Input img1 type is not a torch.Tensor. Got {type(img1)}")
+
+ if not isinstance(img2, torch.Tensor):
+ raise TypeError(f"Input img2 type is not a torch.Tensor. Got {type(img2)}")
+
+ if not isinstance(max_val, float):
+ raise TypeError(f"Input max_val type is not a float. Got {type(max_val)}")
+
+ if not len(img1.shape) == 4:
+ raise ValueError(f"Invalid img1 shape, we expect BxCxHxW. Got: {img1.shape}")
+
+ if not len(img2.shape) == 4:
+ raise ValueError(f"Invalid img2 shape, we expect BxCxHxW. Got: {img2.shape}")
+
+ if not img1.shape == img2.shape:
+ raise ValueError(f"img1 and img2 shapes must be the same. Got: {img1.shape} and {img2.shape}")
+
+ # prepare kernel
+ kernel: torch.Tensor = get_gaussian_kernel2d((window_size, window_size), (1.5, 1.5)).unsqueeze(0)
+
+ # compute coefficients
+ C1: float = (0.01 * max_val) ** 2
+ C2: float = (0.03 * max_val) ** 2
+
+ # compute local mean per channel
+ mu1: torch.Tensor = filter2d(img1, kernel)
+ mu2: torch.Tensor = filter2d(img2, kernel)
+
+ mu1_sq = mu1 ** 2
+ mu2_sq = mu2 ** 2
+ mu1_mu2 = mu1 * mu2
+
+ # compute local sigma per channel
+ sigma1_sq = filter2d(img1 ** 2, kernel) - mu1_sq
+ sigma2_sq = filter2d(img2 ** 2, kernel) - mu2_sq
+ sigma12 = filter2d(img1 * img2, kernel) - mu1_mu2
+
+ # compute the similarity index map
+ num: torch.Tensor = (2.0 * mu1_mu2 + C1) * (2.0 * sigma12 + C2)
+ den: torch.Tensor = (mu1_sq + mu2_sq + C1) * (sigma1_sq + sigma2_sq + C2)
+
+ return num / (den + eps)
+
+
+class SSIM(nn.Module):
+ r"""Create a module that computes the Structural Similarity (SSIM) index between two images.
+
+ Measures the (SSIM) index between each element in the input `x` and target `y`.
+
+ The index can be described as:
+
+ .. math::
+
+ \text{SSIM}(x, y) = \frac{(2\mu_x\mu_y+c_1)(2\sigma_{xy}+c_2)}
+ {(\mu_x^2+\mu_y^2+c_1)(\sigma_x^2+\sigma_y^2+c_2)}
+
+ where:
+ - :math:`c_1=(k_1 L)^2` and :math:`c_2=(k_2 L)^2` are two variables to
+ stabilize the division with weak denominator.
+ - :math:`L` is the dynamic range of the pixel-values (typically this is
+ :math:`2^{\#\text{bits per pixel}}-1`).
+
+ Args:
+ window_size: the size of the gaussian kernel to smooth the images.
+ max_val: the dynamic range of the images.
+ eps: Small value for numerically stability when dividing.
+
+ Shape:
+ - Input: :math:`(B, C, H, W)`.
+ - Target :math:`(B, C, H, W)`.
+ - Output: :math:`(B, C, H, W)`.
+
+ Examples:
+ >>> input1 = torch.rand(1, 4, 5, 5)
+ >>> input2 = torch.rand(1, 4, 5, 5)
+ >>> ssim = SSIM(5)
+ >>> ssim_map = ssim(input1, input2) # 1x4x5x5
+ """
+
+ def __init__(self, window_size: int, max_val: float = 1.0, eps: float = 1e-12) -> None:
+ super().__init__()
+ self.window_size: int = window_size
+ self.max_val: float = max_val
+ self.eps = eps
+
+ def forward(self, img1: torch.Tensor, img2: torch.Tensor) -> torch.Tensor:
+ return ssim(img1, img2, self.window_size, self.max_val, self.eps)
diff --git a/kornia/morphology/__init__.py b/kornia/morphology/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5c8dbe328f26fde6360efc3e883e8db4da5a9b72
--- /dev/null
+++ b/kornia/morphology/__init__.py
@@ -0,0 +1 @@
+from .morphology import *
diff --git a/kornia/morphology/morphology.py b/kornia/morphology/morphology.py
new file mode 100644
index 0000000000000000000000000000000000000000..2db61c93c1e7a4a710fa9e7a2eae6d2a3a5dc53f
--- /dev/null
+++ b/kornia/morphology/morphology.py
@@ -0,0 +1,579 @@
+from typing import List, Optional
+
+import torch
+import torch.nn.functional as F
+
+__all__ = [
+ "dilation",
+ "erosion",
+ "opening",
+ "closing",
+ "gradient",
+ "top_hat",
+ "bottom_hat"
+]
+
+
+def _neight2channels_like_kernel(kernel: torch.Tensor) -> torch.Tensor:
+ h, w = kernel.size()
+ kernel = torch.eye(h * w, dtype=kernel.dtype, device=kernel.device)
+ return kernel.view(h * w, 1, h, w)
+
+
+def dilation(
+ tensor: torch.Tensor,
+ kernel: torch.Tensor,
+ structuring_element: Optional[torch.Tensor] = None,
+ origin: Optional[List[int]] = None,
+ border_type: str = 'geodesic',
+ border_value: float = 0.0,
+ max_val: float = 1e4,
+ engine: str = 'unfold',
+) -> torch.Tensor:
+ r"""Return the dilated image applying the same kernel in each channel.
+
+ .. image:: _static/img/dilation.png
+
+ The kernel must have 2 dimensions.
+
+ Args:
+ tensor: Image with shape :math:`(B, C, H, W)`.
+ kernel: Positions of non-infinite elements of a flat structuring element. Non-zero values give
+ the set of neighbors of the center over which the operation is applied. Its shape is :math:`(k_x, k_y)`.
+ For full structural elements use torch.ones_like(structural_element).
+ structuring_element: Structuring element used for the grayscale dilation. It may be a non-flat
+ structuring element.
+ origin: Origin of the structuring element. Default: ``None`` and uses the center of
+ the structuring element as origin (rounding towards zero).
+ border_type: It determines how the image borders are handled, where ``border_value`` is the value
+ when ``border_type`` is equal to ``constant``. Default: ``geodesic`` which ignores the values that are
+ outside the image when applying the operation.
+ border_value: Value to fill past edges of input if ``border_type`` is ``constant``.
+ max_val: The value of the infinite elements in the kernel.
+ engine: convolution is faster and less memory hungry, and unfold is more stable numerically
+
+ Returns:
+ Dilated image with shape :math:`(B, C, H, W)`.
+
+ .. note::
+ See a working example `here `__.
+
+ Example:
+ >>> tensor = torch.rand(1, 3, 5, 5)
+ >>> kernel = torch.ones(3, 3)
+ >>> dilated_img = dilation(tensor, kernel)
+ """
+
+ if not isinstance(tensor, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(tensor)}")
+
+ if len(tensor.shape) != 4:
+ raise ValueError(f"Input size must have 4 dimensions. Got {tensor.dim()}")
+
+ if not isinstance(kernel, torch.Tensor):
+ raise TypeError(f"Kernel type is not a torch.Tensor. Got {type(kernel)}")
+
+ if len(kernel.shape) != 2:
+ raise ValueError(f"Kernel size must have 2 dimensions. Got {kernel.dim()}")
+
+ # origin
+ se_h, se_w = kernel.shape
+ if origin is None:
+ origin = [se_h // 2, se_w // 2]
+
+ # pad
+ pad_e: List[int] = [origin[1], se_w - origin[1] - 1, origin[0], se_h - origin[0] - 1]
+ if border_type == 'geodesic':
+ border_value = -max_val
+ border_type = 'constant'
+ output: torch.Tensor = F.pad(tensor, pad_e, mode=border_type, value=border_value)
+
+ # computation
+ if structuring_element is None:
+ neighborhood = torch.zeros_like(kernel)
+ neighborhood[kernel == 0] = -max_val
+ else:
+ neighborhood = structuring_element.clone()
+ neighborhood[kernel == 0] = -max_val
+
+ if engine == 'unfold':
+ output = output.unfold(2, se_h, 1).unfold(3, se_w, 1)
+ output, _ = torch.max(output + neighborhood.flip((0, 1)), 4)
+ output, _ = torch.max(output, 4)
+ elif engine == 'convolution':
+ B, C, H, W = tensor.size()
+ h_pad, w_pad = output.shape[-2:]
+ reshape_kernel = _neight2channels_like_kernel(kernel)
+ output, _ = F.conv2d(
+ output.view(B * C, 1, h_pad, w_pad), reshape_kernel, padding=0, bias=neighborhood.view(-1).flip(0)
+ ).max(dim=1)
+ output = output.view(B, C, H, W)
+ else:
+ raise NotImplementedError(f"engine {engine} is unknown, use 'convolution' or 'unfold'")
+ return output.view_as(tensor)
+
+
+def erosion(
+ tensor: torch.Tensor,
+ kernel: torch.Tensor,
+ structuring_element: Optional[torch.Tensor] = None,
+ origin: Optional[List[int]] = None,
+ border_type: str = 'geodesic',
+ border_value: float = 0.0,
+ max_val: float = 1e4,
+ engine: str = 'unfold',
+) -> torch.Tensor:
+ r"""Return the eroded image applying the same kernel in each channel.
+
+ .. image:: _static/img/erosion.png
+
+ The kernel must have 2 dimensions.
+
+ Args:
+ tensor: Image with shape :math:`(B, C, H, W)`.
+ kernel: Positions of non-infinite elements of a flat structuring element. Non-zero values give
+ the set of neighbors of the center over which the operation is applied. Its shape is :math:`(k_x, k_y)`.
+ For full structural elements use torch.ones_like(structural_element).
+ structuring_element (torch.Tensor, optional): Structuring element used for the grayscale dilation.
+ It may be a non-flat structuring element.
+ origin: Origin of the structuring element. Default: ``None`` and uses the center of
+ the structuring element as origin (rounding towards zero).
+ border_type: It determines how the image borders are handled, where ``border_value`` is the value
+ when ``border_type`` is equal to ``constant``. Default: ``geodesic`` which ignores the values that are
+ outside the image when applying the operation.
+ border_value: Value to fill past edges of input if border_type is ``constant``.
+ max_val: The value of the infinite elements in the kernel.
+ engine: ``convolution`` is faster and less memory hungry, and ``unfold`` is more stable numerically
+
+ Returns:
+ Eroded image with shape :math:`(B, C, H, W)`.
+
+ .. note::
+ See a working example `here `__.
+
+ Example:
+ >>> tensor = torch.rand(1, 3, 5, 5)
+ >>> kernel = torch.ones(5, 5)
+ >>> output = erosion(tensor, kernel)
+ """
+
+ if not isinstance(tensor, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(tensor)}")
+
+ if len(tensor.shape) != 4:
+ raise ValueError(f"Input size must have 4 dimensions. Got {tensor.dim()}")
+
+ if not isinstance(kernel, torch.Tensor):
+ raise TypeError(f"Kernel type is not a torch.Tensor. Got {type(kernel)}")
+
+ if len(kernel.shape) != 2:
+ raise ValueError(f"Kernel size must have 2 dimensions. Got {kernel.dim()}")
+
+ # origin
+ se_h, se_w = kernel.shape
+ if origin is None:
+ origin = [se_h // 2, se_w // 2]
+
+ # pad
+ pad_e: List[int] = [origin[1], se_w - origin[1] - 1, origin[0], se_h - origin[0] - 1]
+ if border_type == 'geodesic':
+ border_value = max_val
+ border_type = 'constant'
+ output: torch.Tensor = F.pad(tensor, pad_e, mode=border_type, value=border_value)
+
+ # computation
+ if structuring_element is None:
+ neighborhood = torch.zeros_like(kernel)
+ neighborhood[kernel == 0] = -max_val
+ else:
+ neighborhood = structuring_element.clone()
+ neighborhood[kernel == 0] = -max_val
+
+ if engine == 'unfold':
+ output = output.unfold(2, se_h, 1).unfold(3, se_w, 1)
+ output, _ = torch.min(output - neighborhood, 4)
+ output, _ = torch.min(output, 4)
+ elif engine == 'convolution':
+ B, C, H, W = tensor.size()
+ Hpad, Wpad = output.shape[-2:]
+ reshape_kernel = _neight2channels_like_kernel(kernel)
+ output, _ = F.conv2d(output.view(B * C, 1, Hpad, Wpad),
+ reshape_kernel,
+ padding=0,
+ bias=-neighborhood.view(-1)).min(dim=1)
+ output = output.view(B, C, H, W)
+ else:
+ raise NotImplementedError(f"engine {engine} is unknown, use 'convolution' or 'unfold'")
+
+ return output
+
+
+def opening(
+ tensor: torch.Tensor,
+ kernel: torch.Tensor,
+ structuring_element: Optional[torch.Tensor] = None,
+ origin: Optional[List[int]] = None,
+ border_type: str = 'geodesic',
+ border_value: float = 0.0,
+ max_val: float = 1e4,
+ engine: str = 'unfold',
+) -> torch.Tensor:
+ r"""Return the opened image, (that means, dilation after an erosion) applying the same kernel in each channel.
+
+ .. image:: _static/img/opening.png
+
+ The kernel must have 2 dimensions.
+
+ Args:
+ tensor: Image with shape :math:`(B, C, H, W)`.
+ kernel: Positions of non-infinite elements of a flat structuring element. Non-zero values give
+ the set of neighbors of the center over which the operation is applied. Its shape is :math:`(k_x, k_y)`.
+ For full structural elements use torch.ones_like(structural_element).
+ structuring_element: Structuring element used for the grayscale dilation. It may be a
+ non-flat structuring element.
+ origin: Origin of the structuring element. Default: ``None`` and uses the center of
+ the structuring element as origin (rounding towards zero).
+ border_type: It determines how the image borders are handled, where ``border_value`` is the value
+ when ``border_type`` is equal to ``constant``. Default: ``geodesic`` which ignores the values that are
+ outside the image when applying the operation.
+ border_value: Value to fill past edges of input if ``border_type`` is ``constant``.
+ max_val: The value of the infinite elements in the kernel.
+ engine: convolution is faster and less memory hungry, and unfold is more stable numerically
+
+ Returns:
+ torch.Tensor: Opened image with shape :math:`(B, C, H, W)`.
+
+ .. note::
+ See a working example `here `__.
+
+ Example:
+ >>> tensor = torch.rand(1, 3, 5, 5)
+ >>> kernel = torch.ones(3, 3)
+ >>> opened_img = opening(tensor, kernel)
+ """
+
+ if not isinstance(tensor, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(tensor)}")
+
+ if len(tensor.shape) != 4:
+ raise ValueError(f"Input size must have 4 dimensions. Got {tensor.dim()}")
+
+ if not isinstance(kernel, torch.Tensor):
+ raise TypeError(f"Kernel type is not a torch.Tensor. Got {type(kernel)}")
+
+ if len(kernel.shape) != 2:
+ raise ValueError(f"Kernel size must have 2 dimensions. Got {kernel.dim()}")
+
+ return dilation(
+ erosion(
+ tensor,
+ kernel=kernel,
+ structuring_element=structuring_element,
+ origin=origin,
+ border_type=border_type,
+ border_value=border_value,
+ max_val=max_val,
+ ),
+ kernel=kernel,
+ structuring_element=structuring_element,
+ origin=origin,
+ border_type=border_type,
+ border_value=border_value,
+ max_val=max_val,
+ engine=engine,
+ )
+
+
+def closing(
+ tensor: torch.Tensor,
+ kernel: torch.Tensor,
+ structuring_element: Optional[torch.Tensor] = None,
+ origin: Optional[List[int]] = None,
+ border_type: str = 'geodesic',
+ border_value: float = 0.0,
+ max_val: float = 1e4,
+ engine: str = 'unfold',
+) -> torch.Tensor:
+ r"""Return the closed image, (that means, erosion after a dilation) applying the same kernel in each channel.
+
+ .. image:: _static/img/closing.png
+
+ The kernel must have 2 dimensions.
+
+ Args:
+ tensor: Image with shape :math:`(B, C, H, W)`.
+ kernel: Positions of non-infinite elements of a flat structuring element. Non-zero values give
+ the set of neighbors of the center over which the operation is applied. Its shape is :math:`(k_x, k_y)`.
+ For full structural elements use torch.ones_like(structural_element).
+ structuring_element: Structuring element used for the grayscale dilation. It may be a
+ non-flat structuring element.
+ origin: Origin of the structuring element. Default is None and uses the center of
+ the structuring element as origin (rounding towards zero).
+ border_type: It determines how the image borders are handled, where ``border_value`` is the value
+ when ``border_type`` is equal to ``constant``. Default: ``geodesic`` which ignores the values that are
+ outside the image when applying the operation.
+ border_value: Value to fill past edges of input if ``border_type`` is ``constant``.
+ max_val: The value of the infinite elements in the kernel.
+ engine: convolution is faster and less memory hungry, and unfold is more stable numerically
+
+ Returns:
+ Closed image with shape :math:`(B, C, H, W)`.
+
+ .. note::
+ See a working example `here `__.
+
+ Example:
+ >>> tensor = torch.rand(1, 3, 5, 5)
+ >>> kernel = torch.ones(3, 3)
+ >>> closed_img = closing(tensor, kernel)
+ """
+
+ if not isinstance(tensor, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(tensor)}")
+
+ if len(tensor.shape) != 4:
+ raise ValueError(f"Input size must have 4 dimensions. Got {tensor.dim()}")
+
+ if not isinstance(kernel, torch.Tensor):
+ raise TypeError(f"Kernel type is not a torch.Tensor. Got {type(kernel)}")
+
+ if len(kernel.shape) != 2:
+ raise ValueError(f"Kernel size must have 2 dimensions. Got {kernel.dim()}")
+
+ return erosion(
+ dilation(
+ tensor,
+ kernel=kernel,
+ structuring_element=structuring_element,
+ origin=origin,
+ border_type=border_type,
+ border_value=border_value,
+ max_val=max_val,
+ ),
+ kernel=kernel,
+ structuring_element=structuring_element,
+ origin=origin,
+ border_type=border_type,
+ border_value=border_value,
+ max_val=max_val,
+ engine=engine,
+ )
+
+
+# Morphological Gradient
+def gradient(
+ tensor: torch.Tensor,
+ kernel: torch.Tensor,
+ structuring_element: Optional[torch.Tensor] = None,
+ origin: Optional[List[int]] = None,
+ border_type: str = 'geodesic',
+ border_value: float = 0.0,
+ max_val: float = 1e4,
+ engine: str = 'unfold',
+) -> torch.Tensor:
+ r"""Return the morphological gradient of an image.
+
+ .. image:: _static/img/gradient.png
+
+ That means, (dilation - erosion) applying the same kernel in each channel.
+ The kernel must have 2 dimensions.
+
+ Args:
+ tensor: Image with shape :math:`(B, C, H, W)`.
+ kernel: Positions of non-infinite elements of a flat structuring element. Non-zero values give
+ the set of neighbors of the center over which the operation is applied. Its shape is :math:`(k_x, k_y)`.
+ For full structural elements use torch.ones_like(structural_element).
+ structuring_element: Structuring element used for the grayscale dilation. It may be a
+ non-flat structuring element.
+ origin: Origin of the structuring element. Default is None and uses the center of
+ the structuring element as origin (rounding towards zero).
+ border_type: It determines how the image borders are handled, where ``border_value`` is the value
+ when ``border_type`` is equal to ``constant``. Default: ``geodesic`` which ignores the values that are
+ outside the image when applying the operation.
+ border_value: Value to fill past edges of input if ``border_type`` is ``constant``.
+ max_val: The value of the infinite elements in the kernel.
+ engine: convolution is faster and less memory hungry, and unfold is more stable numerically
+
+ Returns:
+ Gradient image with shape :math:`(B, C, H, W)`.
+
+ .. note::
+ See a working example `here `__.
+
+ Example:
+ >>> tensor = torch.rand(1, 3, 5, 5)
+ >>> kernel = torch.ones(3, 3)
+ >>> gradient_img = gradient(tensor, kernel)
+ """
+
+ return dilation(
+ tensor,
+ kernel=kernel,
+ structuring_element=structuring_element,
+ origin=origin,
+ border_type=border_type,
+ border_value=border_value,
+ max_val=max_val,
+ engine=engine,
+ ) - erosion(
+ tensor,
+ kernel=kernel,
+ structuring_element=structuring_element,
+ origin=origin,
+ border_type=border_type,
+ border_value=border_value,
+ max_val=max_val,
+ engine=engine,
+ )
+
+
+def top_hat(
+ tensor: torch.Tensor,
+ kernel: torch.Tensor,
+ structuring_element: Optional[torch.Tensor] = None,
+ origin: Optional[List[int]] = None,
+ border_type: str = 'geodesic',
+ border_value: float = 0.0,
+ max_val: float = 1e4,
+ engine: str = 'unfold',
+) -> torch.Tensor:
+ r"""Return the top hat transformation of an image.
+
+ .. image:: _static/img/top_hat.png
+
+ That means, (image - opened_image) applying the same kernel in each channel.
+ The kernel must have 2 dimensions.
+
+ See :func:`~kornia.morphology.opening` for details.
+
+ Args:
+ tensor: Image with shape :math:`(B, C, H, W)`.
+ kernel: Positions of non-infinite elements of a flat structuring element. Non-zero values give
+ the set of neighbors of the center over which the operation is applied. Its shape is :math:`(k_x, k_y)`.
+ For full structural elements use torch.ones_like(structural_element).
+ structuring_element: Structuring element used for the grayscale dilation. It may be a
+ non-flat structuring element.
+ origin: Origin of the structuring element. Default: ``None`` and uses the center of
+ the structuring element as origin (rounding towards zero).
+ border_type: It determines how the image borders are handled, where ``border_value`` is the value
+ when ``border_type`` is equal to ``constant``. Default: ``geodesic`` which ignores the values that are
+ outside the image when applying the operation.
+ border_value: Value to fill past edges of input if ``border_type`` is ``constant``.
+ max_val: The value of the infinite elements in the kernel.
+ engine: convolution is faster and less memory hungry, and unfold is more stable numerically
+
+ Returns:
+ Top hat transformed image with shape :math:`(B, C, H, W)`.
+
+ .. note::
+ See a working example `here `__.
+
+ Example:
+ >>> tensor = torch.rand(1, 3, 5, 5)
+ >>> kernel = torch.ones(3, 3)
+ >>> top_hat_img = top_hat(tensor, kernel)
+ """
+
+ if not isinstance(tensor, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(tensor)}")
+
+ if len(tensor.shape) != 4:
+ raise ValueError(f"Input size must have 4 dimensions. Got {tensor.dim()}")
+
+ if not isinstance(kernel, torch.Tensor):
+ raise TypeError(f"Kernel type is not a torch.Tensor. Got {type(kernel)}")
+
+ if len(kernel.shape) != 2:
+ raise ValueError(f"Kernel size must have 2 dimensions. Got {kernel.dim()}")
+
+ return tensor - opening(
+ tensor,
+ kernel=kernel,
+ structuring_element=structuring_element,
+ origin=origin,
+ border_type=border_type,
+ border_value=border_value,
+ max_val=max_val,
+ engine=engine,
+ )
+
+
+def bottom_hat(
+ tensor: torch.Tensor,
+ kernel: torch.Tensor,
+ structuring_element: Optional[torch.Tensor] = None,
+ origin: Optional[List[int]] = None,
+ border_type: str = 'geodesic',
+ border_value: float = 0.0,
+ max_val: float = 1e4,
+ engine: str = 'unfold',
+) -> torch.Tensor:
+ r"""Return the bottom hat transformation of an image.
+
+ .. image:: _static/img/bottom_hat.png
+
+ That means, (closed_image - image) applying the same kernel in each channel.
+ The kernel must have 2 dimensions.
+
+ See :func:`~kornia.morphology.closing` for details.
+
+ Args:
+ tensor: Image with shape :math:`(B, C, H, W)`.
+ kernel: Positions of non-infinite elements of a flat structuring element. Non-zero values give
+ the set of neighbors of the center over which the operation is applied. Its shape is :math:`(k_x, k_y)`.
+ For full structural elements use torch.ones_like(structural_element).
+ structuring_element: Structuring element used for the grayscale dilation. It may be a
+ non-flat structuring element.
+ origin: Origin of the structuring element. Default: ``None`` and uses the center of
+ the structuring element as origin (rounding towards zero).
+ border_type: It determines how the image borders are handled, where ``border_value`` is the value
+ when ``border_type`` is equal to ``constant``. Default: ``geodesic`` which ignores the values that are
+ outside the image when applying the operation.
+ border_value: Value to fill past edges of input if ``border_type`` is ``constant``.
+ max_val: The value of the infinite elements in the kernel.
+ engine: convolution is faster and less memory hungry, and unfold is more stable numerically
+
+ Returns:
+ Top hat transformed image with shape :math:`(B, C, H, W)`.
+
+ .. note::
+ See a working example `here `__.
+
+ Example:
+ >>> tensor = torch.rand(1, 3, 5, 5)
+ >>> kernel = torch.ones(3, 3)
+ >>> bottom_hat_img = bottom_hat(tensor, kernel)
+ """
+
+ if not isinstance(tensor, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(tensor)}")
+
+ if len(tensor.shape) != 4:
+ raise ValueError(f"Input size must have 4 dimensions. Got {tensor.dim()}")
+
+ if not isinstance(kernel, torch.Tensor):
+ raise TypeError(f"Kernel type is not a torch.Tensor. Got {type(kernel)}")
+
+ if len(kernel.shape) != 2:
+ raise ValueError(f"Kernel size must have 2 dimensions. Got {kernel.dim()}")
+
+ return (
+ closing(
+ tensor,
+ kernel=kernel,
+ structuring_element=structuring_element,
+ origin=origin,
+ border_type=border_type,
+ border_value=border_value,
+ max_val=max_val,
+ engine=engine,
+ )
+ - tensor
+ )
diff --git a/kornia/py.typed b/kornia/py.typed
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/kornia/testing/__init__.py b/kornia/testing/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e79807edd52c5d5ae40243627a35bb6428e9eae2
--- /dev/null
+++ b/kornia/testing/__init__.py
@@ -0,0 +1,181 @@
+"""The testing package contains testing-specific utilities."""
+import contextlib
+import importlib
+from abc import ABC, abstractmethod
+from copy import deepcopy
+from itertools import product
+from typing import Any, Optional
+
+import torch
+
+__all__ = ['tensor_to_gradcheck_var', 'create_eye_batch', 'xla_is_available', 'assert_close']
+
+
+def xla_is_available() -> bool:
+ """Return whether `torch_xla` is available in the system."""
+ if importlib.util.find_spec("torch_xla") is not None:
+ return True
+ return False
+
+
+# TODO: Isn't this function duplicated with eye_like?
+def create_eye_batch(batch_size, eye_size, device=None, dtype=None):
+ """Create a batch of identity matrices of shape Bx3x3."""
+ return torch.eye(eye_size, device=device, dtype=dtype).view(1, eye_size, eye_size).expand(batch_size, -1, -1)
+
+
+def create_random_homography(batch_size, eye_size, std_val=1e-3):
+ """Create a batch of random homographies of shape Bx3x3."""
+ std = torch.FloatTensor(batch_size, eye_size, eye_size)
+ eye = create_eye_batch(batch_size, eye_size)
+ return eye + std.uniform_(-std_val, std_val)
+
+
+def tensor_to_gradcheck_var(tensor, dtype=torch.float64, requires_grad=True):
+ """Convert the input tensor to a valid variable to check the gradient.
+
+ `gradcheck` needs 64-bit floating point and requires gradient.
+ """
+ if not torch.is_tensor(tensor):
+ raise AssertionError(type(tensor))
+ return tensor.requires_grad_(requires_grad).type(dtype)
+
+
+def dict_to(data: dict, device: torch.device, dtype: torch.dtype) -> dict:
+ out: dict = {}
+ for key, val in data.items():
+ out[key] = val.to(device, dtype) if isinstance(val, torch.Tensor) else val
+ return out
+
+
+def compute_patch_error(x, y, h, w):
+ """Compute the absolute error between patches."""
+ return torch.abs(x - y)[..., h // 4: -h // 4, w // 4: -w // 4].mean()
+
+
+def check_is_tensor(obj):
+ """Check whether the supplied object is a tensor."""
+ if not isinstance(obj, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(obj)}")
+
+
+def create_rectified_fundamental_matrix(batch_size):
+ """Create a batch of rectified fundamental matrices of shape Bx3x3."""
+ F_rect = torch.tensor([[0.0, 0.0, 0.0], [0.0, 0.0, -1.0], [0.0, 1.0, 0.0]]).view(1, 3, 3)
+ F_repeat = F_rect.repeat(batch_size, 1, 1)
+ return F_repeat
+
+
+def create_random_fundamental_matrix(batch_size, std_val=1e-3):
+ """Create a batch of random fundamental matrices of shape Bx3x3."""
+ F_rect = create_rectified_fundamental_matrix(batch_size)
+ H_left = create_random_homography(batch_size, 3, std_val)
+ H_right = create_random_homography(batch_size, 3, std_val)
+ return H_left.permute(0, 2, 1) @ F_rect @ H_right
+
+
+class BaseTester(ABC):
+ @abstractmethod
+ def test_smoke(self):
+ raise NotImplementedError("Implement a stupid routine.")
+
+ @abstractmethod
+ def test_exception(self):
+ raise NotImplementedError("Implement a stupid routine.")
+
+ @abstractmethod
+ def test_cardinality(self):
+ raise NotImplementedError("Implement a stupid routine.")
+
+ @abstractmethod
+ def test_jit(self):
+ raise NotImplementedError("Implement a stupid routine.")
+
+ @abstractmethod
+ def test_gradcheck(self):
+ raise NotImplementedError("Implement a stupid routine.")
+
+ @abstractmethod
+ def test_module(self):
+ raise NotImplementedError("Implement a stupid routine.")
+
+
+def cartesian_product_of_parameters(**possible_parameters):
+ """Create cartesian product of given parameters."""
+ parameter_names = possible_parameters.keys()
+ possible_values = [possible_parameters[parameter_name] for parameter_name in parameter_names]
+
+ for param_combination in product(*possible_values):
+ yield dict(zip(parameter_names, param_combination))
+
+
+def default_with_one_parameter_changed(*, default={}, **possible_parameters):
+ if not isinstance(default, dict):
+ raise AssertionError(f"default should be a dict not a {type(default)}")
+
+ for parameter_name, possible_values in possible_parameters.items():
+ for v in possible_values:
+ param_set = deepcopy(default)
+ param_set[parameter_name] = v
+ yield param_set
+
+
+def _get_precision(device: torch.device, dtype: torch.dtype) -> float:
+ if 'xla' in device.type:
+ return 1e-2
+ if dtype == torch.float16:
+ return 1e-3
+ return 1e-4
+
+
+def _get_precision_by_name(
+ device: torch.device, device_target: str, tol_val: float, tol_val_default: float = 1e-4
+) -> float:
+ if device_target not in ['cpu', 'cuda', 'xla']:
+ raise ValueError(f"Invalid device name: {device_target}.")
+
+ if device_target in device.type:
+ return tol_val
+
+ return tol_val_default
+
+
+try:
+ # torch.testing.assert_close is only available for torch>=1.9
+ from torch.testing import assert_close as _assert_close # type: ignore
+ from torch.testing._core import _get_default_tolerance # type: ignore
+
+ def assert_close(
+ actual: torch.Tensor,
+ expected: torch.Tensor,
+ *,
+ rtol: Optional[float] = None,
+ atol: Optional[float] = None,
+ **kwargs: Any,
+ ) -> None:
+ if rtol is None and atol is None:
+ with contextlib.suppress(Exception):
+ rtol, atol = _get_default_tolerance(actual, expected)
+
+ return _assert_close(actual, expected, rtol=rtol, atol=atol, check_stride=False, equal_nan=True, **kwargs)
+
+except ImportError:
+ # Partial backport of torch.testing.assert_close for torch<1.9
+ # TODO: remove this branch if kornia relies on torch>=1.9
+ from torch.testing import assert_allclose as _assert_allclose
+
+ class UsageError(Exception):
+ pass
+
+ def assert_close(
+ actual: torch.Tensor,
+ expected: torch.Tensor,
+ *,
+ rtol: Optional[float] = None,
+ atol: Optional[float] = None,
+ **kwargs: Any,
+ ) -> None:
+ try:
+ return _assert_allclose(actual, expected, rtol=rtol, atol=atol, **kwargs)
+ except ValueError as error:
+ raise UsageError(str(error)) from error
diff --git a/kornia/tracking/__init__.py b/kornia/tracking/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3d2a98bbac5056dfcbe507545b6a00ebf49ecea4
--- /dev/null
+++ b/kornia/tracking/__init__.py
@@ -0,0 +1,5 @@
+from .planar_tracker import HomographyTracker
+
+__all__ = [
+ "HomographyTracker",
+]
diff --git a/kornia/tracking/planar_tracker.py b/kornia/tracking/planar_tracker.py
new file mode 100644
index 0000000000000000000000000000000000000000..e1f221312332fc8ee15367f7219607ea0a0de2a0
--- /dev/null
+++ b/kornia/tracking/planar_tracker.py
@@ -0,0 +1,117 @@
+from typing import Dict, Optional, Tuple
+
+import torch
+import torch.nn as nn
+
+from kornia.feature import DescriptorMatcher, GFTTAffNetHardNet, LocalFeatureMatcher, LoFTR
+from kornia.geometry.linalg import transform_points
+from kornia.geometry.ransac import RANSAC
+from kornia.geometry.transform import warp_perspective
+
+
+class HomographyTracker(nn.Module):
+ r"""Module, which performs local-feature-based tracking of the target planar object in the
+ sequence of the frames.
+
+ Args:
+ initial_matcher: image matching module, e.g. :class:`~kornia.feature.LocalFeatureMatcher`
+ or :class:`~kornia.feature.LoFTR`. Default: :class:`~kornia.feature.GFTTAffNetHardNet`.
+ fast_matcher: fast image matching module, e.g. :class:`~kornia.feature.LocalFeatureMatcher`
+ or :class:`~kornia.feature.LoFTR`. Default: :class:`~kornia.feature.DescriptorMatcher`.
+ ransac: homography estimation module. Default: :class:`~kornia.geometry.RANSAC`.
+ minimum_inliers_num: threshold for number inliers for matching to be successful.
+ """
+ def __init__(self,
+ initial_matcher=LocalFeatureMatcher(GFTTAffNetHardNet(3000),
+ DescriptorMatcher('smnn', 0.95)),
+ fast_matcher=LoFTR('outdoor'),
+ ransac=RANSAC('homography',
+ inl_th=5.0,
+ batch_size=4096,
+ max_iter=10,
+ max_lo_iters=10),
+ minimum_inliers_num: int = 30) -> None:
+ super().__init__()
+ self.initial_matcher = initial_matcher
+ self.fast_matcher = fast_matcher
+ self.ransac = ransac
+ self.minimum_inliers_num = minimum_inliers_num
+ self.reset_tracking()
+
+ # placeholders
+ self.target: torch.Tensor
+ self.target_initial_representation: dict
+ self.target_fast_representation: dict
+ self.previous_homography: Optional[torch.Tensor]
+
+ def set_target(self, target: torch.Tensor) -> None:
+ self.target = target
+ self.target_initial_representation = {}
+ self.target_fast_representation = {}
+ if hasattr(self.initial_matcher, 'extract_features'):
+ self.target_initial_representation = self.initial_matcher.extract_features(target)
+ if hasattr(self.fast_matcher, 'extract_features'):
+ self.target_fast_representation = self.fast_matcher.extract_features(target)
+
+ def reset_tracking(self) -> None:
+ self.previous_homography = None
+
+ def no_match(self) -> Tuple[torch.Tensor, bool]:
+ return torch.empty(3, 3), False
+
+ def match_initial(self, x: torch.Tensor) -> Tuple[torch.Tensor, bool]:
+ """The frame `x` is matched with initial_matcher and verified with ransac."""
+ input_dict: Dict[str, torch.Tensor] = {"image0": self.target, "image1": x}
+
+ for k, v in self.target_initial_representation.items():
+ input_dict[f'{k}0'] = v
+
+ match_dict = self.initial_matcher(input_dict)
+ keypoints0 = match_dict['keypoints0'][match_dict['batch_indexes'] == 0]
+ keypoints1 = match_dict['keypoints1'][match_dict['batch_indexes'] == 0]
+
+ if len(keypoints0) < self.minimum_inliers_num:
+ return self.no_match()
+ H, inliers = self.ransac(keypoints0, keypoints1)
+
+ if inliers.sum().item() < self.minimum_inliers_num:
+ return self.no_match()
+ self.previous_homography = H.clone()
+
+ return H, True
+
+ def track_next_frame(self, x: torch.Tensor) -> Tuple[torch.Tensor, bool]:
+ """The frame `x` is prewarped according to the previous frame homography, matched with fast_matcher
+ verified with ransac."""
+ if self.previous_homography is not None: # mypy, shut up
+ Hwarp = self.previous_homography.clone()[None]
+ # make a bit of border for safety
+ Hwarp[:, 0:2, 0:2] = Hwarp[:, 0:2, 0:2] / 0.8
+ Hwarp[:, 0:2, 2] -= 10.0
+ Hinv = torch.inverse(Hwarp)
+ h, w = self.target.shape[2:]
+ frame_warped = warp_perspective(x, Hinv, (h, w))
+ input_dict = {"image0": self.target,
+ "image1": frame_warped}
+ for k, v in self.target_fast_representation.items():
+ input_dict[f'{k}0'] = v
+
+ match_dict = self.fast_matcher(input_dict)
+ keypoints0 = match_dict['keypoints0'][match_dict['batch_indexes'] == 0]
+ keypoints1 = match_dict['keypoints1'][match_dict['batch_indexes'] == 0]
+ keypoints1 = transform_points(Hwarp, keypoints1)
+
+ if len(keypoints0) < self.minimum_inliers_num:
+ self.reset_tracking()
+ return self.no_match()
+ H, inliers = self.ransac(keypoints0, keypoints1)
+ if inliers.sum().item() < self.minimum_inliers_num:
+ self.reset_tracking()
+ return self.no_match()
+ self.previous_homography = H.clone()
+ return H, True
+
+ def forward(self, x: torch.Tensor) -> Tuple[torch.Tensor, bool]:
+ if self.previous_homography is not None:
+ return self.track_next_frame(x)
+ return self.match_initial(x)
diff --git a/kornia/utils/__init__.py b/kornia/utils/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..aae146d52250bd25a8e91823c4a4c627d269c4f2
--- /dev/null
+++ b/kornia/utils/__init__.py
@@ -0,0 +1,27 @@
+from .draw import draw_rectangle
+from .grid import create_meshgrid, create_meshgrid3d
+from .helpers import _extract_device_dtype, safe_inverse_with_mask, safe_solve_with_mask
+from .image import image_list_to_tensor, image_to_tensor, ImageToTensor, tensor_to_image
+from .memory import batched_forward
+from .misc import eye_like, vec_like
+from .one_hot import one_hot
+from .pointcloud_io import load_pointcloud_ply, save_pointcloud_ply
+
+__all__ = [
+ "batched_forward",
+ "one_hot",
+ "create_meshgrid",
+ "create_meshgrid3d",
+ "tensor_to_image",
+ "image_to_tensor",
+ "image_list_to_tensor",
+ "save_pointcloud_ply",
+ "load_pointcloud_ply",
+ "draw_rectangle",
+ "_extract_device_dtype",
+ "safe_inverse_with_mask",
+ "safe_solve_with_mask",
+ "ImageToTensor",
+ "eye_like",
+ "vec_like",
+]
diff --git a/kornia/utils/_compat.py b/kornia/utils/_compat.py
new file mode 100644
index 0000000000000000000000000000000000000000..4bd3beca1ee4b2c6ee061719f40e33ec18aeb6c9
--- /dev/null
+++ b/kornia/utils/_compat.py
@@ -0,0 +1,35 @@
+import torch
+
+from packaging import version
+
+
+def torch_version() -> str:
+ """Parse the `torch.__version__` variable and removes +cu*/cpu."""
+ return torch.__version__.split('+')[0]
+
+
+def torch_version_geq(major, minor) -> bool:
+ _version = version.parse(torch_version())
+ return _version >= version.parse(f"{major}.{minor}")
+
+
+if version.parse(torch_version()) > version.parse("1.7.1"):
+ # TODO: remove the type: ignore once Python 3.6 is deprecated.
+ # It turns out that Pytorch has no attribute `torch.linalg` for
+ # Python 3.6 / PyTorch 1.7.0, 1.7.1
+ from torch.linalg import solve # type: ignore
+else:
+ from torch import solve as _solve
+
+ # NOTE: in previous versions `torch.solve` accepted arguments in another order.
+ def solve(A: torch.Tensor, B: torch.Tensor) -> torch.Tensor:
+ return _solve(B, A).solution
+
+
+if version.parse(torch_version()) > version.parse("1.7.1"):
+ # TODO: remove the type: ignore once Python 3.6 is deprecated.
+ # It turns out that Pytorch has no attribute `torch.linalg` for
+ # Python 3.6 / PyTorch 1.7.0, 1.7.1
+ from torch.linalg import qr as linalg_qr # type: ignore
+else:
+ from torch import qr as linalg_qr # type: ignore # noqa: F401
diff --git a/kornia/utils/draw.py b/kornia/utils/draw.py
new file mode 100644
index 0000000000000000000000000000000000000000..e296dc8c203ada3e2c686f67fae087083efe6dc0
--- /dev/null
+++ b/kornia/utils/draw.py
@@ -0,0 +1,86 @@
+from typing import Optional
+
+import torch
+
+# TODO: implement width of the line
+
+
+def draw_rectangle(
+ image: torch.Tensor,
+ rectangle: torch.Tensor,
+ color: Optional[torch.Tensor] = None,
+ fill: Optional[bool] = None,
+) -> torch.Tensor:
+ r"""Draw N rectangles on a batch of image tensors.
+
+ Args:
+ image: is tensor of BxCxHxW.
+ rectangle: represents number of rectangles to draw in BxNx4
+ N is the number of boxes to draw per batch index[x1, y1, x2, y2]
+ 4 is in (top_left.x, top_left.y, bot_right.x, bot_right.y).
+ color: a size 1, size 3, BxNx1, or BxNx3 tensor.
+ If C is 3, and color is 1 channel it will be broadcasted.
+ fill: is a flag used to fill the boxes with color if True.
+
+ Returns:
+ This operation modifies image inplace but also returns the drawn tensor for
+ convenience with same shape the of the input BxCxHxW.
+
+ Example:
+ >>> img = torch.rand(2, 3, 10, 12)
+ >>> rect = torch.tensor([[[0, 0, 4, 4]], [[4, 4, 10, 10]]])
+ >>> out = draw_rectangle(img, rect)
+ """
+
+ batch, c, h, w = image.shape
+ batch_rect, num_rectangle, num_points = rectangle.shape
+ if batch != batch_rect:
+ raise AssertionError("Image batch and rectangle batch must be equal")
+ if num_points != 4:
+ raise AssertionError("Number of points in rectangle must be 4")
+
+ # clone rectangle, in case it's been expanded assignment from clipping causes problems
+ rectangle = rectangle.long().clone()
+
+ # clip rectangle to hxw bounds
+ rectangle[:, :, 1::2] = torch.clamp(rectangle[:, :, 1::2], 0, h - 1)
+ rectangle[:, :, ::2] = torch.clamp(rectangle[:, :, ::2], 0, w - 1)
+
+ if color is None:
+ color = torch.tensor([0.0] * c).expand(batch, num_rectangle, c)
+
+ if fill is None:
+ fill = False
+
+ if len(color.shape) == 1:
+ color = color.expand(batch, num_rectangle, c)
+
+ b, n, color_channels = color.shape
+
+ if color_channels == 1 and c == 3:
+ color = color.expand(batch, num_rectangle, c)
+
+ for b in range(batch):
+ for n in range(num_rectangle):
+ if fill:
+ image[
+ b,
+ :,
+ int(rectangle[b, n, 1]): int(rectangle[b, n, 3] + 1),
+ int(rectangle[b, n, 0]): int(rectangle[b, n, 2] + 1),
+ ] = color[b, n, :, None, None]
+ else:
+ image[b, :, int(rectangle[b, n, 1]): int(rectangle[b, n, 3] + 1), rectangle[b, n, 0]] = color[
+ b, n, :, None
+ ]
+ image[b, :, int(rectangle[b, n, 1]): int(rectangle[b, n, 3] + 1), rectangle[b, n, 2]] = color[
+ b, n, :, None
+ ]
+ image[b, :, rectangle[b, n, 1], int(rectangle[b, n, 0]): int(rectangle[b, n, 2] + 1)] = color[
+ b, n, :, None
+ ]
+ image[b, :, rectangle[b, n, 3], int(rectangle[b, n, 0]): int(rectangle[b, n, 2] + 1)] = color[
+ b, n, :, None
+ ]
+
+ return image
diff --git a/kornia/utils/grid.py b/kornia/utils/grid.py
new file mode 100644
index 0000000000000000000000000000000000000000..9b625b518ae037210e076e13963c15361a46b2b5
--- /dev/null
+++ b/kornia/utils/grid.py
@@ -0,0 +1,101 @@
+from typing import Optional
+
+import torch
+
+
+def create_meshgrid(
+ height: int,
+ width: int,
+ normalized_coordinates: bool = True,
+ device: Optional[torch.device] = torch.device('cpu'),
+ dtype: torch.dtype = torch.float32,
+) -> torch.Tensor:
+ """Generate a coordinate grid for an image.
+
+ When the flag ``normalized_coordinates`` is set to True, the grid is
+ normalized to be in the range :math:`[-1,1]` to be consistent with the pytorch
+ function :py:func:`torch.nn.functional.grid_sample`.
+
+ Args:
+ height: the image height (rows).
+ width: the image width (cols).
+ normalized_coordinates: whether to normalize
+ coordinates in the range :math:`[-1,1]` in order to be consistent with the
+ PyTorch function :py:func:`torch.nn.functional.grid_sample`.
+ device: the device on which the grid will be generated.
+ dtype: the data type of the generated grid.
+
+ Return:
+ grid tensor with shape :math:`(1, H, W, 2)`.
+
+ Example:
+ >>> create_meshgrid(2, 2)
+ tensor([[[[-1., -1.],
+ [ 1., -1.]],
+
+ [[-1., 1.],
+ [ 1., 1.]]]])
+
+ >>> create_meshgrid(2, 2, normalized_coordinates=False)
+ tensor([[[[0., 0.],
+ [1., 0.]],
+
+ [[0., 1.],
+ [1., 1.]]]])
+ """
+ xs: torch.Tensor = torch.linspace(0, width - 1, width, device=device, dtype=dtype)
+ ys: torch.Tensor = torch.linspace(0, height - 1, height, device=device, dtype=dtype)
+ # Fix TracerWarning
+ # Note: normalize_pixel_coordinates still gots TracerWarning since new width and height
+ # tensors will be generated.
+ # Below is the code using normalize_pixel_coordinates:
+ # base_grid: torch.Tensor = torch.stack(torch.meshgrid([xs, ys]), dim=2)
+ # if normalized_coordinates:
+ # base_grid = K.geometry.normalize_pixel_coordinates(base_grid, height, width)
+ # return torch.unsqueeze(base_grid.transpose(0, 1), dim=0)
+ if normalized_coordinates:
+ xs = (xs / (width - 1) - 0.5) * 2
+ ys = (ys / (height - 1) - 0.5) * 2
+ # generate grid by stacking coordinates
+ base_grid: torch.Tensor = torch.stack(torch.meshgrid([xs, ys]), dim=-1) # WxHx2
+ return base_grid.permute(1, 0, 2).unsqueeze(0) # 1xHxWx2
+
+
+def create_meshgrid3d(
+ depth: int,
+ height: int,
+ width: int,
+ normalized_coordinates: bool = True,
+ device: Optional[torch.device] = torch.device('cpu'),
+ dtype: torch.dtype = torch.float32,
+) -> torch.Tensor:
+ """Generate a coordinate grid for an image.
+
+ When the flag ``normalized_coordinates`` is set to True, the grid is
+ normalized to be in the range :math:`[-1,1]` to be consistent with the pytorch
+ function :py:func:`torch.nn.functional.grid_sample`.
+
+ Args:
+ depth: the image depth (channels).
+ height: the image height (rows).
+ width: the image width (cols).
+ normalized_coordinates: whether to normalize
+ coordinates in the range :math:`[-1,1]` in order to be consistent with the
+ PyTorch function :py:func:`torch.nn.functional.grid_sample`.
+ device: the device on which the grid will be generated.
+ dtype: the data type of the generated grid.
+
+ Return:
+ grid tensor with shape :math:`(1, D, H, W, 3)`.
+ """
+ xs: torch.Tensor = torch.linspace(0, width - 1, width, device=device, dtype=dtype)
+ ys: torch.Tensor = torch.linspace(0, height - 1, height, device=device, dtype=dtype)
+ zs: torch.Tensor = torch.linspace(0, depth - 1, depth, device=device, dtype=dtype)
+ # Fix TracerWarning
+ if normalized_coordinates:
+ xs = (xs / (width - 1) - 0.5) * 2
+ ys = (ys / (height - 1) - 0.5) * 2
+ zs = (zs / (depth - 1) - 0.5) * 2
+ # generate grid by stacking coordinates
+ base_grid: torch.Tensor = torch.stack(torch.meshgrid([zs, xs, ys]), dim=-1) # DxWxHx3
+ return base_grid.permute(0, 2, 1, 3).unsqueeze(0) # 1xDxHxWx3
diff --git a/kornia/utils/helpers.py b/kornia/utils/helpers.py
new file mode 100644
index 0000000000000000000000000000000000000000..8236e6ed5f66d81acfa0225485f1f15cfb656c45
--- /dev/null
+++ b/kornia/utils/helpers.py
@@ -0,0 +1,143 @@
+import warnings
+from typing import Any, List, Optional, Tuple
+
+import torch
+
+from kornia.utils._compat import solve, torch_version_geq
+
+
+def _extract_device_dtype(tensor_list: List[Optional[Any]]) -> Tuple[torch.device, torch.dtype]:
+ """Check if all the input are in the same device (only if when they are torch.Tensor).
+
+ If so, it would return a tuple of (device, dtype). Default: (cpu, ``get_default_dtype()``).
+
+ Returns:
+ [torch.device, torch.dtype]
+ """
+ device, dtype = None, None
+ for tensor in tensor_list:
+ if tensor is not None:
+ if not isinstance(tensor, (torch.Tensor,)):
+ continue
+ _device = tensor.device
+ _dtype = tensor.dtype
+ if device is None and dtype is None:
+ device = _device
+ dtype = _dtype
+ elif device != _device or dtype != _dtype:
+ raise ValueError(
+ "Passed values are not in the same device and dtype."
+ f"Got ({device}, {dtype}) and ({_device}, {_dtype})."
+ )
+ if device is None:
+ # TODO: update this when having torch.get_default_device()
+ device = torch.device('cpu')
+ if dtype is None:
+ dtype = torch.get_default_dtype()
+ return (device, dtype)
+
+
+def _torch_inverse_cast(input: torch.Tensor) -> torch.Tensor:
+ """Helper function to make torch.inverse work with other than fp32/64.
+
+ The function torch.inverse is only implemented for fp32/64 which makes impossible to be used by fp16 or others. What
+ this function does, is cast input data type to fp32, apply torch.inverse, and cast back to the input dtype.
+ """
+ if not isinstance(input, torch.Tensor):
+ raise AssertionError(f"Input must be torch.Tensor. Got: {type(input)}.")
+ dtype: torch.dtype = input.dtype
+ if dtype not in (torch.float32, torch.float64):
+ dtype = torch.float32
+ return torch.inverse(input.to(dtype)).to(input.dtype)
+
+
+def _torch_histc_cast(input: torch.Tensor, bins: int, min: int, max: int) -> torch.Tensor:
+ """Helper function to make torch.histc work with other than fp32/64.
+
+ The function torch.histc is only implemented for fp32/64 which makes impossible to be used by fp16 or others. What
+ this function does, is cast input data type to fp32, apply torch.inverse, and cast back to the input dtype.
+ """
+ if not isinstance(input, torch.Tensor):
+ raise AssertionError(f"Input must be torch.Tensor. Got: {type(input)}.")
+ dtype: torch.dtype = input.dtype
+ if dtype not in (torch.float32, torch.float64):
+ dtype = torch.float32
+ return torch.histc(input.to(dtype), bins, min, max).to(input.dtype)
+
+
+def _torch_svd_cast(input: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+ """Helper function to make torch.svd work with other than fp32/64.
+
+ The function torch.svd is only implemented for fp32/64 which makes
+ impossible to be used by fp16 or others. What this function does, is cast
+ input data type to fp32, apply torch.svd, and cast back to the input dtype.
+
+ NOTE: in torch 1.8.1 this function is recommended to use as torch.linalg.svd
+ """
+ if not isinstance(input, torch.Tensor):
+ raise AssertionError(f"Input must be torch.Tensor. Got: {type(input)}.")
+ dtype: torch.dtype = input.dtype
+ if dtype not in (torch.float32, torch.float64):
+ dtype = torch.float32
+
+ out1, out2, out3 = torch.svd(input.to(dtype))
+
+ return (out1.to(input.dtype), out2.to(input.dtype), out3.to(input.dtype))
+
+
+# TODO: return only `torch.Tensor` and review all the calls to adjust
+def _torch_solve_cast(input: torch.Tensor, A: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+ """Helper function to make torch.solve work with other than fp32/64.
+
+ The function torch.solve is only implemented for fp32/64 which makes impossible to be used by fp16 or others. What
+ this function does, is cast input data type to fp32, apply torch.svd, and cast back to the input dtype.
+ """
+ if not isinstance(input, torch.Tensor):
+ raise AssertionError(f"Input must be torch.Tensor. Got: {type(input)}.")
+ dtype: torch.dtype = input.dtype
+ if dtype not in (torch.float32, torch.float64):
+ dtype = torch.float32
+
+ out = solve(A.to(dtype), input.to(dtype))
+
+ return (out.to(input.dtype), out)
+
+
+def safe_solve_with_mask(B: torch.Tensor, A: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+ r"""Helper function, which avoids crashing because of singular matrix input and outputs the
+ mask of valid solution"""
+ if not torch_version_geq(1, 10):
+ sol, lu = _torch_solve_cast(B, A)
+ warnings.warn('PyTorch version < 1.10, solve validness mask maybe not correct', RuntimeWarning)
+ return sol, lu, torch.ones(len(A), dtype=torch.bool, device=A.device)
+ # Based on https://github.com/pytorch/pytorch/issues/31546#issuecomment-694135622
+ if not isinstance(B, torch.Tensor):
+ raise AssertionError(f"B must be torch.Tensor. Got: {type(B)}.")
+ dtype: torch.dtype = B.dtype
+ if dtype not in (torch.float32, torch.float64):
+ dtype = torch.float32
+ A_LU, pivots, info = torch.lu(A.to(dtype), get_infos=True)
+ valid_mask: torch.Tensor = info == 0
+ X = torch.lu_solve(B.to(dtype), A_LU, pivots)
+ return X.to(B.dtype), A_LU.to(A.dtype), valid_mask
+
+
+def safe_inverse_with_mask(A: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+ r"""Helper function, which avoids crashing because of non-invertable matrix input and outputs the
+ mask of valid solution"""
+ # Based on https://github.com/pytorch/pytorch/issues/31546#issuecomment-694135622
+ if not torch_version_geq(1, 9):
+ inv = _torch_inverse_cast(A)
+ warnings.warn('PyTorch version < 1.9, inverse validness mask maybe not correct', RuntimeWarning)
+ return inv, torch.ones(len(A), dtype=torch.bool, device=A.device)
+ if not isinstance(A, torch.Tensor):
+ raise AssertionError(f"A must be torch.Tensor. Got: {type(A)}.")
+ dtype_original: torch.dtype = A.dtype
+ if dtype_original not in (torch.float32, torch.float64):
+ dtype = torch.float32
+ else:
+ dtype = dtype_original
+ from torch.linalg import inv_ex # type: ignore # (not available in 1.8.1)
+ inverse, info = inv_ex(A.to(dtype))
+ mask = info == 0
+ return inverse.to(dtype_original), mask
diff --git a/kornia/utils/image.py b/kornia/utils/image.py
new file mode 100644
index 0000000000000000000000000000000000000000..3e71fcd51413888c27711a406700016276f73813
--- /dev/null
+++ b/kornia/utils/image.py
@@ -0,0 +1,271 @@
+from functools import wraps
+from typing import Callable, List, TYPE_CHECKING
+
+import torch
+import torch.nn as nn
+
+if TYPE_CHECKING:
+ import numpy as np
+
+
+def image_to_tensor(image: "np.ndarray", keepdim: bool = True) -> torch.Tensor:
+ """Convert a numpy image to a PyTorch 4d tensor image.
+
+ Args:
+ image: image of the form :math:`(H, W, C)`, :math:`(H, W)` or
+ :math:`(B, H, W, C)`.
+ keepdim: If ``False`` unsqueeze the input image to match the shape
+ :math:`(B, H, W, C)`.
+
+ Returns:
+ tensor of the form :math:`(B, C, H, W)` if keepdim is ``False``,
+ :math:`(C, H, W)` otherwise.
+
+ Example:
+ >>> img = np.ones((3, 3))
+ >>> image_to_tensor(img).shape
+ torch.Size([1, 3, 3])
+
+ >>> img = np.ones((4, 4, 1))
+ >>> image_to_tensor(img).shape
+ torch.Size([1, 4, 4])
+
+ >>> img = np.ones((4, 4, 3))
+ >>> image_to_tensor(img, keepdim=False).shape
+ torch.Size([1, 3, 4, 4])
+ """
+ if len(image.shape) > 4 or len(image.shape) < 2:
+ raise ValueError("Input size must be a two, three or four dimensional array")
+
+ input_shape = image.shape
+ tensor: torch.Tensor = torch.from_numpy(image)
+
+ if len(input_shape) == 2:
+ # (H, W) -> (1, H, W)
+ tensor = tensor.unsqueeze(0)
+ elif len(input_shape) == 3:
+ # (H, W, C) -> (C, H, W)
+ tensor = tensor.permute(2, 0, 1)
+ elif len(input_shape) == 4:
+ # (B, H, W, C) -> (B, C, H, W)
+ tensor = tensor.permute(0, 3, 1, 2)
+ keepdim = True # no need to unsqueeze
+ else:
+ raise ValueError(f"Cannot process image with shape {input_shape}")
+
+ return tensor.unsqueeze(0) if not keepdim else tensor
+
+
+def image_list_to_tensor(images: List["np.ndarray"]) -> torch.Tensor:
+ """Converts a list of numpy images to a PyTorch 4d tensor image.
+
+ Args:
+ images: list of images, each of the form :math:`(H, W, C)`.
+ Image shapes must be consistent
+
+ Returns:
+ tensor of the form :math:`(B, C, H, W)`.
+
+ Example:
+ >>> imgs = [np.ones((4, 4, 1)), np.zeros((4, 4, 1))]
+ >>> image_list_to_tensor(imgs).shape
+ torch.Size([2, 1, 4, 4])
+ """
+ if not images:
+ raise ValueError("Input list of numpy images is empty")
+ if len(images[0].shape) != 3:
+ raise ValueError("Input images must be three dimensional arrays")
+
+ list_of_tensors: List[torch.Tensor] = []
+ for image in images:
+ list_of_tensors.append(image_to_tensor(image))
+ tensor: torch.Tensor = torch.stack(list_of_tensors)
+ return tensor
+
+
+def _to_bchw(tensor: torch.Tensor) -> torch.Tensor:
+ """Convert a PyTorch tensor image to BCHW format.
+
+ Args:
+ tensor (torch.Tensor): image of the form :math:`(*, H, W)`.
+
+ Returns:
+ input tensor of the form :math:`(B, C, H, W)`.
+ """
+ if not isinstance(tensor, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(tensor)}")
+
+ if len(tensor.shape) < 2:
+ raise ValueError(f"Input size must be a two, three or four dimensional tensor. Got {tensor.shape}")
+
+ if len(tensor.shape) == 2:
+ tensor = tensor.unsqueeze(0)
+
+ if len(tensor.shape) == 3:
+ tensor = tensor.unsqueeze(0)
+
+ if len(tensor.shape) > 4:
+ tensor = tensor.view(-1, tensor.shape[-3], tensor.shape[-2], tensor.shape[-1])
+
+ return tensor
+
+
+def _to_bcdhw(tensor: torch.Tensor) -> torch.Tensor:
+ """Convert a PyTorch tensor image to BCDHW format.
+
+ Args:
+ tensor (torch.Tensor): image of the form :math:`(*, D, H, W)`.
+
+ Returns:
+ input tensor of the form :math:`(B, C, D, H, W)`.
+ """
+ if not isinstance(tensor, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(tensor)}")
+
+ if len(tensor.shape) < 3:
+ raise ValueError(f"Input size must be a three, four or five dimensional tensor. Got {tensor.shape}")
+
+ if len(tensor.shape) == 3:
+ tensor = tensor.unsqueeze(0)
+
+ if len(tensor.shape) == 4:
+ tensor = tensor.unsqueeze(0)
+
+ if len(tensor.shape) > 5:
+ tensor = tensor.view(-1, tensor.shape[-4], tensor.shape[-3], tensor.shape[-2], tensor.shape[-1])
+
+ return tensor
+
+
+def tensor_to_image(tensor: torch.Tensor, keepdim: bool = False) -> "np.ndarray":
+ """Converts a PyTorch tensor image to a numpy image.
+
+ In case the tensor is in the GPU, it will be copied back to CPU.
+
+ Args:
+ tensor: image of the form :math:`(H, W)`, :math:`(C, H, W)` or
+ :math:`(B, C, H, W)`.
+ keepdim: If ``False`` squeeze the input image to match the shape
+ :math:`(H, W, C)` or :math:`(H, W)`.
+
+ Returns:
+ image of the form :math:`(H, W)`, :math:`(H, W, C)` or :math:`(B, H, W, C)`.
+
+ Example:
+ >>> img = torch.ones(1, 3, 3)
+ >>> tensor_to_image(img).shape
+ (3, 3)
+
+ >>> img = torch.ones(3, 4, 4)
+ >>> tensor_to_image(img).shape
+ (4, 4, 3)
+ """
+ if not isinstance(tensor, torch.Tensor):
+ raise TypeError(f"Input type is not a torch.Tensor. Got {type(tensor)}")
+
+ if len(tensor.shape) > 4 or len(tensor.shape) < 2:
+ raise ValueError("Input size must be a two, three or four dimensional tensor")
+
+ input_shape = tensor.shape
+ image: "np.ndarray" = tensor.cpu().detach().numpy()
+
+ if len(input_shape) == 2:
+ # (H, W) -> (H, W)
+ pass
+ elif len(input_shape) == 3:
+ # (C, H, W) -> (H, W, C)
+ if input_shape[0] == 1:
+ # Grayscale for proper plt.imshow needs to be (H,W)
+ image = image.squeeze()
+ else:
+ image = image.transpose(1, 2, 0)
+ elif len(input_shape) == 4:
+ # (B, C, H, W) -> (B, H, W, C)
+ image = image.transpose(0, 2, 3, 1)
+ if input_shape[0] == 1 and not keepdim:
+ image = image.squeeze(0)
+ if input_shape[1] == 1:
+ image = image.squeeze(-1)
+ else:
+ raise ValueError(f"Cannot process tensor with shape {input_shape}")
+
+ return image
+
+
+class ImageToTensor(nn.Module):
+ """Converts a numpy image to a PyTorch 4d tensor image.
+
+ Args:
+ keepdim: If ``False`` unsqueeze the input image to match the shape :math:`(B, H, W, C)`.
+ """
+
+ def __init__(self, keepdim: bool = False):
+ super().__init__()
+ self.keepdim = keepdim
+
+ def forward(self, x: "np.ndarray") -> torch.Tensor:
+ return image_to_tensor(x, keepdim=self.keepdim)
+
+
+def perform_keep_shape_image(f: Callable) -> Callable:
+ """A decorator that enable `f` to be applied to an image of arbitrary leading dimensions `(*, C, H, W)`.
+
+ It works by first viewing the image as `(B, C, H, W)`, applying the function and re-viewing the image as original
+ shape.
+ """
+
+ @wraps(f)
+ def _wrapper(input: torch.Tensor, *args, **kwargs):
+ if not isinstance(input, torch.Tensor):
+ raise TypeError(f"Input input type is not a torch.Tensor. Got {type(input)}")
+
+ if input.numel() == 0:
+ raise ValueError("Invalid input tensor, it is empty.")
+
+ input_shape = input.shape
+ input = _to_bchw(input) # view input as (B, C, H, W)
+ output: torch.Tensor = f(input, *args, **kwargs)
+ if len(input_shape) == 3:
+ output = output[0]
+
+ if len(input_shape) == 2:
+ output = output[0, 0]
+
+ if len(input_shape) > 4:
+ output = output.view(*(input_shape[:-3] + output.shape[-3:]))
+
+ return output
+
+ return _wrapper
+
+
+def perform_keep_shape_video(f: Callable) -> Callable:
+ """A decorator that enable `f` to be applied to an image of arbitrary leading dimensions `(*, C, D, H, W)`.
+
+ It works by first viewing the image as `(B, C, D, H, W)`, applying the function and re-viewing the image as original
+ shape.
+ """
+
+ @wraps(f)
+ def _wrapper(input: torch.Tensor, *args, **kwargs):
+ if not isinstance(input, torch.Tensor):
+ raise TypeError(f"Input input type is not a torch.Tensor. Got {type(input)}")
+
+ if input.numel() == 0:
+ raise ValueError("Invalid input tensor, it is empty.")
+
+ input_shape = input.shape
+ input = _to_bcdhw(input) # view input as (B, C, D, H, W)
+ output: torch.Tensor = f(input, *args, **kwargs)
+ if len(input_shape) == 4:
+ output = output[0]
+
+ if len(input_shape) == 3:
+ output = output[0, 0]
+
+ if len(input_shape) > 5:
+ output = output.view(*(input_shape[:-4] + output.shape[-4:]))
+
+ return output
+
+ return _wrapper
diff --git a/kornia/utils/memory.py b/kornia/utils/memory.py
new file mode 100644
index 0000000000000000000000000000000000000000..71a47fe8e266f8f38a17f208f9c93a5b7e40af92
--- /dev/null
+++ b/kornia/utils/memory.py
@@ -0,0 +1,50 @@
+import torch
+
+
+def batched_forward(
+ model: torch.nn.Module, data: torch.Tensor, device: torch.device, batch_size: int = 128, **kwargs
+) -> torch.Tensor:
+ r"""Convenience function, which allows to run the forward in micro-batches.
+
+ When the just model.forward(data) does not fit into device memory, e.g. on laptop GPU.
+ In the end, it transfers the output to the device of the input data tensor.
+ E.g. running HardNet on 8000x1x32x32 tensor.
+
+ Args:
+ model: Any torch model, which outputs a single tensor as an output.
+ data: Input data of Bx(Any) shape.
+ device: which device should we run on.
+ batch_size: "micro-batch" size.
+ **kwargs: any other arguments, which accepts model.
+
+ Returns:
+ output of the model.
+
+ Example:
+ >>> patches = torch.rand(8000, 1, 32, 32)
+ >>> sift = kornia.feature.SIFTDescriptor(32)
+ >>> desc_batched = batched_forward(sift, patches, torch.device('cpu'), 128)
+ >>> desc = sift(patches)
+ >>> assert torch.allclose(desc, desc_batched)
+ """
+ model_dev = model.to(device)
+ B: int = len(data)
+ bs: int = batch_size
+ if B > batch_size:
+ out_list = []
+ n_batches = int(B // bs + 1)
+ for batch_idx in range(n_batches):
+ st = batch_idx * bs
+ if batch_idx == n_batches - 1:
+ if (batch_idx + 1) * bs > B:
+ end = B
+ else:
+ end = (batch_idx + 1) * bs
+ else:
+ end = (batch_idx + 1) * bs
+ if st >= end:
+ continue
+ out_list.append(model_dev(data[st:end].to(device), **kwargs))
+ out = torch.cat(out_list, dim=0)
+ return out.to(data.device)
+ return model(data, **kwargs)
diff --git a/kornia/utils/misc.py b/kornia/utils/misc.py
new file mode 100644
index 0000000000000000000000000000000000000000..4a1f5bbc5a9ce98718c82f8f783b65f3e5e2860d
--- /dev/null
+++ b/kornia/utils/misc.py
@@ -0,0 +1,43 @@
+import torch
+
+
+def eye_like(n: int, input: torch.Tensor) -> torch.Tensor:
+ r"""Return a 2-D tensor with ones on the diagonal and zeros elsewhere with the same batch size as the input.
+
+ Args:
+ n: the number of rows :math:`(N)`.
+ input: image tensor that will determine the batch size of the output matrix.
+ The expected shape is :math:`(B, *)`.
+
+ Returns:
+ The identity matrix with the same batch size as the input :math:`(B, N, N)`.
+
+ """
+ if n <= 0:
+ raise AssertionError(type(n), n)
+ if len(input.shape) < 1:
+ raise AssertionError(input.shape)
+
+ identity = torch.eye(n, device=input.device, dtype=input.dtype)
+ return identity[None].repeat(input.shape[0], 1, 1)
+
+
+def vec_like(n, tensor):
+ r"""Return a 2-D tensor with a vector containing zeros with the same batch size as the input.
+
+ Args:
+ n: the number of rows :math:`(N)`.
+ tensor: image tensor that will determine the batch size of the output matrix.
+ The expected shape is :math:`(B, *)`.
+
+ Returns:
+ The vector with the same batch size as the input :math:`(B, N, 1)`.
+
+ """
+ if n <= 0:
+ raise AssertionError(type(n), n)
+ if len(tensor.shape) < 1:
+ raise AssertionError(tensor.shape)
+
+ vec = torch.zeros(n, 1, device=tensor.device, dtype=tensor.dtype)
+ return vec[None].repeat(tensor.shape[0], 1, 1)
diff --git a/kornia/utils/one_hot.py b/kornia/utils/one_hot.py
new file mode 100644
index 0000000000000000000000000000000000000000..02806203748b1ca94d0ac92fde1b7f8bfbaa97ec
--- /dev/null
+++ b/kornia/utils/one_hot.py
@@ -0,0 +1,50 @@
+from typing import Optional
+
+import torch
+
+
+def one_hot(
+ labels: torch.Tensor,
+ num_classes: int,
+ device: Optional[torch.device] = None,
+ dtype: Optional[torch.dtype] = None,
+ eps: float = 1e-6,
+) -> torch.Tensor:
+ r"""Convert an integer label x-D tensor to a one-hot (x+1)-D tensor.
+
+ Args:
+ labels: tensor with labels of shape :math:`(N, *)`, where N is batch size.
+ Each value is an integer representing correct classification.
+ num_classes: number of classes in labels.
+ device: the desired device of returned tensor.
+ dtype: the desired data type of returned tensor.
+
+ Returns:
+ the labels in one hot tensor of shape :math:`(N, C, *)`,
+
+ Examples:
+ >>> labels = torch.LongTensor([[[0, 1], [2, 0]]])
+ >>> one_hot(labels, num_classes=3)
+ tensor([[[[1.0000e+00, 1.0000e-06],
+ [1.0000e-06, 1.0000e+00]],
+
+ [[1.0000e-06, 1.0000e+00],
+ [1.0000e-06, 1.0000e-06]],
+
+ [[1.0000e-06, 1.0000e-06],
+ [1.0000e+00, 1.0000e-06]]]])
+
+ """
+ if not isinstance(labels, torch.Tensor):
+ raise TypeError(f"Input labels type is not a torch.Tensor. Got {type(labels)}")
+
+ if not labels.dtype == torch.int64:
+ raise ValueError(f"labels must be of the same dtype torch.int64. Got: {labels.dtype}")
+
+ if num_classes < 1:
+ raise ValueError("The number of classes must be bigger than one." " Got: {}".format(num_classes))
+
+ shape = labels.shape
+ one_hot = torch.zeros((shape[0], num_classes) + shape[1:], device=device, dtype=dtype)
+
+ return one_hot.scatter_(1, labels.unsqueeze(1), 1.0) + eps
diff --git a/kornia/utils/pointcloud_io.py b/kornia/utils/pointcloud_io.py
new file mode 100644
index 0000000000000000000000000000000000000000..88d63e2b82dcf4918d6dbc5cd008d90ad8d0b8eb
--- /dev/null
+++ b/kornia/utils/pointcloud_io.py
@@ -0,0 +1,83 @@
+import os
+
+import torch
+
+
+def save_pointcloud_ply(filename: str, pointcloud: torch.Tensor) -> None:
+ r"""Utility function to save to disk a pointcloud in PLY format.
+
+ Args:
+ filename: the path to save the pointcloud.
+ pointcloud: tensor containing the pointcloud to save.
+ The tensor must be in the shape of :math:`(*, 3)` where the last
+ component is assumed to be a 3d point coordinate :math:`(X, Y, Z)`.
+ """
+ if not isinstance(filename, str) and filename[-3:] == '.ply':
+ raise TypeError("Input filename must be a string in with the .ply " "extension. Got {}".format(filename))
+
+ if not torch.is_tensor(pointcloud):
+ raise TypeError(f"Input pointcloud type is not a torch.Tensor. Got {type(pointcloud)}")
+
+ if not len(pointcloud.shape) == 3 and pointcloud.shape[-1] == 3:
+ raise TypeError("Input pointcloud must be in the following shape " "HxWx3. Got {}.".format(pointcloud.shape))
+
+ # flatten the input pointcloud in a vector to iterate points
+ xyz_vec: torch.Tensor = pointcloud.reshape(-1, 3)
+
+ with open(filename, 'w') as f:
+ data_str: str = ''
+ num_points: int = xyz_vec.shape[0]
+ for idx in range(num_points):
+ xyz = xyz_vec[idx]
+ if not bool(torch.isfinite(xyz).any()):
+ num_points -= 1
+ continue
+ x: float = xyz[0].item()
+ y: float = xyz[1].item()
+ z: float = xyz[2].item()
+ data_str += f'{x} {y} {z}\n'
+
+ f.write("ply\n")
+ f.write("format ascii 1.0\n")
+ f.write("comment arraiy generated\n")
+ f.write("element vertex %d\n" % num_points)
+ f.write("property double x\n")
+ f.write("property double y\n")
+ f.write("property double z\n")
+ f.write("end_header\n")
+ f.write(data_str)
+
+
+def load_pointcloud_ply(filename: str, header_size: int = 8) -> torch.Tensor:
+ r"""Utility function to load from disk a pointcloud in PLY format.
+
+ Args:
+ filename: the path to the pointcloud.
+ header_size: the size of the ply file header that will
+ be skipped during loading.
+
+ Return:
+ tensor containing the loaded point with shape :math:`(*, 3)` where
+ :math:`*` represents the number of points.
+ """
+ if not isinstance(filename, str) and filename[-3:] == '.ply':
+ raise TypeError("Input filename must be a string in with the .ply " "extension. Got {}".format(filename))
+ if not os.path.isfile(filename):
+ raise ValueError("Input filename is not an existing file.")
+ if not (isinstance(header_size, int) and header_size > 0):
+ raise TypeError(f"Input header_size must be a positive integer. Got {header_size}.")
+ # open the file and populate tensor
+ with open(filename) as f:
+ points = []
+
+ # skip header
+ lines = f.readlines()[header_size:]
+
+ # iterate over the points
+ for line in lines:
+ x_str, y_str, z_str = line.split()
+ points.append((torch.tensor(float(x_str)), torch.tensor(float(y_str)), torch.tensor(float(z_str))))
+
+ # create tensor from list
+ pointcloud: torch.Tensor = torch.tensor(points)
+ return pointcloud
diff --git a/kornia/x/__init__.py b/kornia/x/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..2fb043a1238f69021375ff94aed78fc2a1a4d889
--- /dev/null
+++ b/kornia/x/__init__.py
@@ -0,0 +1,4 @@
+from .callbacks import EarlyStopping, ModelCheckpoint
+from .trainer import Trainer
+from .trainer_classification import ImageClassifierTrainer, SemanticSegmentationTrainer
+from .utils import Configuration, Lambda, TrainerState
diff --git a/kornia/x/callbacks.py b/kornia/x/callbacks.py
new file mode 100644
index 0000000000000000000000000000000000000000..e5487064e4ee077eabb38a976cb600268f55470e
--- /dev/null
+++ b/kornia/x/callbacks.py
@@ -0,0 +1,103 @@
+from pathlib import Path
+from typing import Optional
+
+import torch
+import torch.nn as nn
+
+from .utils import TrainerState
+
+
+class EarlyStopping:
+ """Callback that evaluates whether there is improvement in the loss function.
+
+ The module track the losses and in case of finish patience sends a termination signal to the trainer.
+ In case of termination, the module will save the last model.
+
+ Args:
+ monitor: the name of the value to track.
+ min_delta: the minimum difference between losses to increase the patience counter.
+ patience: the number of times to wait until the trainer does not terminate.
+ filepath: a backup filename to save the file in case of termination.
+
+ **Usage example:**
+
+ .. code:: python
+
+ early_stop = EarlyStopping(
+ monitor="top5", filepath="early_stop_model.pt"
+ )
+
+ trainer = ImageClassifierTrainer(...,
+ callbacks={"terminate", early_stop}
+ )
+ """
+ def __init__(self, monitor: str, min_delta: float = 0., patience: int = 8) -> None:
+ self.monitor = monitor
+ self.min_delta = min_delta
+ self.patience = patience
+
+ self.counter: int = 0
+ self.best_score: Optional[float] = None
+ self.early_stop: bool = False
+
+ def __call__(self, model: nn.Module, epoch: int, valid_metric) -> TrainerState:
+ score: float = -valid_metric[self.monitor].avg
+
+ # TODO: rethink about this logic - doesn't seem to do the job.
+ if self.best_score is None:
+ self.best_score = score
+ elif score < self.best_score + self.min_delta:
+ self.counter += 1
+ if self.counter >= self.patience:
+ self.early_stop = True
+ else:
+ self.best_score = score
+ self.counter = 0
+
+ if self.early_stop:
+ # TODO: figure out later how and where to save
+ # store old metric and save new model
+ # torch.save(model, self.filepath)
+ print(f"[INFO] Early-Stopping the training process. Epoch: {epoch}.")
+ return TrainerState.TERMINATE
+
+ return TrainerState.TRAINING
+
+
+class ModelCheckpoint:
+ """Callback that save the model at the end of everyepoch.
+
+ Args:
+ filepath: the where to save the mode.
+ monitor: the name of the value to track.
+
+ **Usage example:**
+
+ .. code:: python
+
+ model_checkpoint = ModelCheckpoint(
+ filepath="./outputs", monitor="top5",
+ )
+
+ trainer = ImageClassifierTrainer(...,
+ callbacks={"checkpoint", model_checkpoint}
+ )
+ """
+ def __init__(self, filepath: str, monitor: str) -> None:
+ self.filepath = filepath
+ self.monitor = monitor
+
+ # track best model
+ self.best_metric: float = 0.
+
+ # create directory
+ Path(self.filepath).mkdir(parents=True, exist_ok=True)
+
+ def __call__(self, model: nn.Module, epoch: int, valid_metric) -> None:
+ valid_metric_value: float = valid_metric[self.monitor].avg
+ if valid_metric_value > self.best_metric:
+ self.best_metric = valid_metric_value
+ # store old metric and save new model
+ filename = Path(self.filepath) / f"model_{epoch}.pt"
+ torch.save(model, filename)
+ ...
diff --git a/kornia/x/trainer.py b/kornia/x/trainer.py
new file mode 100644
index 0000000000000000000000000000000000000000..9d33bfdf377e6f7745671ac0509a1233de64473a
--- /dev/null
+++ b/kornia/x/trainer.py
@@ -0,0 +1,183 @@
+import logging
+from typing import Callable, Dict
+
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader
+
+# the accelerator library is a requirement for the Trainer
+# but it is optional for grousnd base user of kornia.
+try:
+ from accelerate import Accelerator
+except ImportError:
+ Accelerator = None
+
+from kornia.metrics import AverageMeter
+
+from .utils import Configuration, TrainerState
+
+callbacks_whitelist = [
+ # high level functions
+ "preprocess",
+ "augmentations",
+ "evaluate",
+ "fit",
+ "fit_epoch",
+ # events (by calling order)
+ "on_epoch_start",
+ "on_before_model",
+ "on_after_model",
+ "on_checkpoint",
+ "on_epoch_end",
+]
+
+
+class Trainer:
+ """Base class to train the different models in kornia.
+
+ .. warning::
+ The API is experimental and subject to be modified based on the needs of kornia models.
+
+ Args:
+ model: the nn.Module to be optimized.
+ train_dataloader: the data loader used in the training loop.
+ valid_dataloader: the data loader used in the validation loop.
+ criterion: the nn.Module with the function that computes the loss.
+ optimizer: the torch optimizer object to be used during the optimization.
+ scheduler: the torch scheduler object with defiing the scheduling strategy.
+ accelerator: the Accelerator object to distribute the training.
+ config: a TrainerConfiguration structure containing the experiment hyper parameters.
+ callbacks: a dictionary containing the pointers to the functions to overrides. The
+ main supported hooks are ``evaluate``, ``preprocess``, ``augmentations`` and ``fit``.
+
+ .. important::
+ The API heavily relies on `accelerate `_.
+ """
+ def __init__(
+ self,
+ model: nn.Module,
+ train_dataloader: DataLoader,
+ valid_dataloader: DataLoader,
+ criterion: nn.Module,
+ optimizer: torch.optim.Optimizer,
+ scheduler: torch.optim.lr_scheduler.CosineAnnealingLR,
+ config: Configuration,
+ callbacks: Dict[str, Callable] = {},
+ ) -> None:
+ # setup the accelerator
+ if Accelerator is None:
+ raise ModuleNotFoundError(
+ "accelerate library is not installed: pip install kornia[x]")
+ self.accelerator = Accelerator()
+
+ # setup the data related objects
+ self.model = self.accelerator.prepare(model)
+ self.train_dataloader = self.accelerator.prepare(train_dataloader)
+ self.valid_dataloader = self.accelerator.prepare(valid_dataloader)
+ self.criterion = criterion.to(self.device)
+ self.optimizer = self.accelerator.prepare(optimizer)
+ self.scheduler = scheduler
+ self.config = config
+
+ # configure callbacks
+ for fn_name, fn in callbacks.items():
+ if fn_name not in callbacks_whitelist:
+ raise ValueError(f"Not supported: {fn_name}.")
+ setattr(Trainer, fn_name, fn)
+
+ # hyper-params
+ self.num_epochs = config.num_epochs
+
+ self.state = TrainerState.STARTING
+
+ self._logger = logging.getLogger('train')
+
+ @property
+ def device(self) -> torch.device:
+ return self.accelerator.device
+
+ def backward(self, loss: torch.Tensor) -> None:
+ self.accelerator.backward(loss)
+
+ def fit_epoch(self, epoch: int) -> None:
+ # train loop
+ self.model.train()
+ losses = AverageMeter()
+ for sample_id, sample in enumerate(self.train_dataloader):
+ sample = {"input": sample[0], "target": sample[1]} # new dataset api will come like this
+ self.optimizer.zero_grad()
+ # perform the preprocess and augmentations in batch
+ sample = self.preprocess(sample)
+ sample = self.augmentations(sample)
+ sample = self.on_before_model(sample)
+ # make the actual inference
+ output = self.model(sample["input"])
+ self.on_after_model(output, sample) # for debugging purposes
+ loss = self.criterion(output, sample["target"])
+ self.backward(loss)
+ self.optimizer.step()
+
+ losses.update(loss.item(), sample["target"].shape[0])
+
+ if sample_id % 50 == 0:
+ self._logger.info(
+ f"Train: {epoch + 1}/{self.num_epochs} "
+ f"Sample: {sample_id + 1}/{len(self.train_dataloader)} "
+ f"Loss: {losses.val:.3f} {losses.avg:.3f}"
+ )
+
+ def fit(self,) -> None:
+ # execute the main loop
+ # NOTE: Do not change and keep this structure clear for readability.
+ for epoch in range(self.num_epochs):
+ # call internally the training loop
+ # NOTE: override to customize your evaluation routine
+ self.state = TrainerState.TRAINING
+ self.fit_epoch(epoch)
+
+ # call internally the evaluation loop
+ # NOTE: override to customize your evaluation routine
+ self.state = TrainerState.VALIDATE
+ valid_stats = self.evaluate()
+
+ self.on_checkpoint(self.model, epoch, valid_stats)
+
+ self.on_epoch_end()
+ if self.state == TrainerState.TERMINATE:
+ break
+
+ # END OF THE EPOCH
+ self.scheduler.step()
+
+ ...
+
+ # events stubs
+
+ def evaluate(self):
+ ...
+
+ def on_epoch_start(self, *args, **kwargs):
+ ...
+
+ def preprocess(self, x: dict) -> dict:
+ return x
+
+ def augmentations(self, x: dict) -> dict:
+ return x
+
+ def on_before_model(self, x: dict) -> dict:
+ return x
+
+ def on_after_model(self, output: torch.Tensor, sample: dict):
+ ...
+
+ def on_checkpoint(self, *args, **kwargs):
+ ...
+
+ def on_epoch_end(self, *args, **kwargs):
+ ...
diff --git a/kornia/x/trainer_classification.py b/kornia/x/trainer_classification.py
new file mode 100644
index 0000000000000000000000000000000000000000..a50fa7cf9b395360fc3ddbc074bd22893e512456
--- /dev/null
+++ b/kornia/x/trainer_classification.py
@@ -0,0 +1,88 @@
+import torch
+
+from kornia.metrics import accuracy, AverageMeter, mean_iou
+
+from .trainer import Trainer
+
+
+class ImageClassifierTrainer(Trainer):
+ """Module to be used for Image Classification purposes.
+
+ The module subclasses :py:class:`~kornia.x.Trainer` and overrides the
+ :py:func:`~kornia.x.Trainer.evaluate` function implementing a standard
+ :py:func:`~kornia.metrics.accuracy` topk@[1, 5].
+
+ .. seealso::
+ Learn how to use this class in the following
+ `example
| Geometric Augmentations | +Color-space Augmentations | +
|---|---|
| + +| | 2D | 3D | +| ------------ | ----------- | ------------ | +| RandomHorizontalFlip | โ | โ | +| RandomVerticalFlip | โ | โ | +| RandomDepthicalFlip | - | โ | +| RandomRotation | โ | โ | +| RandomAffine | โ | โ | +| RandomPerspective | โ | โ | +| RandomErasing | โ | โ | +| CenterCrop | โ | โ | +| RandomCrop | โ | โ | +| RandomResizedCrop | โ | - | +| RandomMotionBlur | โ | โ | + + | +
+
+| | 2D | 3D |
+| ------------ | ----------- | ------------ |
+| ColorJitter | โ
| โ |
+| RandomGrayscale | โ
| โ |
+| RandomSolarize | โ
| โ |
+| RandomPosterize | โ
| โ |
+| RandomSharpness | โ
| โ |
+| RandomEqualize | โ
| โ
|
+
+
+ Mix Augmentations
+
+
+| | 2D | 3D |
+| ------------ | ----------- | ------------ |
+| RandomMixUp | โ
| โ |
+| RandomCutMix | โ
| โ |
+ |
+